2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4 Written by Mark Mitchell <mark@codesourcery.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
31 #include "c-family/c-pragma.h"
34 #include "diagnostic-core.h"
38 #include "c-family/c-common.h"
39 #include "c-family/c-objc.h"
41 #include "tree-pretty-print.h"
47 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
48 and c-lex.c) and the C++ parser. */
50 static cp_token eof_token =
52 CPP_EOF, RID_MAX, 0, PRAGMA_NONE, false, false, false, 0, { NULL }
55 /* The various kinds of non integral constant we encounter. */
56 typedef enum non_integral_constant {
58 /* floating-point literal */
62 /* %<__FUNCTION__%> */
64 /* %<__PRETTY_FUNCTION__%> */
72 /* %<typeid%> operator */
74 /* non-constant compound literals */
82 /* an array reference */
88 /* the address of a label */
102 /* calls to overloaded operators */
106 /* a comma operator */
108 /* a call to a constructor */
110 } non_integral_constant;
112 /* The various kinds of errors about name-lookup failing. */
113 typedef enum name_lookup_error {
118 /* is not a class or namespace */
120 /* is not a class, namespace, or enumeration */
124 /* The various kinds of required token */
125 typedef enum required_token {
127 RT_SEMICOLON, /* ';' */
128 RT_OPEN_PAREN, /* '(' */
129 RT_CLOSE_BRACE, /* '}' */
130 RT_OPEN_BRACE, /* '{' */
131 RT_CLOSE_SQUARE, /* ']' */
132 RT_OPEN_SQUARE, /* '[' */
136 RT_GREATER, /* '>' */
138 RT_ELLIPSIS, /* '...' */
142 RT_COLON_SCOPE, /* ':' or '::' */
143 RT_CLOSE_PAREN, /* ')' */
144 RT_COMMA_CLOSE_PAREN, /* ',' or ')' */
145 RT_PRAGMA_EOL, /* end of line */
146 RT_NAME, /* identifier */
148 /* The type is CPP_KEYWORD */
150 RT_DELETE, /* delete */
151 RT_RETURN, /* return */
152 RT_WHILE, /* while */
153 RT_EXTERN, /* extern */
154 RT_STATIC_ASSERT, /* static_assert */
155 RT_DECLTYPE, /* decltype */
156 RT_OPERATOR, /* operator */
157 RT_CLASS, /* class */
158 RT_TEMPLATE, /* template */
159 RT_NAMESPACE, /* namespace */
160 RT_USING, /* using */
163 RT_CATCH, /* catch */
164 RT_THROW, /* throw */
165 RT_LABEL, /* __label__ */
166 RT_AT_TRY, /* @try */
167 RT_AT_SYNCHRONIZED, /* @synchronized */
168 RT_AT_THROW, /* @throw */
170 RT_SELECT, /* selection-statement */
171 RT_INTERATION, /* iteration-statement */
172 RT_JUMP, /* jump-statement */
173 RT_CLASS_KEY, /* class-key */
174 RT_CLASS_TYPENAME_TEMPLATE /* class, typename, or template */
179 static cp_lexer *cp_lexer_new_main
181 static cp_lexer *cp_lexer_new_from_tokens
182 (cp_token_cache *tokens);
183 static void cp_lexer_destroy
185 static int cp_lexer_saving_tokens
187 static cp_token *cp_lexer_token_at
188 (cp_lexer *, cp_token_position);
189 static void cp_lexer_get_preprocessor_token
190 (cp_lexer *, cp_token *);
191 static inline cp_token *cp_lexer_peek_token
193 static cp_token *cp_lexer_peek_nth_token
194 (cp_lexer *, size_t);
195 static inline bool cp_lexer_next_token_is
196 (cp_lexer *, enum cpp_ttype);
197 static bool cp_lexer_next_token_is_not
198 (cp_lexer *, enum cpp_ttype);
199 static bool cp_lexer_next_token_is_keyword
200 (cp_lexer *, enum rid);
201 static cp_token *cp_lexer_consume_token
203 static void cp_lexer_purge_token
205 static void cp_lexer_purge_tokens_after
206 (cp_lexer *, cp_token_position);
207 static void cp_lexer_save_tokens
209 static void cp_lexer_commit_tokens
211 static void cp_lexer_rollback_tokens
213 #ifdef ENABLE_CHECKING
214 static void cp_lexer_print_token
215 (FILE *, cp_token *);
216 static inline bool cp_lexer_debugging_p
218 static void cp_lexer_start_debugging
219 (cp_lexer *) ATTRIBUTE_UNUSED;
220 static void cp_lexer_stop_debugging
221 (cp_lexer *) ATTRIBUTE_UNUSED;
223 /* If we define cp_lexer_debug_stream to NULL it will provoke warnings
224 about passing NULL to functions that require non-NULL arguments
225 (fputs, fprintf). It will never be used, so all we need is a value
226 of the right type that's guaranteed not to be NULL. */
227 #define cp_lexer_debug_stream stdout
228 #define cp_lexer_print_token(str, tok) (void) 0
229 #define cp_lexer_debugging_p(lexer) 0
230 #endif /* ENABLE_CHECKING */
232 static cp_token_cache *cp_token_cache_new
233 (cp_token *, cp_token *);
235 static void cp_parser_initial_pragma
238 /* Manifest constants. */
239 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
240 #define CP_SAVED_TOKEN_STACK 5
244 #ifdef ENABLE_CHECKING
245 /* The stream to which debugging output should be written. */
246 static FILE *cp_lexer_debug_stream;
247 #endif /* ENABLE_CHECKING */
249 /* Nonzero if we are parsing an unevaluated operand: an operand to
250 sizeof, typeof, or alignof. */
251 int cp_unevaluated_operand;
253 #ifdef ENABLE_CHECKING
254 /* Dump up to NUM tokens in BUFFER to FILE. If NUM is 0, dump all the
258 cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer, unsigned num)
263 fprintf (file, "%u tokens\n", VEC_length (cp_token, buffer));
266 num = VEC_length (cp_token, buffer);
268 for (i = 0; VEC_iterate (cp_token, buffer, i, token) && i < num; i++)
270 cp_lexer_print_token (file, token);
275 case CPP_CLOSE_BRACE:
285 if (i == num && i < VEC_length (cp_token, buffer))
287 fprintf (file, " ... ");
288 cp_lexer_print_token (file, VEC_index (cp_token, buffer,
289 VEC_length (cp_token, buffer) - 1));
292 fprintf (file, "\n");
296 /* Dump all tokens in BUFFER to stderr. */
299 cp_lexer_debug_tokens (VEC(cp_token,gc) *buffer)
301 cp_lexer_dump_tokens (stderr, buffer, 0);
306 /* Allocate memory for a new lexer object and return it. */
309 cp_lexer_alloc (void)
313 c_common_no_more_pch ();
315 /* Allocate the memory. */
316 lexer = ggc_alloc_cleared_cp_lexer ();
318 #ifdef ENABLE_CHECKING
319 /* Initially we are not debugging. */
320 lexer->debugging_p = false;
321 #endif /* ENABLE_CHECKING */
322 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
323 CP_SAVED_TOKEN_STACK);
325 /* Create the buffer. */
326 lexer->buffer = VEC_alloc (cp_token, gc, CP_LEXER_BUFFER_SIZE);
332 /* Create a new main C++ lexer, the lexer that gets tokens from the
336 cp_lexer_new_main (void)
341 /* It's possible that parsing the first pragma will load a PCH file,
342 which is a GC collection point. So we have to do that before
343 allocating any memory. */
344 cp_parser_initial_pragma (&token);
346 lexer = cp_lexer_alloc ();
348 /* Put the first token in the buffer. */
349 VEC_quick_push (cp_token, lexer->buffer, &token);
351 /* Get the remaining tokens from the preprocessor. */
352 while (token.type != CPP_EOF)
354 cp_lexer_get_preprocessor_token (lexer, &token);
355 VEC_safe_push (cp_token, gc, lexer->buffer, &token);
358 lexer->last_token = VEC_address (cp_token, lexer->buffer)
359 + VEC_length (cp_token, lexer->buffer)
361 lexer->next_token = VEC_length (cp_token, lexer->buffer)
362 ? VEC_address (cp_token, lexer->buffer)
365 /* Subsequent preprocessor diagnostics should use compiler
366 diagnostic functions to get the compiler source location. */
369 gcc_assert (!lexer->next_token->purged_p);
373 /* Create a new lexer whose token stream is primed with the tokens in
374 CACHE. When these tokens are exhausted, no new tokens will be read. */
377 cp_lexer_new_from_tokens (cp_token_cache *cache)
379 cp_token *first = cache->first;
380 cp_token *last = cache->last;
381 cp_lexer *lexer = ggc_alloc_cleared_cp_lexer ();
383 /* We do not own the buffer. */
384 lexer->buffer = NULL;
385 lexer->next_token = first == last ? &eof_token : first;
386 lexer->last_token = last;
388 lexer->saved_tokens = VEC_alloc (cp_token_position, heap,
389 CP_SAVED_TOKEN_STACK);
391 #ifdef ENABLE_CHECKING
392 /* Initially we are not debugging. */
393 lexer->debugging_p = false;
396 gcc_assert (!lexer->next_token->purged_p);
400 /* Frees all resources associated with LEXER. */
403 cp_lexer_destroy (cp_lexer *lexer)
405 VEC_free (cp_token, gc, lexer->buffer);
406 VEC_free (cp_token_position, heap, lexer->saved_tokens);
410 /* Returns nonzero if debugging information should be output. */
412 #ifdef ENABLE_CHECKING
415 cp_lexer_debugging_p (cp_lexer *lexer)
417 return lexer->debugging_p;
420 #endif /* ENABLE_CHECKING */
422 static inline cp_token_position
423 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
425 gcc_assert (!previous_p || lexer->next_token != &eof_token);
427 return lexer->next_token - previous_p;
430 static inline cp_token *
431 cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos)
437 cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
439 lexer->next_token = cp_lexer_token_at (lexer, pos);
442 static inline cp_token_position
443 cp_lexer_previous_token_position (cp_lexer *lexer)
445 if (lexer->next_token == &eof_token)
446 return lexer->last_token - 1;
448 return cp_lexer_token_position (lexer, true);
451 static inline cp_token *
452 cp_lexer_previous_token (cp_lexer *lexer)
454 cp_token_position tp = cp_lexer_previous_token_position (lexer);
456 return cp_lexer_token_at (lexer, tp);
459 /* nonzero if we are presently saving tokens. */
462 cp_lexer_saving_tokens (const cp_lexer* lexer)
464 return VEC_length (cp_token_position, lexer->saved_tokens) != 0;
467 /* Store the next token from the preprocessor in *TOKEN. Return true
468 if we reach EOF. If LEXER is NULL, assume we are handling an
469 initial #pragma pch_preprocess, and thus want the lexer to return
470 processed strings. */
473 cp_lexer_get_preprocessor_token (cp_lexer *lexer, cp_token *token)
475 static int is_extern_c = 0;
477 /* Get a new token from the preprocessor. */
479 = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
480 lexer == NULL ? 0 : C_LEX_STRING_NO_JOIN);
481 token->keyword = RID_MAX;
482 token->pragma_kind = PRAGMA_NONE;
483 token->purged_p = false;
485 /* On some systems, some header files are surrounded by an
486 implicit extern "C" block. Set a flag in the token if it
487 comes from such a header. */
488 is_extern_c += pending_lang_change;
489 pending_lang_change = 0;
490 token->implicit_extern_c = is_extern_c > 0;
492 /* Check to see if this token is a keyword. */
493 if (token->type == CPP_NAME)
495 if (C_IS_RESERVED_WORD (token->u.value))
497 /* Mark this token as a keyword. */
498 token->type = CPP_KEYWORD;
499 /* Record which keyword. */
500 token->keyword = C_RID_CODE (token->u.value);
504 if (warn_cxx0x_compat
505 && C_RID_CODE (token->u.value) >= RID_FIRST_CXX0X
506 && C_RID_CODE (token->u.value) <= RID_LAST_CXX0X)
508 /* Warn about the C++0x keyword (but still treat it as
510 warning (OPT_Wc__0x_compat,
511 "identifier %qE will become a keyword in C++0x",
514 /* Clear out the C_RID_CODE so we don't warn about this
515 particular identifier-turned-keyword again. */
516 C_SET_RID_CODE (token->u.value, RID_MAX);
519 token->ambiguous_p = false;
520 token->keyword = RID_MAX;
523 else if (token->type == CPP_AT_NAME)
525 /* This only happens in Objective-C++; it must be a keyword. */
526 token->type = CPP_KEYWORD;
527 switch (C_RID_CODE (token->u.value))
529 /* Replace 'class' with '@class', 'private' with '@private',
530 etc. This prevents confusion with the C++ keyword
531 'class', and makes the tokens consistent with other
532 Objective-C 'AT' keywords. For example '@class' is
533 reported as RID_AT_CLASS which is consistent with
534 '@synchronized', which is reported as
537 case RID_CLASS: token->keyword = RID_AT_CLASS; break;
538 case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
539 case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
540 case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
541 case RID_THROW: token->keyword = RID_AT_THROW; break;
542 case RID_TRY: token->keyword = RID_AT_TRY; break;
543 case RID_CATCH: token->keyword = RID_AT_CATCH; break;
544 default: token->keyword = C_RID_CODE (token->u.value);
547 else if (token->type == CPP_PRAGMA)
549 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
550 token->pragma_kind = ((enum pragma_kind)
551 TREE_INT_CST_LOW (token->u.value));
552 token->u.value = NULL_TREE;
556 /* Update the globals input_location and the input file stack from TOKEN. */
558 cp_lexer_set_source_position_from_token (cp_token *token)
560 if (token->type != CPP_EOF)
562 input_location = token->location;
566 /* Return a pointer to the next token in the token stream, but do not
569 static inline cp_token *
570 cp_lexer_peek_token (cp_lexer *lexer)
572 if (cp_lexer_debugging_p (lexer))
574 fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
575 cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
576 putc ('\n', cp_lexer_debug_stream);
578 return lexer->next_token;
581 /* Return true if the next token has the indicated TYPE. */
584 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
586 return cp_lexer_peek_token (lexer)->type == type;
589 /* Return true if the next token does not have the indicated TYPE. */
592 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
594 return !cp_lexer_next_token_is (lexer, type);
597 /* Return true if the next token is the indicated KEYWORD. */
600 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
602 return cp_lexer_peek_token (lexer)->keyword == keyword;
605 /* Return true if the next token is not the indicated KEYWORD. */
608 cp_lexer_next_token_is_not_keyword (cp_lexer* lexer, enum rid keyword)
610 return cp_lexer_peek_token (lexer)->keyword != keyword;
613 /* Return true if the next token is a keyword for a decl-specifier. */
616 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
620 token = cp_lexer_peek_token (lexer);
621 switch (token->keyword)
623 /* auto specifier: storage-class-specifier in C++,
624 simple-type-specifier in C++0x. */
626 /* Storage classes. */
632 /* Elaborated type specifiers. */
638 /* Simple type specifiers. */
653 /* GNU extensions. */
656 /* C++0x extensions. */
658 case RID_UNDERLYING_TYPE:
666 /* Return a pointer to the Nth token in the token stream. If N is 1,
667 then this is precisely equivalent to cp_lexer_peek_token (except
668 that it is not inline). One would like to disallow that case, but
669 there is one case (cp_parser_nth_token_starts_template_id) where
670 the caller passes a variable for N and it might be 1. */
673 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
677 /* N is 1-based, not zero-based. */
680 if (cp_lexer_debugging_p (lexer))
681 fprintf (cp_lexer_debug_stream,
682 "cp_lexer: peeking ahead %ld at token: ", (long)n);
685 token = lexer->next_token;
686 gcc_assert (!n || token != &eof_token);
690 if (token == lexer->last_token)
696 if (!token->purged_p)
700 if (cp_lexer_debugging_p (lexer))
702 cp_lexer_print_token (cp_lexer_debug_stream, token);
703 putc ('\n', cp_lexer_debug_stream);
709 /* Return the next token, and advance the lexer's next_token pointer
710 to point to the next non-purged token. */
713 cp_lexer_consume_token (cp_lexer* lexer)
715 cp_token *token = lexer->next_token;
717 gcc_assert (token != &eof_token);
718 gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
723 if (lexer->next_token == lexer->last_token)
725 lexer->next_token = &eof_token;
730 while (lexer->next_token->purged_p);
732 cp_lexer_set_source_position_from_token (token);
734 /* Provide debugging output. */
735 if (cp_lexer_debugging_p (lexer))
737 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
738 cp_lexer_print_token (cp_lexer_debug_stream, token);
739 putc ('\n', cp_lexer_debug_stream);
745 /* Permanently remove the next token from the token stream, and
746 advance the next_token pointer to refer to the next non-purged
750 cp_lexer_purge_token (cp_lexer *lexer)
752 cp_token *tok = lexer->next_token;
754 gcc_assert (tok != &eof_token);
755 tok->purged_p = true;
756 tok->location = UNKNOWN_LOCATION;
757 tok->u.value = NULL_TREE;
758 tok->keyword = RID_MAX;
763 if (tok == lexer->last_token)
769 while (tok->purged_p);
770 lexer->next_token = tok;
773 /* Permanently remove all tokens after TOK, up to, but not
774 including, the token that will be returned next by
775 cp_lexer_peek_token. */
778 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
780 cp_token *peek = lexer->next_token;
782 if (peek == &eof_token)
783 peek = lexer->last_token;
785 gcc_assert (tok < peek);
787 for ( tok += 1; tok != peek; tok += 1)
789 tok->purged_p = true;
790 tok->location = UNKNOWN_LOCATION;
791 tok->u.value = NULL_TREE;
792 tok->keyword = RID_MAX;
796 /* Begin saving tokens. All tokens consumed after this point will be
800 cp_lexer_save_tokens (cp_lexer* lexer)
802 /* Provide debugging output. */
803 if (cp_lexer_debugging_p (lexer))
804 fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
806 VEC_safe_push (cp_token_position, heap,
807 lexer->saved_tokens, lexer->next_token);
810 /* Commit to the portion of the token stream most recently saved. */
813 cp_lexer_commit_tokens (cp_lexer* lexer)
815 /* Provide debugging output. */
816 if (cp_lexer_debugging_p (lexer))
817 fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
819 VEC_pop (cp_token_position, lexer->saved_tokens);
822 /* Return all tokens saved since the last call to cp_lexer_save_tokens
823 to the token stream. Stop saving tokens. */
826 cp_lexer_rollback_tokens (cp_lexer* lexer)
828 /* Provide debugging output. */
829 if (cp_lexer_debugging_p (lexer))
830 fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
832 lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
835 /* Print a representation of the TOKEN on the STREAM. */
837 #ifdef ENABLE_CHECKING
840 cp_lexer_print_token (FILE * stream, cp_token *token)
842 /* We don't use cpp_type2name here because the parser defines
843 a few tokens of its own. */
844 static const char *const token_names[] = {
845 /* cpplib-defined token types */
851 /* C++ parser token types - see "Manifest constants", above. */
854 "NESTED_NAME_SPECIFIER",
857 /* For some tokens, print the associated data. */
861 /* Some keywords have a value that is not an IDENTIFIER_NODE.
862 For example, `struct' is mapped to an INTEGER_CST. */
863 if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
865 /* else fall through */
867 fputs (IDENTIFIER_POINTER (token->u.value), stream);
875 fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
879 print_generic_expr (stream, token->u.value, 0);
883 /* If we have a name for the token, print it out. Otherwise, we
884 simply give the numeric code. */
885 if (token->type < ARRAY_SIZE(token_names))
886 fputs (token_names[token->type], stream);
888 fprintf (stream, "[%d]", token->type);
893 /* Start emitting debugging information. */
896 cp_lexer_start_debugging (cp_lexer* lexer)
898 lexer->debugging_p = true;
901 /* Stop emitting debugging information. */
904 cp_lexer_stop_debugging (cp_lexer* lexer)
906 lexer->debugging_p = false;
909 #endif /* ENABLE_CHECKING */
911 /* Create a new cp_token_cache, representing a range of tokens. */
913 static cp_token_cache *
914 cp_token_cache_new (cp_token *first, cp_token *last)
916 cp_token_cache *cache = ggc_alloc_cp_token_cache ();
917 cache->first = first;
923 /* Decl-specifiers. */
925 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
928 clear_decl_specs (cp_decl_specifier_seq *decl_specs)
930 memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
935 /* Nothing other than the parser should be creating declarators;
936 declarators are a semi-syntactic representation of C++ entities.
937 Other parts of the front end that need to create entities (like
938 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
940 static cp_declarator *make_call_declarator
941 (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, tree, tree);
942 static cp_declarator *make_array_declarator
943 (cp_declarator *, tree);
944 static cp_declarator *make_pointer_declarator
945 (cp_cv_quals, cp_declarator *);
946 static cp_declarator *make_reference_declarator
947 (cp_cv_quals, cp_declarator *, bool);
948 static cp_parameter_declarator *make_parameter_declarator
949 (cp_decl_specifier_seq *, cp_declarator *, tree);
950 static cp_declarator *make_ptrmem_declarator
951 (cp_cv_quals, tree, cp_declarator *);
953 /* An erroneous declarator. */
954 static cp_declarator *cp_error_declarator;
956 /* The obstack on which declarators and related data structures are
958 static struct obstack declarator_obstack;
960 /* Alloc BYTES from the declarator memory pool. */
963 alloc_declarator (size_t bytes)
965 return obstack_alloc (&declarator_obstack, bytes);
968 /* Allocate a declarator of the indicated KIND. Clear fields that are
969 common to all declarators. */
971 static cp_declarator *
972 make_declarator (cp_declarator_kind kind)
974 cp_declarator *declarator;
976 declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
977 declarator->kind = kind;
978 declarator->attributes = NULL_TREE;
979 declarator->declarator = NULL;
980 declarator->parameter_pack_p = false;
981 declarator->id_loc = UNKNOWN_LOCATION;
986 /* Make a declarator for a generalized identifier. If
987 QUALIFYING_SCOPE is non-NULL, the identifier is
988 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
989 UNQUALIFIED_NAME. SFK indicates the kind of special function this
992 static cp_declarator *
993 make_id_declarator (tree qualifying_scope, tree unqualified_name,
994 special_function_kind sfk)
996 cp_declarator *declarator;
998 /* It is valid to write:
1000 class C { void f(); };
1004 The standard is not clear about whether `typedef const C D' is
1005 legal; as of 2002-09-15 the committee is considering that
1006 question. EDG 3.0 allows that syntax. Therefore, we do as
1008 if (qualifying_scope && TYPE_P (qualifying_scope))
1009 qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
1011 gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
1012 || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
1013 || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
1015 declarator = make_declarator (cdk_id);
1016 declarator->u.id.qualifying_scope = qualifying_scope;
1017 declarator->u.id.unqualified_name = unqualified_name;
1018 declarator->u.id.sfk = sfk;
1023 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1024 of modifiers such as const or volatile to apply to the pointer
1025 type, represented as identifiers. */
1028 make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
1030 cp_declarator *declarator;
1032 declarator = make_declarator (cdk_pointer);
1033 declarator->declarator = target;
1034 declarator->u.pointer.qualifiers = cv_qualifiers;
1035 declarator->u.pointer.class_type = NULL_TREE;
1038 declarator->id_loc = target->id_loc;
1039 declarator->parameter_pack_p = target->parameter_pack_p;
1040 target->parameter_pack_p = false;
1043 declarator->parameter_pack_p = false;
1048 /* Like make_pointer_declarator -- but for references. */
1051 make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1054 cp_declarator *declarator;
1056 declarator = make_declarator (cdk_reference);
1057 declarator->declarator = target;
1058 declarator->u.reference.qualifiers = cv_qualifiers;
1059 declarator->u.reference.rvalue_ref = rvalue_ref;
1062 declarator->id_loc = target->id_loc;
1063 declarator->parameter_pack_p = target->parameter_pack_p;
1064 target->parameter_pack_p = false;
1067 declarator->parameter_pack_p = false;
1072 /* Like make_pointer_declarator -- but for a pointer to a non-static
1073 member of CLASS_TYPE. */
1076 make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
1077 cp_declarator *pointee)
1079 cp_declarator *declarator;
1081 declarator = make_declarator (cdk_ptrmem);
1082 declarator->declarator = pointee;
1083 declarator->u.pointer.qualifiers = cv_qualifiers;
1084 declarator->u.pointer.class_type = class_type;
1088 declarator->parameter_pack_p = pointee->parameter_pack_p;
1089 pointee->parameter_pack_p = false;
1092 declarator->parameter_pack_p = false;
1097 /* Make a declarator for the function given by TARGET, with the
1098 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1099 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1100 indicates what exceptions can be thrown. */
1103 make_call_declarator (cp_declarator *target,
1105 cp_cv_quals cv_qualifiers,
1106 cp_virt_specifiers virt_specifiers,
1107 tree exception_specification,
1108 tree late_return_type)
1110 cp_declarator *declarator;
1112 declarator = make_declarator (cdk_function);
1113 declarator->declarator = target;
1114 declarator->u.function.parameters = parms;
1115 declarator->u.function.qualifiers = cv_qualifiers;
1116 declarator->u.function.virt_specifiers = virt_specifiers;
1117 declarator->u.function.exception_specification = exception_specification;
1118 declarator->u.function.late_return_type = late_return_type;
1121 declarator->id_loc = target->id_loc;
1122 declarator->parameter_pack_p = target->parameter_pack_p;
1123 target->parameter_pack_p = false;
1126 declarator->parameter_pack_p = false;
1131 /* Make a declarator for an array of BOUNDS elements, each of which is
1132 defined by ELEMENT. */
1135 make_array_declarator (cp_declarator *element, tree bounds)
1137 cp_declarator *declarator;
1139 declarator = make_declarator (cdk_array);
1140 declarator->declarator = element;
1141 declarator->u.array.bounds = bounds;
1144 declarator->id_loc = element->id_loc;
1145 declarator->parameter_pack_p = element->parameter_pack_p;
1146 element->parameter_pack_p = false;
1149 declarator->parameter_pack_p = false;
1154 /* Determine whether the declarator we've seen so far can be a
1155 parameter pack, when followed by an ellipsis. */
1157 declarator_can_be_parameter_pack (cp_declarator *declarator)
1159 /* Search for a declarator name, or any other declarator that goes
1160 after the point where the ellipsis could appear in a parameter
1161 pack. If we find any of these, then this declarator can not be
1162 made into a parameter pack. */
1164 while (declarator && !found)
1166 switch ((int)declarator->kind)
1177 declarator = declarator->declarator;
1185 cp_parameter_declarator *no_parameters;
1187 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1188 DECLARATOR and DEFAULT_ARGUMENT. */
1190 cp_parameter_declarator *
1191 make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1192 cp_declarator *declarator,
1193 tree default_argument)
1195 cp_parameter_declarator *parameter;
1197 parameter = ((cp_parameter_declarator *)
1198 alloc_declarator (sizeof (cp_parameter_declarator)));
1199 parameter->next = NULL;
1200 if (decl_specifiers)
1201 parameter->decl_specifiers = *decl_specifiers;
1203 clear_decl_specs (¶meter->decl_specifiers);
1204 parameter->declarator = declarator;
1205 parameter->default_argument = default_argument;
1206 parameter->ellipsis_p = false;
1211 /* Returns true iff DECLARATOR is a declaration for a function. */
1214 function_declarator_p (const cp_declarator *declarator)
1218 if (declarator->kind == cdk_function
1219 && declarator->declarator->kind == cdk_id)
1221 if (declarator->kind == cdk_id
1222 || declarator->kind == cdk_error)
1224 declarator = declarator->declarator;
1234 A cp_parser parses the token stream as specified by the C++
1235 grammar. Its job is purely parsing, not semantic analysis. For
1236 example, the parser breaks the token stream into declarators,
1237 expressions, statements, and other similar syntactic constructs.
1238 It does not check that the types of the expressions on either side
1239 of an assignment-statement are compatible, or that a function is
1240 not declared with a parameter of type `void'.
1242 The parser invokes routines elsewhere in the compiler to perform
1243 semantic analysis and to build up the abstract syntax tree for the
1246 The parser (and the template instantiation code, which is, in a
1247 way, a close relative of parsing) are the only parts of the
1248 compiler that should be calling push_scope and pop_scope, or
1249 related functions. The parser (and template instantiation code)
1250 keeps track of what scope is presently active; everything else
1251 should simply honor that. (The code that generates static
1252 initializers may also need to set the scope, in order to check
1253 access control correctly when emitting the initializers.)
1258 The parser is of the standard recursive-descent variety. Upcoming
1259 tokens in the token stream are examined in order to determine which
1260 production to use when parsing a non-terminal. Some C++ constructs
1261 require arbitrary look ahead to disambiguate. For example, it is
1262 impossible, in the general case, to tell whether a statement is an
1263 expression or declaration without scanning the entire statement.
1264 Therefore, the parser is capable of "parsing tentatively." When the
1265 parser is not sure what construct comes next, it enters this mode.
1266 Then, while we attempt to parse the construct, the parser queues up
1267 error messages, rather than issuing them immediately, and saves the
1268 tokens it consumes. If the construct is parsed successfully, the
1269 parser "commits", i.e., it issues any queued error messages and
1270 the tokens that were being preserved are permanently discarded.
1271 If, however, the construct is not parsed successfully, the parser
1272 rolls back its state completely so that it can resume parsing using
1273 a different alternative.
1278 The performance of the parser could probably be improved substantially.
1279 We could often eliminate the need to parse tentatively by looking ahead
1280 a little bit. In some places, this approach might not entirely eliminate
1281 the need to parse tentatively, but it might still speed up the average
1284 /* Flags that are passed to some parsing functions. These values can
1285 be bitwise-ored together. */
1290 CP_PARSER_FLAGS_NONE = 0x0,
1291 /* The construct is optional. If it is not present, then no error
1292 should be issued. */
1293 CP_PARSER_FLAGS_OPTIONAL = 0x1,
1294 /* When parsing a type-specifier, treat user-defined type-names
1295 as non-type identifiers. */
1296 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
1297 /* When parsing a type-specifier, do not try to parse a class-specifier
1298 or enum-specifier. */
1299 CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
1300 /* When parsing a decl-specifier-seq, only allow type-specifier or
1302 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8
1305 /* This type is used for parameters and variables which hold
1306 combinations of the above flags. */
1307 typedef int cp_parser_flags;
1309 /* The different kinds of declarators we want to parse. */
1311 typedef enum cp_parser_declarator_kind
1313 /* We want an abstract declarator. */
1314 CP_PARSER_DECLARATOR_ABSTRACT,
1315 /* We want a named declarator. */
1316 CP_PARSER_DECLARATOR_NAMED,
1317 /* We don't mind, but the name must be an unqualified-id. */
1318 CP_PARSER_DECLARATOR_EITHER
1319 } cp_parser_declarator_kind;
1321 /* The precedence values used to parse binary expressions. The minimum value
1322 of PREC must be 1, because zero is reserved to quickly discriminate
1323 binary operators from other tokens. */
1328 PREC_LOGICAL_OR_EXPRESSION,
1329 PREC_LOGICAL_AND_EXPRESSION,
1330 PREC_INCLUSIVE_OR_EXPRESSION,
1331 PREC_EXCLUSIVE_OR_EXPRESSION,
1332 PREC_AND_EXPRESSION,
1333 PREC_EQUALITY_EXPRESSION,
1334 PREC_RELATIONAL_EXPRESSION,
1335 PREC_SHIFT_EXPRESSION,
1336 PREC_ADDITIVE_EXPRESSION,
1337 PREC_MULTIPLICATIVE_EXPRESSION,
1339 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1342 /* A mapping from a token type to a corresponding tree node type, with a
1343 precedence value. */
1345 typedef struct cp_parser_binary_operations_map_node
1347 /* The token type. */
1348 enum cpp_ttype token_type;
1349 /* The corresponding tree code. */
1350 enum tree_code tree_type;
1351 /* The precedence of this operator. */
1352 enum cp_parser_prec prec;
1353 } cp_parser_binary_operations_map_node;
1355 typedef struct cp_parser_expression_stack_entry
1357 /* Left hand side of the binary operation we are currently
1360 /* Original tree code for left hand side, if it was a binary
1361 expression itself (used for -Wparentheses). */
1362 enum tree_code lhs_type;
1363 /* Tree code for the binary operation we are parsing. */
1364 enum tree_code tree_type;
1365 /* Precedence of the binary operation we are parsing. */
1366 enum cp_parser_prec prec;
1367 } cp_parser_expression_stack_entry;
1369 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1370 entries because precedence levels on the stack are monotonically
1372 typedef struct cp_parser_expression_stack_entry
1373 cp_parser_expression_stack[NUM_PREC_VALUES];
1377 /* Constructors and destructors. */
1379 static cp_parser_context *cp_parser_context_new
1380 (cp_parser_context *);
1382 /* Class variables. */
1384 static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
1386 /* The operator-precedence table used by cp_parser_binary_expression.
1387 Transformed into an associative array (binops_by_token) by
1390 static const cp_parser_binary_operations_map_node binops[] = {
1391 { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
1392 { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
1394 { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1395 { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1396 { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1398 { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1399 { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1401 { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1402 { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1404 { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
1405 { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
1406 { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
1407 { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
1409 { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
1410 { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
1412 { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
1414 { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
1416 { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
1418 { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
1420 { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1423 /* The same as binops, but initialized by cp_parser_new so that
1424 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1426 static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
1428 /* Constructors and destructors. */
1430 /* Construct a new context. The context below this one on the stack
1431 is given by NEXT. */
1433 static cp_parser_context *
1434 cp_parser_context_new (cp_parser_context* next)
1436 cp_parser_context *context;
1438 /* Allocate the storage. */
1439 if (cp_parser_context_free_list != NULL)
1441 /* Pull the first entry from the free list. */
1442 context = cp_parser_context_free_list;
1443 cp_parser_context_free_list = context->next;
1444 memset (context, 0, sizeof (*context));
1447 context = ggc_alloc_cleared_cp_parser_context ();
1449 /* No errors have occurred yet in this context. */
1450 context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
1451 /* If this is not the bottommost context, copy information that we
1452 need from the previous context. */
1455 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1456 expression, then we are parsing one in this context, too. */
1457 context->object_type = next->object_type;
1458 /* Thread the stack. */
1459 context->next = next;
1465 /* Managing the unparsed function queues. */
1467 #define unparsed_funs_with_default_args \
1468 VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_default_args
1469 #define unparsed_funs_with_definitions \
1470 VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_definitions
1473 push_unparsed_function_queues (cp_parser *parser)
1475 VEC_safe_push (cp_unparsed_functions_entry, gc,
1476 parser->unparsed_queues, NULL);
1477 unparsed_funs_with_default_args = NULL;
1478 unparsed_funs_with_definitions = make_tree_vector ();
1482 pop_unparsed_function_queues (cp_parser *parser)
1484 release_tree_vector (unparsed_funs_with_definitions);
1485 VEC_pop (cp_unparsed_functions_entry, parser->unparsed_queues);
1490 /* Constructors and destructors. */
1492 static cp_parser *cp_parser_new
1495 /* Routines to parse various constructs.
1497 Those that return `tree' will return the error_mark_node (rather
1498 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1499 Sometimes, they will return an ordinary node if error-recovery was
1500 attempted, even though a parse error occurred. So, to check
1501 whether or not a parse error occurred, you should always use
1502 cp_parser_error_occurred. If the construct is optional (indicated
1503 either by an `_opt' in the name of the function that does the
1504 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1505 the construct is not present. */
1507 /* Lexical conventions [gram.lex] */
1509 static tree cp_parser_identifier
1511 static tree cp_parser_string_literal
1512 (cp_parser *, bool, bool);
1514 /* Basic concepts [gram.basic] */
1516 static bool cp_parser_translation_unit
1519 /* Expressions [gram.expr] */
1521 static tree cp_parser_primary_expression
1522 (cp_parser *, bool, bool, bool, cp_id_kind *);
1523 static tree cp_parser_id_expression
1524 (cp_parser *, bool, bool, bool *, bool, bool);
1525 static tree cp_parser_unqualified_id
1526 (cp_parser *, bool, bool, bool, bool);
1527 static tree cp_parser_nested_name_specifier_opt
1528 (cp_parser *, bool, bool, bool, bool);
1529 static tree cp_parser_nested_name_specifier
1530 (cp_parser *, bool, bool, bool, bool);
1531 static tree cp_parser_qualifying_entity
1532 (cp_parser *, bool, bool, bool, bool, bool);
1533 static tree cp_parser_postfix_expression
1534 (cp_parser *, bool, bool, bool, cp_id_kind *);
1535 static tree cp_parser_postfix_open_square_expression
1536 (cp_parser *, tree, bool);
1537 static tree cp_parser_postfix_dot_deref_expression
1538 (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *, location_t);
1539 static VEC(tree,gc) *cp_parser_parenthesized_expression_list
1540 (cp_parser *, int, bool, bool, bool *);
1541 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1542 enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
1543 static void cp_parser_pseudo_destructor_name
1544 (cp_parser *, tree *, tree *);
1545 static tree cp_parser_unary_expression
1546 (cp_parser *, bool, bool, cp_id_kind *);
1547 static enum tree_code cp_parser_unary_operator
1549 static tree cp_parser_new_expression
1551 static VEC(tree,gc) *cp_parser_new_placement
1553 static tree cp_parser_new_type_id
1554 (cp_parser *, tree *);
1555 static cp_declarator *cp_parser_new_declarator_opt
1557 static cp_declarator *cp_parser_direct_new_declarator
1559 static VEC(tree,gc) *cp_parser_new_initializer
1561 static tree cp_parser_delete_expression
1563 static tree cp_parser_cast_expression
1564 (cp_parser *, bool, bool, cp_id_kind *);
1565 static tree cp_parser_binary_expression
1566 (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
1567 static tree cp_parser_question_colon_clause
1568 (cp_parser *, tree);
1569 static tree cp_parser_assignment_expression
1570 (cp_parser *, bool, cp_id_kind *);
1571 static enum tree_code cp_parser_assignment_operator_opt
1573 static tree cp_parser_expression
1574 (cp_parser *, bool, cp_id_kind *);
1575 static tree cp_parser_constant_expression
1576 (cp_parser *, bool, bool *);
1577 static tree cp_parser_builtin_offsetof
1579 static tree cp_parser_lambda_expression
1581 static void cp_parser_lambda_introducer
1582 (cp_parser *, tree);
1583 static void cp_parser_lambda_declarator_opt
1584 (cp_parser *, tree);
1585 static void cp_parser_lambda_body
1586 (cp_parser *, tree);
1588 /* Statements [gram.stmt.stmt] */
1590 static void cp_parser_statement
1591 (cp_parser *, tree, bool, bool *);
1592 static void cp_parser_label_for_labeled_statement
1594 static tree cp_parser_expression_statement
1595 (cp_parser *, tree);
1596 static tree cp_parser_compound_statement
1597 (cp_parser *, tree, bool, bool);
1598 static void cp_parser_statement_seq_opt
1599 (cp_parser *, tree);
1600 static tree cp_parser_selection_statement
1601 (cp_parser *, bool *);
1602 static tree cp_parser_condition
1604 static tree cp_parser_iteration_statement
1606 static bool cp_parser_for_init_statement
1607 (cp_parser *, tree *decl);
1608 static tree cp_parser_for
1610 static tree cp_parser_c_for
1611 (cp_parser *, tree, tree);
1612 static tree cp_parser_range_for
1613 (cp_parser *, tree, tree, tree);
1614 static tree cp_parser_perform_range_for_lookup
1615 (tree, tree *, tree *);
1616 static tree cp_parser_range_for_member_function
1618 static tree cp_parser_jump_statement
1620 static void cp_parser_declaration_statement
1623 static tree cp_parser_implicitly_scoped_statement
1624 (cp_parser *, bool *);
1625 static void cp_parser_already_scoped_statement
1628 /* Declarations [gram.dcl.dcl] */
1630 static void cp_parser_declaration_seq_opt
1632 static void cp_parser_declaration
1634 static void cp_parser_block_declaration
1635 (cp_parser *, bool);
1636 static void cp_parser_simple_declaration
1637 (cp_parser *, bool, tree *);
1638 static void cp_parser_decl_specifier_seq
1639 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
1640 static tree cp_parser_storage_class_specifier_opt
1642 static tree cp_parser_function_specifier_opt
1643 (cp_parser *, cp_decl_specifier_seq *);
1644 static tree cp_parser_type_specifier
1645 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
1647 static tree cp_parser_simple_type_specifier
1648 (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
1649 static tree cp_parser_type_name
1651 static tree cp_parser_nonclass_name
1652 (cp_parser* parser);
1653 static tree cp_parser_elaborated_type_specifier
1654 (cp_parser *, bool, bool);
1655 static tree cp_parser_enum_specifier
1657 static void cp_parser_enumerator_list
1658 (cp_parser *, tree);
1659 static void cp_parser_enumerator_definition
1660 (cp_parser *, tree);
1661 static tree cp_parser_namespace_name
1663 static void cp_parser_namespace_definition
1665 static void cp_parser_namespace_body
1667 static tree cp_parser_qualified_namespace_specifier
1669 static void cp_parser_namespace_alias_definition
1671 static bool cp_parser_using_declaration
1672 (cp_parser *, bool);
1673 static void cp_parser_using_directive
1675 static void cp_parser_asm_definition
1677 static void cp_parser_linkage_specification
1679 static void cp_parser_static_assert
1680 (cp_parser *, bool);
1681 static tree cp_parser_decltype
1684 /* Declarators [gram.dcl.decl] */
1686 static tree cp_parser_init_declarator
1687 (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *, tree *);
1688 static cp_declarator *cp_parser_declarator
1689 (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
1690 static cp_declarator *cp_parser_direct_declarator
1691 (cp_parser *, cp_parser_declarator_kind, int *, bool);
1692 static enum tree_code cp_parser_ptr_operator
1693 (cp_parser *, tree *, cp_cv_quals *);
1694 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1696 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
1698 static tree cp_parser_late_return_type_opt
1700 static tree cp_parser_declarator_id
1701 (cp_parser *, bool);
1702 static tree cp_parser_type_id
1704 static tree cp_parser_template_type_arg
1706 static tree cp_parser_trailing_type_id (cp_parser *);
1707 static tree cp_parser_type_id_1
1708 (cp_parser *, bool, bool);
1709 static void cp_parser_type_specifier_seq
1710 (cp_parser *, bool, bool, cp_decl_specifier_seq *);
1711 static tree cp_parser_parameter_declaration_clause
1713 static tree cp_parser_parameter_declaration_list
1714 (cp_parser *, bool *);
1715 static cp_parameter_declarator *cp_parser_parameter_declaration
1716 (cp_parser *, bool, bool *);
1717 static tree cp_parser_default_argument
1718 (cp_parser *, bool);
1719 static void cp_parser_function_body
1721 static tree cp_parser_initializer
1722 (cp_parser *, bool *, bool *);
1723 static tree cp_parser_initializer_clause
1724 (cp_parser *, bool *);
1725 static tree cp_parser_braced_list
1726 (cp_parser*, bool*);
1727 static VEC(constructor_elt,gc) *cp_parser_initializer_list
1728 (cp_parser *, bool *);
1730 static bool cp_parser_ctor_initializer_opt_and_function_body
1733 /* Classes [gram.class] */
1735 static tree cp_parser_class_name
1736 (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
1737 static tree cp_parser_class_specifier
1739 static tree cp_parser_class_head
1740 (cp_parser *, bool *, tree *, tree *);
1741 static enum tag_types cp_parser_class_key
1743 static void cp_parser_member_specification_opt
1745 static void cp_parser_member_declaration
1747 static tree cp_parser_pure_specifier
1749 static tree cp_parser_constant_initializer
1752 /* Derived classes [gram.class.derived] */
1754 static tree cp_parser_base_clause
1756 static tree cp_parser_base_specifier
1759 /* Special member functions [gram.special] */
1761 static tree cp_parser_conversion_function_id
1763 static tree cp_parser_conversion_type_id
1765 static cp_declarator *cp_parser_conversion_declarator_opt
1767 static bool cp_parser_ctor_initializer_opt
1769 static void cp_parser_mem_initializer_list
1771 static tree cp_parser_mem_initializer
1773 static tree cp_parser_mem_initializer_id
1776 /* Overloading [gram.over] */
1778 static tree cp_parser_operator_function_id
1780 static tree cp_parser_operator
1783 /* Templates [gram.temp] */
1785 static void cp_parser_template_declaration
1786 (cp_parser *, bool);
1787 static tree cp_parser_template_parameter_list
1789 static tree cp_parser_template_parameter
1790 (cp_parser *, bool *, bool *);
1791 static tree cp_parser_type_parameter
1792 (cp_parser *, bool *);
1793 static tree cp_parser_template_id
1794 (cp_parser *, bool, bool, bool);
1795 static tree cp_parser_template_name
1796 (cp_parser *, bool, bool, bool, bool *);
1797 static tree cp_parser_template_argument_list
1799 static tree cp_parser_template_argument
1801 static void cp_parser_explicit_instantiation
1803 static void cp_parser_explicit_specialization
1806 /* Exception handling [gram.exception] */
1808 static tree cp_parser_try_block
1810 static bool cp_parser_function_try_block
1812 static void cp_parser_handler_seq
1814 static void cp_parser_handler
1816 static tree cp_parser_exception_declaration
1818 static tree cp_parser_throw_expression
1820 static tree cp_parser_exception_specification_opt
1822 static tree cp_parser_type_id_list
1825 /* GNU Extensions */
1827 static tree cp_parser_asm_specification_opt
1829 static tree cp_parser_asm_operand_list
1831 static tree cp_parser_asm_clobber_list
1833 static tree cp_parser_asm_label_list
1835 static tree cp_parser_attributes_opt
1837 static tree cp_parser_attribute_list
1839 static bool cp_parser_extension_opt
1840 (cp_parser *, int *);
1841 static void cp_parser_label_declaration
1844 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1845 static bool cp_parser_pragma
1846 (cp_parser *, enum pragma_context);
1848 /* Objective-C++ Productions */
1850 static tree cp_parser_objc_message_receiver
1852 static tree cp_parser_objc_message_args
1854 static tree cp_parser_objc_message_expression
1856 static tree cp_parser_objc_encode_expression
1858 static tree cp_parser_objc_defs_expression
1860 static tree cp_parser_objc_protocol_expression
1862 static tree cp_parser_objc_selector_expression
1864 static tree cp_parser_objc_expression
1866 static bool cp_parser_objc_selector_p
1868 static tree cp_parser_objc_selector
1870 static tree cp_parser_objc_protocol_refs_opt
1872 static void cp_parser_objc_declaration
1873 (cp_parser *, tree);
1874 static tree cp_parser_objc_statement
1876 static bool cp_parser_objc_valid_prefix_attributes
1877 (cp_parser *, tree *);
1878 static void cp_parser_objc_at_property_declaration
1880 static void cp_parser_objc_at_synthesize_declaration
1882 static void cp_parser_objc_at_dynamic_declaration
1884 static tree cp_parser_objc_struct_declaration
1887 /* Utility Routines */
1889 static tree cp_parser_lookup_name
1890 (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *, location_t);
1891 static tree cp_parser_lookup_name_simple
1892 (cp_parser *, tree, location_t);
1893 static tree cp_parser_maybe_treat_template_as_class
1895 static bool cp_parser_check_declarator_template_parameters
1896 (cp_parser *, cp_declarator *, location_t);
1897 static bool cp_parser_check_template_parameters
1898 (cp_parser *, unsigned, location_t, cp_declarator *);
1899 static tree cp_parser_simple_cast_expression
1901 static tree cp_parser_global_scope_opt
1902 (cp_parser *, bool);
1903 static bool cp_parser_constructor_declarator_p
1904 (cp_parser *, bool);
1905 static tree cp_parser_function_definition_from_specifiers_and_declarator
1906 (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
1907 static tree cp_parser_function_definition_after_declarator
1908 (cp_parser *, bool);
1909 static void cp_parser_template_declaration_after_export
1910 (cp_parser *, bool);
1911 static void cp_parser_perform_template_parameter_access_checks
1912 (VEC (deferred_access_check,gc)*);
1913 static tree cp_parser_single_declaration
1914 (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool, bool *);
1915 static tree cp_parser_functional_cast
1916 (cp_parser *, tree);
1917 static tree cp_parser_save_member_function_body
1918 (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
1919 static tree cp_parser_enclosed_template_argument_list
1921 static void cp_parser_save_default_args
1922 (cp_parser *, tree);
1923 static void cp_parser_late_parsing_for_member
1924 (cp_parser *, tree);
1925 static void cp_parser_late_parsing_default_args
1926 (cp_parser *, tree);
1927 static tree cp_parser_sizeof_operand
1928 (cp_parser *, enum rid);
1929 static tree cp_parser_trait_expr
1930 (cp_parser *, enum rid);
1931 static bool cp_parser_declares_only_class_p
1933 static void cp_parser_set_storage_class
1934 (cp_parser *, cp_decl_specifier_seq *, enum rid, location_t);
1935 static void cp_parser_set_decl_spec_type
1936 (cp_decl_specifier_seq *, tree, location_t, bool);
1937 static bool cp_parser_friend_p
1938 (const cp_decl_specifier_seq *);
1939 static void cp_parser_required_error
1940 (cp_parser *, required_token, bool);
1941 static cp_token *cp_parser_require
1942 (cp_parser *, enum cpp_ttype, required_token);
1943 static cp_token *cp_parser_require_keyword
1944 (cp_parser *, enum rid, required_token);
1945 static bool cp_parser_token_starts_function_definition_p
1947 static bool cp_parser_next_token_starts_class_definition_p
1949 static bool cp_parser_next_token_ends_template_argument_p
1951 static bool cp_parser_nth_token_starts_template_argument_list_p
1952 (cp_parser *, size_t);
1953 static enum tag_types cp_parser_token_is_class_key
1955 static void cp_parser_check_class_key
1956 (enum tag_types, tree type);
1957 static void cp_parser_check_access_in_redeclaration
1958 (tree type, location_t location);
1959 static bool cp_parser_optional_template_keyword
1961 static void cp_parser_pre_parsed_nested_name_specifier
1963 static bool cp_parser_cache_group
1964 (cp_parser *, enum cpp_ttype, unsigned);
1965 static void cp_parser_parse_tentatively
1967 static void cp_parser_commit_to_tentative_parse
1969 static void cp_parser_abort_tentative_parse
1971 static bool cp_parser_parse_definitely
1973 static inline bool cp_parser_parsing_tentatively
1975 static bool cp_parser_uncommitted_to_tentative_parse_p
1977 static void cp_parser_error
1978 (cp_parser *, const char *);
1979 static void cp_parser_name_lookup_error
1980 (cp_parser *, tree, tree, name_lookup_error, location_t);
1981 static bool cp_parser_simulate_error
1983 static bool cp_parser_check_type_definition
1985 static void cp_parser_check_for_definition_in_return_type
1986 (cp_declarator *, tree, location_t type_location);
1987 static void cp_parser_check_for_invalid_template_id
1988 (cp_parser *, tree, location_t location);
1989 static bool cp_parser_non_integral_constant_expression
1990 (cp_parser *, non_integral_constant);
1991 static void cp_parser_diagnose_invalid_type_name
1992 (cp_parser *, tree, tree, location_t);
1993 static bool cp_parser_parse_and_diagnose_invalid_type_name
1995 static int cp_parser_skip_to_closing_parenthesis
1996 (cp_parser *, bool, bool, bool);
1997 static void cp_parser_skip_to_end_of_statement
1999 static void cp_parser_consume_semicolon_at_end_of_statement
2001 static void cp_parser_skip_to_end_of_block_or_statement
2003 static bool cp_parser_skip_to_closing_brace
2005 static void cp_parser_skip_to_end_of_template_parameter_list
2007 static void cp_parser_skip_to_pragma_eol
2008 (cp_parser*, cp_token *);
2009 static bool cp_parser_error_occurred
2011 static bool cp_parser_allow_gnu_extensions_p
2013 static bool cp_parser_is_string_literal
2015 static bool cp_parser_is_keyword
2016 (cp_token *, enum rid);
2017 static tree cp_parser_make_typename_type
2018 (cp_parser *, tree, tree, location_t location);
2019 static cp_declarator * cp_parser_make_indirect_declarator
2020 (enum tree_code, tree, cp_cv_quals, cp_declarator *);
2022 /* Returns nonzero if we are parsing tentatively. */
2025 cp_parser_parsing_tentatively (cp_parser* parser)
2027 return parser->context->next != NULL;
2030 /* Returns nonzero if TOKEN is a string literal. */
2033 cp_parser_is_string_literal (cp_token* token)
2035 return (token->type == CPP_STRING ||
2036 token->type == CPP_STRING16 ||
2037 token->type == CPP_STRING32 ||
2038 token->type == CPP_WSTRING ||
2039 token->type == CPP_UTF8STRING);
2042 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2045 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2047 return token->keyword == keyword;
2050 /* If not parsing tentatively, issue a diagnostic of the form
2051 FILE:LINE: MESSAGE before TOKEN
2052 where TOKEN is the next token in the input stream. MESSAGE
2053 (specified by the caller) is usually of the form "expected
2057 cp_parser_error (cp_parser* parser, const char* gmsgid)
2059 if (!cp_parser_simulate_error (parser))
2061 cp_token *token = cp_lexer_peek_token (parser->lexer);
2062 /* This diagnostic makes more sense if it is tagged to the line
2063 of the token we just peeked at. */
2064 cp_lexer_set_source_position_from_token (token);
2066 if (token->type == CPP_PRAGMA)
2068 error_at (token->location,
2069 "%<#pragma%> is not allowed here");
2070 cp_parser_skip_to_pragma_eol (parser, token);
2074 c_parse_error (gmsgid,
2075 /* Because c_parser_error does not understand
2076 CPP_KEYWORD, keywords are treated like
2078 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2079 token->u.value, token->flags);
2083 /* Issue an error about name-lookup failing. NAME is the
2084 IDENTIFIER_NODE DECL is the result of
2085 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2086 the thing that we hoped to find. */
2089 cp_parser_name_lookup_error (cp_parser* parser,
2092 name_lookup_error desired,
2093 location_t location)
2095 /* If name lookup completely failed, tell the user that NAME was not
2097 if (decl == error_mark_node)
2099 if (parser->scope && parser->scope != global_namespace)
2100 error_at (location, "%<%E::%E%> has not been declared",
2101 parser->scope, name);
2102 else if (parser->scope == global_namespace)
2103 error_at (location, "%<::%E%> has not been declared", name);
2104 else if (parser->object_scope
2105 && !CLASS_TYPE_P (parser->object_scope))
2106 error_at (location, "request for member %qE in non-class type %qT",
2107 name, parser->object_scope);
2108 else if (parser->object_scope)
2109 error_at (location, "%<%T::%E%> has not been declared",
2110 parser->object_scope, name);
2112 error_at (location, "%qE has not been declared", name);
2114 else if (parser->scope && parser->scope != global_namespace)
2119 error_at (location, "%<%E::%E%> is not a type",
2120 parser->scope, name);
2123 error_at (location, "%<%E::%E%> is not a class or namespace",
2124 parser->scope, name);
2128 "%<%E::%E%> is not a class, namespace, or enumeration",
2129 parser->scope, name);
2136 else if (parser->scope == global_namespace)
2141 error_at (location, "%<::%E%> is not a type", name);
2144 error_at (location, "%<::%E%> is not a class or namespace", name);
2148 "%<::%E%> is not a class, namespace, or enumeration",
2160 error_at (location, "%qE is not a type", name);
2163 error_at (location, "%qE is not a class or namespace", name);
2167 "%qE is not a class, namespace, or enumeration", name);
2175 /* If we are parsing tentatively, remember that an error has occurred
2176 during this tentative parse. Returns true if the error was
2177 simulated; false if a message should be issued by the caller. */
2180 cp_parser_simulate_error (cp_parser* parser)
2182 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2184 parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2190 /* Check for repeated decl-specifiers. */
2193 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs,
2194 location_t location)
2198 for (ds = ds_first; ds != ds_last; ++ds)
2200 unsigned count = decl_specs->specs[ds];
2203 /* The "long" specifier is a special case because of "long long". */
2207 error_at (location, "%<long long long%> is too long for GCC");
2209 pedwarn_cxx98 (location, OPT_Wlong_long,
2210 "ISO C++ 1998 does not support %<long long%>");
2214 static const char *const decl_spec_names[] = {
2231 error_at (location, "duplicate %qs", decl_spec_names[ds]);
2236 /* This function is called when a type is defined. If type
2237 definitions are forbidden at this point, an error message is
2241 cp_parser_check_type_definition (cp_parser* parser)
2243 /* If types are forbidden here, issue a message. */
2244 if (parser->type_definition_forbidden_message)
2246 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2247 in the message need to be interpreted. */
2248 error (parser->type_definition_forbidden_message);
2254 /* This function is called when the DECLARATOR is processed. The TYPE
2255 was a type defined in the decl-specifiers. If it is invalid to
2256 define a type in the decl-specifiers for DECLARATOR, an error is
2257 issued. TYPE_LOCATION is the location of TYPE and is used
2258 for error reporting. */
2261 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2262 tree type, location_t type_location)
2264 /* [dcl.fct] forbids type definitions in return types.
2265 Unfortunately, it's not easy to know whether or not we are
2266 processing a return type until after the fact. */
2268 && (declarator->kind == cdk_pointer
2269 || declarator->kind == cdk_reference
2270 || declarator->kind == cdk_ptrmem))
2271 declarator = declarator->declarator;
2273 && declarator->kind == cdk_function)
2275 error_at (type_location,
2276 "new types may not be defined in a return type");
2277 inform (type_location,
2278 "(perhaps a semicolon is missing after the definition of %qT)",
2283 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2284 "<" in any valid C++ program. If the next token is indeed "<",
2285 issue a message warning the user about what appears to be an
2286 invalid attempt to form a template-id. LOCATION is the location
2287 of the type-specifier (TYPE) */
2290 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2291 tree type, location_t location)
2293 cp_token_position start = 0;
2295 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2298 error_at (location, "%qT is not a template", type);
2299 else if (TREE_CODE (type) == IDENTIFIER_NODE)
2300 error_at (location, "%qE is not a template", type);
2302 error_at (location, "invalid template-id");
2303 /* Remember the location of the invalid "<". */
2304 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2305 start = cp_lexer_token_position (parser->lexer, true);
2306 /* Consume the "<". */
2307 cp_lexer_consume_token (parser->lexer);
2308 /* Parse the template arguments. */
2309 cp_parser_enclosed_template_argument_list (parser);
2310 /* Permanently remove the invalid template arguments so that
2311 this error message is not issued again. */
2313 cp_lexer_purge_tokens_after (parser->lexer, start);
2317 /* If parsing an integral constant-expression, issue an error message
2318 about the fact that THING appeared and return true. Otherwise,
2319 return false. In either case, set
2320 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2323 cp_parser_non_integral_constant_expression (cp_parser *parser,
2324 non_integral_constant thing)
2326 parser->non_integral_constant_expression_p = true;
2327 if (parser->integral_constant_expression_p)
2329 if (!parser->allow_non_integral_constant_expression_p)
2331 const char *msg = NULL;
2335 error ("floating-point literal "
2336 "cannot appear in a constant-expression");
2339 error ("a cast to a type other than an integral or "
2340 "enumeration type cannot appear in a "
2341 "constant-expression");
2344 error ("%<typeid%> operator "
2345 "cannot appear in a constant-expression");
2348 error ("non-constant compound literals "
2349 "cannot appear in a constant-expression");
2352 error ("a function call "
2353 "cannot appear in a constant-expression");
2356 error ("an increment "
2357 "cannot appear in a constant-expression");
2360 error ("an decrement "
2361 "cannot appear in a constant-expression");
2364 error ("an array reference "
2365 "cannot appear in a constant-expression");
2367 case NIC_ADDR_LABEL:
2368 error ("the address of a label "
2369 "cannot appear in a constant-expression");
2371 case NIC_OVERLOADED:
2372 error ("calls to overloaded operators "
2373 "cannot appear in a constant-expression");
2375 case NIC_ASSIGNMENT:
2376 error ("an assignment cannot appear in a constant-expression");
2379 error ("a comma operator "
2380 "cannot appear in a constant-expression");
2382 case NIC_CONSTRUCTOR:
2383 error ("a call to a constructor "
2384 "cannot appear in a constant-expression");
2390 msg = "__FUNCTION__";
2392 case NIC_PRETTY_FUNC:
2393 msg = "__PRETTY_FUNCTION__";
2413 case NIC_PREINCREMENT:
2416 case NIC_PREDECREMENT:
2429 error ("%qs cannot appear in a constant-expression", msg);
2436 /* Emit a diagnostic for an invalid type name. SCOPE is the
2437 qualifying scope (or NULL, if none) for ID. This function commits
2438 to the current active tentative parse, if any. (Otherwise, the
2439 problematic construct might be encountered again later, resulting
2440 in duplicate error messages.) LOCATION is the location of ID. */
2443 cp_parser_diagnose_invalid_type_name (cp_parser *parser,
2444 tree scope, tree id,
2445 location_t location)
2447 tree decl, old_scope;
2448 cp_parser_commit_to_tentative_parse (parser);
2449 /* Try to lookup the identifier. */
2450 old_scope = parser->scope;
2451 parser->scope = scope;
2452 decl = cp_parser_lookup_name_simple (parser, id, location);
2453 parser->scope = old_scope;
2454 /* If the lookup found a template-name, it means that the user forgot
2455 to specify an argument list. Emit a useful error message. */
2456 if (TREE_CODE (decl) == TEMPLATE_DECL)
2458 "invalid use of template-name %qE without an argument list",
2460 else if (TREE_CODE (id) == BIT_NOT_EXPR)
2461 error_at (location, "invalid use of destructor %qD as a type", id);
2462 else if (TREE_CODE (decl) == TYPE_DECL)
2463 /* Something like 'unsigned A a;' */
2464 error_at (location, "invalid combination of multiple type-specifiers");
2465 else if (!parser->scope)
2467 /* Issue an error message. */
2468 error_at (location, "%qE does not name a type", id);
2469 /* If we're in a template class, it's possible that the user was
2470 referring to a type from a base class. For example:
2472 template <typename T> struct A { typedef T X; };
2473 template <typename T> struct B : public A<T> { X x; };
2475 The user should have said "typename A<T>::X". */
2476 if (cxx_dialect < cxx0x && id == ridpointers[(int)RID_CONSTEXPR])
2477 inform (location, "C++0x %<constexpr%> only available with "
2478 "-std=c++0x or -std=gnu++0x");
2479 else if (processing_template_decl && current_class_type
2480 && TYPE_BINFO (current_class_type))
2484 for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2488 tree base_type = BINFO_TYPE (b);
2489 if (CLASS_TYPE_P (base_type)
2490 && dependent_type_p (base_type))
2493 /* Go from a particular instantiation of the
2494 template (which will have an empty TYPE_FIELDs),
2495 to the main version. */
2496 base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2497 for (field = TYPE_FIELDS (base_type);
2499 field = DECL_CHAIN (field))
2500 if (TREE_CODE (field) == TYPE_DECL
2501 && DECL_NAME (field) == id)
2504 "(perhaps %<typename %T::%E%> was intended)",
2505 BINFO_TYPE (b), id);
2514 /* Here we diagnose qualified-ids where the scope is actually correct,
2515 but the identifier does not resolve to a valid type name. */
2516 else if (parser->scope != error_mark_node)
2518 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2519 error_at (location, "%qE in namespace %qE does not name a type",
2521 else if (CLASS_TYPE_P (parser->scope)
2522 && constructor_name_p (id, parser->scope))
2525 error_at (location, "%<%T::%E%> names the constructor, not"
2526 " the type", parser->scope, id);
2527 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2528 error_at (location, "and %qT has no template constructors",
2531 else if (TYPE_P (parser->scope)
2532 && dependent_scope_p (parser->scope))
2533 error_at (location, "need %<typename%> before %<%T::%E%> because "
2534 "%qT is a dependent scope",
2535 parser->scope, id, parser->scope);
2536 else if (TYPE_P (parser->scope))
2537 error_at (location, "%qE in %q#T does not name a type",
2544 /* Check for a common situation where a type-name should be present,
2545 but is not, and issue a sensible error message. Returns true if an
2546 invalid type-name was detected.
2548 The situation handled by this function are variable declarations of the
2549 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2550 Usually, `ID' should name a type, but if we got here it means that it
2551 does not. We try to emit the best possible error message depending on
2552 how exactly the id-expression looks like. */
2555 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2558 cp_token *token = cp_lexer_peek_token (parser->lexer);
2560 /* Avoid duplicate error about ambiguous lookup. */
2561 if (token->type == CPP_NESTED_NAME_SPECIFIER)
2563 cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
2564 if (next->type == CPP_NAME && next->ambiguous_p)
2568 cp_parser_parse_tentatively (parser);
2569 id = cp_parser_id_expression (parser,
2570 /*template_keyword_p=*/false,
2571 /*check_dependency_p=*/true,
2572 /*template_p=*/NULL,
2573 /*declarator_p=*/true,
2574 /*optional_p=*/false);
2575 /* If the next token is a (, this is a function with no explicit return
2576 type, i.e. constructor, destructor or conversion op. */
2577 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
2578 || TREE_CODE (id) == TYPE_DECL)
2580 cp_parser_abort_tentative_parse (parser);
2583 if (!cp_parser_parse_definitely (parser))
2586 /* Emit a diagnostic for the invalid type. */
2587 cp_parser_diagnose_invalid_type_name (parser, parser->scope,
2588 id, token->location);
2590 /* If we aren't in the middle of a declarator (i.e. in a
2591 parameter-declaration-clause), skip to the end of the declaration;
2592 there's no point in trying to process it. */
2593 if (!parser->in_declarator_p)
2594 cp_parser_skip_to_end_of_block_or_statement (parser);
2598 /* Consume tokens up to, and including, the next non-nested closing `)'.
2599 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2600 are doing error recovery. Returns -1 if OR_COMMA is true and we
2601 found an unnested comma. */
2604 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2609 unsigned paren_depth = 0;
2610 unsigned brace_depth = 0;
2611 unsigned square_depth = 0;
2613 if (recovering && !or_comma
2614 && cp_parser_uncommitted_to_tentative_parse_p (parser))
2619 cp_token * token = cp_lexer_peek_token (parser->lexer);
2621 switch (token->type)
2624 case CPP_PRAGMA_EOL:
2625 /* If we've run out of tokens, then there is no closing `)'. */
2628 /* This is good for lambda expression capture-lists. */
2629 case CPP_OPEN_SQUARE:
2632 case CPP_CLOSE_SQUARE:
2633 if (!square_depth--)
2638 /* This matches the processing in skip_to_end_of_statement. */
2643 case CPP_OPEN_BRACE:
2646 case CPP_CLOSE_BRACE:
2652 if (recovering && or_comma && !brace_depth && !paren_depth
2657 case CPP_OPEN_PAREN:
2662 case CPP_CLOSE_PAREN:
2663 if (!brace_depth && !paren_depth--)
2666 cp_lexer_consume_token (parser->lexer);
2675 /* Consume the token. */
2676 cp_lexer_consume_token (parser->lexer);
2680 /* Consume tokens until we reach the end of the current statement.
2681 Normally, that will be just before consuming a `;'. However, if a
2682 non-nested `}' comes first, then we stop before consuming that. */
2685 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2687 unsigned nesting_depth = 0;
2691 cp_token *token = cp_lexer_peek_token (parser->lexer);
2693 switch (token->type)
2696 case CPP_PRAGMA_EOL:
2697 /* If we've run out of tokens, stop. */
2701 /* If the next token is a `;', we have reached the end of the
2707 case CPP_CLOSE_BRACE:
2708 /* If this is a non-nested '}', stop before consuming it.
2709 That way, when confronted with something like:
2713 we stop before consuming the closing '}', even though we
2714 have not yet reached a `;'. */
2715 if (nesting_depth == 0)
2718 /* If it is the closing '}' for a block that we have
2719 scanned, stop -- but only after consuming the token.
2725 we will stop after the body of the erroneously declared
2726 function, but before consuming the following `typedef'
2728 if (--nesting_depth == 0)
2730 cp_lexer_consume_token (parser->lexer);
2734 case CPP_OPEN_BRACE:
2742 /* Consume the token. */
2743 cp_lexer_consume_token (parser->lexer);
2747 /* This function is called at the end of a statement or declaration.
2748 If the next token is a semicolon, it is consumed; otherwise, error
2749 recovery is attempted. */
2752 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
2754 /* Look for the trailing `;'. */
2755 if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
2757 /* If there is additional (erroneous) input, skip to the end of
2759 cp_parser_skip_to_end_of_statement (parser);
2760 /* If the next token is now a `;', consume it. */
2761 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
2762 cp_lexer_consume_token (parser->lexer);
2766 /* Skip tokens until we have consumed an entire block, or until we
2767 have consumed a non-nested `;'. */
2770 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
2772 int nesting_depth = 0;
2774 while (nesting_depth >= 0)
2776 cp_token *token = cp_lexer_peek_token (parser->lexer);
2778 switch (token->type)
2781 case CPP_PRAGMA_EOL:
2782 /* If we've run out of tokens, stop. */
2786 /* Stop if this is an unnested ';'. */
2791 case CPP_CLOSE_BRACE:
2792 /* Stop if this is an unnested '}', or closes the outermost
2795 if (nesting_depth < 0)
2801 case CPP_OPEN_BRACE:
2810 /* Consume the token. */
2811 cp_lexer_consume_token (parser->lexer);
2815 /* Skip tokens until a non-nested closing curly brace is the next
2816 token, or there are no more tokens. Return true in the first case,
2820 cp_parser_skip_to_closing_brace (cp_parser *parser)
2822 unsigned nesting_depth = 0;
2826 cp_token *token = cp_lexer_peek_token (parser->lexer);
2828 switch (token->type)
2831 case CPP_PRAGMA_EOL:
2832 /* If we've run out of tokens, stop. */
2835 case CPP_CLOSE_BRACE:
2836 /* If the next token is a non-nested `}', then we have reached
2837 the end of the current block. */
2838 if (nesting_depth-- == 0)
2842 case CPP_OPEN_BRACE:
2843 /* If it the next token is a `{', then we are entering a new
2844 block. Consume the entire block. */
2852 /* Consume the token. */
2853 cp_lexer_consume_token (parser->lexer);
2857 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
2858 parameter is the PRAGMA token, allowing us to purge the entire pragma
2862 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
2866 parser->lexer->in_pragma = false;
2869 token = cp_lexer_consume_token (parser->lexer);
2870 while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
2872 /* Ensure that the pragma is not parsed again. */
2873 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
2876 /* Require pragma end of line, resyncing with it as necessary. The
2877 arguments are as for cp_parser_skip_to_pragma_eol. */
2880 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
2882 parser->lexer->in_pragma = false;
2883 if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
2884 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
2887 /* This is a simple wrapper around make_typename_type. When the id is
2888 an unresolved identifier node, we can provide a superior diagnostic
2889 using cp_parser_diagnose_invalid_type_name. */
2892 cp_parser_make_typename_type (cp_parser *parser, tree scope,
2893 tree id, location_t id_location)
2896 if (TREE_CODE (id) == IDENTIFIER_NODE)
2898 result = make_typename_type (scope, id, typename_type,
2899 /*complain=*/tf_none);
2900 if (result == error_mark_node)
2901 cp_parser_diagnose_invalid_type_name (parser, scope, id, id_location);
2904 return make_typename_type (scope, id, typename_type, tf_error);
2907 /* This is a wrapper around the
2908 make_{pointer,ptrmem,reference}_declarator functions that decides
2909 which one to call based on the CODE and CLASS_TYPE arguments. The
2910 CODE argument should be one of the values returned by
2911 cp_parser_ptr_operator. */
2912 static cp_declarator *
2913 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
2914 cp_cv_quals cv_qualifiers,
2915 cp_declarator *target)
2917 if (code == ERROR_MARK)
2918 return cp_error_declarator;
2920 if (code == INDIRECT_REF)
2921 if (class_type == NULL_TREE)
2922 return make_pointer_declarator (cv_qualifiers, target);
2924 return make_ptrmem_declarator (cv_qualifiers, class_type, target);
2925 else if (code == ADDR_EXPR && class_type == NULL_TREE)
2926 return make_reference_declarator (cv_qualifiers, target, false);
2927 else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
2928 return make_reference_declarator (cv_qualifiers, target, true);
2932 /* Create a new C++ parser. */
2935 cp_parser_new (void)
2941 /* cp_lexer_new_main is called before doing GC allocation because
2942 cp_lexer_new_main might load a PCH file. */
2943 lexer = cp_lexer_new_main ();
2945 /* Initialize the binops_by_token so that we can get the tree
2946 directly from the token. */
2947 for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
2948 binops_by_token[binops[i].token_type] = binops[i];
2950 parser = ggc_alloc_cleared_cp_parser ();
2951 parser->lexer = lexer;
2952 parser->context = cp_parser_context_new (NULL);
2954 /* For now, we always accept GNU extensions. */
2955 parser->allow_gnu_extensions_p = 1;
2957 /* The `>' token is a greater-than operator, not the end of a
2959 parser->greater_than_is_operator_p = true;
2961 parser->default_arg_ok_p = true;
2963 /* We are not parsing a constant-expression. */
2964 parser->integral_constant_expression_p = false;
2965 parser->allow_non_integral_constant_expression_p = false;
2966 parser->non_integral_constant_expression_p = false;
2968 /* Local variable names are not forbidden. */
2969 parser->local_variables_forbidden_p = false;
2971 /* We are not processing an `extern "C"' declaration. */
2972 parser->in_unbraced_linkage_specification_p = false;
2974 /* We are not processing a declarator. */
2975 parser->in_declarator_p = false;
2977 /* We are not processing a template-argument-list. */
2978 parser->in_template_argument_list_p = false;
2980 /* We are not in an iteration statement. */
2981 parser->in_statement = 0;
2983 /* We are not in a switch statement. */
2984 parser->in_switch_statement_p = false;
2986 /* We are not parsing a type-id inside an expression. */
2987 parser->in_type_id_in_expr_p = false;
2989 /* Declarations aren't implicitly extern "C". */
2990 parser->implicit_extern_c = false;
2992 /* String literals should be translated to the execution character set. */
2993 parser->translate_strings_p = true;
2995 /* We are not parsing a function body. */
2996 parser->in_function_body = false;
2998 /* We can correct until told otherwise. */
2999 parser->colon_corrects_to_scope_p = true;
3001 /* The unparsed function queue is empty. */
3002 push_unparsed_function_queues (parser);
3004 /* There are no classes being defined. */
3005 parser->num_classes_being_defined = 0;
3007 /* No template parameters apply. */
3008 parser->num_template_parameter_lists = 0;
3013 /* Create a cp_lexer structure which will emit the tokens in CACHE
3014 and push it onto the parser's lexer stack. This is used for delayed
3015 parsing of in-class method bodies and default arguments, and should
3016 not be confused with tentative parsing. */
3018 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
3020 cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
3021 lexer->next = parser->lexer;
3022 parser->lexer = lexer;
3024 /* Move the current source position to that of the first token in the
3026 cp_lexer_set_source_position_from_token (lexer->next_token);
3029 /* Pop the top lexer off the parser stack. This is never used for the
3030 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3032 cp_parser_pop_lexer (cp_parser *parser)
3034 cp_lexer *lexer = parser->lexer;
3035 parser->lexer = lexer->next;
3036 cp_lexer_destroy (lexer);
3038 /* Put the current source position back where it was before this
3039 lexer was pushed. */
3040 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
3043 /* Lexical conventions [gram.lex] */
3045 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3049 cp_parser_identifier (cp_parser* parser)
3053 /* Look for the identifier. */
3054 token = cp_parser_require (parser, CPP_NAME, RT_NAME);
3055 /* Return the value. */
3056 return token ? token->u.value : error_mark_node;
3059 /* Parse a sequence of adjacent string constants. Returns a
3060 TREE_STRING representing the combined, nul-terminated string
3061 constant. If TRANSLATE is true, translate the string to the
3062 execution character set. If WIDE_OK is true, a wide string is
3065 C++98 [lex.string] says that if a narrow string literal token is
3066 adjacent to a wide string literal token, the behavior is undefined.
3067 However, C99 6.4.5p4 says that this results in a wide string literal.
3068 We follow C99 here, for consistency with the C front end.
3070 This code is largely lifted from lex_string() in c-lex.c.
3072 FUTURE: ObjC++ will need to handle @-strings here. */
3074 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
3078 struct obstack str_ob;
3079 cpp_string str, istr, *strs;
3081 enum cpp_ttype type;
3083 tok = cp_lexer_peek_token (parser->lexer);
3084 if (!cp_parser_is_string_literal (tok))
3086 cp_parser_error (parser, "expected string-literal");
3087 return error_mark_node;
3092 /* Try to avoid the overhead of creating and destroying an obstack
3093 for the common case of just one string. */
3094 if (!cp_parser_is_string_literal
3095 (cp_lexer_peek_nth_token (parser->lexer, 2)))
3097 cp_lexer_consume_token (parser->lexer);
3099 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
3100 str.len = TREE_STRING_LENGTH (tok->u.value);
3107 gcc_obstack_init (&str_ob);
3112 cp_lexer_consume_token (parser->lexer);
3114 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
3115 str.len = TREE_STRING_LENGTH (tok->u.value);
3117 if (type != tok->type)
3119 if (type == CPP_STRING)
3121 else if (tok->type != CPP_STRING)
3122 error_at (tok->location,
3123 "unsupported non-standard concatenation "
3124 "of string literals");
3127 obstack_grow (&str_ob, &str, sizeof (cpp_string));
3129 tok = cp_lexer_peek_token (parser->lexer);
3131 while (cp_parser_is_string_literal (tok));
3133 strs = (cpp_string *) obstack_finish (&str_ob);
3136 if (type != CPP_STRING && !wide_ok)
3138 cp_parser_error (parser, "a wide string is invalid in this context");
3142 if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
3143 (parse_in, strs, count, &istr, type))
3145 value = build_string (istr.len, (const char *)istr.text);
3146 free (CONST_CAST (unsigned char *, istr.text));
3152 case CPP_UTF8STRING:
3153 TREE_TYPE (value) = char_array_type_node;
3156 TREE_TYPE (value) = char16_array_type_node;
3159 TREE_TYPE (value) = char32_array_type_node;
3162 TREE_TYPE (value) = wchar_array_type_node;
3166 value = fix_string_type (value);
3169 /* cpp_interpret_string has issued an error. */
3170 value = error_mark_node;
3173 obstack_free (&str_ob, 0);
3179 /* Basic concepts [gram.basic] */
3181 /* Parse a translation-unit.
3184 declaration-seq [opt]
3186 Returns TRUE if all went well. */
3189 cp_parser_translation_unit (cp_parser* parser)
3191 /* The address of the first non-permanent object on the declarator
3193 static void *declarator_obstack_base;
3197 /* Create the declarator obstack, if necessary. */
3198 if (!cp_error_declarator)
3200 gcc_obstack_init (&declarator_obstack);
3201 /* Create the error declarator. */
3202 cp_error_declarator = make_declarator (cdk_error);
3203 /* Create the empty parameter list. */
3204 no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
3205 /* Remember where the base of the declarator obstack lies. */
3206 declarator_obstack_base = obstack_next_free (&declarator_obstack);
3209 cp_parser_declaration_seq_opt (parser);
3211 /* If there are no tokens left then all went well. */
3212 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
3214 /* Get rid of the token array; we don't need it any more. */
3215 cp_lexer_destroy (parser->lexer);
3216 parser->lexer = NULL;
3218 /* This file might have been a context that's implicitly extern
3219 "C". If so, pop the lang context. (Only relevant for PCH.) */
3220 if (parser->implicit_extern_c)
3222 pop_lang_context ();
3223 parser->implicit_extern_c = false;
3227 finish_translation_unit ();
3233 cp_parser_error (parser, "expected declaration");
3237 /* Make sure the declarator obstack was fully cleaned up. */
3238 gcc_assert (obstack_next_free (&declarator_obstack)
3239 == declarator_obstack_base);
3241 /* All went well. */
3245 /* Expressions [gram.expr] */
3247 /* Parse a primary-expression.
3258 ( compound-statement )
3259 __builtin_va_arg ( assignment-expression , type-id )
3260 __builtin_offsetof ( type-id , offsetof-expression )
3263 __has_nothrow_assign ( type-id )
3264 __has_nothrow_constructor ( type-id )
3265 __has_nothrow_copy ( type-id )
3266 __has_trivial_assign ( type-id )
3267 __has_trivial_constructor ( type-id )
3268 __has_trivial_copy ( type-id )
3269 __has_trivial_destructor ( type-id )
3270 __has_virtual_destructor ( type-id )
3271 __is_abstract ( type-id )
3272 __is_base_of ( type-id , type-id )
3273 __is_class ( type-id )
3274 __is_convertible_to ( type-id , type-id )
3275 __is_empty ( type-id )
3276 __is_enum ( type-id )
3277 __is_literal_type ( type-id )
3278 __is_pod ( type-id )
3279 __is_polymorphic ( type-id )
3280 __is_std_layout ( type-id )
3281 __is_trivial ( type-id )
3282 __is_union ( type-id )
3284 Objective-C++ Extension:
3292 ADDRESS_P is true iff this expression was immediately preceded by
3293 "&" and therefore might denote a pointer-to-member. CAST_P is true
3294 iff this expression is the target of a cast. TEMPLATE_ARG_P is
3295 true iff this expression is a template argument.
3297 Returns a representation of the expression. Upon return, *IDK
3298 indicates what kind of id-expression (if any) was present. */
3301 cp_parser_primary_expression (cp_parser *parser,
3304 bool template_arg_p,
3307 cp_token *token = NULL;
3309 /* Assume the primary expression is not an id-expression. */
3310 *idk = CP_ID_KIND_NONE;
3312 /* Peek at the next token. */
3313 token = cp_lexer_peek_token (parser->lexer);
3314 switch (token->type)
3327 token = cp_lexer_consume_token (parser->lexer);
3328 if (TREE_CODE (token->u.value) == FIXED_CST)
3330 error_at (token->location,
3331 "fixed-point types not supported in C++");
3332 return error_mark_node;
3334 /* Floating-point literals are only allowed in an integral
3335 constant expression if they are cast to an integral or
3336 enumeration type. */
3337 if (TREE_CODE (token->u.value) == REAL_CST
3338 && parser->integral_constant_expression_p
3341 /* CAST_P will be set even in invalid code like "int(2.7 +
3342 ...)". Therefore, we have to check that the next token
3343 is sure to end the cast. */
3346 cp_token *next_token;
3348 next_token = cp_lexer_peek_token (parser->lexer);
3349 if (/* The comma at the end of an
3350 enumerator-definition. */
3351 next_token->type != CPP_COMMA
3352 /* The curly brace at the end of an enum-specifier. */
3353 && next_token->type != CPP_CLOSE_BRACE
3354 /* The end of a statement. */
3355 && next_token->type != CPP_SEMICOLON
3356 /* The end of the cast-expression. */
3357 && next_token->type != CPP_CLOSE_PAREN
3358 /* The end of an array bound. */
3359 && next_token->type != CPP_CLOSE_SQUARE
3360 /* The closing ">" in a template-argument-list. */
3361 && (next_token->type != CPP_GREATER
3362 || parser->greater_than_is_operator_p)
3363 /* C++0x only: A ">>" treated like two ">" tokens,
3364 in a template-argument-list. */
3365 && (next_token->type != CPP_RSHIFT
3366 || (cxx_dialect == cxx98)
3367 || parser->greater_than_is_operator_p))
3371 /* If we are within a cast, then the constraint that the
3372 cast is to an integral or enumeration type will be
3373 checked at that point. If we are not within a cast, then
3374 this code is invalid. */
3376 cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
3378 return token->u.value;
3384 case CPP_UTF8STRING:
3385 /* ??? Should wide strings be allowed when parser->translate_strings_p
3386 is false (i.e. in attributes)? If not, we can kill the third
3387 argument to cp_parser_string_literal. */
3388 return cp_parser_string_literal (parser,
3389 parser->translate_strings_p,
3392 case CPP_OPEN_PAREN:
3395 bool saved_greater_than_is_operator_p;
3397 /* Consume the `('. */
3398 cp_lexer_consume_token (parser->lexer);
3399 /* Within a parenthesized expression, a `>' token is always
3400 the greater-than operator. */
3401 saved_greater_than_is_operator_p
3402 = parser->greater_than_is_operator_p;
3403 parser->greater_than_is_operator_p = true;
3404 /* If we see `( { ' then we are looking at the beginning of
3405 a GNU statement-expression. */
3406 if (cp_parser_allow_gnu_extensions_p (parser)
3407 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
3409 /* Statement-expressions are not allowed by the standard. */
3410 pedwarn (token->location, OPT_pedantic,
3411 "ISO C++ forbids braced-groups within expressions");
3413 /* And they're not allowed outside of a function-body; you
3414 cannot, for example, write:
3416 int i = ({ int j = 3; j + 1; });
3418 at class or namespace scope. */
3419 if (!parser->in_function_body
3420 || parser->in_template_argument_list_p)
3422 error_at (token->location,
3423 "statement-expressions are not allowed outside "
3424 "functions nor in template-argument lists");
3425 cp_parser_skip_to_end_of_block_or_statement (parser);
3426 expr = error_mark_node;
3430 /* Start the statement-expression. */
3431 expr = begin_stmt_expr ();
3432 /* Parse the compound-statement. */
3433 cp_parser_compound_statement (parser, expr, false, false);
3435 expr = finish_stmt_expr (expr, false);
3440 /* Parse the parenthesized expression. */
3441 expr = cp_parser_expression (parser, cast_p, idk);
3442 /* Let the front end know that this expression was
3443 enclosed in parentheses. This matters in case, for
3444 example, the expression is of the form `A::B', since
3445 `&A::B' might be a pointer-to-member, but `&(A::B)' is
3447 finish_parenthesized_expr (expr);
3448 /* DR 705: Wrapping an unqualified name in parentheses
3449 suppresses arg-dependent lookup. We want to pass back
3450 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
3451 (c++/37862), but none of the others. */
3452 if (*idk != CP_ID_KIND_QUALIFIED)
3453 *idk = CP_ID_KIND_NONE;
3455 /* The `>' token might be the end of a template-id or
3456 template-parameter-list now. */
3457 parser->greater_than_is_operator_p
3458 = saved_greater_than_is_operator_p;
3459 /* Consume the `)'. */
3460 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
3461 cp_parser_skip_to_end_of_statement (parser);
3466 case CPP_OPEN_SQUARE:
3467 if (c_dialect_objc ())
3468 /* We have an Objective-C++ message. */
3469 return cp_parser_objc_expression (parser);
3471 tree lam = cp_parser_lambda_expression (parser);
3472 /* Don't warn about a failed tentative parse. */
3473 if (cp_parser_error_occurred (parser))
3474 return error_mark_node;
3475 maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
3479 case CPP_OBJC_STRING:
3480 if (c_dialect_objc ())
3481 /* We have an Objective-C++ string literal. */
3482 return cp_parser_objc_expression (parser);
3483 cp_parser_error (parser, "expected primary-expression");
3484 return error_mark_node;
3487 switch (token->keyword)
3489 /* These two are the boolean literals. */
3491 cp_lexer_consume_token (parser->lexer);
3492 return boolean_true_node;
3494 cp_lexer_consume_token (parser->lexer);
3495 return boolean_false_node;
3497 /* The `__null' literal. */
3499 cp_lexer_consume_token (parser->lexer);
3502 /* The `nullptr' literal. */
3504 cp_lexer_consume_token (parser->lexer);
3505 return nullptr_node;
3507 /* Recognize the `this' keyword. */
3509 cp_lexer_consume_token (parser->lexer);
3510 if (parser->local_variables_forbidden_p)
3512 error_at (token->location,
3513 "%<this%> may not be used in this context");
3514 return error_mark_node;
3516 /* Pointers cannot appear in constant-expressions. */
3517 if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
3518 return error_mark_node;
3519 return finish_this_expr ();
3521 /* The `operator' keyword can be the beginning of an
3526 case RID_FUNCTION_NAME:
3527 case RID_PRETTY_FUNCTION_NAME:
3528 case RID_C99_FUNCTION_NAME:
3530 non_integral_constant name;
3532 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
3533 __func__ are the names of variables -- but they are
3534 treated specially. Therefore, they are handled here,
3535 rather than relying on the generic id-expression logic
3536 below. Grammatically, these names are id-expressions.
3538 Consume the token. */
3539 token = cp_lexer_consume_token (parser->lexer);
3541 switch (token->keyword)
3543 case RID_FUNCTION_NAME:
3544 name = NIC_FUNC_NAME;
3546 case RID_PRETTY_FUNCTION_NAME:
3547 name = NIC_PRETTY_FUNC;
3549 case RID_C99_FUNCTION_NAME:
3550 name = NIC_C99_FUNC;
3556 if (cp_parser_non_integral_constant_expression (parser, name))
3557 return error_mark_node;
3559 /* Look up the name. */
3560 return finish_fname (token->u.value);
3568 /* The `__builtin_va_arg' construct is used to handle
3569 `va_arg'. Consume the `__builtin_va_arg' token. */
3570 cp_lexer_consume_token (parser->lexer);
3571 /* Look for the opening `('. */
3572 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
3573 /* Now, parse the assignment-expression. */
3574 expression = cp_parser_assignment_expression (parser,
3575 /*cast_p=*/false, NULL);
3576 /* Look for the `,'. */
3577 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
3578 /* Parse the type-id. */
3579 type = cp_parser_type_id (parser);
3580 /* Look for the closing `)'. */
3581 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
3582 /* Using `va_arg' in a constant-expression is not
3584 if (cp_parser_non_integral_constant_expression (parser,
3586 return error_mark_node;
3587 return build_x_va_arg (expression, type);
3591 return cp_parser_builtin_offsetof (parser);
3593 case RID_HAS_NOTHROW_ASSIGN:
3594 case RID_HAS_NOTHROW_CONSTRUCTOR:
3595 case RID_HAS_NOTHROW_COPY:
3596 case RID_HAS_TRIVIAL_ASSIGN:
3597 case RID_HAS_TRIVIAL_CONSTRUCTOR:
3598 case RID_HAS_TRIVIAL_COPY:
3599 case RID_HAS_TRIVIAL_DESTRUCTOR:
3600 case RID_HAS_VIRTUAL_DESTRUCTOR:
3601 case RID_IS_ABSTRACT:
3602 case RID_IS_BASE_OF:
3604 case RID_IS_CONVERTIBLE_TO:
3607 case RID_IS_LITERAL_TYPE:
3609 case RID_IS_POLYMORPHIC:
3610 case RID_IS_STD_LAYOUT:
3611 case RID_IS_TRIVIAL:
3613 return cp_parser_trait_expr (parser, token->keyword);
3615 /* Objective-C++ expressions. */
3617 case RID_AT_PROTOCOL:
3618 case RID_AT_SELECTOR:
3619 return cp_parser_objc_expression (parser);
3622 if (parser->in_function_body
3623 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3626 error_at (token->location,
3627 "a template declaration cannot appear at block scope");
3628 cp_parser_skip_to_end_of_block_or_statement (parser);
3629 return error_mark_node;
3632 cp_parser_error (parser, "expected primary-expression");
3633 return error_mark_node;
3636 /* An id-expression can start with either an identifier, a
3637 `::' as the beginning of a qualified-id, or the "operator"
3641 case CPP_TEMPLATE_ID:
3642 case CPP_NESTED_NAME_SPECIFIER:
3646 const char *error_msg;
3649 cp_token *id_expr_token;
3652 /* Parse the id-expression. */
3654 = cp_parser_id_expression (parser,
3655 /*template_keyword_p=*/false,
3656 /*check_dependency_p=*/true,
3658 /*declarator_p=*/false,
3659 /*optional_p=*/false);
3660 if (id_expression == error_mark_node)
3661 return error_mark_node;
3662 id_expr_token = token;
3663 token = cp_lexer_peek_token (parser->lexer);
3664 done = (token->type != CPP_OPEN_SQUARE
3665 && token->type != CPP_OPEN_PAREN
3666 && token->type != CPP_DOT
3667 && token->type != CPP_DEREF
3668 && token->type != CPP_PLUS_PLUS
3669 && token->type != CPP_MINUS_MINUS);
3670 /* If we have a template-id, then no further lookup is
3671 required. If the template-id was for a template-class, we
3672 will sometimes have a TYPE_DECL at this point. */
3673 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
3674 || TREE_CODE (id_expression) == TYPE_DECL)
3675 decl = id_expression;
3676 /* Look up the name. */
3679 tree ambiguous_decls;
3681 /* If we already know that this lookup is ambiguous, then
3682 we've already issued an error message; there's no reason
3684 if (id_expr_token->type == CPP_NAME
3685 && id_expr_token->ambiguous_p)
3687 cp_parser_simulate_error (parser);
3688 return error_mark_node;
3691 decl = cp_parser_lookup_name (parser, id_expression,
3694 /*is_namespace=*/false,
3695 /*check_dependency=*/true,
3697 id_expr_token->location);
3698 /* If the lookup was ambiguous, an error will already have
3700 if (ambiguous_decls)
3701 return error_mark_node;
3703 /* In Objective-C++, we may have an Objective-C 2.0
3704 dot-syntax for classes here. */
3705 if (c_dialect_objc ()
3706 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
3707 && TREE_CODE (decl) == TYPE_DECL
3708 && objc_is_class_name (decl))
3711 cp_lexer_consume_token (parser->lexer);
3712 component = cp_parser_identifier (parser);
3713 if (component == error_mark_node)
3714 return error_mark_node;
3716 return objc_build_class_component_ref (id_expression, component);
3719 /* In Objective-C++, an instance variable (ivar) may be preferred
3720 to whatever cp_parser_lookup_name() found. */
3721 decl = objc_lookup_ivar (decl, id_expression);
3723 /* If name lookup gives us a SCOPE_REF, then the
3724 qualifying scope was dependent. */
3725 if (TREE_CODE (decl) == SCOPE_REF)
3727 /* At this point, we do not know if DECL is a valid
3728 integral constant expression. We assume that it is
3729 in fact such an expression, so that code like:
3731 template <int N> struct A {
3735 is accepted. At template-instantiation time, we
3736 will check that B<N>::i is actually a constant. */
3739 /* Check to see if DECL is a local variable in a context
3740 where that is forbidden. */
3741 if (parser->local_variables_forbidden_p
3742 && local_variable_p (decl))
3744 /* It might be that we only found DECL because we are
3745 trying to be generous with pre-ISO scoping rules.
3746 For example, consider:
3750 for (int i = 0; i < 10; ++i) {}
3751 extern void f(int j = i);
3754 Here, name look up will originally find the out
3755 of scope `i'. We need to issue a warning message,
3756 but then use the global `i'. */
3757 decl = check_for_out_of_scope_variable (decl);
3758 if (local_variable_p (decl))
3760 error_at (id_expr_token->location,
3761 "local variable %qD may not appear in this context",
3763 return error_mark_node;
3768 decl = (finish_id_expression
3769 (id_expression, decl, parser->scope,
3771 parser->integral_constant_expression_p,
3772 parser->allow_non_integral_constant_expression_p,
3773 &parser->non_integral_constant_expression_p,
3774 template_p, done, address_p,
3777 id_expr_token->location));
3779 cp_parser_error (parser, error_msg);
3783 /* Anything else is an error. */
3785 cp_parser_error (parser, "expected primary-expression");
3786 return error_mark_node;
3790 /* Parse an id-expression.
3797 :: [opt] nested-name-specifier template [opt] unqualified-id
3799 :: operator-function-id
3802 Return a representation of the unqualified portion of the
3803 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
3804 a `::' or nested-name-specifier.
3806 Often, if the id-expression was a qualified-id, the caller will
3807 want to make a SCOPE_REF to represent the qualified-id. This
3808 function does not do this in order to avoid wastefully creating
3809 SCOPE_REFs when they are not required.
3811 If TEMPLATE_KEYWORD_P is true, then we have just seen the
3814 If CHECK_DEPENDENCY_P is false, then names are looked up inside
3815 uninstantiated templates.
3817 If *TEMPLATE_P is non-NULL, it is set to true iff the
3818 `template' keyword is used to explicitly indicate that the entity
3819 named is a template.
3821 If DECLARATOR_P is true, the id-expression is appearing as part of
3822 a declarator, rather than as part of an expression. */
3825 cp_parser_id_expression (cp_parser *parser,
3826 bool template_keyword_p,
3827 bool check_dependency_p,
3832 bool global_scope_p;
3833 bool nested_name_specifier_p;
3835 /* Assume the `template' keyword was not used. */
3837 *template_p = template_keyword_p;
3839 /* Look for the optional `::' operator. */
3841 = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
3843 /* Look for the optional nested-name-specifier. */
3844 nested_name_specifier_p
3845 = (cp_parser_nested_name_specifier_opt (parser,
3846 /*typename_keyword_p=*/false,
3851 /* If there is a nested-name-specifier, then we are looking at
3852 the first qualified-id production. */
3853 if (nested_name_specifier_p)
3856 tree saved_object_scope;
3857 tree saved_qualifying_scope;
3858 tree unqualified_id;
3861 /* See if the next token is the `template' keyword. */
3863 template_p = &is_template;
3864 *template_p = cp_parser_optional_template_keyword (parser);
3865 /* Name lookup we do during the processing of the
3866 unqualified-id might obliterate SCOPE. */
3867 saved_scope = parser->scope;
3868 saved_object_scope = parser->object_scope;
3869 saved_qualifying_scope = parser->qualifying_scope;
3870 /* Process the final unqualified-id. */
3871 unqualified_id = cp_parser_unqualified_id (parser, *template_p,
3874 /*optional_p=*/false);
3875 /* Restore the SAVED_SCOPE for our caller. */
3876 parser->scope = saved_scope;
3877 parser->object_scope = saved_object_scope;
3878 parser->qualifying_scope = saved_qualifying_scope;
3880 return unqualified_id;
3882 /* Otherwise, if we are in global scope, then we are looking at one
3883 of the other qualified-id productions. */
3884 else if (global_scope_p)
3889 /* Peek at the next token. */
3890 token = cp_lexer_peek_token (parser->lexer);
3892 /* If it's an identifier, and the next token is not a "<", then
3893 we can avoid the template-id case. This is an optimization
3894 for this common case. */
3895 if (token->type == CPP_NAME
3896 && !cp_parser_nth_token_starts_template_argument_list_p
3898 return cp_parser_identifier (parser);
3900 cp_parser_parse_tentatively (parser);
3901 /* Try a template-id. */
3902 id = cp_parser_template_id (parser,
3903 /*template_keyword_p=*/false,
3904 /*check_dependency_p=*/true,
3906 /* If that worked, we're done. */
3907 if (cp_parser_parse_definitely (parser))
3910 /* Peek at the next token. (Changes in the token buffer may
3911 have invalidated the pointer obtained above.) */
3912 token = cp_lexer_peek_token (parser->lexer);
3914 switch (token->type)
3917 return cp_parser_identifier (parser);
3920 if (token->keyword == RID_OPERATOR)
3921 return cp_parser_operator_function_id (parser);
3925 cp_parser_error (parser, "expected id-expression");
3926 return error_mark_node;
3930 return cp_parser_unqualified_id (parser, template_keyword_p,
3931 /*check_dependency_p=*/true,
3936 /* Parse an unqualified-id.
3940 operator-function-id
3941 conversion-function-id
3945 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
3946 keyword, in a construct like `A::template ...'.
3948 Returns a representation of unqualified-id. For the `identifier'
3949 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
3950 production a BIT_NOT_EXPR is returned; the operand of the
3951 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
3952 other productions, see the documentation accompanying the
3953 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
3954 names are looked up in uninstantiated templates. If DECLARATOR_P
3955 is true, the unqualified-id is appearing as part of a declarator,
3956 rather than as part of an expression. */
3959 cp_parser_unqualified_id (cp_parser* parser,
3960 bool template_keyword_p,
3961 bool check_dependency_p,
3967 /* Peek at the next token. */
3968 token = cp_lexer_peek_token (parser->lexer);
3970 switch (token->type)
3976 /* We don't know yet whether or not this will be a
3978 cp_parser_parse_tentatively (parser);
3979 /* Try a template-id. */
3980 id = cp_parser_template_id (parser, template_keyword_p,
3983 /* If it worked, we're done. */
3984 if (cp_parser_parse_definitely (parser))
3986 /* Otherwise, it's an ordinary identifier. */
3987 return cp_parser_identifier (parser);
3990 case CPP_TEMPLATE_ID:
3991 return cp_parser_template_id (parser, template_keyword_p,
3998 tree qualifying_scope;
4003 /* Consume the `~' token. */
4004 cp_lexer_consume_token (parser->lexer);
4005 /* Parse the class-name. The standard, as written, seems to
4008 template <typename T> struct S { ~S (); };
4009 template <typename T> S<T>::~S() {}
4011 is invalid, since `~' must be followed by a class-name, but
4012 `S<T>' is dependent, and so not known to be a class.
4013 That's not right; we need to look in uninstantiated
4014 templates. A further complication arises from:
4016 template <typename T> void f(T t) {
4020 Here, it is not possible to look up `T' in the scope of `T'
4021 itself. We must look in both the current scope, and the
4022 scope of the containing complete expression.
4024 Yet another issue is:
4033 The standard does not seem to say that the `S' in `~S'
4034 should refer to the type `S' and not the data member
4037 /* DR 244 says that we look up the name after the "~" in the
4038 same scope as we looked up the qualifying name. That idea
4039 isn't fully worked out; it's more complicated than that. */
4040 scope = parser->scope;
4041 object_scope = parser->object_scope;
4042 qualifying_scope = parser->qualifying_scope;
4044 /* Check for invalid scopes. */
4045 if (scope == error_mark_node)
4047 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
4048 cp_lexer_consume_token (parser->lexer);
4049 return error_mark_node;
4051 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
4053 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
4054 error_at (token->location,
4055 "scope %qT before %<~%> is not a class-name",
4057 cp_parser_simulate_error (parser);
4058 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
4059 cp_lexer_consume_token (parser->lexer);
4060 return error_mark_node;
4062 gcc_assert (!scope || TYPE_P (scope));
4064 /* If the name is of the form "X::~X" it's OK even if X is a
4066 token = cp_lexer_peek_token (parser->lexer);
4068 && token->type == CPP_NAME
4069 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4071 && (token->u.value == TYPE_IDENTIFIER (scope)
4072 || constructor_name_p (token->u.value, scope)))
4074 cp_lexer_consume_token (parser->lexer);
4075 return build_nt (BIT_NOT_EXPR, scope);
4078 /* If there was an explicit qualification (S::~T), first look
4079 in the scope given by the qualification (i.e., S).
4081 Note: in the calls to cp_parser_class_name below we pass
4082 typename_type so that lookup finds the injected-class-name
4083 rather than the constructor. */
4085 type_decl = NULL_TREE;
4088 cp_parser_parse_tentatively (parser);
4089 type_decl = cp_parser_class_name (parser,
4090 /*typename_keyword_p=*/false,
4091 /*template_keyword_p=*/false,
4093 /*check_dependency=*/false,
4094 /*class_head_p=*/false,
4096 if (cp_parser_parse_definitely (parser))
4099 /* In "N::S::~S", look in "N" as well. */
4100 if (!done && scope && qualifying_scope)
4102 cp_parser_parse_tentatively (parser);
4103 parser->scope = qualifying_scope;
4104 parser->object_scope = NULL_TREE;
4105 parser->qualifying_scope = NULL_TREE;
4107 = cp_parser_class_name (parser,
4108 /*typename_keyword_p=*/false,
4109 /*template_keyword_p=*/false,
4111 /*check_dependency=*/false,
4112 /*class_head_p=*/false,
4114 if (cp_parser_parse_definitely (parser))
4117 /* In "p->S::~T", look in the scope given by "*p" as well. */
4118 else if (!done && object_scope)
4120 cp_parser_parse_tentatively (parser);
4121 parser->scope = object_scope;
4122 parser->object_scope = NULL_TREE;
4123 parser->qualifying_scope = NULL_TREE;
4125 = cp_parser_class_name (parser,
4126 /*typename_keyword_p=*/false,
4127 /*template_keyword_p=*/false,
4129 /*check_dependency=*/false,
4130 /*class_head_p=*/false,
4132 if (cp_parser_parse_definitely (parser))
4135 /* Look in the surrounding context. */
4138 parser->scope = NULL_TREE;
4139 parser->object_scope = NULL_TREE;
4140 parser->qualifying_scope = NULL_TREE;
4141 if (processing_template_decl)
4142 cp_parser_parse_tentatively (parser);
4144 = cp_parser_class_name (parser,
4145 /*typename_keyword_p=*/false,
4146 /*template_keyword_p=*/false,
4148 /*check_dependency=*/false,
4149 /*class_head_p=*/false,
4151 if (processing_template_decl
4152 && ! cp_parser_parse_definitely (parser))
4154 /* We couldn't find a type with this name, so just accept
4155 it and check for a match at instantiation time. */
4156 type_decl = cp_parser_identifier (parser);
4157 if (type_decl != error_mark_node)
4158 type_decl = build_nt (BIT_NOT_EXPR, type_decl);
4162 /* If an error occurred, assume that the name of the
4163 destructor is the same as the name of the qualifying
4164 class. That allows us to keep parsing after running
4165 into ill-formed destructor names. */
4166 if (type_decl == error_mark_node && scope)
4167 return build_nt (BIT_NOT_EXPR, scope);
4168 else if (type_decl == error_mark_node)
4169 return error_mark_node;
4171 /* Check that destructor name and scope match. */
4172 if (declarator_p && scope && !check_dtor_name (scope, type_decl))
4174 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
4175 error_at (token->location,
4176 "declaration of %<~%T%> as member of %qT",
4178 cp_parser_simulate_error (parser);
4179 return error_mark_node;
4184 A typedef-name that names a class shall not be used as the
4185 identifier in the declarator for a destructor declaration. */
4187 && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
4188 && !DECL_SELF_REFERENCE_P (type_decl)
4189 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
4190 error_at (token->location,
4191 "typedef-name %qD used as destructor declarator",
4194 return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
4198 if (token->keyword == RID_OPERATOR)
4202 /* This could be a template-id, so we try that first. */
4203 cp_parser_parse_tentatively (parser);
4204 /* Try a template-id. */
4205 id = cp_parser_template_id (parser, template_keyword_p,
4206 /*check_dependency_p=*/true,
4208 /* If that worked, we're done. */
4209 if (cp_parser_parse_definitely (parser))
4211 /* We still don't know whether we're looking at an
4212 operator-function-id or a conversion-function-id. */
4213 cp_parser_parse_tentatively (parser);
4214 /* Try an operator-function-id. */
4215 id = cp_parser_operator_function_id (parser);
4216 /* If that didn't work, try a conversion-function-id. */
4217 if (!cp_parser_parse_definitely (parser))
4218 id = cp_parser_conversion_function_id (parser);
4227 cp_parser_error (parser, "expected unqualified-id");
4228 return error_mark_node;
4232 /* Parse an (optional) nested-name-specifier.
4234 nested-name-specifier: [C++98]
4235 class-or-namespace-name :: nested-name-specifier [opt]
4236 class-or-namespace-name :: template nested-name-specifier [opt]
4238 nested-name-specifier: [C++0x]
4241 nested-name-specifier identifier ::
4242 nested-name-specifier template [opt] simple-template-id ::
4244 PARSER->SCOPE should be set appropriately before this function is
4245 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
4246 effect. TYPE_P is TRUE if we non-type bindings should be ignored
4249 Sets PARSER->SCOPE to the class (TYPE) or namespace
4250 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
4251 it unchanged if there is no nested-name-specifier. Returns the new
4252 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
4254 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
4255 part of a declaration and/or decl-specifier. */
4258 cp_parser_nested_name_specifier_opt (cp_parser *parser,
4259 bool typename_keyword_p,
4260 bool check_dependency_p,
4262 bool is_declaration)
4264 bool success = false;
4265 cp_token_position start = 0;
4268 /* Remember where the nested-name-specifier starts. */
4269 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
4271 start = cp_lexer_token_position (parser->lexer, false);
4272 push_deferring_access_checks (dk_deferred);
4279 tree saved_qualifying_scope;
4280 bool template_keyword_p;
4282 /* Spot cases that cannot be the beginning of a
4283 nested-name-specifier. */
4284 token = cp_lexer_peek_token (parser->lexer);
4286 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
4287 the already parsed nested-name-specifier. */
4288 if (token->type == CPP_NESTED_NAME_SPECIFIER)
4290 /* Grab the nested-name-specifier and continue the loop. */
4291 cp_parser_pre_parsed_nested_name_specifier (parser);
4292 /* If we originally encountered this nested-name-specifier
4293 with IS_DECLARATION set to false, we will not have
4294 resolved TYPENAME_TYPEs, so we must do so here. */
4296 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
4298 new_scope = resolve_typename_type (parser->scope,
4299 /*only_current_p=*/false);
4300 if (TREE_CODE (new_scope) != TYPENAME_TYPE)
4301 parser->scope = new_scope;
4307 /* Spot cases that cannot be the beginning of a
4308 nested-name-specifier. On the second and subsequent times
4309 through the loop, we look for the `template' keyword. */
4310 if (success && token->keyword == RID_TEMPLATE)
4312 /* A template-id can start a nested-name-specifier. */
4313 else if (token->type == CPP_TEMPLATE_ID)
4317 /* If the next token is not an identifier, then it is
4318 definitely not a type-name or namespace-name. */
4319 if (token->type != CPP_NAME)
4321 /* If the following token is neither a `<' (to begin a
4322 template-id), nor a `::', then we are not looking at a
4323 nested-name-specifier. */
4324 token = cp_lexer_peek_nth_token (parser->lexer, 2);
4326 if (token->type == CPP_COLON
4327 && parser->colon_corrects_to_scope_p
4328 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME)
4330 error_at (token->location,
4331 "found %<:%> in nested-name-specifier, expected %<::%>");
4332 token->type = CPP_SCOPE;
4335 if (token->type != CPP_SCOPE
4336 && !cp_parser_nth_token_starts_template_argument_list_p
4341 /* The nested-name-specifier is optional, so we parse
4343 cp_parser_parse_tentatively (parser);
4345 /* Look for the optional `template' keyword, if this isn't the
4346 first time through the loop. */
4348 template_keyword_p = cp_parser_optional_template_keyword (parser);
4350 template_keyword_p = false;
4352 /* Save the old scope since the name lookup we are about to do
4353 might destroy it. */
4354 old_scope = parser->scope;
4355 saved_qualifying_scope = parser->qualifying_scope;
4356 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
4357 look up names in "X<T>::I" in order to determine that "Y" is
4358 a template. So, if we have a typename at this point, we make
4359 an effort to look through it. */
4361 && !typename_keyword_p
4363 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
4364 parser->scope = resolve_typename_type (parser->scope,
4365 /*only_current_p=*/false);
4366 /* Parse the qualifying entity. */
4368 = cp_parser_qualifying_entity (parser,
4374 /* Look for the `::' token. */
4375 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
4377 /* If we found what we wanted, we keep going; otherwise, we're
4379 if (!cp_parser_parse_definitely (parser))
4381 bool error_p = false;
4383 /* Restore the OLD_SCOPE since it was valid before the
4384 failed attempt at finding the last
4385 class-or-namespace-name. */
4386 parser->scope = old_scope;
4387 parser->qualifying_scope = saved_qualifying_scope;
4388 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
4390 /* If the next token is an identifier, and the one after
4391 that is a `::', then any valid interpretation would have
4392 found a class-or-namespace-name. */
4393 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
4394 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4396 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
4399 token = cp_lexer_consume_token (parser->lexer);
4402 if (!token->ambiguous_p)
4405 tree ambiguous_decls;
4407 decl = cp_parser_lookup_name (parser, token->u.value,
4409 /*is_template=*/false,
4410 /*is_namespace=*/false,
4411 /*check_dependency=*/true,
4414 if (TREE_CODE (decl) == TEMPLATE_DECL)
4415 error_at (token->location,
4416 "%qD used without template parameters",
4418 else if (ambiguous_decls)
4420 error_at (token->location,
4421 "reference to %qD is ambiguous",
4423 print_candidates (ambiguous_decls);
4424 decl = error_mark_node;
4428 if (cxx_dialect != cxx98)
4429 cp_parser_name_lookup_error
4430 (parser, token->u.value, decl, NLE_NOT_CXX98,
4433 cp_parser_name_lookup_error
4434 (parser, token->u.value, decl, NLE_CXX98,
4438 parser->scope = error_mark_node;
4440 /* Treat this as a successful nested-name-specifier
4445 If the name found is not a class-name (clause
4446 _class_) or namespace-name (_namespace.def_), the
4447 program is ill-formed. */
4450 cp_lexer_consume_token (parser->lexer);
4454 /* We've found one valid nested-name-specifier. */
4456 /* Name lookup always gives us a DECL. */
4457 if (TREE_CODE (new_scope) == TYPE_DECL)
4458 new_scope = TREE_TYPE (new_scope);
4459 /* Uses of "template" must be followed by actual templates. */
4460 if (template_keyword_p
4461 && !(CLASS_TYPE_P (new_scope)
4462 && ((CLASSTYPE_USE_TEMPLATE (new_scope)
4463 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
4464 || CLASSTYPE_IS_TEMPLATE (new_scope)))
4465 && !(TREE_CODE (new_scope) == TYPENAME_TYPE
4466 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
4467 == TEMPLATE_ID_EXPR)))
4468 permerror (input_location, TYPE_P (new_scope)
4469 ? "%qT is not a template"
4470 : "%qD is not a template",
4472 /* If it is a class scope, try to complete it; we are about to
4473 be looking up names inside the class. */
4474 if (TYPE_P (new_scope)
4475 /* Since checking types for dependency can be expensive,
4476 avoid doing it if the type is already complete. */
4477 && !COMPLETE_TYPE_P (new_scope)
4478 /* Do not try to complete dependent types. */
4479 && !dependent_type_p (new_scope))
4481 new_scope = complete_type (new_scope);
4482 /* If it is a typedef to current class, use the current
4483 class instead, as the typedef won't have any names inside
4485 if (!COMPLETE_TYPE_P (new_scope)
4486 && currently_open_class (new_scope))
4487 new_scope = TYPE_MAIN_VARIANT (new_scope);
4489 /* Make sure we look in the right scope the next time through
4491 parser->scope = new_scope;
4494 /* If parsing tentatively, replace the sequence of tokens that makes
4495 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
4496 token. That way, should we re-parse the token stream, we will
4497 not have to repeat the effort required to do the parse, nor will
4498 we issue duplicate error messages. */
4499 if (success && start)
4503 token = cp_lexer_token_at (parser->lexer, start);
4504 /* Reset the contents of the START token. */
4505 token->type = CPP_NESTED_NAME_SPECIFIER;
4506 /* Retrieve any deferred checks. Do not pop this access checks yet
4507 so the memory will not be reclaimed during token replacing below. */
4508 token->u.tree_check_value = ggc_alloc_cleared_tree_check ();
4509 token->u.tree_check_value->value = parser->scope;
4510 token->u.tree_check_value->checks = get_deferred_access_checks ();
4511 token->u.tree_check_value->qualifying_scope =
4512 parser->qualifying_scope;
4513 token->keyword = RID_MAX;
4515 /* Purge all subsequent tokens. */
4516 cp_lexer_purge_tokens_after (parser->lexer, start);
4520 pop_to_parent_deferring_access_checks ();
4522 return success ? parser->scope : NULL_TREE;
4525 /* Parse a nested-name-specifier. See
4526 cp_parser_nested_name_specifier_opt for details. This function
4527 behaves identically, except that it will an issue an error if no
4528 nested-name-specifier is present. */
4531 cp_parser_nested_name_specifier (cp_parser *parser,
4532 bool typename_keyword_p,
4533 bool check_dependency_p,
4535 bool is_declaration)
4539 /* Look for the nested-name-specifier. */
4540 scope = cp_parser_nested_name_specifier_opt (parser,
4545 /* If it was not present, issue an error message. */
4548 cp_parser_error (parser, "expected nested-name-specifier");
4549 parser->scope = NULL_TREE;
4555 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
4556 this is either a class-name or a namespace-name (which corresponds
4557 to the class-or-namespace-name production in the grammar). For
4558 C++0x, it can also be a type-name that refers to an enumeration
4561 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
4562 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
4563 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
4564 TYPE_P is TRUE iff the next name should be taken as a class-name,
4565 even the same name is declared to be another entity in the same
4568 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
4569 specified by the class-or-namespace-name. If neither is found the
4570 ERROR_MARK_NODE is returned. */
4573 cp_parser_qualifying_entity (cp_parser *parser,
4574 bool typename_keyword_p,
4575 bool template_keyword_p,
4576 bool check_dependency_p,
4578 bool is_declaration)
4581 tree saved_qualifying_scope;
4582 tree saved_object_scope;
4585 bool successful_parse_p;
4587 /* Before we try to parse the class-name, we must save away the
4588 current PARSER->SCOPE since cp_parser_class_name will destroy
4590 saved_scope = parser->scope;
4591 saved_qualifying_scope = parser->qualifying_scope;
4592 saved_object_scope = parser->object_scope;
4593 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
4594 there is no need to look for a namespace-name. */
4595 only_class_p = template_keyword_p
4596 || (saved_scope && TYPE_P (saved_scope) && cxx_dialect == cxx98);
4598 cp_parser_parse_tentatively (parser);
4599 scope = cp_parser_class_name (parser,
4602 type_p ? class_type : none_type,
4604 /*class_head_p=*/false,
4606 successful_parse_p = only_class_p || cp_parser_parse_definitely (parser);
4607 /* If that didn't work and we're in C++0x mode, try for a type-name. */
4609 && cxx_dialect != cxx98
4610 && !successful_parse_p)
4612 /* Restore the saved scope. */
4613 parser->scope = saved_scope;
4614 parser->qualifying_scope = saved_qualifying_scope;
4615 parser->object_scope = saved_object_scope;
4617 /* Parse tentatively. */
4618 cp_parser_parse_tentatively (parser);
4620 /* Parse a typedef-name or enum-name. */
4621 scope = cp_parser_nonclass_name (parser);
4623 /* "If the name found does not designate a namespace or a class,
4624 enumeration, or dependent type, the program is ill-formed."
4626 We cover classes and dependent types above and namespaces below,
4627 so this code is only looking for enums. */
4628 if (!scope || TREE_CODE (scope) != TYPE_DECL
4629 || TREE_CODE (TREE_TYPE (scope)) != ENUMERAL_TYPE)
4630 cp_parser_simulate_error (parser);
4632 successful_parse_p = cp_parser_parse_definitely (parser);
4634 /* If that didn't work, try for a namespace-name. */
4635 if (!only_class_p && !successful_parse_p)
4637 /* Restore the saved scope. */
4638 parser->scope = saved_scope;
4639 parser->qualifying_scope = saved_qualifying_scope;
4640 parser->object_scope = saved_object_scope;
4641 /* If we are not looking at an identifier followed by the scope
4642 resolution operator, then this is not part of a
4643 nested-name-specifier. (Note that this function is only used
4644 to parse the components of a nested-name-specifier.) */
4645 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
4646 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
4647 return error_mark_node;
4648 scope = cp_parser_namespace_name (parser);
4654 /* Parse a postfix-expression.
4658 postfix-expression [ expression ]
4659 postfix-expression ( expression-list [opt] )
4660 simple-type-specifier ( expression-list [opt] )
4661 typename :: [opt] nested-name-specifier identifier
4662 ( expression-list [opt] )
4663 typename :: [opt] nested-name-specifier template [opt] template-id
4664 ( expression-list [opt] )
4665 postfix-expression . template [opt] id-expression
4666 postfix-expression -> template [opt] id-expression
4667 postfix-expression . pseudo-destructor-name
4668 postfix-expression -> pseudo-destructor-name
4669 postfix-expression ++
4670 postfix-expression --
4671 dynamic_cast < type-id > ( expression )
4672 static_cast < type-id > ( expression )
4673 reinterpret_cast < type-id > ( expression )
4674 const_cast < type-id > ( expression )
4675 typeid ( expression )
4681 ( type-id ) { initializer-list , [opt] }
4683 This extension is a GNU version of the C99 compound-literal
4684 construct. (The C99 grammar uses `type-name' instead of `type-id',
4685 but they are essentially the same concept.)
4687 If ADDRESS_P is true, the postfix expression is the operand of the
4688 `&' operator. CAST_P is true if this expression is the target of a
4691 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
4692 class member access expressions [expr.ref].
4694 Returns a representation of the expression. */
4697 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
4698 bool member_access_only_p,
4699 cp_id_kind * pidk_return)
4703 cp_id_kind idk = CP_ID_KIND_NONE;
4704 tree postfix_expression = NULL_TREE;
4705 bool is_member_access = false;
4707 /* Peek at the next token. */
4708 token = cp_lexer_peek_token (parser->lexer);
4709 /* Some of the productions are determined by keywords. */
4710 keyword = token->keyword;
4720 const char *saved_message;
4722 /* All of these can be handled in the same way from the point
4723 of view of parsing. Begin by consuming the token
4724 identifying the cast. */
4725 cp_lexer_consume_token (parser->lexer);
4727 /* New types cannot be defined in the cast. */
4728 saved_message = parser->type_definition_forbidden_message;
4729 parser->type_definition_forbidden_message
4730 = G_("types may not be defined in casts");
4732 /* Look for the opening `<'. */
4733 cp_parser_require (parser, CPP_LESS, RT_LESS);
4734 /* Parse the type to which we are casting. */
4735 type = cp_parser_type_id (parser);
4736 /* Look for the closing `>'. */
4737 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
4738 /* Restore the old message. */
4739 parser->type_definition_forbidden_message = saved_message;
4741 /* And the expression which is being cast. */
4742 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4743 expression = cp_parser_expression (parser, /*cast_p=*/true, & idk);
4744 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4746 /* Only type conversions to integral or enumeration types
4747 can be used in constant-expressions. */
4748 if (!cast_valid_in_integral_constant_expression_p (type)
4749 && cp_parser_non_integral_constant_expression (parser, NIC_CAST))
4750 return error_mark_node;
4756 = build_dynamic_cast (type, expression, tf_warning_or_error);
4760 = build_static_cast (type, expression, tf_warning_or_error);
4764 = build_reinterpret_cast (type, expression,
4765 tf_warning_or_error);
4769 = build_const_cast (type, expression, tf_warning_or_error);
4780 const char *saved_message;
4781 bool saved_in_type_id_in_expr_p;
4783 /* Consume the `typeid' token. */
4784 cp_lexer_consume_token (parser->lexer);
4785 /* Look for the `(' token. */
4786 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4787 /* Types cannot be defined in a `typeid' expression. */
4788 saved_message = parser->type_definition_forbidden_message;
4789 parser->type_definition_forbidden_message
4790 = G_("types may not be defined in a %<typeid%> expression");
4791 /* We can't be sure yet whether we're looking at a type-id or an
4793 cp_parser_parse_tentatively (parser);
4794 /* Try a type-id first. */
4795 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4796 parser->in_type_id_in_expr_p = true;
4797 type = cp_parser_type_id (parser);
4798 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4799 /* Look for the `)' token. Otherwise, we can't be sure that
4800 we're not looking at an expression: consider `typeid (int
4801 (3))', for example. */
4802 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4803 /* If all went well, simply lookup the type-id. */
4804 if (cp_parser_parse_definitely (parser))
4805 postfix_expression = get_typeid (type);
4806 /* Otherwise, fall back to the expression variant. */
4811 /* Look for an expression. */
4812 expression = cp_parser_expression (parser, /*cast_p=*/false, & idk);
4813 /* Compute its typeid. */
4814 postfix_expression = build_typeid (expression);
4815 /* Look for the `)' token. */
4816 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4818 /* Restore the saved message. */
4819 parser->type_definition_forbidden_message = saved_message;
4820 /* `typeid' may not appear in an integral constant expression. */
4821 if (cp_parser_non_integral_constant_expression(parser, NIC_TYPEID))
4822 return error_mark_node;
4829 /* The syntax permitted here is the same permitted for an
4830 elaborated-type-specifier. */
4831 type = cp_parser_elaborated_type_specifier (parser,
4832 /*is_friend=*/false,
4833 /*is_declaration=*/false);
4834 postfix_expression = cp_parser_functional_cast (parser, type);
4842 /* If the next thing is a simple-type-specifier, we may be
4843 looking at a functional cast. We could also be looking at
4844 an id-expression. So, we try the functional cast, and if
4845 that doesn't work we fall back to the primary-expression. */
4846 cp_parser_parse_tentatively (parser);
4847 /* Look for the simple-type-specifier. */
4848 type = cp_parser_simple_type_specifier (parser,
4849 /*decl_specs=*/NULL,
4850 CP_PARSER_FLAGS_NONE);
4851 /* Parse the cast itself. */
4852 if (!cp_parser_error_occurred (parser))
4854 = cp_parser_functional_cast (parser, type);
4855 /* If that worked, we're done. */
4856 if (cp_parser_parse_definitely (parser))
4859 /* If the functional-cast didn't work out, try a
4860 compound-literal. */
4861 if (cp_parser_allow_gnu_extensions_p (parser)
4862 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
4864 VEC(constructor_elt,gc) *initializer_list = NULL;
4865 bool saved_in_type_id_in_expr_p;
4867 cp_parser_parse_tentatively (parser);
4868 /* Consume the `('. */
4869 cp_lexer_consume_token (parser->lexer);
4870 /* Parse the type. */
4871 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4872 parser->in_type_id_in_expr_p = true;
4873 type = cp_parser_type_id (parser);
4874 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4875 /* Look for the `)'. */
4876 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4877 /* Look for the `{'. */
4878 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
4879 /* If things aren't going well, there's no need to
4881 if (!cp_parser_error_occurred (parser))
4883 bool non_constant_p;
4884 /* Parse the initializer-list. */
4886 = cp_parser_initializer_list (parser, &non_constant_p);
4887 /* Allow a trailing `,'. */
4888 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
4889 cp_lexer_consume_token (parser->lexer);
4890 /* Look for the final `}'. */
4891 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
4893 /* If that worked, we're definitely looking at a
4894 compound-literal expression. */
4895 if (cp_parser_parse_definitely (parser))
4897 /* Warn the user that a compound literal is not
4898 allowed in standard C++. */
4899 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids compound-literals");
4900 /* For simplicity, we disallow compound literals in
4901 constant-expressions. We could
4902 allow compound literals of integer type, whose
4903 initializer was a constant, in constant
4904 expressions. Permitting that usage, as a further
4905 extension, would not change the meaning of any
4906 currently accepted programs. (Of course, as
4907 compound literals are not part of ISO C++, the
4908 standard has nothing to say.) */
4909 if (cp_parser_non_integral_constant_expression (parser,
4912 postfix_expression = error_mark_node;
4915 /* Form the representation of the compound-literal. */
4917 = (finish_compound_literal
4918 (type, build_constructor (init_list_type_node,
4920 tf_warning_or_error));
4925 /* It must be a primary-expression. */
4927 = cp_parser_primary_expression (parser, address_p, cast_p,
4928 /*template_arg_p=*/false,
4934 /* Keep looping until the postfix-expression is complete. */
4937 if (idk == CP_ID_KIND_UNQUALIFIED
4938 && TREE_CODE (postfix_expression) == IDENTIFIER_NODE
4939 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
4940 /* It is not a Koenig lookup function call. */
4942 = unqualified_name_lookup_error (postfix_expression);
4944 /* Peek at the next token. */
4945 token = cp_lexer_peek_token (parser->lexer);
4947 switch (token->type)
4949 case CPP_OPEN_SQUARE:
4951 = cp_parser_postfix_open_square_expression (parser,
4954 idk = CP_ID_KIND_NONE;
4955 is_member_access = false;
4958 case CPP_OPEN_PAREN:
4959 /* postfix-expression ( expression-list [opt] ) */
4962 bool is_builtin_constant_p;
4963 bool saved_integral_constant_expression_p = false;
4964 bool saved_non_integral_constant_expression_p = false;
4967 is_member_access = false;
4969 is_builtin_constant_p
4970 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
4971 if (is_builtin_constant_p)
4973 /* The whole point of __builtin_constant_p is to allow
4974 non-constant expressions to appear as arguments. */
4975 saved_integral_constant_expression_p
4976 = parser->integral_constant_expression_p;
4977 saved_non_integral_constant_expression_p
4978 = parser->non_integral_constant_expression_p;
4979 parser->integral_constant_expression_p = false;
4981 args = (cp_parser_parenthesized_expression_list
4983 /*cast_p=*/false, /*allow_expansion_p=*/true,
4984 /*non_constant_p=*/NULL));
4985 if (is_builtin_constant_p)
4987 parser->integral_constant_expression_p
4988 = saved_integral_constant_expression_p;
4989 parser->non_integral_constant_expression_p
4990 = saved_non_integral_constant_expression_p;
4995 postfix_expression = error_mark_node;
4999 /* Function calls are not permitted in
5000 constant-expressions. */
5001 if (! builtin_valid_in_constant_expr_p (postfix_expression)
5002 && cp_parser_non_integral_constant_expression (parser,
5005 postfix_expression = error_mark_node;
5006 release_tree_vector (args);
5011 if (idk == CP_ID_KIND_UNQUALIFIED
5012 || idk == CP_ID_KIND_TEMPLATE_ID)
5014 if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
5016 if (!VEC_empty (tree, args))
5019 if (!any_type_dependent_arguments_p (args))
5021 = perform_koenig_lookup (postfix_expression, args,
5022 /*include_std=*/false,
5023 tf_warning_or_error);
5027 = unqualified_fn_lookup_error (postfix_expression);
5029 /* We do not perform argument-dependent lookup if
5030 normal lookup finds a non-function, in accordance
5031 with the expected resolution of DR 218. */
5032 else if (!VEC_empty (tree, args)
5033 && is_overloaded_fn (postfix_expression))
5035 tree fn = get_first_fn (postfix_expression);
5036 fn = STRIP_TEMPLATE (fn);
5038 /* Do not do argument dependent lookup if regular
5039 lookup finds a member function or a block-scope
5040 function declaration. [basic.lookup.argdep]/3 */
5041 if (!DECL_FUNCTION_MEMBER_P (fn)
5042 && !DECL_LOCAL_FUNCTION_P (fn))
5045 if (!any_type_dependent_arguments_p (args))
5047 = perform_koenig_lookup (postfix_expression, args,
5048 /*include_std=*/false,
5049 tf_warning_or_error);
5054 if (TREE_CODE (postfix_expression) == COMPONENT_REF)
5056 tree instance = TREE_OPERAND (postfix_expression, 0);
5057 tree fn = TREE_OPERAND (postfix_expression, 1);
5059 if (processing_template_decl
5060 && (type_dependent_expression_p (instance)
5061 || (!BASELINK_P (fn)
5062 && TREE_CODE (fn) != FIELD_DECL)
5063 || type_dependent_expression_p (fn)
5064 || any_type_dependent_arguments_p (args)))
5067 = build_nt_call_vec (postfix_expression, args);
5068 release_tree_vector (args);
5072 if (BASELINK_P (fn))
5075 = (build_new_method_call
5076 (instance, fn, &args, NULL_TREE,
5077 (idk == CP_ID_KIND_QUALIFIED
5078 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
5081 tf_warning_or_error));
5085 = finish_call_expr (postfix_expression, &args,
5086 /*disallow_virtual=*/false,
5088 tf_warning_or_error);
5090 else if (TREE_CODE (postfix_expression) == OFFSET_REF
5091 || TREE_CODE (postfix_expression) == MEMBER_REF
5092 || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
5093 postfix_expression = (build_offset_ref_call_from_tree
5094 (postfix_expression, &args));
5095 else if (idk == CP_ID_KIND_QUALIFIED)
5096 /* A call to a static class member, or a namespace-scope
5099 = finish_call_expr (postfix_expression, &args,
5100 /*disallow_virtual=*/true,
5102 tf_warning_or_error);
5104 /* All other function calls. */
5106 = finish_call_expr (postfix_expression, &args,
5107 /*disallow_virtual=*/false,
5109 tf_warning_or_error);
5111 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
5112 idk = CP_ID_KIND_NONE;
5114 release_tree_vector (args);
5120 /* postfix-expression . template [opt] id-expression
5121 postfix-expression . pseudo-destructor-name
5122 postfix-expression -> template [opt] id-expression
5123 postfix-expression -> pseudo-destructor-name */
5125 /* Consume the `.' or `->' operator. */
5126 cp_lexer_consume_token (parser->lexer);
5129 = cp_parser_postfix_dot_deref_expression (parser, token->type,
5134 is_member_access = true;
5138 /* postfix-expression ++ */
5139 /* Consume the `++' token. */
5140 cp_lexer_consume_token (parser->lexer);
5141 /* Generate a representation for the complete expression. */
5143 = finish_increment_expr (postfix_expression,
5144 POSTINCREMENT_EXPR);
5145 /* Increments may not appear in constant-expressions. */
5146 if (cp_parser_non_integral_constant_expression (parser, NIC_INC))
5147 postfix_expression = error_mark_node;
5148 idk = CP_ID_KIND_NONE;
5149 is_member_access = false;
5152 case CPP_MINUS_MINUS:
5153 /* postfix-expression -- */
5154 /* Consume the `--' token. */
5155 cp_lexer_consume_token (parser->lexer);
5156 /* Generate a representation for the complete expression. */
5158 = finish_increment_expr (postfix_expression,
5159 POSTDECREMENT_EXPR);
5160 /* Decrements may not appear in constant-expressions. */
5161 if (cp_parser_non_integral_constant_expression (parser, NIC_DEC))
5162 postfix_expression = error_mark_node;
5163 idk = CP_ID_KIND_NONE;
5164 is_member_access = false;
5168 if (pidk_return != NULL)
5169 * pidk_return = idk;
5170 if (member_access_only_p)
5171 return is_member_access? postfix_expression : error_mark_node;
5173 return postfix_expression;
5177 /* We should never get here. */
5179 return error_mark_node;
5182 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
5183 by cp_parser_builtin_offsetof. We're looking for
5185 postfix-expression [ expression ]
5187 FOR_OFFSETOF is set if we're being called in that context, which
5188 changes how we deal with integer constant expressions. */
5191 cp_parser_postfix_open_square_expression (cp_parser *parser,
5192 tree postfix_expression,
5197 /* Consume the `[' token. */
5198 cp_lexer_consume_token (parser->lexer);
5200 /* Parse the index expression. */
5201 /* ??? For offsetof, there is a question of what to allow here. If
5202 offsetof is not being used in an integral constant expression context,
5203 then we *could* get the right answer by computing the value at runtime.
5204 If we are in an integral constant expression context, then we might
5205 could accept any constant expression; hard to say without analysis.
5206 Rather than open the barn door too wide right away, allow only integer
5207 constant expressions here. */
5209 index = cp_parser_constant_expression (parser, false, NULL);
5211 index = cp_parser_expression (parser, /*cast_p=*/false, NULL);
5213 /* Look for the closing `]'. */
5214 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
5216 /* Build the ARRAY_REF. */
5217 postfix_expression = grok_array_decl (postfix_expression, index);
5219 /* When not doing offsetof, array references are not permitted in
5220 constant-expressions. */
5222 && (cp_parser_non_integral_constant_expression (parser, NIC_ARRAY_REF)))
5223 postfix_expression = error_mark_node;
5225 return postfix_expression;
5228 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
5229 by cp_parser_builtin_offsetof. We're looking for
5231 postfix-expression . template [opt] id-expression
5232 postfix-expression . pseudo-destructor-name
5233 postfix-expression -> template [opt] id-expression
5234 postfix-expression -> pseudo-destructor-name
5236 FOR_OFFSETOF is set if we're being called in that context. That sorta
5237 limits what of the above we'll actually accept, but nevermind.
5238 TOKEN_TYPE is the "." or "->" token, which will already have been
5239 removed from the stream. */
5242 cp_parser_postfix_dot_deref_expression (cp_parser *parser,
5243 enum cpp_ttype token_type,
5244 tree postfix_expression,
5245 bool for_offsetof, cp_id_kind *idk,
5246 location_t location)
5250 bool pseudo_destructor_p;
5251 tree scope = NULL_TREE;
5253 /* If this is a `->' operator, dereference the pointer. */
5254 if (token_type == CPP_DEREF)
5255 postfix_expression = build_x_arrow (postfix_expression);
5256 /* Check to see whether or not the expression is type-dependent. */
5257 dependent_p = type_dependent_expression_p (postfix_expression);
5258 /* The identifier following the `->' or `.' is not qualified. */
5259 parser->scope = NULL_TREE;
5260 parser->qualifying_scope = NULL_TREE;
5261 parser->object_scope = NULL_TREE;
5262 *idk = CP_ID_KIND_NONE;
5264 /* Enter the scope corresponding to the type of the object
5265 given by the POSTFIX_EXPRESSION. */
5266 if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
5268 scope = TREE_TYPE (postfix_expression);
5269 /* According to the standard, no expression should ever have
5270 reference type. Unfortunately, we do not currently match
5271 the standard in this respect in that our internal representation
5272 of an expression may have reference type even when the standard
5273 says it does not. Therefore, we have to manually obtain the
5274 underlying type here. */
5275 scope = non_reference (scope);
5276 /* The type of the POSTFIX_EXPRESSION must be complete. */
5277 if (scope == unknown_type_node)
5279 error_at (location, "%qE does not have class type",
5280 postfix_expression);
5284 scope = complete_type_or_else (scope, NULL_TREE);
5285 /* Let the name lookup machinery know that we are processing a
5286 class member access expression. */
5287 parser->context->object_type = scope;
5288 /* If something went wrong, we want to be able to discern that case,
5289 as opposed to the case where there was no SCOPE due to the type
5290 of expression being dependent. */
5292 scope = error_mark_node;
5293 /* If the SCOPE was erroneous, make the various semantic analysis
5294 functions exit quickly -- and without issuing additional error
5296 if (scope == error_mark_node)
5297 postfix_expression = error_mark_node;
5300 /* Assume this expression is not a pseudo-destructor access. */
5301 pseudo_destructor_p = false;
5303 /* If the SCOPE is a scalar type, then, if this is a valid program,
5304 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
5305 is type dependent, it can be pseudo-destructor-name or something else.
5306 Try to parse it as pseudo-destructor-name first. */
5307 if ((scope && SCALAR_TYPE_P (scope)) || dependent_p)
5312 cp_parser_parse_tentatively (parser);
5313 /* Parse the pseudo-destructor-name. */
5315 cp_parser_pseudo_destructor_name (parser, &s, &type);
5317 && (cp_parser_error_occurred (parser)
5318 || TREE_CODE (type) != TYPE_DECL
5319 || !SCALAR_TYPE_P (TREE_TYPE (type))))
5320 cp_parser_abort_tentative_parse (parser);
5321 else if (cp_parser_parse_definitely (parser))
5323 pseudo_destructor_p = true;
5325 = finish_pseudo_destructor_expr (postfix_expression,
5326 s, TREE_TYPE (type));
5330 if (!pseudo_destructor_p)
5332 /* If the SCOPE is not a scalar type, we are looking at an
5333 ordinary class member access expression, rather than a
5334 pseudo-destructor-name. */
5336 cp_token *token = cp_lexer_peek_token (parser->lexer);
5337 /* Parse the id-expression. */
5338 name = (cp_parser_id_expression
5340 cp_parser_optional_template_keyword (parser),
5341 /*check_dependency_p=*/true,
5343 /*declarator_p=*/false,
5344 /*optional_p=*/false));
5345 /* In general, build a SCOPE_REF if the member name is qualified.
5346 However, if the name was not dependent and has already been
5347 resolved; there is no need to build the SCOPE_REF. For example;
5349 struct X { void f(); };
5350 template <typename T> void f(T* t) { t->X::f(); }
5352 Even though "t" is dependent, "X::f" is not and has been resolved
5353 to a BASELINK; there is no need to include scope information. */
5355 /* But we do need to remember that there was an explicit scope for
5356 virtual function calls. */
5358 *idk = CP_ID_KIND_QUALIFIED;
5360 /* If the name is a template-id that names a type, we will get a
5361 TYPE_DECL here. That is invalid code. */
5362 if (TREE_CODE (name) == TYPE_DECL)
5364 error_at (token->location, "invalid use of %qD", name);
5365 postfix_expression = error_mark_node;
5369 if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
5371 name = build_qualified_name (/*type=*/NULL_TREE,
5375 parser->scope = NULL_TREE;
5376 parser->qualifying_scope = NULL_TREE;
5377 parser->object_scope = NULL_TREE;
5379 if (scope && name && BASELINK_P (name))
5380 adjust_result_of_qualified_name_lookup
5381 (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope);
5383 = finish_class_member_access_expr (postfix_expression, name,
5385 tf_warning_or_error);
5389 /* We no longer need to look up names in the scope of the object on
5390 the left-hand side of the `.' or `->' operator. */
5391 parser->context->object_type = NULL_TREE;
5393 /* Outside of offsetof, these operators may not appear in
5394 constant-expressions. */
5396 && (cp_parser_non_integral_constant_expression
5397 (parser, token_type == CPP_DEREF ? NIC_ARROW : NIC_POINT)))
5398 postfix_expression = error_mark_node;
5400 return postfix_expression;
5403 /* Parse a parenthesized expression-list.
5406 assignment-expression
5407 expression-list, assignment-expression
5412 identifier, expression-list
5414 CAST_P is true if this expression is the target of a cast.
5416 ALLOW_EXPANSION_P is true if this expression allows expansion of an
5419 Returns a vector of trees. Each element is a representation of an
5420 assignment-expression. NULL is returned if the ( and or ) are
5421 missing. An empty, but allocated, vector is returned on no
5422 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
5423 if we are parsing an attribute list for an attribute that wants a
5424 plain identifier argument, normal_attr for an attribute that wants
5425 an expression, or non_attr if we aren't parsing an attribute list. If
5426 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
5427 not all of the expressions in the list were constant. */
5429 static VEC(tree,gc) *
5430 cp_parser_parenthesized_expression_list (cp_parser* parser,
5431 int is_attribute_list,
5433 bool allow_expansion_p,
5434 bool *non_constant_p)
5436 VEC(tree,gc) *expression_list;
5437 bool fold_expr_p = is_attribute_list != non_attr;
5438 tree identifier = NULL_TREE;
5439 bool saved_greater_than_is_operator_p;
5441 /* Assume all the expressions will be constant. */
5443 *non_constant_p = false;
5445 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
5448 expression_list = make_tree_vector ();
5450 /* Within a parenthesized expression, a `>' token is always
5451 the greater-than operator. */
5452 saved_greater_than_is_operator_p
5453 = parser->greater_than_is_operator_p;
5454 parser->greater_than_is_operator_p = true;
5456 /* Consume expressions until there are no more. */
5457 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
5462 /* At the beginning of attribute lists, check to see if the
5463 next token is an identifier. */
5464 if (is_attribute_list == id_attr
5465 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
5469 /* Consume the identifier. */
5470 token = cp_lexer_consume_token (parser->lexer);
5471 /* Save the identifier. */
5472 identifier = token->u.value;
5476 bool expr_non_constant_p;
5478 /* Parse the next assignment-expression. */
5479 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
5481 /* A braced-init-list. */
5482 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5483 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
5484 if (non_constant_p && expr_non_constant_p)
5485 *non_constant_p = true;
5487 else if (non_constant_p)
5489 expr = (cp_parser_constant_expression
5490 (parser, /*allow_non_constant_p=*/true,
5491 &expr_non_constant_p));
5492 if (expr_non_constant_p)
5493 *non_constant_p = true;
5496 expr = cp_parser_assignment_expression (parser, cast_p, NULL);
5499 expr = fold_non_dependent_expr (expr);
5501 /* If we have an ellipsis, then this is an expression
5503 if (allow_expansion_p
5504 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5506 /* Consume the `...'. */
5507 cp_lexer_consume_token (parser->lexer);
5509 /* Build the argument pack. */
5510 expr = make_pack_expansion (expr);
5513 /* Add it to the list. We add error_mark_node
5514 expressions to the list, so that we can still tell if
5515 the correct form for a parenthesized expression-list
5516 is found. That gives better errors. */
5517 VEC_safe_push (tree, gc, expression_list, expr);
5519 if (expr == error_mark_node)
5523 /* After the first item, attribute lists look the same as
5524 expression lists. */
5525 is_attribute_list = non_attr;
5528 /* If the next token isn't a `,', then we are done. */
5529 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
5532 /* Otherwise, consume the `,' and keep going. */
5533 cp_lexer_consume_token (parser->lexer);
5536 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
5541 /* We try and resync to an unnested comma, as that will give the
5542 user better diagnostics. */
5543 ending = cp_parser_skip_to_closing_parenthesis (parser,
5544 /*recovering=*/true,
5546 /*consume_paren=*/true);
5551 parser->greater_than_is_operator_p
5552 = saved_greater_than_is_operator_p;
5557 parser->greater_than_is_operator_p
5558 = saved_greater_than_is_operator_p;
5561 VEC_safe_insert (tree, gc, expression_list, 0, identifier);
5563 return expression_list;
5566 /* Parse a pseudo-destructor-name.
5568 pseudo-destructor-name:
5569 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
5570 :: [opt] nested-name-specifier template template-id :: ~ type-name
5571 :: [opt] nested-name-specifier [opt] ~ type-name
5573 If either of the first two productions is used, sets *SCOPE to the
5574 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
5575 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
5576 or ERROR_MARK_NODE if the parse fails. */
5579 cp_parser_pseudo_destructor_name (cp_parser* parser,
5583 bool nested_name_specifier_p;
5585 /* Assume that things will not work out. */
5586 *type = error_mark_node;
5588 /* Look for the optional `::' operator. */
5589 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
5590 /* Look for the optional nested-name-specifier. */
5591 nested_name_specifier_p
5592 = (cp_parser_nested_name_specifier_opt (parser,
5593 /*typename_keyword_p=*/false,
5594 /*check_dependency_p=*/true,
5596 /*is_declaration=*/false)
5598 /* Now, if we saw a nested-name-specifier, we might be doing the
5599 second production. */
5600 if (nested_name_specifier_p
5601 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
5603 /* Consume the `template' keyword. */
5604 cp_lexer_consume_token (parser->lexer);
5605 /* Parse the template-id. */
5606 cp_parser_template_id (parser,
5607 /*template_keyword_p=*/true,
5608 /*check_dependency_p=*/false,
5609 /*is_declaration=*/true);
5610 /* Look for the `::' token. */
5611 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
5613 /* If the next token is not a `~', then there might be some
5614 additional qualification. */
5615 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
5617 /* At this point, we're looking for "type-name :: ~". The type-name
5618 must not be a class-name, since this is a pseudo-destructor. So,
5619 it must be either an enum-name, or a typedef-name -- both of which
5620 are just identifiers. So, we peek ahead to check that the "::"
5621 and "~" tokens are present; if they are not, then we can avoid
5622 calling type_name. */
5623 if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
5624 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
5625 || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
5627 cp_parser_error (parser, "non-scalar type");
5631 /* Look for the type-name. */
5632 *scope = TREE_TYPE (cp_parser_nonclass_name (parser));
5633 if (*scope == error_mark_node)
5636 /* Look for the `::' token. */
5637 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
5642 /* Look for the `~'. */
5643 cp_parser_require (parser, CPP_COMPL, RT_COMPL);
5644 /* Look for the type-name again. We are not responsible for
5645 checking that it matches the first type-name. */
5646 *type = cp_parser_nonclass_name (parser);
5649 /* Parse a unary-expression.
5655 unary-operator cast-expression
5656 sizeof unary-expression
5658 alignof ( type-id ) [C++0x]
5665 __extension__ cast-expression
5666 __alignof__ unary-expression
5667 __alignof__ ( type-id )
5668 alignof unary-expression [C++0x]
5669 __real__ cast-expression
5670 __imag__ cast-expression
5673 ADDRESS_P is true iff the unary-expression is appearing as the
5674 operand of the `&' operator. CAST_P is true if this expression is
5675 the target of a cast.
5677 Returns a representation of the expression. */
5680 cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p,
5684 enum tree_code unary_operator;
5686 /* Peek at the next token. */
5687 token = cp_lexer_peek_token (parser->lexer);
5688 /* Some keywords give away the kind of expression. */
5689 if (token->type == CPP_KEYWORD)
5691 enum rid keyword = token->keyword;
5701 op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
5702 /* Consume the token. */
5703 cp_lexer_consume_token (parser->lexer);
5704 /* Parse the operand. */
5705 operand = cp_parser_sizeof_operand (parser, keyword);
5707 if (TYPE_P (operand))
5708 return cxx_sizeof_or_alignof_type (operand, op, true);
5711 /* ISO C++ defines alignof only with types, not with
5712 expressions. So pedwarn if alignof is used with a non-
5713 type expression. However, __alignof__ is ok. */
5714 if (!strcmp (IDENTIFIER_POINTER (token->u.value), "alignof"))
5715 pedwarn (token->location, OPT_pedantic,
5716 "ISO C++ does not allow %<alignof%> "
5719 return cxx_sizeof_or_alignof_expr (operand, op, true);
5724 return cp_parser_new_expression (parser);
5727 return cp_parser_delete_expression (parser);
5731 /* The saved value of the PEDANTIC flag. */
5735 /* Save away the PEDANTIC flag. */
5736 cp_parser_extension_opt (parser, &saved_pedantic);
5737 /* Parse the cast-expression. */
5738 expr = cp_parser_simple_cast_expression (parser);
5739 /* Restore the PEDANTIC flag. */
5740 pedantic = saved_pedantic;
5750 /* Consume the `__real__' or `__imag__' token. */
5751 cp_lexer_consume_token (parser->lexer);
5752 /* Parse the cast-expression. */
5753 expression = cp_parser_simple_cast_expression (parser);
5754 /* Create the complete representation. */
5755 return build_x_unary_op ((keyword == RID_REALPART
5756 ? REALPART_EXPR : IMAGPART_EXPR),
5758 tf_warning_or_error);
5765 const char *saved_message;
5766 bool saved_integral_constant_expression_p;
5767 bool saved_non_integral_constant_expression_p;
5768 bool saved_greater_than_is_operator_p;
5770 cp_lexer_consume_token (parser->lexer);
5771 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
5773 saved_message = parser->type_definition_forbidden_message;
5774 parser->type_definition_forbidden_message
5775 = G_("types may not be defined in %<noexcept%> expressions");
5777 saved_integral_constant_expression_p
5778 = parser->integral_constant_expression_p;
5779 saved_non_integral_constant_expression_p
5780 = parser->non_integral_constant_expression_p;
5781 parser->integral_constant_expression_p = false;
5783 saved_greater_than_is_operator_p
5784 = parser->greater_than_is_operator_p;
5785 parser->greater_than_is_operator_p = true;
5787 ++cp_unevaluated_operand;
5788 ++c_inhibit_evaluation_warnings;
5789 expr = cp_parser_expression (parser, false, NULL);
5790 --c_inhibit_evaluation_warnings;
5791 --cp_unevaluated_operand;
5793 parser->greater_than_is_operator_p
5794 = saved_greater_than_is_operator_p;
5796 parser->integral_constant_expression_p
5797 = saved_integral_constant_expression_p;
5798 parser->non_integral_constant_expression_p
5799 = saved_non_integral_constant_expression_p;
5801 parser->type_definition_forbidden_message = saved_message;
5803 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
5804 return finish_noexcept_expr (expr, tf_warning_or_error);
5812 /* Look for the `:: new' and `:: delete', which also signal the
5813 beginning of a new-expression, or delete-expression,
5814 respectively. If the next token is `::', then it might be one of
5816 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
5820 /* See if the token after the `::' is one of the keywords in
5821 which we're interested. */
5822 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
5823 /* If it's `new', we have a new-expression. */
5824 if (keyword == RID_NEW)
5825 return cp_parser_new_expression (parser);
5826 /* Similarly, for `delete'. */
5827 else if (keyword == RID_DELETE)
5828 return cp_parser_delete_expression (parser);
5831 /* Look for a unary operator. */
5832 unary_operator = cp_parser_unary_operator (token);
5833 /* The `++' and `--' operators can be handled similarly, even though
5834 they are not technically unary-operators in the grammar. */
5835 if (unary_operator == ERROR_MARK)
5837 if (token->type == CPP_PLUS_PLUS)
5838 unary_operator = PREINCREMENT_EXPR;
5839 else if (token->type == CPP_MINUS_MINUS)
5840 unary_operator = PREDECREMENT_EXPR;
5841 /* Handle the GNU address-of-label extension. */
5842 else if (cp_parser_allow_gnu_extensions_p (parser)
5843 && token->type == CPP_AND_AND)
5847 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
5849 /* Consume the '&&' token. */
5850 cp_lexer_consume_token (parser->lexer);
5851 /* Look for the identifier. */
5852 identifier = cp_parser_identifier (parser);
5853 /* Create an expression representing the address. */
5854 expression = finish_label_address_expr (identifier, loc);
5855 if (cp_parser_non_integral_constant_expression (parser,
5857 expression = error_mark_node;
5861 if (unary_operator != ERROR_MARK)
5863 tree cast_expression;
5864 tree expression = error_mark_node;
5865 non_integral_constant non_constant_p = NIC_NONE;
5867 /* Consume the operator token. */
5868 token = cp_lexer_consume_token (parser->lexer);
5869 /* Parse the cast-expression. */
5871 = cp_parser_cast_expression (parser,
5872 unary_operator == ADDR_EXPR,
5873 /*cast_p=*/false, pidk);
5874 /* Now, build an appropriate representation. */
5875 switch (unary_operator)
5878 non_constant_p = NIC_STAR;
5879 expression = build_x_indirect_ref (cast_expression, RO_UNARY_STAR,
5880 tf_warning_or_error);
5884 non_constant_p = NIC_ADDR;
5887 expression = build_x_unary_op (unary_operator, cast_expression,
5888 tf_warning_or_error);
5891 case PREINCREMENT_EXPR:
5892 case PREDECREMENT_EXPR:
5893 non_constant_p = unary_operator == PREINCREMENT_EXPR
5894 ? NIC_PREINCREMENT : NIC_PREDECREMENT;
5896 case UNARY_PLUS_EXPR:
5898 case TRUTH_NOT_EXPR:
5899 expression = finish_unary_op_expr (unary_operator, cast_expression);
5906 if (non_constant_p != NIC_NONE
5907 && cp_parser_non_integral_constant_expression (parser,
5909 expression = error_mark_node;
5914 return cp_parser_postfix_expression (parser, address_p, cast_p,
5915 /*member_access_only_p=*/false,
5919 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
5920 unary-operator, the corresponding tree code is returned. */
5922 static enum tree_code
5923 cp_parser_unary_operator (cp_token* token)
5925 switch (token->type)
5928 return INDIRECT_REF;
5934 return UNARY_PLUS_EXPR;
5940 return TRUTH_NOT_EXPR;
5943 return BIT_NOT_EXPR;
5950 /* Parse a new-expression.
5953 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
5954 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
5956 Returns a representation of the expression. */
5959 cp_parser_new_expression (cp_parser* parser)
5961 bool global_scope_p;
5962 VEC(tree,gc) *placement;
5964 VEC(tree,gc) *initializer;
5968 /* Look for the optional `::' operator. */
5970 = (cp_parser_global_scope_opt (parser,
5971 /*current_scope_valid_p=*/false)
5973 /* Look for the `new' operator. */
5974 cp_parser_require_keyword (parser, RID_NEW, RT_NEW);
5975 /* There's no easy way to tell a new-placement from the
5976 `( type-id )' construct. */
5977 cp_parser_parse_tentatively (parser);
5978 /* Look for a new-placement. */
5979 placement = cp_parser_new_placement (parser);
5980 /* If that didn't work out, there's no new-placement. */
5981 if (!cp_parser_parse_definitely (parser))
5983 if (placement != NULL)
5984 release_tree_vector (placement);
5988 /* If the next token is a `(', then we have a parenthesized
5990 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
5993 /* Consume the `('. */
5994 cp_lexer_consume_token (parser->lexer);
5995 /* Parse the type-id. */
5996 type = cp_parser_type_id (parser);
5997 /* Look for the closing `)'. */
5998 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
5999 token = cp_lexer_peek_token (parser->lexer);
6000 /* There should not be a direct-new-declarator in this production,
6001 but GCC used to allowed this, so we check and emit a sensible error
6002 message for this case. */
6003 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
6005 error_at (token->location,
6006 "array bound forbidden after parenthesized type-id");
6007 inform (token->location,
6008 "try removing the parentheses around the type-id");
6009 cp_parser_direct_new_declarator (parser);
6013 /* Otherwise, there must be a new-type-id. */
6015 type = cp_parser_new_type_id (parser, &nelts);
6017 /* If the next token is a `(' or '{', then we have a new-initializer. */
6018 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
6019 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
6020 initializer = cp_parser_new_initializer (parser);
6024 /* A new-expression may not appear in an integral constant
6026 if (cp_parser_non_integral_constant_expression (parser, NIC_NEW))
6027 ret = error_mark_node;
6030 /* Create a representation of the new-expression. */
6031 ret = build_new (&placement, type, nelts, &initializer, global_scope_p,
6032 tf_warning_or_error);
6035 if (placement != NULL)
6036 release_tree_vector (placement);
6037 if (initializer != NULL)
6038 release_tree_vector (initializer);
6043 /* Parse a new-placement.
6048 Returns the same representation as for an expression-list. */
6050 static VEC(tree,gc) *
6051 cp_parser_new_placement (cp_parser* parser)
6053 VEC(tree,gc) *expression_list;
6055 /* Parse the expression-list. */
6056 expression_list = (cp_parser_parenthesized_expression_list
6057 (parser, non_attr, /*cast_p=*/false,
6058 /*allow_expansion_p=*/true,
6059 /*non_constant_p=*/NULL));
6061 return expression_list;
6064 /* Parse a new-type-id.
6067 type-specifier-seq new-declarator [opt]
6069 Returns the TYPE allocated. If the new-type-id indicates an array
6070 type, *NELTS is set to the number of elements in the last array
6071 bound; the TYPE will not include the last array bound. */
6074 cp_parser_new_type_id (cp_parser* parser, tree *nelts)
6076 cp_decl_specifier_seq type_specifier_seq;
6077 cp_declarator *new_declarator;
6078 cp_declarator *declarator;
6079 cp_declarator *outer_declarator;
6080 const char *saved_message;
6083 /* The type-specifier sequence must not contain type definitions.
6084 (It cannot contain declarations of new types either, but if they
6085 are not definitions we will catch that because they are not
6087 saved_message = parser->type_definition_forbidden_message;
6088 parser->type_definition_forbidden_message
6089 = G_("types may not be defined in a new-type-id");
6090 /* Parse the type-specifier-seq. */
6091 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
6092 /*is_trailing_return=*/false,
6093 &type_specifier_seq);
6094 /* Restore the old message. */
6095 parser->type_definition_forbidden_message = saved_message;
6096 /* Parse the new-declarator. */
6097 new_declarator = cp_parser_new_declarator_opt (parser);
6099 /* Determine the number of elements in the last array dimension, if
6102 /* Skip down to the last array dimension. */
6103 declarator = new_declarator;
6104 outer_declarator = NULL;
6105 while (declarator && (declarator->kind == cdk_pointer
6106 || declarator->kind == cdk_ptrmem))
6108 outer_declarator = declarator;
6109 declarator = declarator->declarator;
6112 && declarator->kind == cdk_array
6113 && declarator->declarator
6114 && declarator->declarator->kind == cdk_array)
6116 outer_declarator = declarator;
6117 declarator = declarator->declarator;
6120 if (declarator && declarator->kind == cdk_array)
6122 *nelts = declarator->u.array.bounds;
6123 if (*nelts == error_mark_node)
6124 *nelts = integer_one_node;
6126 if (outer_declarator)
6127 outer_declarator->declarator = declarator->declarator;
6129 new_declarator = NULL;
6132 type = groktypename (&type_specifier_seq, new_declarator, false);
6136 /* Parse an (optional) new-declarator.
6139 ptr-operator new-declarator [opt]
6140 direct-new-declarator
6142 Returns the declarator. */
6144 static cp_declarator *
6145 cp_parser_new_declarator_opt (cp_parser* parser)
6147 enum tree_code code;
6149 cp_cv_quals cv_quals;
6151 /* We don't know if there's a ptr-operator next, or not. */
6152 cp_parser_parse_tentatively (parser);
6153 /* Look for a ptr-operator. */
6154 code = cp_parser_ptr_operator (parser, &type, &cv_quals);
6155 /* If that worked, look for more new-declarators. */
6156 if (cp_parser_parse_definitely (parser))
6158 cp_declarator *declarator;
6160 /* Parse another optional declarator. */
6161 declarator = cp_parser_new_declarator_opt (parser);
6163 return cp_parser_make_indirect_declarator
6164 (code, type, cv_quals, declarator);
6167 /* If the next token is a `[', there is a direct-new-declarator. */
6168 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
6169 return cp_parser_direct_new_declarator (parser);
6174 /* Parse a direct-new-declarator.
6176 direct-new-declarator:
6178 direct-new-declarator [constant-expression]
6182 static cp_declarator *
6183 cp_parser_direct_new_declarator (cp_parser* parser)
6185 cp_declarator *declarator = NULL;
6191 /* Look for the opening `['. */
6192 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
6193 /* The first expression is not required to be constant. */
6196 cp_token *token = cp_lexer_peek_token (parser->lexer);
6197 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
6198 /* The standard requires that the expression have integral
6199 type. DR 74 adds enumeration types. We believe that the
6200 real intent is that these expressions be handled like the
6201 expression in a `switch' condition, which also allows
6202 classes with a single conversion to integral or
6203 enumeration type. */
6204 if (!processing_template_decl)
6207 = build_expr_type_conversion (WANT_INT | WANT_ENUM,
6212 error_at (token->location,
6213 "expression in new-declarator must have integral "
6214 "or enumeration type");
6215 expression = error_mark_node;
6219 /* But all the other expressions must be. */
6222 = cp_parser_constant_expression (parser,
6223 /*allow_non_constant=*/false,
6225 /* Look for the closing `]'. */
6226 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
6228 /* Add this bound to the declarator. */
6229 declarator = make_array_declarator (declarator, expression);
6231 /* If the next token is not a `[', then there are no more
6233 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
6240 /* Parse a new-initializer.
6243 ( expression-list [opt] )
6246 Returns a representation of the expression-list. */
6248 static VEC(tree,gc) *
6249 cp_parser_new_initializer (cp_parser* parser)
6251 VEC(tree,gc) *expression_list;
6253 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
6256 bool expr_non_constant_p;
6257 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6258 t = cp_parser_braced_list (parser, &expr_non_constant_p);
6259 CONSTRUCTOR_IS_DIRECT_INIT (t) = 1;
6260 expression_list = make_tree_vector_single (t);
6263 expression_list = (cp_parser_parenthesized_expression_list
6264 (parser, non_attr, /*cast_p=*/false,
6265 /*allow_expansion_p=*/true,
6266 /*non_constant_p=*/NULL));
6268 return expression_list;
6271 /* Parse a delete-expression.
6274 :: [opt] delete cast-expression
6275 :: [opt] delete [ ] cast-expression
6277 Returns a representation of the expression. */
6280 cp_parser_delete_expression (cp_parser* parser)
6282 bool global_scope_p;
6286 /* Look for the optional `::' operator. */
6288 = (cp_parser_global_scope_opt (parser,
6289 /*current_scope_valid_p=*/false)
6291 /* Look for the `delete' keyword. */
6292 cp_parser_require_keyword (parser, RID_DELETE, RT_DELETE);
6293 /* See if the array syntax is in use. */
6294 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
6296 /* Consume the `[' token. */
6297 cp_lexer_consume_token (parser->lexer);
6298 /* Look for the `]' token. */
6299 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
6300 /* Remember that this is the `[]' construct. */
6306 /* Parse the cast-expression. */
6307 expression = cp_parser_simple_cast_expression (parser);
6309 /* A delete-expression may not appear in an integral constant
6311 if (cp_parser_non_integral_constant_expression (parser, NIC_DEL))
6312 return error_mark_node;
6314 return delete_sanity (expression, NULL_TREE, array_p, global_scope_p,
6315 tf_warning_or_error);
6318 /* Returns true if TOKEN may start a cast-expression and false
6322 cp_parser_token_starts_cast_expression (cp_token *token)
6324 switch (token->type)
6330 case CPP_CLOSE_SQUARE:
6331 case CPP_CLOSE_PAREN:
6332 case CPP_CLOSE_BRACE:
6336 case CPP_DEREF_STAR:
6344 case CPP_GREATER_EQ:
6364 /* '[' may start a primary-expression in obj-c++. */
6365 case CPP_OPEN_SQUARE:
6366 return c_dialect_objc ();
6373 /* Parse a cast-expression.
6377 ( type-id ) cast-expression
6379 ADDRESS_P is true iff the unary-expression is appearing as the
6380 operand of the `&' operator. CAST_P is true if this expression is
6381 the target of a cast.
6383 Returns a representation of the expression. */
6386 cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
6389 /* If it's a `(', then we might be looking at a cast. */
6390 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
6392 tree type = NULL_TREE;
6393 tree expr = NULL_TREE;
6394 bool compound_literal_p;
6395 const char *saved_message;
6397 /* There's no way to know yet whether or not this is a cast.
6398 For example, `(int (3))' is a unary-expression, while `(int)
6399 3' is a cast. So, we resort to parsing tentatively. */
6400 cp_parser_parse_tentatively (parser);
6401 /* Types may not be defined in a cast. */
6402 saved_message = parser->type_definition_forbidden_message;
6403 parser->type_definition_forbidden_message
6404 = G_("types may not be defined in casts");
6405 /* Consume the `('. */
6406 cp_lexer_consume_token (parser->lexer);
6407 /* A very tricky bit is that `(struct S) { 3 }' is a
6408 compound-literal (which we permit in C++ as an extension).
6409 But, that construct is not a cast-expression -- it is a
6410 postfix-expression. (The reason is that `(struct S) { 3 }.i'
6411 is legal; if the compound-literal were a cast-expression,
6412 you'd need an extra set of parentheses.) But, if we parse
6413 the type-id, and it happens to be a class-specifier, then we
6414 will commit to the parse at that point, because we cannot
6415 undo the action that is done when creating a new class. So,
6416 then we cannot back up and do a postfix-expression.
6418 Therefore, we scan ahead to the closing `)', and check to see
6419 if the token after the `)' is a `{'. If so, we are not
6420 looking at a cast-expression.
6422 Save tokens so that we can put them back. */
6423 cp_lexer_save_tokens (parser->lexer);
6424 /* Skip tokens until the next token is a closing parenthesis.
6425 If we find the closing `)', and the next token is a `{', then
6426 we are looking at a compound-literal. */
6428 = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
6429 /*consume_paren=*/true)
6430 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
6431 /* Roll back the tokens we skipped. */
6432 cp_lexer_rollback_tokens (parser->lexer);
6433 /* If we were looking at a compound-literal, simulate an error
6434 so that the call to cp_parser_parse_definitely below will
6436 if (compound_literal_p)
6437 cp_parser_simulate_error (parser);
6440 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
6441 parser->in_type_id_in_expr_p = true;
6442 /* Look for the type-id. */
6443 type = cp_parser_type_id (parser);
6444 /* Look for the closing `)'. */
6445 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
6446 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
6449 /* Restore the saved message. */
6450 parser->type_definition_forbidden_message = saved_message;
6452 /* At this point this can only be either a cast or a
6453 parenthesized ctor such as `(T ())' that looks like a cast to
6454 function returning T. */
6455 if (!cp_parser_error_occurred (parser)
6456 && cp_parser_token_starts_cast_expression (cp_lexer_peek_token
6459 cp_parser_parse_definitely (parser);
6460 expr = cp_parser_cast_expression (parser,
6461 /*address_p=*/false,
6462 /*cast_p=*/true, pidk);
6464 /* Warn about old-style casts, if so requested. */
6465 if (warn_old_style_cast
6466 && !in_system_header
6467 && !VOID_TYPE_P (type)
6468 && current_lang_name != lang_name_c)
6469 warning (OPT_Wold_style_cast, "use of old-style cast");
6471 /* Only type conversions to integral or enumeration types
6472 can be used in constant-expressions. */
6473 if (!cast_valid_in_integral_constant_expression_p (type)
6474 && cp_parser_non_integral_constant_expression (parser,
6476 return error_mark_node;
6478 /* Perform the cast. */
6479 expr = build_c_cast (input_location, type, expr);
6483 cp_parser_abort_tentative_parse (parser);
6486 /* If we get here, then it's not a cast, so it must be a
6487 unary-expression. */
6488 return cp_parser_unary_expression (parser, address_p, cast_p, pidk);
6491 /* Parse a binary expression of the general form:
6495 pm-expression .* cast-expression
6496 pm-expression ->* cast-expression
6498 multiplicative-expression:
6500 multiplicative-expression * pm-expression
6501 multiplicative-expression / pm-expression
6502 multiplicative-expression % pm-expression
6504 additive-expression:
6505 multiplicative-expression
6506 additive-expression + multiplicative-expression
6507 additive-expression - multiplicative-expression
6511 shift-expression << additive-expression
6512 shift-expression >> additive-expression
6514 relational-expression:
6516 relational-expression < shift-expression
6517 relational-expression > shift-expression
6518 relational-expression <= shift-expression
6519 relational-expression >= shift-expression
6523 relational-expression:
6524 relational-expression <? shift-expression
6525 relational-expression >? shift-expression
6527 equality-expression:
6528 relational-expression
6529 equality-expression == relational-expression
6530 equality-expression != relational-expression
6534 and-expression & equality-expression
6536 exclusive-or-expression:
6538 exclusive-or-expression ^ and-expression
6540 inclusive-or-expression:
6541 exclusive-or-expression
6542 inclusive-or-expression | exclusive-or-expression
6544 logical-and-expression:
6545 inclusive-or-expression
6546 logical-and-expression && inclusive-or-expression
6548 logical-or-expression:
6549 logical-and-expression
6550 logical-or-expression || logical-and-expression
6552 All these are implemented with a single function like:
6555 simple-cast-expression
6556 binary-expression <token> binary-expression
6558 CAST_P is true if this expression is the target of a cast.
6560 The binops_by_token map is used to get the tree codes for each <token> type.
6561 binary-expressions are associated according to a precedence table. */
6563 #define TOKEN_PRECEDENCE(token) \
6564 (((token->type == CPP_GREATER \
6565 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
6566 && !parser->greater_than_is_operator_p) \
6567 ? PREC_NOT_OPERATOR \
6568 : binops_by_token[token->type].prec)
6571 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
6572 bool no_toplevel_fold_p,
6573 enum cp_parser_prec prec,
6576 cp_parser_expression_stack stack;
6577 cp_parser_expression_stack_entry *sp = &stack[0];
6580 enum tree_code tree_type, lhs_type, rhs_type;
6581 enum cp_parser_prec new_prec, lookahead_prec;
6584 /* Parse the first expression. */
6585 lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p, pidk);
6586 lhs_type = ERROR_MARK;
6590 /* Get an operator token. */
6591 token = cp_lexer_peek_token (parser->lexer);
6593 if (warn_cxx0x_compat
6594 && token->type == CPP_RSHIFT
6595 && !parser->greater_than_is_operator_p)
6597 if (warning_at (token->location, OPT_Wc__0x_compat,
6598 "%<>>%> operator will be treated as"
6599 " two right angle brackets in C++0x"))
6600 inform (token->location,
6601 "suggest parentheses around %<>>%> expression");
6604 new_prec = TOKEN_PRECEDENCE (token);
6606 /* Popping an entry off the stack means we completed a subexpression:
6607 - either we found a token which is not an operator (`>' where it is not
6608 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
6609 will happen repeatedly;
6610 - or, we found an operator which has lower priority. This is the case
6611 where the recursive descent *ascends*, as in `3 * 4 + 5' after
6613 if (new_prec <= prec)
6622 tree_type = binops_by_token[token->type].tree_type;
6624 /* We used the operator token. */
6625 cp_lexer_consume_token (parser->lexer);
6627 /* For "false && x" or "true || x", x will never be executed;
6628 disable warnings while evaluating it. */
6629 if (tree_type == TRUTH_ANDIF_EXPR)
6630 c_inhibit_evaluation_warnings += lhs == truthvalue_false_node;
6631 else if (tree_type == TRUTH_ORIF_EXPR)
6632 c_inhibit_evaluation_warnings += lhs == truthvalue_true_node;
6634 /* Extract another operand. It may be the RHS of this expression
6635 or the LHS of a new, higher priority expression. */
6636 rhs = cp_parser_simple_cast_expression (parser);
6637 rhs_type = ERROR_MARK;
6639 /* Get another operator token. Look up its precedence to avoid
6640 building a useless (immediately popped) stack entry for common
6641 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
6642 token = cp_lexer_peek_token (parser->lexer);
6643 lookahead_prec = TOKEN_PRECEDENCE (token);
6644 if (lookahead_prec > new_prec)
6646 /* ... and prepare to parse the RHS of the new, higher priority
6647 expression. Since precedence levels on the stack are
6648 monotonically increasing, we do not have to care about
6651 sp->tree_type = tree_type;
6653 sp->lhs_type = lhs_type;
6656 lhs_type = rhs_type;
6658 new_prec = lookahead_prec;
6662 lookahead_prec = new_prec;
6663 /* If the stack is not empty, we have parsed into LHS the right side
6664 (`4' in the example above) of an expression we had suspended.
6665 We can use the information on the stack to recover the LHS (`3')
6666 from the stack together with the tree code (`MULT_EXPR'), and
6667 the precedence of the higher level subexpression
6668 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
6669 which will be used to actually build the additive expression. */
6672 tree_type = sp->tree_type;
6674 rhs_type = lhs_type;
6676 lhs_type = sp->lhs_type;
6679 /* Undo the disabling of warnings done above. */
6680 if (tree_type == TRUTH_ANDIF_EXPR)
6681 c_inhibit_evaluation_warnings -= lhs == truthvalue_false_node;
6682 else if (tree_type == TRUTH_ORIF_EXPR)
6683 c_inhibit_evaluation_warnings -= lhs == truthvalue_true_node;
6685 overloaded_p = false;
6686 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
6687 ERROR_MARK for everything that is not a binary expression.
6688 This makes warn_about_parentheses miss some warnings that
6689 involve unary operators. For unary expressions we should
6690 pass the correct tree_code unless the unary expression was
6691 surrounded by parentheses.
6693 if (no_toplevel_fold_p
6694 && lookahead_prec <= prec
6696 && TREE_CODE_CLASS (tree_type) == tcc_comparison)
6697 lhs = build2 (tree_type, boolean_type_node, lhs, rhs);
6699 lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type,
6700 &overloaded_p, tf_warning_or_error);
6701 lhs_type = tree_type;
6703 /* If the binary operator required the use of an overloaded operator,
6704 then this expression cannot be an integral constant-expression.
6705 An overloaded operator can be used even if both operands are
6706 otherwise permissible in an integral constant-expression if at
6707 least one of the operands is of enumeration type. */
6710 && cp_parser_non_integral_constant_expression (parser,
6712 return error_mark_node;
6719 /* Parse the `? expression : assignment-expression' part of a
6720 conditional-expression. The LOGICAL_OR_EXPR is the
6721 logical-or-expression that started the conditional-expression.
6722 Returns a representation of the entire conditional-expression.
6724 This routine is used by cp_parser_assignment_expression.
6726 ? expression : assignment-expression
6730 ? : assignment-expression */
6733 cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
6736 tree assignment_expr;
6737 struct cp_token *token;
6739 /* Consume the `?' token. */
6740 cp_lexer_consume_token (parser->lexer);
6741 token = cp_lexer_peek_token (parser->lexer);
6742 if (cp_parser_allow_gnu_extensions_p (parser)
6743 && token->type == CPP_COLON)
6745 pedwarn (token->location, OPT_pedantic,
6746 "ISO C++ does not allow ?: with omitted middle operand");
6747 /* Implicit true clause. */
6749 c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_true_node;
6750 warn_for_omitted_condop (token->location, logical_or_expr);
6754 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
6755 parser->colon_corrects_to_scope_p = false;
6756 /* Parse the expression. */
6757 c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_false_node;
6758 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
6759 c_inhibit_evaluation_warnings +=
6760 ((logical_or_expr == truthvalue_true_node)
6761 - (logical_or_expr == truthvalue_false_node));
6762 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
6765 /* The next token should be a `:'. */
6766 cp_parser_require (parser, CPP_COLON, RT_COLON);
6767 /* Parse the assignment-expression. */
6768 assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
6769 c_inhibit_evaluation_warnings -= logical_or_expr == truthvalue_true_node;
6771 /* Build the conditional-expression. */
6772 return build_x_conditional_expr (logical_or_expr,
6775 tf_warning_or_error);
6778 /* Parse an assignment-expression.
6780 assignment-expression:
6781 conditional-expression
6782 logical-or-expression assignment-operator assignment_expression
6785 CAST_P is true if this expression is the target of a cast.
6787 Returns a representation for the expression. */
6790 cp_parser_assignment_expression (cp_parser* parser, bool cast_p,
6795 /* If the next token is the `throw' keyword, then we're looking at
6796 a throw-expression. */
6797 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
6798 expr = cp_parser_throw_expression (parser);
6799 /* Otherwise, it must be that we are looking at a
6800 logical-or-expression. */
6803 /* Parse the binary expressions (logical-or-expression). */
6804 expr = cp_parser_binary_expression (parser, cast_p, false,
6805 PREC_NOT_OPERATOR, pidk);
6806 /* If the next token is a `?' then we're actually looking at a
6807 conditional-expression. */
6808 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
6809 return cp_parser_question_colon_clause (parser, expr);
6812 enum tree_code assignment_operator;
6814 /* If it's an assignment-operator, we're using the second
6817 = cp_parser_assignment_operator_opt (parser);
6818 if (assignment_operator != ERROR_MARK)
6820 bool non_constant_p;
6822 /* Parse the right-hand side of the assignment. */
6823 tree rhs = cp_parser_initializer_clause (parser, &non_constant_p);
6825 if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
6826 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6828 /* An assignment may not appear in a
6829 constant-expression. */
6830 if (cp_parser_non_integral_constant_expression (parser,
6832 return error_mark_node;
6833 /* Build the assignment expression. */
6834 expr = build_x_modify_expr (expr,
6835 assignment_operator,
6837 tf_warning_or_error);
6845 /* Parse an (optional) assignment-operator.
6847 assignment-operator: one of
6848 = *= /= %= += -= >>= <<= &= ^= |=
6852 assignment-operator: one of
6855 If the next token is an assignment operator, the corresponding tree
6856 code is returned, and the token is consumed. For example, for
6857 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
6858 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
6859 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
6860 operator, ERROR_MARK is returned. */
6862 static enum tree_code
6863 cp_parser_assignment_operator_opt (cp_parser* parser)
6868 /* Peek at the next token. */
6869 token = cp_lexer_peek_token (parser->lexer);
6871 switch (token->type)
6882 op = TRUNC_DIV_EXPR;
6886 op = TRUNC_MOD_EXPR;
6918 /* Nothing else is an assignment operator. */
6922 /* If it was an assignment operator, consume it. */
6923 if (op != ERROR_MARK)
6924 cp_lexer_consume_token (parser->lexer);
6929 /* Parse an expression.
6932 assignment-expression
6933 expression , assignment-expression
6935 CAST_P is true if this expression is the target of a cast.
6937 Returns a representation of the expression. */
6940 cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk)
6942 tree expression = NULL_TREE;
6946 tree assignment_expression;
6948 /* Parse the next assignment-expression. */
6949 assignment_expression
6950 = cp_parser_assignment_expression (parser, cast_p, pidk);
6951 /* If this is the first assignment-expression, we can just
6954 expression = assignment_expression;
6956 expression = build_x_compound_expr (expression,
6957 assignment_expression,
6958 tf_warning_or_error);
6959 /* If the next token is not a comma, then we are done with the
6961 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
6963 /* Consume the `,'. */
6964 cp_lexer_consume_token (parser->lexer);
6965 /* A comma operator cannot appear in a constant-expression. */
6966 if (cp_parser_non_integral_constant_expression (parser, NIC_COMMA))
6967 expression = error_mark_node;
6973 /* Parse a constant-expression.
6975 constant-expression:
6976 conditional-expression
6978 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
6979 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
6980 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
6981 is false, NON_CONSTANT_P should be NULL. */
6984 cp_parser_constant_expression (cp_parser* parser,
6985 bool allow_non_constant_p,
6986 bool *non_constant_p)
6988 bool saved_integral_constant_expression_p;
6989 bool saved_allow_non_integral_constant_expression_p;
6990 bool saved_non_integral_constant_expression_p;
6993 /* It might seem that we could simply parse the
6994 conditional-expression, and then check to see if it were
6995 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
6996 one that the compiler can figure out is constant, possibly after
6997 doing some simplifications or optimizations. The standard has a
6998 precise definition of constant-expression, and we must honor
6999 that, even though it is somewhat more restrictive.
7005 is not a legal declaration, because `(2, 3)' is not a
7006 constant-expression. The `,' operator is forbidden in a
7007 constant-expression. However, GCC's constant-folding machinery
7008 will fold this operation to an INTEGER_CST for `3'. */
7010 /* Save the old settings. */
7011 saved_integral_constant_expression_p = parser->integral_constant_expression_p;
7012 saved_allow_non_integral_constant_expression_p
7013 = parser->allow_non_integral_constant_expression_p;
7014 saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
7015 /* We are now parsing a constant-expression. */
7016 parser->integral_constant_expression_p = true;
7017 parser->allow_non_integral_constant_expression_p
7018 = (allow_non_constant_p || cxx_dialect >= cxx0x);
7019 parser->non_integral_constant_expression_p = false;
7020 /* Although the grammar says "conditional-expression", we parse an
7021 "assignment-expression", which also permits "throw-expression"
7022 and the use of assignment operators. In the case that
7023 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
7024 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
7025 actually essential that we look for an assignment-expression.
7026 For example, cp_parser_initializer_clauses uses this function to
7027 determine whether a particular assignment-expression is in fact
7029 expression = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
7030 /* Restore the old settings. */
7031 parser->integral_constant_expression_p
7032 = saved_integral_constant_expression_p;
7033 parser->allow_non_integral_constant_expression_p
7034 = saved_allow_non_integral_constant_expression_p;
7035 if (cxx_dialect >= cxx0x)
7037 /* Require an rvalue constant expression here; that's what our
7038 callers expect. Reference constant expressions are handled
7039 separately in e.g. cp_parser_template_argument. */
7040 bool is_const = potential_rvalue_constant_expression (expression);
7041 parser->non_integral_constant_expression_p = !is_const;
7042 if (!is_const && !allow_non_constant_p)
7043 require_potential_rvalue_constant_expression (expression);
7045 if (allow_non_constant_p)
7046 *non_constant_p = parser->non_integral_constant_expression_p;
7047 else if (parser->non_integral_constant_expression_p)
7048 expression = error_mark_node;
7049 parser->non_integral_constant_expression_p
7050 = saved_non_integral_constant_expression_p;
7055 /* Parse __builtin_offsetof.
7057 offsetof-expression:
7058 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
7060 offsetof-member-designator:
7062 | offsetof-member-designator "." id-expression
7063 | offsetof-member-designator "[" expression "]"
7064 | offsetof-member-designator "->" id-expression */
7067 cp_parser_builtin_offsetof (cp_parser *parser)
7069 int save_ice_p, save_non_ice_p;
7074 /* We're about to accept non-integral-constant things, but will
7075 definitely yield an integral constant expression. Save and
7076 restore these values around our local parsing. */
7077 save_ice_p = parser->integral_constant_expression_p;
7078 save_non_ice_p = parser->non_integral_constant_expression_p;
7080 /* Consume the "__builtin_offsetof" token. */
7081 cp_lexer_consume_token (parser->lexer);
7082 /* Consume the opening `('. */
7083 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
7084 /* Parse the type-id. */
7085 type = cp_parser_type_id (parser);
7086 /* Look for the `,'. */
7087 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7088 token = cp_lexer_peek_token (parser->lexer);
7090 /* Build the (type *)null that begins the traditional offsetof macro. */
7091 expr = build_static_cast (build_pointer_type (type), null_pointer_node,
7092 tf_warning_or_error);
7094 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
7095 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
7096 true, &dummy, token->location);
7099 token = cp_lexer_peek_token (parser->lexer);
7100 switch (token->type)
7102 case CPP_OPEN_SQUARE:
7103 /* offsetof-member-designator "[" expression "]" */
7104 expr = cp_parser_postfix_open_square_expression (parser, expr, true);
7108 /* offsetof-member-designator "->" identifier */
7109 expr = grok_array_decl (expr, integer_zero_node);
7113 /* offsetof-member-designator "." identifier */
7114 cp_lexer_consume_token (parser->lexer);
7115 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT,
7120 case CPP_CLOSE_PAREN:
7121 /* Consume the ")" token. */
7122 cp_lexer_consume_token (parser->lexer);
7126 /* Error. We know the following require will fail, but
7127 that gives the proper error message. */
7128 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7129 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
7130 expr = error_mark_node;
7136 /* If we're processing a template, we can't finish the semantics yet.
7137 Otherwise we can fold the entire expression now. */
7138 if (processing_template_decl)
7139 expr = build1 (OFFSETOF_EXPR, size_type_node, expr);
7141 expr = finish_offsetof (expr);
7144 parser->integral_constant_expression_p = save_ice_p;
7145 parser->non_integral_constant_expression_p = save_non_ice_p;
7150 /* Parse a trait expression.
7152 Returns a representation of the expression, the underlying type
7153 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
7156 cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
7159 tree type1, type2 = NULL_TREE;
7160 bool binary = false;
7161 cp_decl_specifier_seq decl_specs;
7165 case RID_HAS_NOTHROW_ASSIGN:
7166 kind = CPTK_HAS_NOTHROW_ASSIGN;
7168 case RID_HAS_NOTHROW_CONSTRUCTOR:
7169 kind = CPTK_HAS_NOTHROW_CONSTRUCTOR;
7171 case RID_HAS_NOTHROW_COPY:
7172 kind = CPTK_HAS_NOTHROW_COPY;
7174 case RID_HAS_TRIVIAL_ASSIGN:
7175 kind = CPTK_HAS_TRIVIAL_ASSIGN;
7177 case RID_HAS_TRIVIAL_CONSTRUCTOR:
7178 kind = CPTK_HAS_TRIVIAL_CONSTRUCTOR;
7180 case RID_HAS_TRIVIAL_COPY:
7181 kind = CPTK_HAS_TRIVIAL_COPY;
7183 case RID_HAS_TRIVIAL_DESTRUCTOR:
7184 kind = CPTK_HAS_TRIVIAL_DESTRUCTOR;
7186 case RID_HAS_VIRTUAL_DESTRUCTOR:
7187 kind = CPTK_HAS_VIRTUAL_DESTRUCTOR;
7189 case RID_IS_ABSTRACT:
7190 kind = CPTK_IS_ABSTRACT;
7192 case RID_IS_BASE_OF:
7193 kind = CPTK_IS_BASE_OF;
7197 kind = CPTK_IS_CLASS;
7199 case RID_IS_CONVERTIBLE_TO:
7200 kind = CPTK_IS_CONVERTIBLE_TO;
7204 kind = CPTK_IS_EMPTY;
7207 kind = CPTK_IS_ENUM;
7209 case RID_IS_LITERAL_TYPE:
7210 kind = CPTK_IS_LITERAL_TYPE;
7215 case RID_IS_POLYMORPHIC:
7216 kind = CPTK_IS_POLYMORPHIC;
7218 case RID_IS_STD_LAYOUT:
7219 kind = CPTK_IS_STD_LAYOUT;
7221 case RID_IS_TRIVIAL:
7222 kind = CPTK_IS_TRIVIAL;
7225 kind = CPTK_IS_UNION;
7227 case RID_UNDERLYING_TYPE:
7228 kind = CPTK_UNDERLYING_TYPE;
7234 /* Consume the token. */
7235 cp_lexer_consume_token (parser->lexer);
7237 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
7239 type1 = cp_parser_type_id (parser);
7241 if (type1 == error_mark_node)
7242 return error_mark_node;
7244 /* Build a trivial decl-specifier-seq. */
7245 clear_decl_specs (&decl_specs);
7246 decl_specs.type = type1;
7248 /* Call grokdeclarator to figure out what type this is. */
7249 type1 = grokdeclarator (NULL, &decl_specs, TYPENAME,
7250 /*initialized=*/0, /*attrlist=*/NULL);
7254 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7256 type2 = cp_parser_type_id (parser);
7258 if (type2 == error_mark_node)
7259 return error_mark_node;
7261 /* Build a trivial decl-specifier-seq. */
7262 clear_decl_specs (&decl_specs);
7263 decl_specs.type = type2;
7265 /* Call grokdeclarator to figure out what type this is. */
7266 type2 = grokdeclarator (NULL, &decl_specs, TYPENAME,
7267 /*initialized=*/0, /*attrlist=*/NULL);
7270 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7272 /* Complete the trait expression, which may mean either processing
7273 the trait expr now or saving it for template instantiation. */
7274 return kind != CPTK_UNDERLYING_TYPE
7275 ? finish_trait_expr (kind, type1, type2)
7276 : finish_underlying_type (type1);
7279 /* Lambdas that appear in variable initializer or default argument scope
7280 get that in their mangling, so we need to record it. We might as well
7281 use the count for function and namespace scopes as well. */
7282 static GTY(()) tree lambda_scope;
7283 static GTY(()) int lambda_count;
7284 typedef struct GTY(()) tree_int
7289 DEF_VEC_O(tree_int);
7290 DEF_VEC_ALLOC_O(tree_int,gc);
7291 static GTY(()) VEC(tree_int,gc) *lambda_scope_stack;
7294 start_lambda_scope (tree decl)
7298 /* Once we're inside a function, we ignore other scopes and just push
7299 the function again so that popping works properly. */
7300 if (current_function_decl && TREE_CODE (decl) != FUNCTION_DECL)
7301 decl = current_function_decl;
7302 ti.t = lambda_scope;
7303 ti.i = lambda_count;
7304 VEC_safe_push (tree_int, gc, lambda_scope_stack, &ti);
7305 if (lambda_scope != decl)
7307 /* Don't reset the count if we're still in the same function. */
7308 lambda_scope = decl;
7314 record_lambda_scope (tree lambda)
7316 LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope;
7317 LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++;
7321 finish_lambda_scope (void)
7323 tree_int *p = VEC_last (tree_int, lambda_scope_stack);
7324 if (lambda_scope != p->t)
7326 lambda_scope = p->t;
7327 lambda_count = p->i;
7329 VEC_pop (tree_int, lambda_scope_stack);
7332 /* Parse a lambda expression.
7335 lambda-introducer lambda-declarator [opt] compound-statement
7337 Returns a representation of the expression. */
7340 cp_parser_lambda_expression (cp_parser* parser)
7342 tree lambda_expr = build_lambda_expr ();
7345 LAMBDA_EXPR_LOCATION (lambda_expr)
7346 = cp_lexer_peek_token (parser->lexer)->location;
7348 if (cp_unevaluated_operand)
7349 error_at (LAMBDA_EXPR_LOCATION (lambda_expr),
7350 "lambda-expression in unevaluated context");
7352 /* We may be in the middle of deferred access check. Disable
7354 push_deferring_access_checks (dk_no_deferred);
7356 cp_parser_lambda_introducer (parser, lambda_expr);
7358 type = begin_lambda_type (lambda_expr);
7360 record_lambda_scope (lambda_expr);
7362 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
7363 determine_visibility (TYPE_NAME (type));
7365 /* Now that we've started the type, add the capture fields for any
7366 explicit captures. */
7367 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr));
7370 /* Inside the class, surrounding template-parameter-lists do not apply. */
7371 unsigned int saved_num_template_parameter_lists
7372 = parser->num_template_parameter_lists;
7374 parser->num_template_parameter_lists = 0;
7376 /* By virtue of defining a local class, a lambda expression has access to
7377 the private variables of enclosing classes. */
7379 cp_parser_lambda_declarator_opt (parser, lambda_expr);
7381 cp_parser_lambda_body (parser, lambda_expr);
7383 /* The capture list was built up in reverse order; fix that now. */
7385 tree newlist = NULL_TREE;
7388 for (elt = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
7391 tree field = TREE_PURPOSE (elt);
7394 next = TREE_CHAIN (elt);
7395 TREE_CHAIN (elt) = newlist;
7398 /* Also add __ to the beginning of the field name so that code
7399 outside the lambda body can't see the captured name. We could
7400 just remove the name entirely, but this is more useful for
7402 if (field == LAMBDA_EXPR_THIS_CAPTURE (lambda_expr))
7403 /* The 'this' capture already starts with __. */
7406 buf = (char *) alloca (IDENTIFIER_LENGTH (DECL_NAME (field)) + 3);
7407 buf[1] = buf[0] = '_';
7408 memcpy (buf + 2, IDENTIFIER_POINTER (DECL_NAME (field)),
7409 IDENTIFIER_LENGTH (DECL_NAME (field)) + 1);
7410 DECL_NAME (field) = get_identifier (buf);
7412 LAMBDA_EXPR_CAPTURE_LIST (lambda_expr) = newlist;
7415 maybe_add_lambda_conv_op (type);
7417 type = finish_struct (type, /*attributes=*/NULL_TREE);
7419 parser->num_template_parameter_lists = saved_num_template_parameter_lists;
7422 pop_deferring_access_checks ();
7424 return build_lambda_object (lambda_expr);
7427 /* Parse the beginning of a lambda expression.
7430 [ lambda-capture [opt] ]
7432 LAMBDA_EXPR is the current representation of the lambda expression. */
7435 cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
7437 /* Need commas after the first capture. */
7440 /* Eat the leading `['. */
7441 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
7443 /* Record default capture mode. "[&" "[=" "[&," "[=," */
7444 if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
7445 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_NAME)
7446 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_REFERENCE;
7447 else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
7448 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_COPY;
7450 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE)
7452 cp_lexer_consume_token (parser->lexer);
7456 while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
7458 cp_token* capture_token;
7460 tree capture_init_expr;
7461 cp_id_kind idk = CP_ID_KIND_NONE;
7462 bool explicit_init_p = false;
7464 enum capture_kind_type
7469 enum capture_kind_type capture_kind = BY_COPY;
7471 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
7473 error ("expected end of capture-list");
7480 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7482 /* Possibly capture `this'. */
7483 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THIS))
7485 cp_lexer_consume_token (parser->lexer);
7486 add_capture (lambda_expr,
7487 /*id=*/get_identifier ("__this"),
7488 /*initializer=*/finish_this_expr(),
7489 /*by_reference_p=*/false,
7494 /* Remember whether we want to capture as a reference or not. */
7495 if (cp_lexer_next_token_is (parser->lexer, CPP_AND))
7497 capture_kind = BY_REFERENCE;
7498 cp_lexer_consume_token (parser->lexer);
7501 /* Get the identifier. */
7502 capture_token = cp_lexer_peek_token (parser->lexer);
7503 capture_id = cp_parser_identifier (parser);
7505 if (capture_id == error_mark_node)
7506 /* Would be nice to have a cp_parser_skip_to_closing_x for general
7507 delimiters, but I modified this to stop on unnested ']' as well. It
7508 was already changed to stop on unnested '}', so the
7509 "closing_parenthesis" name is no more misleading with my change. */
7511 cp_parser_skip_to_closing_parenthesis (parser,
7512 /*recovering=*/true,
7514 /*consume_paren=*/true);
7518 /* Find the initializer for this capture. */
7519 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
7521 /* An explicit expression exists. */
7522 cp_lexer_consume_token (parser->lexer);
7523 pedwarn (input_location, OPT_pedantic,
7524 "ISO C++ does not allow initializers "
7525 "in lambda expression capture lists");
7526 capture_init_expr = cp_parser_assignment_expression (parser,
7529 explicit_init_p = true;
7533 const char* error_msg;
7535 /* Turn the identifier into an id-expression. */
7537 = cp_parser_lookup_name
7541 /*is_template=*/false,
7542 /*is_namespace=*/false,
7543 /*check_dependency=*/true,
7544 /*ambiguous_decls=*/NULL,
7545 capture_token->location);
7548 = finish_id_expression
7553 /*integral_constant_expression_p=*/false,
7554 /*allow_non_integral_constant_expression_p=*/false,
7555 /*non_integral_constant_expression_p=*/NULL,
7556 /*template_p=*/false,
7558 /*address_p=*/false,
7559 /*template_arg_p=*/false,
7561 capture_token->location);
7564 if (TREE_CODE (capture_init_expr) == IDENTIFIER_NODE)
7566 = unqualified_name_lookup_error (capture_init_expr);
7568 add_capture (lambda_expr,
7571 /*by_reference_p=*/capture_kind == BY_REFERENCE,
7575 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
7578 /* Parse the (optional) middle of a lambda expression.
7581 ( parameter-declaration-clause [opt] )
7582 attribute-specifier [opt]
7584 exception-specification [opt]
7585 lambda-return-type-clause [opt]
7587 LAMBDA_EXPR is the current representation of the lambda expression. */
7590 cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr)
7592 /* 5.1.1.4 of the standard says:
7593 If a lambda-expression does not include a lambda-declarator, it is as if
7594 the lambda-declarator were ().
7595 This means an empty parameter list, no attributes, and no exception
7597 tree param_list = void_list_node;
7598 tree attributes = NULL_TREE;
7599 tree exception_spec = NULL_TREE;
7602 /* The lambda-declarator is optional, but must begin with an opening
7603 parenthesis if present. */
7604 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
7606 cp_lexer_consume_token (parser->lexer);
7608 begin_scope (sk_function_parms, /*entity=*/NULL_TREE);
7610 /* Parse parameters. */
7611 param_list = cp_parser_parameter_declaration_clause (parser);
7613 /* Default arguments shall not be specified in the
7614 parameter-declaration-clause of a lambda-declarator. */
7615 for (t = param_list; t; t = TREE_CHAIN (t))
7616 if (TREE_PURPOSE (t))
7617 pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t)), OPT_pedantic,
7618 "default argument specified for lambda parameter");
7620 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7622 attributes = cp_parser_attributes_opt (parser);
7624 /* Parse optional `mutable' keyword. */
7625 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_MUTABLE))
7627 cp_lexer_consume_token (parser->lexer);
7628 LAMBDA_EXPR_MUTABLE_P (lambda_expr) = 1;
7631 /* Parse optional exception specification. */
7632 exception_spec = cp_parser_exception_specification_opt (parser);
7634 /* Parse optional trailing return type. */
7635 if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
7637 cp_lexer_consume_token (parser->lexer);
7638 LAMBDA_EXPR_RETURN_TYPE (lambda_expr) = cp_parser_type_id (parser);
7641 /* The function parameters must be in scope all the way until after the
7642 trailing-return-type in case of decltype. */
7643 for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
7644 pop_binding (DECL_NAME (t), t);
7649 /* Create the function call operator.
7651 Messing with declarators like this is no uglier than building up the
7652 FUNCTION_DECL by hand, and this is less likely to get out of sync with
7655 cp_decl_specifier_seq return_type_specs;
7656 cp_declarator* declarator;
7661 clear_decl_specs (&return_type_specs);
7662 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
7663 return_type_specs.type = LAMBDA_EXPR_RETURN_TYPE (lambda_expr);
7665 /* Maybe we will deduce the return type later, but we can use void
7666 as a placeholder return type anyways. */
7667 return_type_specs.type = void_type_node;
7669 p = obstack_alloc (&declarator_obstack, 0);
7671 declarator = make_id_declarator (NULL_TREE, ansi_opname (CALL_EXPR),
7674 quals = (LAMBDA_EXPR_MUTABLE_P (lambda_expr)
7675 ? TYPE_UNQUALIFIED : TYPE_QUAL_CONST);
7676 declarator = make_call_declarator (declarator, param_list, quals,
7677 VIRT_SPEC_UNSPECIFIED,
7679 /*late_return_type=*/NULL_TREE);
7680 declarator->id_loc = LAMBDA_EXPR_LOCATION (lambda_expr);
7682 fco = grokmethod (&return_type_specs,
7685 DECL_INITIALIZED_IN_CLASS_P (fco) = 1;
7686 DECL_ARTIFICIAL (fco) = 1;
7688 finish_member_declaration (fco);
7690 obstack_free (&declarator_obstack, p);
7694 /* Parse the body of a lambda expression, which is simply
7698 but which requires special handling.
7699 LAMBDA_EXPR is the current representation of the lambda expression. */
7702 cp_parser_lambda_body (cp_parser* parser, tree lambda_expr)
7704 bool nested = (current_function_decl != NULL_TREE);
7706 push_function_context ();
7708 /* Finish the function call operator
7710 + late_parsing_for_member
7711 + function_definition_after_declarator
7712 + ctor_initializer_opt_and_function_body */
7714 tree fco = lambda_function (lambda_expr);
7718 /* Let the front end know that we are going to be defining this
7720 start_preparsed_function (fco,
7722 SF_PRE_PARSED | SF_INCLASS_INLINE);
7724 start_lambda_scope (fco);
7725 body = begin_function_body ();
7727 /* 5.1.1.4 of the standard says:
7728 If a lambda-expression does not include a trailing-return-type, it
7729 is as if the trailing-return-type denotes the following type:
7730 * if the compound-statement is of the form
7731 { return attribute-specifier [opt] expression ; }
7732 the type of the returned expression after lvalue-to-rvalue
7733 conversion (_conv.lval_ 4.1), array-to-pointer conversion
7734 (_conv.array_ 4.2), and function-to-pointer conversion
7736 * otherwise, void. */
7738 /* In a lambda that has neither a lambda-return-type-clause
7739 nor a deducible form, errors should be reported for return statements
7740 in the body. Since we used void as the placeholder return type, parsing
7741 the body as usual will give such desired behavior. */
7742 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr)
7743 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
7744 && cp_lexer_peek_nth_token (parser->lexer, 2)->keyword == RID_RETURN
7745 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_SEMICOLON)
7748 tree expr = NULL_TREE;
7749 cp_id_kind idk = CP_ID_KIND_NONE;
7751 /* Parse tentatively in case there's more after the initial return
7753 cp_parser_parse_tentatively (parser);
7755 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
7756 cp_parser_require_keyword (parser, RID_RETURN, RT_RETURN);
7758 expr = cp_parser_expression (parser, /*cast_p=*/false, &idk);
7760 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
7761 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
7763 if (cp_parser_parse_definitely (parser))
7765 apply_lambda_return_type (lambda_expr, lambda_return_type (expr));
7767 compound_stmt = begin_compound_stmt (0);
7768 /* Will get error here if type not deduced yet. */
7769 finish_return_stmt (expr);
7770 finish_compound_stmt (compound_stmt);
7778 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
7779 LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda_expr) = true;
7780 /* TODO: does begin_compound_stmt want BCS_FN_BODY?
7781 cp_parser_compound_stmt does not pass it. */
7782 cp_parser_function_body (parser);
7783 LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda_expr) = false;
7786 finish_function_body (body);
7787 finish_lambda_scope ();
7789 /* Finish the function and generate code for it if necessary. */
7790 expand_or_defer_fn (finish_function (/*inline*/2));
7794 pop_function_context();
7797 /* Statements [gram.stmt.stmt] */
7799 /* Parse a statement.
7803 expression-statement
7808 declaration-statement
7811 IN_COMPOUND is true when the statement is nested inside a
7812 cp_parser_compound_statement; this matters for certain pragmas.
7814 If IF_P is not NULL, *IF_P is set to indicate whether the statement
7815 is a (possibly labeled) if statement which is not enclosed in braces
7816 and has an else clause. This is used to implement -Wparentheses. */
7819 cp_parser_statement (cp_parser* parser, tree in_statement_expr,
7820 bool in_compound, bool *if_p)
7824 location_t statement_location;
7829 /* There is no statement yet. */
7830 statement = NULL_TREE;
7831 /* Peek at the next token. */
7832 token = cp_lexer_peek_token (parser->lexer);
7833 /* Remember the location of the first token in the statement. */
7834 statement_location = token->location;
7835 /* If this is a keyword, then that will often determine what kind of
7836 statement we have. */
7837 if (token->type == CPP_KEYWORD)
7839 enum rid keyword = token->keyword;
7845 /* Looks like a labeled-statement with a case label.
7846 Parse the label, and then use tail recursion to parse
7848 cp_parser_label_for_labeled_statement (parser);
7853 statement = cp_parser_selection_statement (parser, if_p);
7859 statement = cp_parser_iteration_statement (parser);
7866 statement = cp_parser_jump_statement (parser);
7869 /* Objective-C++ exception-handling constructs. */
7872 case RID_AT_FINALLY:
7873 case RID_AT_SYNCHRONIZED:
7875 statement = cp_parser_objc_statement (parser);
7879 statement = cp_parser_try_block (parser);
7883 /* This must be a namespace alias definition. */
7884 cp_parser_declaration_statement (parser);
7888 /* It might be a keyword like `int' that can start a
7889 declaration-statement. */
7893 else if (token->type == CPP_NAME)
7895 /* If the next token is a `:', then we are looking at a
7896 labeled-statement. */
7897 token = cp_lexer_peek_nth_token (parser->lexer, 2);
7898 if (token->type == CPP_COLON)
7900 /* Looks like a labeled-statement with an ordinary label.
7901 Parse the label, and then use tail recursion to parse
7903 cp_parser_label_for_labeled_statement (parser);
7907 /* Anything that starts with a `{' must be a compound-statement. */
7908 else if (token->type == CPP_OPEN_BRACE)
7909 statement = cp_parser_compound_statement (parser, NULL, false, false);
7910 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
7911 a statement all its own. */
7912 else if (token->type == CPP_PRAGMA)
7914 /* Only certain OpenMP pragmas are attached to statements, and thus
7915 are considered statements themselves. All others are not. In
7916 the context of a compound, accept the pragma as a "statement" and
7917 return so that we can check for a close brace. Otherwise we
7918 require a real statement and must go back and read one. */
7920 cp_parser_pragma (parser, pragma_compound);
7921 else if (!cp_parser_pragma (parser, pragma_stmt))
7925 else if (token->type == CPP_EOF)
7927 cp_parser_error (parser, "expected statement");
7931 /* Everything else must be a declaration-statement or an
7932 expression-statement. Try for the declaration-statement
7933 first, unless we are looking at a `;', in which case we know that
7934 we have an expression-statement. */
7937 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
7939 cp_parser_parse_tentatively (parser);
7940 /* Try to parse the declaration-statement. */
7941 cp_parser_declaration_statement (parser);
7942 /* If that worked, we're done. */
7943 if (cp_parser_parse_definitely (parser))
7946 /* Look for an expression-statement instead. */
7947 statement = cp_parser_expression_statement (parser, in_statement_expr);
7950 /* Set the line number for the statement. */
7951 if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
7952 SET_EXPR_LOCATION (statement, statement_location);
7955 /* Parse the label for a labeled-statement, i.e.
7958 case constant-expression :
7962 case constant-expression ... constant-expression : statement
7964 When a label is parsed without errors, the label is added to the
7965 parse tree by the finish_* functions, so this function doesn't
7966 have to return the label. */
7969 cp_parser_label_for_labeled_statement (cp_parser* parser)
7972 tree label = NULL_TREE;
7973 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
7975 /* The next token should be an identifier. */
7976 token = cp_lexer_peek_token (parser->lexer);
7977 if (token->type != CPP_NAME
7978 && token->type != CPP_KEYWORD)
7980 cp_parser_error (parser, "expected labeled-statement");
7984 parser->colon_corrects_to_scope_p = false;
7985 switch (token->keyword)
7992 /* Consume the `case' token. */
7993 cp_lexer_consume_token (parser->lexer);
7994 /* Parse the constant-expression. */
7995 expr = cp_parser_constant_expression (parser,
7996 /*allow_non_constant_p=*/false,
7999 ellipsis = cp_lexer_peek_token (parser->lexer);
8000 if (ellipsis->type == CPP_ELLIPSIS)
8002 /* Consume the `...' token. */
8003 cp_lexer_consume_token (parser->lexer);
8005 cp_parser_constant_expression (parser,
8006 /*allow_non_constant_p=*/false,
8008 /* We don't need to emit warnings here, as the common code
8009 will do this for us. */
8012 expr_hi = NULL_TREE;
8014 if (parser->in_switch_statement_p)
8015 finish_case_label (token->location, expr, expr_hi);
8017 error_at (token->location,
8018 "case label %qE not within a switch statement",
8024 /* Consume the `default' token. */
8025 cp_lexer_consume_token (parser->lexer);
8027 if (parser->in_switch_statement_p)
8028 finish_case_label (token->location, NULL_TREE, NULL_TREE);
8030 error_at (token->location, "case label not within a switch statement");
8034 /* Anything else must be an ordinary label. */
8035 label = finish_label_stmt (cp_parser_identifier (parser));
8039 /* Require the `:' token. */
8040 cp_parser_require (parser, CPP_COLON, RT_COLON);
8042 /* An ordinary label may optionally be followed by attributes.
8043 However, this is only permitted if the attributes are then
8044 followed by a semicolon. This is because, for backward
8045 compatibility, when parsing
8046 lab: __attribute__ ((unused)) int i;
8047 we want the attribute to attach to "i", not "lab". */
8048 if (label != NULL_TREE
8049 && cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
8053 cp_parser_parse_tentatively (parser);
8054 attrs = cp_parser_attributes_opt (parser);
8055 if (attrs == NULL_TREE
8056 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8057 cp_parser_abort_tentative_parse (parser);
8058 else if (!cp_parser_parse_definitely (parser))
8061 cplus_decl_attributes (&label, attrs, 0);
8064 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
8067 /* Parse an expression-statement.
8069 expression-statement:
8072 Returns the new EXPR_STMT -- or NULL_TREE if the expression
8073 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
8074 indicates whether this expression-statement is part of an
8075 expression statement. */
8078 cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
8080 tree statement = NULL_TREE;
8081 cp_token *token = cp_lexer_peek_token (parser->lexer);
8083 /* If the next token is a ';', then there is no expression
8085 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8086 statement = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8088 /* Give a helpful message for "A<T>::type t;" and the like. */
8089 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
8090 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
8092 if (TREE_CODE (statement) == SCOPE_REF)
8093 error_at (token->location, "need %<typename%> before %qE because "
8094 "%qT is a dependent scope",
8095 statement, TREE_OPERAND (statement, 0));
8096 else if (is_overloaded_fn (statement)
8097 && DECL_CONSTRUCTOR_P (get_first_fn (statement)))
8100 tree fn = get_first_fn (statement);
8101 error_at (token->location,
8102 "%<%T::%D%> names the constructor, not the type",
8103 DECL_CONTEXT (fn), DECL_NAME (fn));
8107 /* Consume the final `;'. */
8108 cp_parser_consume_semicolon_at_end_of_statement (parser);
8110 if (in_statement_expr
8111 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
8112 /* This is the final expression statement of a statement
8114 statement = finish_stmt_expr_expr (statement, in_statement_expr);
8116 statement = finish_expr_stmt (statement);
8123 /* Parse a compound-statement.
8126 { statement-seq [opt] }
8131 { label-declaration-seq [opt] statement-seq [opt] }
8133 label-declaration-seq:
8135 label-declaration-seq label-declaration
8137 Returns a tree representing the statement. */
8140 cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
8141 bool in_try, bool function_body)
8145 /* Consume the `{'. */
8146 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
8147 return error_mark_node;
8148 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
8150 pedwarn (input_location, OPT_pedantic,
8151 "compound-statement in constexpr function");
8152 /* Begin the compound-statement. */
8153 compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
8154 /* If the next keyword is `__label__' we have a label declaration. */
8155 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
8156 cp_parser_label_declaration (parser);
8157 /* Parse an (optional) statement-seq. */
8158 cp_parser_statement_seq_opt (parser, in_statement_expr);
8159 /* Finish the compound-statement. */
8160 finish_compound_stmt (compound_stmt);
8161 /* Consume the `}'. */
8162 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
8164 return compound_stmt;
8167 /* Parse an (optional) statement-seq.
8171 statement-seq [opt] statement */
8174 cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
8176 /* Scan statements until there aren't any more. */
8179 cp_token *token = cp_lexer_peek_token (parser->lexer);
8181 /* If we are looking at a `}', then we have run out of
8182 statements; the same is true if we have reached the end
8183 of file, or have stumbled upon a stray '@end'. */
8184 if (token->type == CPP_CLOSE_BRACE
8185 || token->type == CPP_EOF
8186 || token->type == CPP_PRAGMA_EOL
8187 || (token->type == CPP_KEYWORD && token->keyword == RID_AT_END))
8190 /* If we are in a compound statement and find 'else' then
8191 something went wrong. */
8192 else if (token->type == CPP_KEYWORD && token->keyword == RID_ELSE)
8194 if (parser->in_statement & IN_IF_STMT)
8198 token = cp_lexer_consume_token (parser->lexer);
8199 error_at (token->location, "%<else%> without a previous %<if%>");
8203 /* Parse the statement. */
8204 cp_parser_statement (parser, in_statement_expr, true, NULL);
8208 /* Parse a selection-statement.
8210 selection-statement:
8211 if ( condition ) statement
8212 if ( condition ) statement else statement
8213 switch ( condition ) statement
8215 Returns the new IF_STMT or SWITCH_STMT.
8217 If IF_P is not NULL, *IF_P is set to indicate whether the statement
8218 is a (possibly labeled) if statement which is not enclosed in
8219 braces and has an else clause. This is used to implement
8223 cp_parser_selection_statement (cp_parser* parser, bool *if_p)
8231 /* Peek at the next token. */
8232 token = cp_parser_require (parser, CPP_KEYWORD, RT_SELECT);
8234 /* See what kind of keyword it is. */
8235 keyword = token->keyword;
8244 /* Look for the `('. */
8245 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
8247 cp_parser_skip_to_end_of_statement (parser);
8248 return error_mark_node;
8251 /* Begin the selection-statement. */
8252 if (keyword == RID_IF)
8253 statement = begin_if_stmt ();
8255 statement = begin_switch_stmt ();
8257 /* Parse the condition. */
8258 condition = cp_parser_condition (parser);
8259 /* Look for the `)'. */
8260 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
8261 cp_parser_skip_to_closing_parenthesis (parser, true, false,
8262 /*consume_paren=*/true);
8264 if (keyword == RID_IF)
8267 unsigned char in_statement;
8269 /* Add the condition. */
8270 finish_if_stmt_cond (condition, statement);
8272 /* Parse the then-clause. */
8273 in_statement = parser->in_statement;
8274 parser->in_statement |= IN_IF_STMT;
8275 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
8277 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8278 add_stmt (build_empty_stmt (loc));
8279 cp_lexer_consume_token (parser->lexer);
8280 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
8281 warning_at (loc, OPT_Wempty_body, "suggest braces around "
8282 "empty body in an %<if%> statement");
8286 cp_parser_implicitly_scoped_statement (parser, &nested_if);
8287 parser->in_statement = in_statement;
8289 finish_then_clause (statement);
8291 /* If the next token is `else', parse the else-clause. */
8292 if (cp_lexer_next_token_is_keyword (parser->lexer,
8295 /* Consume the `else' keyword. */
8296 cp_lexer_consume_token (parser->lexer);
8297 begin_else_clause (statement);
8298 /* Parse the else-clause. */
8299 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
8302 loc = cp_lexer_peek_token (parser->lexer)->location;
8304 OPT_Wempty_body, "suggest braces around "
8305 "empty body in an %<else%> statement");
8306 add_stmt (build_empty_stmt (loc));
8307 cp_lexer_consume_token (parser->lexer);
8310 cp_parser_implicitly_scoped_statement (parser, NULL);
8312 finish_else_clause (statement);
8314 /* If we are currently parsing a then-clause, then
8315 IF_P will not be NULL. We set it to true to
8316 indicate that this if statement has an else clause.
8317 This may trigger the Wparentheses warning below
8318 when we get back up to the parent if statement. */
8324 /* This if statement does not have an else clause. If
8325 NESTED_IF is true, then the then-clause is an if
8326 statement which does have an else clause. We warn
8327 about the potential ambiguity. */
8329 warning_at (EXPR_LOCATION (statement), OPT_Wparentheses,
8330 "suggest explicit braces to avoid ambiguous"
8334 /* Now we're all done with the if-statement. */
8335 finish_if_stmt (statement);
8339 bool in_switch_statement_p;
8340 unsigned char in_statement;
8342 /* Add the condition. */
8343 finish_switch_cond (condition, statement);
8345 /* Parse the body of the switch-statement. */
8346 in_switch_statement_p = parser->in_switch_statement_p;
8347 in_statement = parser->in_statement;
8348 parser->in_switch_statement_p = true;
8349 parser->in_statement |= IN_SWITCH_STMT;
8350 cp_parser_implicitly_scoped_statement (parser, NULL);
8351 parser->in_switch_statement_p = in_switch_statement_p;
8352 parser->in_statement = in_statement;
8354 /* Now we're all done with the switch-statement. */
8355 finish_switch_stmt (statement);
8363 cp_parser_error (parser, "expected selection-statement");
8364 return error_mark_node;
8368 /* Parse a condition.
8372 type-specifier-seq declarator = initializer-clause
8373 type-specifier-seq declarator braced-init-list
8378 type-specifier-seq declarator asm-specification [opt]
8379 attributes [opt] = assignment-expression
8381 Returns the expression that should be tested. */
8384 cp_parser_condition (cp_parser* parser)
8386 cp_decl_specifier_seq type_specifiers;
8387 const char *saved_message;
8388 int declares_class_or_enum;
8390 /* Try the declaration first. */
8391 cp_parser_parse_tentatively (parser);
8392 /* New types are not allowed in the type-specifier-seq for a
8394 saved_message = parser->type_definition_forbidden_message;
8395 parser->type_definition_forbidden_message
8396 = G_("types may not be defined in conditions");
8397 /* Parse the type-specifier-seq. */
8398 cp_parser_decl_specifier_seq (parser,
8399 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
8401 &declares_class_or_enum);
8402 /* Restore the saved message. */
8403 parser->type_definition_forbidden_message = saved_message;
8404 /* If all is well, we might be looking at a declaration. */
8405 if (!cp_parser_error_occurred (parser))
8408 tree asm_specification;
8410 cp_declarator *declarator;
8411 tree initializer = NULL_TREE;
8413 /* Parse the declarator. */
8414 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
8415 /*ctor_dtor_or_conv_p=*/NULL,
8416 /*parenthesized_p=*/NULL,
8417 /*member_p=*/false);
8418 /* Parse the attributes. */
8419 attributes = cp_parser_attributes_opt (parser);
8420 /* Parse the asm-specification. */
8421 asm_specification = cp_parser_asm_specification_opt (parser);
8422 /* If the next token is not an `=' or '{', then we might still be
8423 looking at an expression. For example:
8427 looks like a decl-specifier-seq and a declarator -- but then
8428 there is no `=', so this is an expression. */
8429 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
8430 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
8431 cp_parser_simulate_error (parser);
8433 /* If we did see an `=' or '{', then we are looking at a declaration
8435 if (cp_parser_parse_definitely (parser))
8438 bool non_constant_p;
8439 bool flags = LOOKUP_ONLYCONVERTING;
8441 /* Create the declaration. */
8442 decl = start_decl (declarator, &type_specifiers,
8443 /*initialized_p=*/true,
8444 attributes, /*prefix_attributes=*/NULL_TREE,
8447 /* Parse the initializer. */
8448 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8450 initializer = cp_parser_braced_list (parser, &non_constant_p);
8451 CONSTRUCTOR_IS_DIRECT_INIT (initializer) = 1;
8456 /* Consume the `='. */
8457 cp_parser_require (parser, CPP_EQ, RT_EQ);
8458 initializer = cp_parser_initializer_clause (parser, &non_constant_p);
8460 if (BRACE_ENCLOSED_INITIALIZER_P (initializer))
8461 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
8463 /* Process the initializer. */
8464 cp_finish_decl (decl,
8465 initializer, !non_constant_p,
8470 pop_scope (pushed_scope);
8472 return convert_from_reference (decl);
8475 /* If we didn't even get past the declarator successfully, we are
8476 definitely not looking at a declaration. */
8478 cp_parser_abort_tentative_parse (parser);
8480 /* Otherwise, we are looking at an expression. */
8481 return cp_parser_expression (parser, /*cast_p=*/false, NULL);
8484 /* Parses a for-statement or range-for-statement until the closing ')',
8488 cp_parser_for (cp_parser *parser)
8490 tree init, scope, decl;
8493 /* Begin the for-statement. */
8494 scope = begin_for_scope (&init);
8496 /* Parse the initialization. */
8497 is_range_for = cp_parser_for_init_statement (parser, &decl);
8500 return cp_parser_range_for (parser, scope, init, decl);
8502 return cp_parser_c_for (parser, scope, init);
8506 cp_parser_c_for (cp_parser *parser, tree scope, tree init)
8508 /* Normal for loop */
8509 tree condition = NULL_TREE;
8510 tree expression = NULL_TREE;
8513 stmt = begin_for_stmt (scope, init);
8514 /* The for-init-statement has already been parsed in
8515 cp_parser_for_init_statement, so no work is needed here. */
8516 finish_for_init_stmt (stmt);
8518 /* If there's a condition, process it. */
8519 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8520 condition = cp_parser_condition (parser);
8521 finish_for_cond (condition, stmt);
8522 /* Look for the `;'. */
8523 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
8525 /* If there's an expression, process it. */
8526 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
8527 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8528 finish_for_expr (expression, stmt);
8533 /* Tries to parse a range-based for-statement:
8536 decl-specifier-seq declarator : expression
8538 The decl-specifier-seq declarator and the `:' are already parsed by
8539 cp_parser_for_init_statement. If processing_template_decl it returns a
8540 newly created RANGE_FOR_STMT; if not, it is converted to a
8541 regular FOR_STMT. */
8544 cp_parser_range_for (cp_parser *parser, tree scope, tree init, tree range_decl)
8546 tree stmt, range_expr;
8548 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8550 bool expr_non_constant_p;
8551 range_expr = cp_parser_braced_list (parser, &expr_non_constant_p);
8554 range_expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8556 /* If in template, STMT is converted to a normal for-statement
8557 at instantiation. If not, it is done just ahead. */
8558 if (processing_template_decl)
8560 stmt = begin_range_for_stmt (scope, init);
8561 finish_range_for_decl (stmt, range_decl, range_expr);
8565 stmt = begin_for_stmt (scope, init);
8566 stmt = cp_convert_range_for (stmt, range_decl, range_expr);
8571 /* Converts a range-based for-statement into a normal
8572 for-statement, as per the definition.
8574 for (RANGE_DECL : RANGE_EXPR)
8577 should be equivalent to:
8580 auto &&__range = RANGE_EXPR;
8581 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
8585 RANGE_DECL = *__begin;
8590 If RANGE_EXPR is an array:
8591 BEGIN_EXPR = __range
8592 END_EXPR = __range + ARRAY_SIZE(__range)
8593 Else if RANGE_EXPR has a member 'begin' or 'end':
8594 BEGIN_EXPR = __range.begin()
8595 END_EXPR = __range.end()
8597 BEGIN_EXPR = begin(__range)
8598 END_EXPR = end(__range);
8600 If __range has a member 'begin' but not 'end', or vice versa, we must
8601 still use the second alternative (it will surely fail, however).
8602 When calling begin()/end() in the third alternative we must use
8603 argument dependent lookup, but always considering 'std' as an associated
8607 cp_convert_range_for (tree statement, tree range_decl, tree range_expr)
8609 tree range_type, range_temp;
8611 tree iter_type, begin_expr, end_expr;
8612 tree condition, expression;
8614 if (range_decl == error_mark_node || range_expr == error_mark_node)
8615 /* If an error happened previously do nothing or else a lot of
8616 unhelpful errors would be issued. */
8617 begin_expr = end_expr = iter_type = error_mark_node;
8620 /* Find out the type deduced by the declaration
8621 `auto &&__range = range_expr'. */
8622 range_type = cp_build_reference_type (make_auto (), true);
8623 range_type = do_auto_deduction (range_type, range_expr,
8624 type_uses_auto (range_type));
8626 /* Create the __range variable. */
8627 range_temp = build_decl (input_location, VAR_DECL,
8628 get_identifier ("__for_range"), range_type);
8629 TREE_USED (range_temp) = 1;
8630 DECL_ARTIFICIAL (range_temp) = 1;
8631 pushdecl (range_temp);
8632 cp_finish_decl (range_temp, range_expr,
8633 /*is_constant_init*/false, NULL_TREE,
8634 LOOKUP_ONLYCONVERTING);
8636 range_temp = convert_from_reference (range_temp);
8637 iter_type = cp_parser_perform_range_for_lookup (range_temp,
8638 &begin_expr, &end_expr);
8641 /* The new for initialization statement. */
8642 begin = build_decl (input_location, VAR_DECL,
8643 get_identifier ("__for_begin"), iter_type);
8644 TREE_USED (begin) = 1;
8645 DECL_ARTIFICIAL (begin) = 1;
8647 cp_finish_decl (begin, begin_expr,
8648 /*is_constant_init*/false, NULL_TREE,
8649 LOOKUP_ONLYCONVERTING);
8651 end = build_decl (input_location, VAR_DECL,
8652 get_identifier ("__for_end"), iter_type);
8653 TREE_USED (end) = 1;
8654 DECL_ARTIFICIAL (end) = 1;
8656 cp_finish_decl (end, end_expr,
8657 /*is_constant_init*/false, NULL_TREE,
8658 LOOKUP_ONLYCONVERTING);
8660 finish_for_init_stmt (statement);
8662 /* The new for condition. */
8663 condition = build_x_binary_op (NE_EXPR,
8666 NULL, tf_warning_or_error);
8667 finish_for_cond (condition, statement);
8669 /* The new increment expression. */
8670 expression = finish_unary_op_expr (PREINCREMENT_EXPR, begin);
8671 finish_for_expr (expression, statement);
8673 /* The declaration is initialized with *__begin inside the loop body. */
8674 cp_finish_decl (range_decl,
8675 build_x_indirect_ref (begin, RO_NULL, tf_warning_or_error),
8676 /*is_constant_init*/false, NULL_TREE,
8677 LOOKUP_ONLYCONVERTING);
8682 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
8683 We need to solve both at the same time because the method used
8684 depends on the existence of members begin or end.
8685 Returns the type deduced for the iterator expression. */
8688 cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end)
8690 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (range))))
8692 error ("range-based %<for%> expression of type %qT "
8693 "has incomplete type", TREE_TYPE (range));
8694 *begin = *end = error_mark_node;
8695 return error_mark_node;
8697 if (TREE_CODE (TREE_TYPE (range)) == ARRAY_TYPE)
8699 /* If RANGE is an array, we will use pointer arithmetic. */
8701 *end = build_binary_op (input_location, PLUS_EXPR,
8703 array_type_nelts_top (TREE_TYPE (range)),
8705 return build_pointer_type (TREE_TYPE (TREE_TYPE (range)));
8709 /* If it is not an array, we must do a bit of magic. */
8710 tree id_begin, id_end;
8711 tree member_begin, member_end;
8713 *begin = *end = error_mark_node;
8715 id_begin = get_identifier ("begin");
8716 id_end = get_identifier ("end");
8717 member_begin = lookup_member (TREE_TYPE (range), id_begin,
8718 /*protect=*/2, /*want_type=*/false);
8719 member_end = lookup_member (TREE_TYPE (range), id_end,
8720 /*protect=*/2, /*want_type=*/false);
8722 if (member_begin != NULL_TREE || member_end != NULL_TREE)
8724 /* Use the member functions. */
8725 if (member_begin != NULL_TREE)
8726 *begin = cp_parser_range_for_member_function (range, id_begin);
8728 error ("range-based %<for%> expression of type %qT has an "
8729 "%<end%> member but not a %<begin%>", TREE_TYPE (range));
8731 if (member_end != NULL_TREE)
8732 *end = cp_parser_range_for_member_function (range, id_end);
8734 error ("range-based %<for%> expression of type %qT has a "
8735 "%<begin%> member but not an %<end%>", TREE_TYPE (range));
8739 /* Use global functions with ADL. */
8741 vec = make_tree_vector ();
8743 VEC_safe_push (tree, gc, vec, range);
8745 member_begin = perform_koenig_lookup (id_begin, vec,
8746 /*include_std=*/true,
8747 tf_warning_or_error);
8748 *begin = finish_call_expr (member_begin, &vec, false, true,
8749 tf_warning_or_error);
8750 member_end = perform_koenig_lookup (id_end, vec,
8751 /*include_std=*/true,
8752 tf_warning_or_error);
8753 *end = finish_call_expr (member_end, &vec, false, true,
8754 tf_warning_or_error);
8756 release_tree_vector (vec);
8759 /* Last common checks. */
8760 if (*begin == error_mark_node || *end == error_mark_node)
8762 /* If one of the expressions is an error do no more checks. */
8763 *begin = *end = error_mark_node;
8764 return error_mark_node;
8768 tree iter_type = cv_unqualified (TREE_TYPE (*begin));
8769 /* The unqualified type of the __begin and __end temporaries should
8770 be the same, as required by the multiple auto declaration. */
8771 if (!same_type_p (iter_type, cv_unqualified (TREE_TYPE (*end))))
8772 error ("inconsistent begin/end types in range-based %<for%> "
8773 "statement: %qT and %qT",
8774 TREE_TYPE (*begin), TREE_TYPE (*end));
8780 /* Helper function for cp_parser_perform_range_for_lookup.
8781 Builds a tree for RANGE.IDENTIFIER(). */
8784 cp_parser_range_for_member_function (tree range, tree identifier)
8789 member = finish_class_member_access_expr (range, identifier,
8790 false, tf_warning_or_error);
8791 if (member == error_mark_node)
8792 return error_mark_node;
8794 vec = make_tree_vector ();
8795 res = finish_call_expr (member, &vec,
8796 /*disallow_virtual=*/false,
8798 tf_warning_or_error);
8799 release_tree_vector (vec);
8803 /* Parse an iteration-statement.
8805 iteration-statement:
8806 while ( condition ) statement
8807 do statement while ( expression ) ;
8808 for ( for-init-statement condition [opt] ; expression [opt] )
8811 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
8814 cp_parser_iteration_statement (cp_parser* parser)
8819 unsigned char in_statement;
8821 /* Peek at the next token. */
8822 token = cp_parser_require (parser, CPP_KEYWORD, RT_INTERATION);
8824 return error_mark_node;
8826 /* Remember whether or not we are already within an iteration
8828 in_statement = parser->in_statement;
8830 /* See what kind of keyword it is. */
8831 keyword = token->keyword;
8838 /* Begin the while-statement. */
8839 statement = begin_while_stmt ();
8840 /* Look for the `('. */
8841 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8842 /* Parse the condition. */
8843 condition = cp_parser_condition (parser);
8844 finish_while_stmt_cond (condition, statement);
8845 /* Look for the `)'. */
8846 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8847 /* Parse the dependent statement. */
8848 parser->in_statement = IN_ITERATION_STMT;
8849 cp_parser_already_scoped_statement (parser);
8850 parser->in_statement = in_statement;
8851 /* We're done with the while-statement. */
8852 finish_while_stmt (statement);
8860 /* Begin the do-statement. */
8861 statement = begin_do_stmt ();
8862 /* Parse the body of the do-statement. */
8863 parser->in_statement = IN_ITERATION_STMT;
8864 cp_parser_implicitly_scoped_statement (parser, NULL);
8865 parser->in_statement = in_statement;
8866 finish_do_body (statement);
8867 /* Look for the `while' keyword. */
8868 cp_parser_require_keyword (parser, RID_WHILE, RT_WHILE);
8869 /* Look for the `('. */
8870 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8871 /* Parse the expression. */
8872 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8873 /* We're done with the do-statement. */
8874 finish_do_stmt (expression, statement);
8875 /* Look for the `)'. */
8876 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8877 /* Look for the `;'. */
8878 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
8884 /* Look for the `('. */
8885 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8887 statement = cp_parser_for (parser);
8889 /* Look for the `)'. */
8890 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8892 /* Parse the body of the for-statement. */
8893 parser->in_statement = IN_ITERATION_STMT;
8894 cp_parser_already_scoped_statement (parser);
8895 parser->in_statement = in_statement;
8897 /* We're done with the for-statement. */
8898 finish_for_stmt (statement);
8903 cp_parser_error (parser, "expected iteration-statement");
8904 statement = error_mark_node;
8911 /* Parse a for-init-statement or the declarator of a range-based-for.
8912 Returns true if a range-based-for declaration is seen.
8915 expression-statement
8916 simple-declaration */
8919 cp_parser_for_init_statement (cp_parser* parser, tree *decl)
8921 /* If the next token is a `;', then we have an empty
8922 expression-statement. Grammatically, this is also a
8923 simple-declaration, but an invalid one, because it does not
8924 declare anything. Therefore, if we did not handle this case
8925 specially, we would issue an error message about an invalid
8927 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8929 bool is_range_for = false;
8930 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
8932 parser->colon_corrects_to_scope_p = false;
8934 /* We're going to speculatively look for a declaration, falling back
8935 to an expression, if necessary. */
8936 cp_parser_parse_tentatively (parser);
8937 /* Parse the declaration. */
8938 cp_parser_simple_declaration (parser,
8939 /*function_definition_allowed_p=*/false,
8941 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
8942 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
8944 /* It is a range-for, consume the ':' */
8945 cp_lexer_consume_token (parser->lexer);
8946 is_range_for = true;
8947 if (cxx_dialect < cxx0x)
8949 error_at (cp_lexer_peek_token (parser->lexer)->location,
8950 "range-based %<for%> loops are not allowed "
8952 *decl = error_mark_node;
8956 /* The ';' is not consumed yet because we told
8957 cp_parser_simple_declaration not to. */
8958 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
8960 if (cp_parser_parse_definitely (parser))
8961 return is_range_for;
8962 /* If the tentative parse failed, then we shall need to look for an
8963 expression-statement. */
8965 /* If we are here, it is an expression-statement. */
8966 cp_parser_expression_statement (parser, NULL_TREE);
8970 /* Parse a jump-statement.
8975 return expression [opt] ;
8976 return braced-init-list ;
8984 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
8987 cp_parser_jump_statement (cp_parser* parser)
8989 tree statement = error_mark_node;
8992 unsigned char in_statement;
8994 /* Peek at the next token. */
8995 token = cp_parser_require (parser, CPP_KEYWORD, RT_JUMP);
8997 return error_mark_node;
8999 /* See what kind of keyword it is. */
9000 keyword = token->keyword;
9004 in_statement = parser->in_statement & ~IN_IF_STMT;
9005 switch (in_statement)
9008 error_at (token->location, "break statement not within loop or switch");
9011 gcc_assert ((in_statement & IN_SWITCH_STMT)
9012 || in_statement == IN_ITERATION_STMT);
9013 statement = finish_break_stmt ();
9016 error_at (token->location, "invalid exit from OpenMP structured block");
9019 error_at (token->location, "break statement used with OpenMP for loop");
9022 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9026 switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
9029 error_at (token->location, "continue statement not within a loop");
9031 case IN_ITERATION_STMT:
9033 statement = finish_continue_stmt ();
9036 error_at (token->location, "invalid exit from OpenMP structured block");
9041 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9047 bool expr_non_constant_p;
9049 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9051 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
9052 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
9054 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
9055 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
9057 /* If the next token is a `;', then there is no
9060 /* Build the return-statement. */
9061 statement = finish_return_stmt (expr);
9062 /* Look for the final `;'. */
9063 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9068 /* Create the goto-statement. */
9069 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
9071 /* Issue a warning about this use of a GNU extension. */
9072 pedwarn (token->location, OPT_pedantic, "ISO C++ forbids computed gotos");
9073 /* Consume the '*' token. */
9074 cp_lexer_consume_token (parser->lexer);
9075 /* Parse the dependent expression. */
9076 finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false, NULL));
9079 finish_goto_stmt (cp_parser_identifier (parser));
9080 /* Look for the final `;'. */
9081 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9085 cp_parser_error (parser, "expected jump-statement");
9092 /* Parse a declaration-statement.
9094 declaration-statement:
9095 block-declaration */
9098 cp_parser_declaration_statement (cp_parser* parser)
9102 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
9103 p = obstack_alloc (&declarator_obstack, 0);
9105 /* Parse the block-declaration. */
9106 cp_parser_block_declaration (parser, /*statement_p=*/true);
9108 /* Free any declarators allocated. */
9109 obstack_free (&declarator_obstack, p);
9111 /* Finish off the statement. */
9115 /* Some dependent statements (like `if (cond) statement'), are
9116 implicitly in their own scope. In other words, if the statement is
9117 a single statement (as opposed to a compound-statement), it is
9118 none-the-less treated as if it were enclosed in braces. Any
9119 declarations appearing in the dependent statement are out of scope
9120 after control passes that point. This function parses a statement,
9121 but ensures that is in its own scope, even if it is not a
9124 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9125 is a (possibly labeled) if statement which is not enclosed in
9126 braces and has an else clause. This is used to implement
9129 Returns the new statement. */
9132 cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
9139 /* Mark if () ; with a special NOP_EXPR. */
9140 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
9142 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
9143 cp_lexer_consume_token (parser->lexer);
9144 statement = add_stmt (build_empty_stmt (loc));
9146 /* if a compound is opened, we simply parse the statement directly. */
9147 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9148 statement = cp_parser_compound_statement (parser, NULL, false, false);
9149 /* If the token is not a `{', then we must take special action. */
9152 /* Create a compound-statement. */
9153 statement = begin_compound_stmt (0);
9154 /* Parse the dependent-statement. */
9155 cp_parser_statement (parser, NULL_TREE, false, if_p);
9156 /* Finish the dummy compound-statement. */
9157 finish_compound_stmt (statement);
9160 /* Return the statement. */
9164 /* For some dependent statements (like `while (cond) statement'), we
9165 have already created a scope. Therefore, even if the dependent
9166 statement is a compound-statement, we do not want to create another
9170 cp_parser_already_scoped_statement (cp_parser* parser)
9172 /* If the token is a `{', then we must take special action. */
9173 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
9174 cp_parser_statement (parser, NULL_TREE, false, NULL);
9177 /* Avoid calling cp_parser_compound_statement, so that we
9178 don't create a new scope. Do everything else by hand. */
9179 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
9180 /* If the next keyword is `__label__' we have a label declaration. */
9181 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
9182 cp_parser_label_declaration (parser);
9183 /* Parse an (optional) statement-seq. */
9184 cp_parser_statement_seq_opt (parser, NULL_TREE);
9185 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
9189 /* Declarations [gram.dcl.dcl] */
9191 /* Parse an optional declaration-sequence.
9195 declaration-seq declaration */
9198 cp_parser_declaration_seq_opt (cp_parser* parser)
9204 token = cp_lexer_peek_token (parser->lexer);
9206 if (token->type == CPP_CLOSE_BRACE
9207 || token->type == CPP_EOF
9208 || token->type == CPP_PRAGMA_EOL)
9211 if (token->type == CPP_SEMICOLON)
9213 /* A declaration consisting of a single semicolon is
9214 invalid. Allow it unless we're being pedantic. */
9215 cp_lexer_consume_token (parser->lexer);
9216 if (!in_system_header)
9217 pedwarn (input_location, OPT_pedantic, "extra %<;%>");
9221 /* If we're entering or exiting a region that's implicitly
9222 extern "C", modify the lang context appropriately. */
9223 if (!parser->implicit_extern_c && token->implicit_extern_c)
9225 push_lang_context (lang_name_c);
9226 parser->implicit_extern_c = true;
9228 else if (parser->implicit_extern_c && !token->implicit_extern_c)
9230 pop_lang_context ();
9231 parser->implicit_extern_c = false;
9234 if (token->type == CPP_PRAGMA)
9236 /* A top-level declaration can consist solely of a #pragma.
9237 A nested declaration cannot, so this is done here and not
9238 in cp_parser_declaration. (A #pragma at block scope is
9239 handled in cp_parser_statement.) */
9240 cp_parser_pragma (parser, pragma_external);
9244 /* Parse the declaration itself. */
9245 cp_parser_declaration (parser);
9249 /* Parse a declaration.
9254 template-declaration
9255 explicit-instantiation
9256 explicit-specialization
9257 linkage-specification
9258 namespace-definition
9263 __extension__ declaration */
9266 cp_parser_declaration (cp_parser* parser)
9272 tree attributes = NULL_TREE;
9274 /* Check for the `__extension__' keyword. */
9275 if (cp_parser_extension_opt (parser, &saved_pedantic))
9277 /* Parse the qualified declaration. */
9278 cp_parser_declaration (parser);
9279 /* Restore the PEDANTIC flag. */
9280 pedantic = saved_pedantic;
9285 /* Try to figure out what kind of declaration is present. */
9286 token1 = *cp_lexer_peek_token (parser->lexer);
9288 if (token1.type != CPP_EOF)
9289 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
9292 token2.type = CPP_EOF;
9293 token2.keyword = RID_MAX;
9296 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
9297 p = obstack_alloc (&declarator_obstack, 0);
9299 /* If the next token is `extern' and the following token is a string
9300 literal, then we have a linkage specification. */
9301 if (token1.keyword == RID_EXTERN
9302 && cp_parser_is_string_literal (&token2))
9303 cp_parser_linkage_specification (parser);
9304 /* If the next token is `template', then we have either a template
9305 declaration, an explicit instantiation, or an explicit
9307 else if (token1.keyword == RID_TEMPLATE)
9309 /* `template <>' indicates a template specialization. */
9310 if (token2.type == CPP_LESS
9311 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
9312 cp_parser_explicit_specialization (parser);
9313 /* `template <' indicates a template declaration. */
9314 else if (token2.type == CPP_LESS)
9315 cp_parser_template_declaration (parser, /*member_p=*/false);
9316 /* Anything else must be an explicit instantiation. */
9318 cp_parser_explicit_instantiation (parser);
9320 /* If the next token is `export', then we have a template
9322 else if (token1.keyword == RID_EXPORT)
9323 cp_parser_template_declaration (parser, /*member_p=*/false);
9324 /* If the next token is `extern', 'static' or 'inline' and the one
9325 after that is `template', we have a GNU extended explicit
9326 instantiation directive. */
9327 else if (cp_parser_allow_gnu_extensions_p (parser)
9328 && (token1.keyword == RID_EXTERN
9329 || token1.keyword == RID_STATIC
9330 || token1.keyword == RID_INLINE)
9331 && token2.keyword == RID_TEMPLATE)
9332 cp_parser_explicit_instantiation (parser);
9333 /* If the next token is `namespace', check for a named or unnamed
9334 namespace definition. */
9335 else if (token1.keyword == RID_NAMESPACE
9336 && (/* A named namespace definition. */
9337 (token2.type == CPP_NAME
9338 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
9340 /* An unnamed namespace definition. */
9341 || token2.type == CPP_OPEN_BRACE
9342 || token2.keyword == RID_ATTRIBUTE))
9343 cp_parser_namespace_definition (parser);
9344 /* An inline (associated) namespace definition. */
9345 else if (token1.keyword == RID_INLINE
9346 && token2.keyword == RID_NAMESPACE)
9347 cp_parser_namespace_definition (parser);
9348 /* Objective-C++ declaration/definition. */
9349 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
9350 cp_parser_objc_declaration (parser, NULL_TREE);
9351 else if (c_dialect_objc ()
9352 && token1.keyword == RID_ATTRIBUTE
9353 && cp_parser_objc_valid_prefix_attributes (parser, &attributes))
9354 cp_parser_objc_declaration (parser, attributes);
9355 /* We must have either a block declaration or a function
9358 /* Try to parse a block-declaration, or a function-definition. */
9359 cp_parser_block_declaration (parser, /*statement_p=*/false);
9361 /* Free any declarators allocated. */
9362 obstack_free (&declarator_obstack, p);
9365 /* Parse a block-declaration.
9370 namespace-alias-definition
9377 __extension__ block-declaration
9382 static_assert-declaration
9384 If STATEMENT_P is TRUE, then this block-declaration is occurring as
9385 part of a declaration-statement. */
9388 cp_parser_block_declaration (cp_parser *parser,
9394 /* Check for the `__extension__' keyword. */
9395 if (cp_parser_extension_opt (parser, &saved_pedantic))
9397 /* Parse the qualified declaration. */
9398 cp_parser_block_declaration (parser, statement_p);
9399 /* Restore the PEDANTIC flag. */
9400 pedantic = saved_pedantic;
9405 /* Peek at the next token to figure out which kind of declaration is
9407 token1 = cp_lexer_peek_token (parser->lexer);
9409 /* If the next keyword is `asm', we have an asm-definition. */
9410 if (token1->keyword == RID_ASM)
9413 cp_parser_commit_to_tentative_parse (parser);
9414 cp_parser_asm_definition (parser);
9416 /* If the next keyword is `namespace', we have a
9417 namespace-alias-definition. */
9418 else if (token1->keyword == RID_NAMESPACE)
9419 cp_parser_namespace_alias_definition (parser);
9420 /* If the next keyword is `using', we have either a
9421 using-declaration or a using-directive. */
9422 else if (token1->keyword == RID_USING)
9427 cp_parser_commit_to_tentative_parse (parser);
9428 /* If the token after `using' is `namespace', then we have a
9430 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
9431 if (token2->keyword == RID_NAMESPACE)
9432 cp_parser_using_directive (parser);
9433 /* Otherwise, it's a using-declaration. */
9435 cp_parser_using_declaration (parser,
9436 /*access_declaration_p=*/false);
9438 /* If the next keyword is `__label__' we have a misplaced label
9440 else if (token1->keyword == RID_LABEL)
9442 cp_lexer_consume_token (parser->lexer);
9443 error_at (token1->location, "%<__label__%> not at the beginning of a block");
9444 cp_parser_skip_to_end_of_statement (parser);
9445 /* If the next token is now a `;', consume it. */
9446 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
9447 cp_lexer_consume_token (parser->lexer);
9449 /* If the next token is `static_assert' we have a static assertion. */
9450 else if (token1->keyword == RID_STATIC_ASSERT)
9451 cp_parser_static_assert (parser, /*member_p=*/false);
9452 /* Anything else must be a simple-declaration. */
9454 cp_parser_simple_declaration (parser, !statement_p,
9455 /*maybe_range_for_decl*/NULL);
9458 /* Parse a simple-declaration.
9461 decl-specifier-seq [opt] init-declarator-list [opt] ;
9463 init-declarator-list:
9465 init-declarator-list , init-declarator
9467 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
9468 function-definition as a simple-declaration.
9470 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
9471 parsed declaration if it is an uninitialized single declarator not followed
9472 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
9473 if present, will not be consumed. */
9476 cp_parser_simple_declaration (cp_parser* parser,
9477 bool function_definition_allowed_p,
9478 tree *maybe_range_for_decl)
9480 cp_decl_specifier_seq decl_specifiers;
9481 int declares_class_or_enum;
9482 bool saw_declarator;
9484 if (maybe_range_for_decl)
9485 *maybe_range_for_decl = NULL_TREE;
9487 /* Defer access checks until we know what is being declared; the
9488 checks for names appearing in the decl-specifier-seq should be
9489 done as if we were in the scope of the thing being declared. */
9490 push_deferring_access_checks (dk_deferred);
9492 /* Parse the decl-specifier-seq. We have to keep track of whether
9493 or not the decl-specifier-seq declares a named class or
9494 enumeration type, since that is the only case in which the
9495 init-declarator-list is allowed to be empty.
9499 In a simple-declaration, the optional init-declarator-list can be
9500 omitted only when declaring a class or enumeration, that is when
9501 the decl-specifier-seq contains either a class-specifier, an
9502 elaborated-type-specifier, or an enum-specifier. */
9503 cp_parser_decl_specifier_seq (parser,
9504 CP_PARSER_FLAGS_OPTIONAL,
9506 &declares_class_or_enum);
9507 /* We no longer need to defer access checks. */
9508 stop_deferring_access_checks ();
9510 /* In a block scope, a valid declaration must always have a
9511 decl-specifier-seq. By not trying to parse declarators, we can
9512 resolve the declaration/expression ambiguity more quickly. */
9513 if (!function_definition_allowed_p
9514 && !decl_specifiers.any_specifiers_p)
9516 cp_parser_error (parser, "expected declaration");
9520 /* If the next two tokens are both identifiers, the code is
9521 erroneous. The usual cause of this situation is code like:
9525 where "T" should name a type -- but does not. */
9526 if (!decl_specifiers.any_type_specifiers_p
9527 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
9529 /* If parsing tentatively, we should commit; we really are
9530 looking at a declaration. */
9531 cp_parser_commit_to_tentative_parse (parser);
9536 /* If we have seen at least one decl-specifier, and the next token
9537 is not a parenthesis, then we must be looking at a declaration.
9538 (After "int (" we might be looking at a functional cast.) */
9539 if (decl_specifiers.any_specifiers_p
9540 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)
9541 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
9542 && !cp_parser_error_occurred (parser))
9543 cp_parser_commit_to_tentative_parse (parser);
9545 /* Keep going until we hit the `;' at the end of the simple
9547 saw_declarator = false;
9548 while (cp_lexer_next_token_is_not (parser->lexer,
9552 bool function_definition_p;
9557 /* If we are processing next declarator, coma is expected */
9558 token = cp_lexer_peek_token (parser->lexer);
9559 gcc_assert (token->type == CPP_COMMA);
9560 cp_lexer_consume_token (parser->lexer);
9561 if (maybe_range_for_decl)
9562 *maybe_range_for_decl = error_mark_node;
9565 saw_declarator = true;
9567 /* Parse the init-declarator. */
9568 decl = cp_parser_init_declarator (parser, &decl_specifiers,
9570 function_definition_allowed_p,
9572 declares_class_or_enum,
9573 &function_definition_p,
9574 maybe_range_for_decl);
9575 /* If an error occurred while parsing tentatively, exit quickly.
9576 (That usually happens when in the body of a function; each
9577 statement is treated as a declaration-statement until proven
9579 if (cp_parser_error_occurred (parser))
9581 /* Handle function definitions specially. */
9582 if (function_definition_p)
9584 /* If the next token is a `,', then we are probably
9585 processing something like:
9589 which is erroneous. */
9590 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
9592 cp_token *token = cp_lexer_peek_token (parser->lexer);
9593 error_at (token->location,
9595 " declarations and function-definitions is forbidden");
9597 /* Otherwise, we're done with the list of declarators. */
9600 pop_deferring_access_checks ();
9604 if (maybe_range_for_decl && *maybe_range_for_decl == NULL_TREE)
9605 *maybe_range_for_decl = decl;
9606 /* The next token should be either a `,' or a `;'. */
9607 token = cp_lexer_peek_token (parser->lexer);
9608 /* If it's a `,', there are more declarators to come. */
9609 if (token->type == CPP_COMMA)
9610 /* will be consumed next time around */;
9611 /* If it's a `;', we are done. */
9612 else if (token->type == CPP_SEMICOLON || maybe_range_for_decl)
9614 /* Anything else is an error. */
9617 /* If we have already issued an error message we don't need
9618 to issue another one. */
9619 if (decl != error_mark_node
9620 || cp_parser_uncommitted_to_tentative_parse_p (parser))
9621 cp_parser_error (parser, "expected %<,%> or %<;%>");
9622 /* Skip tokens until we reach the end of the statement. */
9623 cp_parser_skip_to_end_of_statement (parser);
9624 /* If the next token is now a `;', consume it. */
9625 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
9626 cp_lexer_consume_token (parser->lexer);
9629 /* After the first time around, a function-definition is not
9630 allowed -- even if it was OK at first. For example:
9635 function_definition_allowed_p = false;
9638 /* Issue an error message if no declarators are present, and the
9639 decl-specifier-seq does not itself declare a class or
9641 if (!saw_declarator)
9643 if (cp_parser_declares_only_class_p (parser))
9644 shadow_tag (&decl_specifiers);
9645 /* Perform any deferred access checks. */
9646 perform_deferred_access_checks ();
9649 /* Consume the `;'. */
9650 if (!maybe_range_for_decl)
9651 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9654 pop_deferring_access_checks ();
9657 /* Parse a decl-specifier-seq.
9660 decl-specifier-seq [opt] decl-specifier
9663 storage-class-specifier
9674 Set *DECL_SPECS to a representation of the decl-specifier-seq.
9676 The parser flags FLAGS is used to control type-specifier parsing.
9678 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
9681 1: one of the decl-specifiers is an elaborated-type-specifier
9682 (i.e., a type declaration)
9683 2: one of the decl-specifiers is an enum-specifier or a
9684 class-specifier (i.e., a type definition)
9689 cp_parser_decl_specifier_seq (cp_parser* parser,
9690 cp_parser_flags flags,
9691 cp_decl_specifier_seq *decl_specs,
9692 int* declares_class_or_enum)
9694 bool constructor_possible_p = !parser->in_declarator_p;
9695 cp_token *start_token = NULL;
9697 /* Clear DECL_SPECS. */
9698 clear_decl_specs (decl_specs);
9700 /* Assume no class or enumeration type is declared. */
9701 *declares_class_or_enum = 0;
9703 /* Keep reading specifiers until there are no more to read. */
9707 bool found_decl_spec;
9710 /* Peek at the next token. */
9711 token = cp_lexer_peek_token (parser->lexer);
9713 /* Save the first token of the decl spec list for error
9716 start_token = token;
9717 /* Handle attributes. */
9718 if (token->keyword == RID_ATTRIBUTE)
9720 /* Parse the attributes. */
9721 decl_specs->attributes
9722 = chainon (decl_specs->attributes,
9723 cp_parser_attributes_opt (parser));
9726 /* Assume we will find a decl-specifier keyword. */
9727 found_decl_spec = true;
9728 /* If the next token is an appropriate keyword, we can simply
9729 add it to the list. */
9730 switch (token->keyword)
9736 if (!at_class_scope_p ())
9738 error_at (token->location, "%<friend%> used outside of class");
9739 cp_lexer_purge_token (parser->lexer);
9743 ++decl_specs->specs[(int) ds_friend];
9744 /* Consume the token. */
9745 cp_lexer_consume_token (parser->lexer);
9750 ++decl_specs->specs[(int) ds_constexpr];
9751 cp_lexer_consume_token (parser->lexer);
9754 /* function-specifier:
9761 cp_parser_function_specifier_opt (parser, decl_specs);
9767 ++decl_specs->specs[(int) ds_typedef];
9768 /* Consume the token. */
9769 cp_lexer_consume_token (parser->lexer);
9770 /* A constructor declarator cannot appear in a typedef. */
9771 constructor_possible_p = false;
9772 /* The "typedef" keyword can only occur in a declaration; we
9773 may as well commit at this point. */
9774 cp_parser_commit_to_tentative_parse (parser);
9776 if (decl_specs->storage_class != sc_none)
9777 decl_specs->conflicting_specifiers_p = true;
9780 /* storage-class-specifier:
9790 if (cxx_dialect == cxx98)
9792 /* Consume the token. */
9793 cp_lexer_consume_token (parser->lexer);
9795 /* Complain about `auto' as a storage specifier, if
9796 we're complaining about C++0x compatibility. */
9797 warning_at (token->location, OPT_Wc__0x_compat, "%<auto%>"
9798 " will change meaning in C++0x; please remove it");
9800 /* Set the storage class anyway. */
9801 cp_parser_set_storage_class (parser, decl_specs, RID_AUTO,
9805 /* C++0x auto type-specifier. */
9806 found_decl_spec = false;
9813 /* Consume the token. */
9814 cp_lexer_consume_token (parser->lexer);
9815 cp_parser_set_storage_class (parser, decl_specs, token->keyword,
9819 /* Consume the token. */
9820 cp_lexer_consume_token (parser->lexer);
9821 ++decl_specs->specs[(int) ds_thread];
9825 /* We did not yet find a decl-specifier yet. */
9826 found_decl_spec = false;
9831 && (flags & CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR)
9832 && token->keyword != RID_CONSTEXPR)
9833 error ("decl-specifier invalid in condition");
9835 /* Constructors are a special case. The `S' in `S()' is not a
9836 decl-specifier; it is the beginning of the declarator. */
9839 && constructor_possible_p
9840 && (cp_parser_constructor_declarator_p
9841 (parser, decl_specs->specs[(int) ds_friend] != 0)));
9843 /* If we don't have a DECL_SPEC yet, then we must be looking at
9844 a type-specifier. */
9845 if (!found_decl_spec && !constructor_p)
9847 int decl_spec_declares_class_or_enum;
9848 bool is_cv_qualifier;
9852 = cp_parser_type_specifier (parser, flags,
9854 /*is_declaration=*/true,
9855 &decl_spec_declares_class_or_enum,
9857 *declares_class_or_enum |= decl_spec_declares_class_or_enum;
9859 /* If this type-specifier referenced a user-defined type
9860 (a typedef, class-name, etc.), then we can't allow any
9861 more such type-specifiers henceforth.
9865 The longest sequence of decl-specifiers that could
9866 possibly be a type name is taken as the
9867 decl-specifier-seq of a declaration. The sequence shall
9868 be self-consistent as described below.
9872 As a general rule, at most one type-specifier is allowed
9873 in the complete decl-specifier-seq of a declaration. The
9874 only exceptions are the following:
9876 -- const or volatile can be combined with any other
9879 -- signed or unsigned can be combined with char, long,
9887 void g (const int Pc);
9889 Here, Pc is *not* part of the decl-specifier seq; it's
9890 the declarator. Therefore, once we see a type-specifier
9891 (other than a cv-qualifier), we forbid any additional
9892 user-defined types. We *do* still allow things like `int
9893 int' to be considered a decl-specifier-seq, and issue the
9894 error message later. */
9895 if (type_spec && !is_cv_qualifier)
9896 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
9897 /* A constructor declarator cannot follow a type-specifier. */
9900 constructor_possible_p = false;
9901 found_decl_spec = true;
9902 if (!is_cv_qualifier)
9903 decl_specs->any_type_specifiers_p = true;
9907 /* If we still do not have a DECL_SPEC, then there are no more
9909 if (!found_decl_spec)
9912 decl_specs->any_specifiers_p = true;
9913 /* After we see one decl-specifier, further decl-specifiers are
9915 flags |= CP_PARSER_FLAGS_OPTIONAL;
9918 cp_parser_check_decl_spec (decl_specs, start_token->location);
9920 /* Don't allow a friend specifier with a class definition. */
9921 if (decl_specs->specs[(int) ds_friend] != 0
9922 && (*declares_class_or_enum & 2))
9923 error_at (start_token->location,
9924 "class definition may not be declared a friend");
9927 /* Parse an (optional) storage-class-specifier.
9929 storage-class-specifier:
9938 storage-class-specifier:
9941 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
9944 cp_parser_storage_class_specifier_opt (cp_parser* parser)
9946 switch (cp_lexer_peek_token (parser->lexer)->keyword)
9949 if (cxx_dialect != cxx98)
9951 /* Fall through for C++98. */
9958 /* Consume the token. */
9959 return cp_lexer_consume_token (parser->lexer)->u.value;
9966 /* Parse an (optional) function-specifier.
9973 Returns an IDENTIFIER_NODE corresponding to the keyword used.
9974 Updates DECL_SPECS, if it is non-NULL. */
9977 cp_parser_function_specifier_opt (cp_parser* parser,
9978 cp_decl_specifier_seq *decl_specs)
9980 cp_token *token = cp_lexer_peek_token (parser->lexer);
9981 switch (token->keyword)
9985 ++decl_specs->specs[(int) ds_inline];
9989 /* 14.5.2.3 [temp.mem]
9991 A member function template shall not be virtual. */
9992 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
9993 error_at (token->location, "templates may not be %<virtual%>");
9994 else if (decl_specs)
9995 ++decl_specs->specs[(int) ds_virtual];
10000 ++decl_specs->specs[(int) ds_explicit];
10007 /* Consume the token. */
10008 return cp_lexer_consume_token (parser->lexer)->u.value;
10011 /* Parse a linkage-specification.
10013 linkage-specification:
10014 extern string-literal { declaration-seq [opt] }
10015 extern string-literal declaration */
10018 cp_parser_linkage_specification (cp_parser* parser)
10022 /* Look for the `extern' keyword. */
10023 cp_parser_require_keyword (parser, RID_EXTERN, RT_EXTERN);
10025 /* Look for the string-literal. */
10026 linkage = cp_parser_string_literal (parser, false, false);
10028 /* Transform the literal into an identifier. If the literal is a
10029 wide-character string, or contains embedded NULs, then we can't
10030 handle it as the user wants. */
10031 if (strlen (TREE_STRING_POINTER (linkage))
10032 != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
10034 cp_parser_error (parser, "invalid linkage-specification");
10035 /* Assume C++ linkage. */
10036 linkage = lang_name_cplusplus;
10039 linkage = get_identifier (TREE_STRING_POINTER (linkage));
10041 /* We're now using the new linkage. */
10042 push_lang_context (linkage);
10044 /* If the next token is a `{', then we're using the first
10046 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10048 /* Consume the `{' token. */
10049 cp_lexer_consume_token (parser->lexer);
10050 /* Parse the declarations. */
10051 cp_parser_declaration_seq_opt (parser);
10052 /* Look for the closing `}'. */
10053 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
10055 /* Otherwise, there's just one declaration. */
10058 bool saved_in_unbraced_linkage_specification_p;
10060 saved_in_unbraced_linkage_specification_p
10061 = parser->in_unbraced_linkage_specification_p;
10062 parser->in_unbraced_linkage_specification_p = true;
10063 cp_parser_declaration (parser);
10064 parser->in_unbraced_linkage_specification_p
10065 = saved_in_unbraced_linkage_specification_p;
10068 /* We're done with the linkage-specification. */
10069 pop_lang_context ();
10072 /* Parse a static_assert-declaration.
10074 static_assert-declaration:
10075 static_assert ( constant-expression , string-literal ) ;
10077 If MEMBER_P, this static_assert is a class member. */
10080 cp_parser_static_assert(cp_parser *parser, bool member_p)
10085 location_t saved_loc;
10088 /* Peek at the `static_assert' token so we can keep track of exactly
10089 where the static assertion started. */
10090 token = cp_lexer_peek_token (parser->lexer);
10091 saved_loc = token->location;
10093 /* Look for the `static_assert' keyword. */
10094 if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
10098 /* We know we are in a static assertion; commit to any tentative
10100 if (cp_parser_parsing_tentatively (parser))
10101 cp_parser_commit_to_tentative_parse (parser);
10103 /* Parse the `(' starting the static assertion condition. */
10104 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
10106 /* Parse the constant-expression. Allow a non-constant expression
10107 here in order to give better diagnostics in finish_static_assert. */
10109 cp_parser_constant_expression (parser,
10110 /*allow_non_constant_p=*/true,
10111 /*non_constant_p=*/&dummy);
10113 /* Parse the separating `,'. */
10114 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
10116 /* Parse the string-literal message. */
10117 message = cp_parser_string_literal (parser,
10118 /*translate=*/false,
10121 /* A `)' completes the static assertion. */
10122 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
10123 cp_parser_skip_to_closing_parenthesis (parser,
10124 /*recovering=*/true,
10125 /*or_comma=*/false,
10126 /*consume_paren=*/true);
10128 /* A semicolon terminates the declaration. */
10129 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
10131 /* Complete the static assertion, which may mean either processing
10132 the static assert now or saving it for template instantiation. */
10133 finish_static_assert (condition, message, saved_loc, member_p);
10136 /* Parse a `decltype' type. Returns the type.
10138 simple-type-specifier:
10139 decltype ( expression ) */
10142 cp_parser_decltype (cp_parser *parser)
10145 bool id_expression_or_member_access_p = false;
10146 const char *saved_message;
10147 bool saved_integral_constant_expression_p;
10148 bool saved_non_integral_constant_expression_p;
10149 cp_token *id_expr_start_token;
10151 /* Look for the `decltype' token. */
10152 if (!cp_parser_require_keyword (parser, RID_DECLTYPE, RT_DECLTYPE))
10153 return error_mark_node;
10155 /* Types cannot be defined in a `decltype' expression. Save away the
10157 saved_message = parser->type_definition_forbidden_message;
10159 /* And create the new one. */
10160 parser->type_definition_forbidden_message
10161 = G_("types may not be defined in %<decltype%> expressions");
10163 /* The restrictions on constant-expressions do not apply inside
10164 decltype expressions. */
10165 saved_integral_constant_expression_p
10166 = parser->integral_constant_expression_p;
10167 saved_non_integral_constant_expression_p
10168 = parser->non_integral_constant_expression_p;
10169 parser->integral_constant_expression_p = false;
10171 /* Do not actually evaluate the expression. */
10172 ++cp_unevaluated_operand;
10174 /* Do not warn about problems with the expression. */
10175 ++c_inhibit_evaluation_warnings;
10177 /* Parse the opening `('. */
10178 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
10179 return error_mark_node;
10181 /* First, try parsing an id-expression. */
10182 id_expr_start_token = cp_lexer_peek_token (parser->lexer);
10183 cp_parser_parse_tentatively (parser);
10184 expr = cp_parser_id_expression (parser,
10185 /*template_keyword_p=*/false,
10186 /*check_dependency_p=*/true,
10187 /*template_p=*/NULL,
10188 /*declarator_p=*/false,
10189 /*optional_p=*/false);
10191 if (!cp_parser_error_occurred (parser) && expr != error_mark_node)
10193 bool non_integral_constant_expression_p = false;
10194 tree id_expression = expr;
10196 const char *error_msg;
10198 if (TREE_CODE (expr) == IDENTIFIER_NODE)
10199 /* Lookup the name we got back from the id-expression. */
10200 expr = cp_parser_lookup_name (parser, expr,
10202 /*is_template=*/false,
10203 /*is_namespace=*/false,
10204 /*check_dependency=*/true,
10205 /*ambiguous_decls=*/NULL,
10206 id_expr_start_token->location);
10209 && expr != error_mark_node
10210 && TREE_CODE (expr) != TEMPLATE_ID_EXPR
10211 && TREE_CODE (expr) != TYPE_DECL
10212 && (TREE_CODE (expr) != BIT_NOT_EXPR
10213 || !TYPE_P (TREE_OPERAND (expr, 0)))
10214 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
10216 /* Complete lookup of the id-expression. */
10217 expr = (finish_id_expression
10218 (id_expression, expr, parser->scope, &idk,
10219 /*integral_constant_expression_p=*/false,
10220 /*allow_non_integral_constant_expression_p=*/true,
10221 &non_integral_constant_expression_p,
10222 /*template_p=*/false,
10224 /*address_p=*/false,
10225 /*template_arg_p=*/false,
10227 id_expr_start_token->location));
10229 if (expr == error_mark_node)
10230 /* We found an id-expression, but it was something that we
10231 should not have found. This is an error, not something
10232 we can recover from, so note that we found an
10233 id-expression and we'll recover as gracefully as
10235 id_expression_or_member_access_p = true;
10239 && expr != error_mark_node
10240 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
10241 /* We have an id-expression. */
10242 id_expression_or_member_access_p = true;
10245 if (!id_expression_or_member_access_p)
10247 /* Abort the id-expression parse. */
10248 cp_parser_abort_tentative_parse (parser);
10250 /* Parsing tentatively, again. */
10251 cp_parser_parse_tentatively (parser);
10253 /* Parse a class member access. */
10254 expr = cp_parser_postfix_expression (parser, /*address_p=*/false,
10256 /*member_access_only_p=*/true, NULL);
10259 && expr != error_mark_node
10260 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
10261 /* We have an id-expression. */
10262 id_expression_or_member_access_p = true;
10265 if (id_expression_or_member_access_p)
10266 /* We have parsed the complete id-expression or member access. */
10267 cp_parser_parse_definitely (parser);
10270 bool saved_greater_than_is_operator_p;
10272 /* Abort our attempt to parse an id-expression or member access
10274 cp_parser_abort_tentative_parse (parser);
10276 /* Within a parenthesized expression, a `>' token is always
10277 the greater-than operator. */
10278 saved_greater_than_is_operator_p
10279 = parser->greater_than_is_operator_p;
10280 parser->greater_than_is_operator_p = true;
10282 /* Parse a full expression. */
10283 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
10285 /* The `>' token might be the end of a template-id or
10286 template-parameter-list now. */
10287 parser->greater_than_is_operator_p
10288 = saved_greater_than_is_operator_p;
10291 /* Go back to evaluating expressions. */
10292 --cp_unevaluated_operand;
10293 --c_inhibit_evaluation_warnings;
10295 /* Restore the old message and the integral constant expression
10297 parser->type_definition_forbidden_message = saved_message;
10298 parser->integral_constant_expression_p
10299 = saved_integral_constant_expression_p;
10300 parser->non_integral_constant_expression_p
10301 = saved_non_integral_constant_expression_p;
10303 if (expr == error_mark_node)
10305 /* Skip everything up to the closing `)'. */
10306 cp_parser_skip_to_closing_parenthesis (parser, true, false,
10307 /*consume_paren=*/true);
10308 return error_mark_node;
10311 /* Parse to the closing `)'. */
10312 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
10314 cp_parser_skip_to_closing_parenthesis (parser, true, false,
10315 /*consume_paren=*/true);
10316 return error_mark_node;
10319 return finish_decltype_type (expr, id_expression_or_member_access_p,
10320 tf_warning_or_error);
10323 /* Special member functions [gram.special] */
10325 /* Parse a conversion-function-id.
10327 conversion-function-id:
10328 operator conversion-type-id
10330 Returns an IDENTIFIER_NODE representing the operator. */
10333 cp_parser_conversion_function_id (cp_parser* parser)
10337 tree saved_qualifying_scope;
10338 tree saved_object_scope;
10339 tree pushed_scope = NULL_TREE;
10341 /* Look for the `operator' token. */
10342 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
10343 return error_mark_node;
10344 /* When we parse the conversion-type-id, the current scope will be
10345 reset. However, we need that information in able to look up the
10346 conversion function later, so we save it here. */
10347 saved_scope = parser->scope;
10348 saved_qualifying_scope = parser->qualifying_scope;
10349 saved_object_scope = parser->object_scope;
10350 /* We must enter the scope of the class so that the names of
10351 entities declared within the class are available in the
10352 conversion-type-id. For example, consider:
10359 S::operator I() { ... }
10361 In order to see that `I' is a type-name in the definition, we
10362 must be in the scope of `S'. */
10364 pushed_scope = push_scope (saved_scope);
10365 /* Parse the conversion-type-id. */
10366 type = cp_parser_conversion_type_id (parser);
10367 /* Leave the scope of the class, if any. */
10369 pop_scope (pushed_scope);
10370 /* Restore the saved scope. */
10371 parser->scope = saved_scope;
10372 parser->qualifying_scope = saved_qualifying_scope;
10373 parser->object_scope = saved_object_scope;
10374 /* If the TYPE is invalid, indicate failure. */
10375 if (type == error_mark_node)
10376 return error_mark_node;
10377 return mangle_conv_op_name_for_type (type);
10380 /* Parse a conversion-type-id:
10382 conversion-type-id:
10383 type-specifier-seq conversion-declarator [opt]
10385 Returns the TYPE specified. */
10388 cp_parser_conversion_type_id (cp_parser* parser)
10391 cp_decl_specifier_seq type_specifiers;
10392 cp_declarator *declarator;
10393 tree type_specified;
10395 /* Parse the attributes. */
10396 attributes = cp_parser_attributes_opt (parser);
10397 /* Parse the type-specifiers. */
10398 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
10399 /*is_trailing_return=*/false,
10401 /* If that didn't work, stop. */
10402 if (type_specifiers.type == error_mark_node)
10403 return error_mark_node;
10404 /* Parse the conversion-declarator. */
10405 declarator = cp_parser_conversion_declarator_opt (parser);
10407 type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
10408 /*initialized=*/0, &attributes);
10410 cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
10412 /* Don't give this error when parsing tentatively. This happens to
10413 work because we always parse this definitively once. */
10414 if (! cp_parser_uncommitted_to_tentative_parse_p (parser)
10415 && type_uses_auto (type_specified))
10417 error ("invalid use of %<auto%> in conversion operator");
10418 return error_mark_node;
10421 return type_specified;
10424 /* Parse an (optional) conversion-declarator.
10426 conversion-declarator:
10427 ptr-operator conversion-declarator [opt]
10431 static cp_declarator *
10432 cp_parser_conversion_declarator_opt (cp_parser* parser)
10434 enum tree_code code;
10436 cp_cv_quals cv_quals;
10438 /* We don't know if there's a ptr-operator next, or not. */
10439 cp_parser_parse_tentatively (parser);
10440 /* Try the ptr-operator. */
10441 code = cp_parser_ptr_operator (parser, &class_type, &cv_quals);
10442 /* If it worked, look for more conversion-declarators. */
10443 if (cp_parser_parse_definitely (parser))
10445 cp_declarator *declarator;
10447 /* Parse another optional declarator. */
10448 declarator = cp_parser_conversion_declarator_opt (parser);
10450 return cp_parser_make_indirect_declarator
10451 (code, class_type, cv_quals, declarator);
10457 /* Parse an (optional) ctor-initializer.
10460 : mem-initializer-list
10462 Returns TRUE iff the ctor-initializer was actually present. */
10465 cp_parser_ctor_initializer_opt (cp_parser* parser)
10467 /* If the next token is not a `:', then there is no
10468 ctor-initializer. */
10469 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
10471 /* Do default initialization of any bases and members. */
10472 if (DECL_CONSTRUCTOR_P (current_function_decl))
10473 finish_mem_initializers (NULL_TREE);
10478 /* Consume the `:' token. */
10479 cp_lexer_consume_token (parser->lexer);
10480 /* And the mem-initializer-list. */
10481 cp_parser_mem_initializer_list (parser);
10486 /* Parse a mem-initializer-list.
10488 mem-initializer-list:
10489 mem-initializer ... [opt]
10490 mem-initializer ... [opt] , mem-initializer-list */
10493 cp_parser_mem_initializer_list (cp_parser* parser)
10495 tree mem_initializer_list = NULL_TREE;
10496 cp_token *token = cp_lexer_peek_token (parser->lexer);
10498 /* Let the semantic analysis code know that we are starting the
10499 mem-initializer-list. */
10500 if (!DECL_CONSTRUCTOR_P (current_function_decl))
10501 error_at (token->location,
10502 "only constructors take member initializers");
10504 /* Loop through the list. */
10507 tree mem_initializer;
10509 token = cp_lexer_peek_token (parser->lexer);
10510 /* Parse the mem-initializer. */
10511 mem_initializer = cp_parser_mem_initializer (parser);
10512 /* If the next token is a `...', we're expanding member initializers. */
10513 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10515 /* Consume the `...'. */
10516 cp_lexer_consume_token (parser->lexer);
10518 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
10519 can be expanded but members cannot. */
10520 if (mem_initializer != error_mark_node
10521 && !TYPE_P (TREE_PURPOSE (mem_initializer)))
10523 error_at (token->location,
10524 "cannot expand initializer for member %<%D%>",
10525 TREE_PURPOSE (mem_initializer));
10526 mem_initializer = error_mark_node;
10529 /* Construct the pack expansion type. */
10530 if (mem_initializer != error_mark_node)
10531 mem_initializer = make_pack_expansion (mem_initializer);
10533 /* Add it to the list, unless it was erroneous. */
10534 if (mem_initializer != error_mark_node)
10536 TREE_CHAIN (mem_initializer) = mem_initializer_list;
10537 mem_initializer_list = mem_initializer;
10539 /* If the next token is not a `,', we're done. */
10540 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
10542 /* Consume the `,' token. */
10543 cp_lexer_consume_token (parser->lexer);
10546 /* Perform semantic analysis. */
10547 if (DECL_CONSTRUCTOR_P (current_function_decl))
10548 finish_mem_initializers (mem_initializer_list);
10551 /* Parse a mem-initializer.
10554 mem-initializer-id ( expression-list [opt] )
10555 mem-initializer-id braced-init-list
10560 ( expression-list [opt] )
10562 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
10563 class) or FIELD_DECL (for a non-static data member) to initialize;
10564 the TREE_VALUE is the expression-list. An empty initialization
10565 list is represented by void_list_node. */
10568 cp_parser_mem_initializer (cp_parser* parser)
10570 tree mem_initializer_id;
10571 tree expression_list;
10573 cp_token *token = cp_lexer_peek_token (parser->lexer);
10575 /* Find out what is being initialized. */
10576 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
10578 permerror (token->location,
10579 "anachronistic old-style base class initializer");
10580 mem_initializer_id = NULL_TREE;
10584 mem_initializer_id = cp_parser_mem_initializer_id (parser);
10585 if (mem_initializer_id == error_mark_node)
10586 return mem_initializer_id;
10588 member = expand_member_init (mem_initializer_id);
10589 if (member && !DECL_P (member))
10590 in_base_initializer = 1;
10592 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10594 bool expr_non_constant_p;
10595 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
10596 expression_list = cp_parser_braced_list (parser, &expr_non_constant_p);
10597 CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
10598 expression_list = build_tree_list (NULL_TREE, expression_list);
10603 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
10605 /*allow_expansion_p=*/true,
10606 /*non_constant_p=*/NULL);
10608 return error_mark_node;
10609 expression_list = build_tree_list_vec (vec);
10610 release_tree_vector (vec);
10613 if (expression_list == error_mark_node)
10614 return error_mark_node;
10615 if (!expression_list)
10616 expression_list = void_type_node;
10618 in_base_initializer = 0;
10620 return member ? build_tree_list (member, expression_list) : error_mark_node;
10623 /* Parse a mem-initializer-id.
10625 mem-initializer-id:
10626 :: [opt] nested-name-specifier [opt] class-name
10629 Returns a TYPE indicating the class to be initializer for the first
10630 production. Returns an IDENTIFIER_NODE indicating the data member
10631 to be initialized for the second production. */
10634 cp_parser_mem_initializer_id (cp_parser* parser)
10636 bool global_scope_p;
10637 bool nested_name_specifier_p;
10638 bool template_p = false;
10641 cp_token *token = cp_lexer_peek_token (parser->lexer);
10643 /* `typename' is not allowed in this context ([temp.res]). */
10644 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
10646 error_at (token->location,
10647 "keyword %<typename%> not allowed in this context (a qualified "
10648 "member initializer is implicitly a type)");
10649 cp_lexer_consume_token (parser->lexer);
10651 /* Look for the optional `::' operator. */
10653 = (cp_parser_global_scope_opt (parser,
10654 /*current_scope_valid_p=*/false)
10656 /* Look for the optional nested-name-specifier. The simplest way to
10661 The keyword `typename' is not permitted in a base-specifier or
10662 mem-initializer; in these contexts a qualified name that
10663 depends on a template-parameter is implicitly assumed to be a
10666 is to assume that we have seen the `typename' keyword at this
10668 nested_name_specifier_p
10669 = (cp_parser_nested_name_specifier_opt (parser,
10670 /*typename_keyword_p=*/true,
10671 /*check_dependency_p=*/true,
10673 /*is_declaration=*/true)
10675 if (nested_name_specifier_p)
10676 template_p = cp_parser_optional_template_keyword (parser);
10677 /* If there is a `::' operator or a nested-name-specifier, then we
10678 are definitely looking for a class-name. */
10679 if (global_scope_p || nested_name_specifier_p)
10680 return cp_parser_class_name (parser,
10681 /*typename_keyword_p=*/true,
10682 /*template_keyword_p=*/template_p,
10684 /*check_dependency_p=*/true,
10685 /*class_head_p=*/false,
10686 /*is_declaration=*/true);
10687 /* Otherwise, we could also be looking for an ordinary identifier. */
10688 cp_parser_parse_tentatively (parser);
10689 /* Try a class-name. */
10690 id = cp_parser_class_name (parser,
10691 /*typename_keyword_p=*/true,
10692 /*template_keyword_p=*/false,
10694 /*check_dependency_p=*/true,
10695 /*class_head_p=*/false,
10696 /*is_declaration=*/true);
10697 /* If we found one, we're done. */
10698 if (cp_parser_parse_definitely (parser))
10700 /* Otherwise, look for an ordinary identifier. */
10701 return cp_parser_identifier (parser);
10704 /* Overloading [gram.over] */
10706 /* Parse an operator-function-id.
10708 operator-function-id:
10711 Returns an IDENTIFIER_NODE for the operator which is a
10712 human-readable spelling of the identifier, e.g., `operator +'. */
10715 cp_parser_operator_function_id (cp_parser* parser)
10717 /* Look for the `operator' keyword. */
10718 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
10719 return error_mark_node;
10720 /* And then the name of the operator itself. */
10721 return cp_parser_operator (parser);
10724 /* Parse an operator.
10727 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
10728 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
10729 || ++ -- , ->* -> () []
10736 Returns an IDENTIFIER_NODE for the operator which is a
10737 human-readable spelling of the identifier, e.g., `operator +'. */
10740 cp_parser_operator (cp_parser* parser)
10742 tree id = NULL_TREE;
10745 /* Peek at the next token. */
10746 token = cp_lexer_peek_token (parser->lexer);
10747 /* Figure out which operator we have. */
10748 switch (token->type)
10754 /* The keyword should be either `new' or `delete'. */
10755 if (token->keyword == RID_NEW)
10757 else if (token->keyword == RID_DELETE)
10762 /* Consume the `new' or `delete' token. */
10763 cp_lexer_consume_token (parser->lexer);
10765 /* Peek at the next token. */
10766 token = cp_lexer_peek_token (parser->lexer);
10767 /* If it's a `[' token then this is the array variant of the
10769 if (token->type == CPP_OPEN_SQUARE)
10771 /* Consume the `[' token. */
10772 cp_lexer_consume_token (parser->lexer);
10773 /* Look for the `]' token. */
10774 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
10775 id = ansi_opname (op == NEW_EXPR
10776 ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
10778 /* Otherwise, we have the non-array variant. */
10780 id = ansi_opname (op);
10786 id = ansi_opname (PLUS_EXPR);
10790 id = ansi_opname (MINUS_EXPR);
10794 id = ansi_opname (MULT_EXPR);
10798 id = ansi_opname (TRUNC_DIV_EXPR);
10802 id = ansi_opname (TRUNC_MOD_EXPR);
10806 id = ansi_opname (BIT_XOR_EXPR);
10810 id = ansi_opname (BIT_AND_EXPR);
10814 id = ansi_opname (BIT_IOR_EXPR);
10818 id = ansi_opname (BIT_NOT_EXPR);
10822 id = ansi_opname (TRUTH_NOT_EXPR);
10826 id = ansi_assopname (NOP_EXPR);
10830 id = ansi_opname (LT_EXPR);
10834 id = ansi_opname (GT_EXPR);
10838 id = ansi_assopname (PLUS_EXPR);
10842 id = ansi_assopname (MINUS_EXPR);
10846 id = ansi_assopname (MULT_EXPR);
10850 id = ansi_assopname (TRUNC_DIV_EXPR);
10854 id = ansi_assopname (TRUNC_MOD_EXPR);
10858 id = ansi_assopname (BIT_XOR_EXPR);
10862 id = ansi_assopname (BIT_AND_EXPR);
10866 id = ansi_assopname (BIT_IOR_EXPR);
10870 id = ansi_opname (LSHIFT_EXPR);
10874 id = ansi_opname (RSHIFT_EXPR);
10877 case CPP_LSHIFT_EQ:
10878 id = ansi_assopname (LSHIFT_EXPR);
10881 case CPP_RSHIFT_EQ:
10882 id = ansi_assopname (RSHIFT_EXPR);
10886 id = ansi_opname (EQ_EXPR);
10890 id = ansi_opname (NE_EXPR);
10894 id = ansi_opname (LE_EXPR);
10897 case CPP_GREATER_EQ:
10898 id = ansi_opname (GE_EXPR);
10902 id = ansi_opname (TRUTH_ANDIF_EXPR);
10906 id = ansi_opname (TRUTH_ORIF_EXPR);
10909 case CPP_PLUS_PLUS:
10910 id = ansi_opname (POSTINCREMENT_EXPR);
10913 case CPP_MINUS_MINUS:
10914 id = ansi_opname (PREDECREMENT_EXPR);
10918 id = ansi_opname (COMPOUND_EXPR);
10921 case CPP_DEREF_STAR:
10922 id = ansi_opname (MEMBER_REF);
10926 id = ansi_opname (COMPONENT_REF);
10929 case CPP_OPEN_PAREN:
10930 /* Consume the `('. */
10931 cp_lexer_consume_token (parser->lexer);
10932 /* Look for the matching `)'. */
10933 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
10934 return ansi_opname (CALL_EXPR);
10936 case CPP_OPEN_SQUARE:
10937 /* Consume the `['. */
10938 cp_lexer_consume_token (parser->lexer);
10939 /* Look for the matching `]'. */
10940 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
10941 return ansi_opname (ARRAY_REF);
10944 /* Anything else is an error. */
10948 /* If we have selected an identifier, we need to consume the
10951 cp_lexer_consume_token (parser->lexer);
10952 /* Otherwise, no valid operator name was present. */
10955 cp_parser_error (parser, "expected operator");
10956 id = error_mark_node;
10962 /* Parse a template-declaration.
10964 template-declaration:
10965 export [opt] template < template-parameter-list > declaration
10967 If MEMBER_P is TRUE, this template-declaration occurs within a
10970 The grammar rule given by the standard isn't correct. What
10971 is really meant is:
10973 template-declaration:
10974 export [opt] template-parameter-list-seq
10975 decl-specifier-seq [opt] init-declarator [opt] ;
10976 export [opt] template-parameter-list-seq
10977 function-definition
10979 template-parameter-list-seq:
10980 template-parameter-list-seq [opt]
10981 template < template-parameter-list > */
10984 cp_parser_template_declaration (cp_parser* parser, bool member_p)
10986 /* Check for `export'. */
10987 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
10989 /* Consume the `export' token. */
10990 cp_lexer_consume_token (parser->lexer);
10991 /* Warn that we do not support `export'. */
10992 warning (0, "keyword %<export%> not implemented, and will be ignored");
10995 cp_parser_template_declaration_after_export (parser, member_p);
10998 /* Parse a template-parameter-list.
11000 template-parameter-list:
11002 template-parameter-list , template-parameter
11004 Returns a TREE_LIST. Each node represents a template parameter.
11005 The nodes are connected via their TREE_CHAINs. */
11008 cp_parser_template_parameter_list (cp_parser* parser)
11010 tree parameter_list = NULL_TREE;
11012 begin_template_parm_list ();
11014 /* The loop below parses the template parms. We first need to know
11015 the total number of template parms to be able to compute proper
11016 canonical types of each dependent type. So after the loop, when
11017 we know the total number of template parms,
11018 end_template_parm_list computes the proper canonical types and
11019 fixes up the dependent types accordingly. */
11024 bool is_parameter_pack;
11025 location_t parm_loc;
11027 /* Parse the template-parameter. */
11028 parm_loc = cp_lexer_peek_token (parser->lexer)->location;
11029 parameter = cp_parser_template_parameter (parser,
11031 &is_parameter_pack);
11032 /* Add it to the list. */
11033 if (parameter != error_mark_node)
11034 parameter_list = process_template_parm (parameter_list,
11042 tree err_parm = build_tree_list (parameter, parameter);
11043 parameter_list = chainon (parameter_list, err_parm);
11046 /* If the next token is not a `,', we're done. */
11047 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
11049 /* Otherwise, consume the `,' token. */
11050 cp_lexer_consume_token (parser->lexer);
11053 return end_template_parm_list (parameter_list);
11056 /* Parse a template-parameter.
11058 template-parameter:
11060 parameter-declaration
11062 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
11063 the parameter. The TREE_PURPOSE is the default value, if any.
11064 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
11065 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
11066 set to true iff this parameter is a parameter pack. */
11069 cp_parser_template_parameter (cp_parser* parser, bool *is_non_type,
11070 bool *is_parameter_pack)
11073 cp_parameter_declarator *parameter_declarator;
11074 cp_declarator *id_declarator;
11077 /* Assume it is a type parameter or a template parameter. */
11078 *is_non_type = false;
11079 /* Assume it not a parameter pack. */
11080 *is_parameter_pack = false;
11081 /* Peek at the next token. */
11082 token = cp_lexer_peek_token (parser->lexer);
11083 /* If it is `class' or `template', we have a type-parameter. */
11084 if (token->keyword == RID_TEMPLATE)
11085 return cp_parser_type_parameter (parser, is_parameter_pack);
11086 /* If it is `class' or `typename' we do not know yet whether it is a
11087 type parameter or a non-type parameter. Consider:
11089 template <typename T, typename T::X X> ...
11093 template <class C, class D*> ...
11095 Here, the first parameter is a type parameter, and the second is
11096 a non-type parameter. We can tell by looking at the token after
11097 the identifier -- if it is a `,', `=', or `>' then we have a type
11099 if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
11101 /* Peek at the token after `class' or `typename'. */
11102 token = cp_lexer_peek_nth_token (parser->lexer, 2);
11103 /* If it's an ellipsis, we have a template type parameter
11105 if (token->type == CPP_ELLIPSIS)
11106 return cp_parser_type_parameter (parser, is_parameter_pack);
11107 /* If it's an identifier, skip it. */
11108 if (token->type == CPP_NAME)
11109 token = cp_lexer_peek_nth_token (parser->lexer, 3);
11110 /* Now, see if the token looks like the end of a template
11112 if (token->type == CPP_COMMA
11113 || token->type == CPP_EQ
11114 || token->type == CPP_GREATER)
11115 return cp_parser_type_parameter (parser, is_parameter_pack);
11118 /* Otherwise, it is a non-type parameter.
11122 When parsing a default template-argument for a non-type
11123 template-parameter, the first non-nested `>' is taken as the end
11124 of the template parameter-list rather than a greater-than
11126 *is_non_type = true;
11127 parameter_declarator
11128 = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
11129 /*parenthesized_p=*/NULL);
11131 /* If the parameter declaration is marked as a parameter pack, set
11132 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
11133 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
11135 if (parameter_declarator
11136 && parameter_declarator->declarator
11137 && parameter_declarator->declarator->parameter_pack_p)
11139 *is_parameter_pack = true;
11140 parameter_declarator->declarator->parameter_pack_p = false;
11143 /* If the next token is an ellipsis, and we don't already have it
11144 marked as a parameter pack, then we have a parameter pack (that
11145 has no declarator). */
11146 if (!*is_parameter_pack
11147 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
11148 && declarator_can_be_parameter_pack (parameter_declarator->declarator))
11150 /* Consume the `...'. */
11151 cp_lexer_consume_token (parser->lexer);
11152 maybe_warn_variadic_templates ();
11154 *is_parameter_pack = true;
11156 /* We might end up with a pack expansion as the type of the non-type
11157 template parameter, in which case this is a non-type template
11159 else if (parameter_declarator
11160 && parameter_declarator->decl_specifiers.type
11161 && PACK_EXPANSION_P (parameter_declarator->decl_specifiers.type))
11163 *is_parameter_pack = true;
11164 parameter_declarator->decl_specifiers.type =
11165 PACK_EXPANSION_PATTERN (parameter_declarator->decl_specifiers.type);
11168 if (*is_parameter_pack && cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11170 /* Parameter packs cannot have default arguments. However, a
11171 user may try to do so, so we'll parse them and give an
11172 appropriate diagnostic here. */
11174 /* Consume the `='. */
11175 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
11176 cp_lexer_consume_token (parser->lexer);
11178 /* Find the name of the parameter pack. */
11179 id_declarator = parameter_declarator->declarator;
11180 while (id_declarator && id_declarator->kind != cdk_id)
11181 id_declarator = id_declarator->declarator;
11183 if (id_declarator && id_declarator->kind == cdk_id)
11184 error_at (start_token->location,
11185 "template parameter pack %qD cannot have a default argument",
11186 id_declarator->u.id.unqualified_name);
11188 error_at (start_token->location,
11189 "template parameter pack cannot have a default argument");
11191 /* Parse the default argument, but throw away the result. */
11192 cp_parser_default_argument (parser, /*template_parm_p=*/true);
11195 parm = grokdeclarator (parameter_declarator->declarator,
11196 ¶meter_declarator->decl_specifiers,
11197 TPARM, /*initialized=*/0,
11198 /*attrlist=*/NULL);
11199 if (parm == error_mark_node)
11200 return error_mark_node;
11202 return build_tree_list (parameter_declarator->default_argument, parm);
11205 /* Parse a type-parameter.
11208 class identifier [opt]
11209 class identifier [opt] = type-id
11210 typename identifier [opt]
11211 typename identifier [opt] = type-id
11212 template < template-parameter-list > class identifier [opt]
11213 template < template-parameter-list > class identifier [opt]
11216 GNU Extension (variadic templates):
11219 class ... identifier [opt]
11220 typename ... identifier [opt]
11222 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
11223 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
11224 the declaration of the parameter.
11226 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
11229 cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack)
11234 /* Look for a keyword to tell us what kind of parameter this is. */
11235 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_TYPENAME_TEMPLATE);
11237 return error_mark_node;
11239 switch (token->keyword)
11245 tree default_argument;
11247 /* If the next token is an ellipsis, we have a template
11249 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11251 /* Consume the `...' token. */
11252 cp_lexer_consume_token (parser->lexer);
11253 maybe_warn_variadic_templates ();
11255 *is_parameter_pack = true;
11258 /* If the next token is an identifier, then it names the
11260 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
11261 identifier = cp_parser_identifier (parser);
11263 identifier = NULL_TREE;
11265 /* Create the parameter. */
11266 parameter = finish_template_type_parm (class_type_node, identifier);
11268 /* If the next token is an `=', we have a default argument. */
11269 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11271 /* Consume the `=' token. */
11272 cp_lexer_consume_token (parser->lexer);
11273 /* Parse the default-argument. */
11274 push_deferring_access_checks (dk_no_deferred);
11275 default_argument = cp_parser_type_id (parser);
11277 /* Template parameter packs cannot have default
11279 if (*is_parameter_pack)
11282 error_at (token->location,
11283 "template parameter pack %qD cannot have a "
11284 "default argument", identifier);
11286 error_at (token->location,
11287 "template parameter packs cannot have "
11288 "default arguments");
11289 default_argument = NULL_TREE;
11291 pop_deferring_access_checks ();
11294 default_argument = NULL_TREE;
11296 /* Create the combined representation of the parameter and the
11297 default argument. */
11298 parameter = build_tree_list (default_argument, parameter);
11305 tree default_argument;
11307 /* Look for the `<'. */
11308 cp_parser_require (parser, CPP_LESS, RT_LESS);
11309 /* Parse the template-parameter-list. */
11310 cp_parser_template_parameter_list (parser);
11311 /* Look for the `>'. */
11312 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
11313 /* Look for the `class' keyword. */
11314 cp_parser_require_keyword (parser, RID_CLASS, RT_CLASS);
11315 /* If the next token is an ellipsis, we have a template
11317 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11319 /* Consume the `...' token. */
11320 cp_lexer_consume_token (parser->lexer);
11321 maybe_warn_variadic_templates ();
11323 *is_parameter_pack = true;
11325 /* If the next token is an `=', then there is a
11326 default-argument. If the next token is a `>', we are at
11327 the end of the parameter-list. If the next token is a `,',
11328 then we are at the end of this parameter. */
11329 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
11330 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
11331 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
11333 identifier = cp_parser_identifier (parser);
11334 /* Treat invalid names as if the parameter were nameless. */
11335 if (identifier == error_mark_node)
11336 identifier = NULL_TREE;
11339 identifier = NULL_TREE;
11341 /* Create the template parameter. */
11342 parameter = finish_template_template_parm (class_type_node,
11345 /* If the next token is an `=', then there is a
11346 default-argument. */
11347 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11351 /* Consume the `='. */
11352 cp_lexer_consume_token (parser->lexer);
11353 /* Parse the id-expression. */
11354 push_deferring_access_checks (dk_no_deferred);
11355 /* save token before parsing the id-expression, for error
11357 token = cp_lexer_peek_token (parser->lexer);
11359 = cp_parser_id_expression (parser,
11360 /*template_keyword_p=*/false,
11361 /*check_dependency_p=*/true,
11362 /*template_p=*/&is_template,
11363 /*declarator_p=*/false,
11364 /*optional_p=*/false);
11365 if (TREE_CODE (default_argument) == TYPE_DECL)
11366 /* If the id-expression was a template-id that refers to
11367 a template-class, we already have the declaration here,
11368 so no further lookup is needed. */
11371 /* Look up the name. */
11373 = cp_parser_lookup_name (parser, default_argument,
11375 /*is_template=*/is_template,
11376 /*is_namespace=*/false,
11377 /*check_dependency=*/true,
11378 /*ambiguous_decls=*/NULL,
11380 /* See if the default argument is valid. */
11382 = check_template_template_default_arg (default_argument);
11384 /* Template parameter packs cannot have default
11386 if (*is_parameter_pack)
11389 error_at (token->location,
11390 "template parameter pack %qD cannot "
11391 "have a default argument",
11394 error_at (token->location, "template parameter packs cannot "
11395 "have default arguments");
11396 default_argument = NULL_TREE;
11398 pop_deferring_access_checks ();
11401 default_argument = NULL_TREE;
11403 /* Create the combined representation of the parameter and the
11404 default argument. */
11405 parameter = build_tree_list (default_argument, parameter);
11410 gcc_unreachable ();
11417 /* Parse a template-id.
11420 template-name < template-argument-list [opt] >
11422 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
11423 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
11424 returned. Otherwise, if the template-name names a function, or set
11425 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
11426 names a class, returns a TYPE_DECL for the specialization.
11428 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
11429 uninstantiated templates. */
11432 cp_parser_template_id (cp_parser *parser,
11433 bool template_keyword_p,
11434 bool check_dependency_p,
11435 bool is_declaration)
11441 cp_token_position start_of_id = 0;
11442 deferred_access_check *chk;
11443 VEC (deferred_access_check,gc) *access_check;
11444 cp_token *next_token = NULL, *next_token_2 = NULL;
11445 bool is_identifier;
11447 /* If the next token corresponds to a template-id, there is no need
11449 next_token = cp_lexer_peek_token (parser->lexer);
11450 if (next_token->type == CPP_TEMPLATE_ID)
11452 struct tree_check *check_value;
11454 /* Get the stored value. */
11455 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
11456 /* Perform any access checks that were deferred. */
11457 access_check = check_value->checks;
11460 FOR_EACH_VEC_ELT (deferred_access_check, access_check, i, chk)
11461 perform_or_defer_access_check (chk->binfo,
11465 /* Return the stored value. */
11466 return check_value->value;
11469 /* Avoid performing name lookup if there is no possibility of
11470 finding a template-id. */
11471 if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
11472 || (next_token->type == CPP_NAME
11473 && !cp_parser_nth_token_starts_template_argument_list_p
11476 cp_parser_error (parser, "expected template-id");
11477 return error_mark_node;
11480 /* Remember where the template-id starts. */
11481 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
11482 start_of_id = cp_lexer_token_position (parser->lexer, false);
11484 push_deferring_access_checks (dk_deferred);
11486 /* Parse the template-name. */
11487 is_identifier = false;
11488 templ = cp_parser_template_name (parser, template_keyword_p,
11489 check_dependency_p,
11492 if (templ == error_mark_node || is_identifier)
11494 pop_deferring_access_checks ();
11498 /* If we find the sequence `[:' after a template-name, it's probably
11499 a digraph-typo for `< ::'. Substitute the tokens and check if we can
11500 parse correctly the argument list. */
11501 next_token = cp_lexer_peek_token (parser->lexer);
11502 next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
11503 if (next_token->type == CPP_OPEN_SQUARE
11504 && next_token->flags & DIGRAPH
11505 && next_token_2->type == CPP_COLON
11506 && !(next_token_2->flags & PREV_WHITE))
11508 cp_parser_parse_tentatively (parser);
11509 /* Change `:' into `::'. */
11510 next_token_2->type = CPP_SCOPE;
11511 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
11513 cp_lexer_consume_token (parser->lexer);
11515 /* Parse the arguments. */
11516 arguments = cp_parser_enclosed_template_argument_list (parser);
11517 if (!cp_parser_parse_definitely (parser))
11519 /* If we couldn't parse an argument list, then we revert our changes
11520 and return simply an error. Maybe this is not a template-id
11522 next_token_2->type = CPP_COLON;
11523 cp_parser_error (parser, "expected %<<%>");
11524 pop_deferring_access_checks ();
11525 return error_mark_node;
11527 /* Otherwise, emit an error about the invalid digraph, but continue
11528 parsing because we got our argument list. */
11529 if (permerror (next_token->location,
11530 "%<<::%> cannot begin a template-argument list"))
11532 static bool hint = false;
11533 inform (next_token->location,
11534 "%<<:%> is an alternate spelling for %<[%>."
11535 " Insert whitespace between %<<%> and %<::%>");
11536 if (!hint && !flag_permissive)
11538 inform (next_token->location, "(if you use %<-fpermissive%>"
11539 " G++ will accept your code)");
11546 /* Look for the `<' that starts the template-argument-list. */
11547 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
11549 pop_deferring_access_checks ();
11550 return error_mark_node;
11552 /* Parse the arguments. */
11553 arguments = cp_parser_enclosed_template_argument_list (parser);
11556 /* Build a representation of the specialization. */
11557 if (TREE_CODE (templ) == IDENTIFIER_NODE)
11558 template_id = build_min_nt (TEMPLATE_ID_EXPR, templ, arguments);
11559 else if (DECL_CLASS_TEMPLATE_P (templ)
11560 || DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
11562 bool entering_scope;
11563 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
11564 template (rather than some instantiation thereof) only if
11565 is not nested within some other construct. For example, in
11566 "template <typename T> void f(T) { A<T>::", A<T> is just an
11567 instantiation of A. */
11568 entering_scope = (template_parm_scope_p ()
11569 && cp_lexer_next_token_is (parser->lexer,
11572 = finish_template_type (templ, arguments, entering_scope);
11576 /* If it's not a class-template or a template-template, it should be
11577 a function-template. */
11578 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
11579 || TREE_CODE (templ) == OVERLOAD
11580 || BASELINK_P (templ)));
11582 template_id = lookup_template_function (templ, arguments);
11585 /* If parsing tentatively, replace the sequence of tokens that makes
11586 up the template-id with a CPP_TEMPLATE_ID token. That way,
11587 should we re-parse the token stream, we will not have to repeat
11588 the effort required to do the parse, nor will we issue duplicate
11589 error messages about problems during instantiation of the
11593 cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);
11595 /* Reset the contents of the START_OF_ID token. */
11596 token->type = CPP_TEMPLATE_ID;
11597 /* Retrieve any deferred checks. Do not pop this access checks yet
11598 so the memory will not be reclaimed during token replacing below. */
11599 token->u.tree_check_value = ggc_alloc_cleared_tree_check ();
11600 token->u.tree_check_value->value = template_id;
11601 token->u.tree_check_value->checks = get_deferred_access_checks ();
11602 token->keyword = RID_MAX;
11604 /* Purge all subsequent tokens. */
11605 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
11607 /* ??? Can we actually assume that, if template_id ==
11608 error_mark_node, we will have issued a diagnostic to the
11609 user, as opposed to simply marking the tentative parse as
11611 if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
11612 error_at (token->location, "parse error in template argument list");
11615 pop_deferring_access_checks ();
11616 return template_id;
11619 /* Parse a template-name.
11624 The standard should actually say:
11628 operator-function-id
11630 A defect report has been filed about this issue.
11632 A conversion-function-id cannot be a template name because they cannot
11633 be part of a template-id. In fact, looking at this code:
11635 a.operator K<int>()
11637 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
11638 It is impossible to call a templated conversion-function-id with an
11639 explicit argument list, since the only allowed template parameter is
11640 the type to which it is converting.
11642 If TEMPLATE_KEYWORD_P is true, then we have just seen the
11643 `template' keyword, in a construction like:
11647 In that case `f' is taken to be a template-name, even though there
11648 is no way of knowing for sure.
11650 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
11651 name refers to a set of overloaded functions, at least one of which
11652 is a template, or an IDENTIFIER_NODE with the name of the template,
11653 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
11654 names are looked up inside uninstantiated templates. */
11657 cp_parser_template_name (cp_parser* parser,
11658 bool template_keyword_p,
11659 bool check_dependency_p,
11660 bool is_declaration,
11661 bool *is_identifier)
11666 cp_token *token = cp_lexer_peek_token (parser->lexer);
11668 /* If the next token is `operator', then we have either an
11669 operator-function-id or a conversion-function-id. */
11670 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
11672 /* We don't know whether we're looking at an
11673 operator-function-id or a conversion-function-id. */
11674 cp_parser_parse_tentatively (parser);
11675 /* Try an operator-function-id. */
11676 identifier = cp_parser_operator_function_id (parser);
11677 /* If that didn't work, try a conversion-function-id. */
11678 if (!cp_parser_parse_definitely (parser))
11680 cp_parser_error (parser, "expected template-name");
11681 return error_mark_node;
11684 /* Look for the identifier. */
11686 identifier = cp_parser_identifier (parser);
11688 /* If we didn't find an identifier, we don't have a template-id. */
11689 if (identifier == error_mark_node)
11690 return error_mark_node;
11692 /* If the name immediately followed the `template' keyword, then it
11693 is a template-name. However, if the next token is not `<', then
11694 we do not treat it as a template-name, since it is not being used
11695 as part of a template-id. This enables us to handle constructs
11698 template <typename T> struct S { S(); };
11699 template <typename T> S<T>::S();
11701 correctly. We would treat `S' as a template -- if it were `S<T>'
11702 -- but we do not if there is no `<'. */
11704 if (processing_template_decl
11705 && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
11707 /* In a declaration, in a dependent context, we pretend that the
11708 "template" keyword was present in order to improve error
11709 recovery. For example, given:
11711 template <typename T> void f(T::X<int>);
11713 we want to treat "X<int>" as a template-id. */
11715 && !template_keyword_p
11716 && parser->scope && TYPE_P (parser->scope)
11717 && check_dependency_p
11718 && dependent_scope_p (parser->scope)
11719 /* Do not do this for dtors (or ctors), since they never
11720 need the template keyword before their name. */
11721 && !constructor_name_p (identifier, parser->scope))
11723 cp_token_position start = 0;
11725 /* Explain what went wrong. */
11726 error_at (token->location, "non-template %qD used as template",
11728 inform (token->location, "use %<%T::template %D%> to indicate that it is a template",
11729 parser->scope, identifier);
11730 /* If parsing tentatively, find the location of the "<" token. */
11731 if (cp_parser_simulate_error (parser))
11732 start = cp_lexer_token_position (parser->lexer, true);
11733 /* Parse the template arguments so that we can issue error
11734 messages about them. */
11735 cp_lexer_consume_token (parser->lexer);
11736 cp_parser_enclosed_template_argument_list (parser);
11737 /* Skip tokens until we find a good place from which to
11738 continue parsing. */
11739 cp_parser_skip_to_closing_parenthesis (parser,
11740 /*recovering=*/true,
11742 /*consume_paren=*/false);
11743 /* If parsing tentatively, permanently remove the
11744 template argument list. That will prevent duplicate
11745 error messages from being issued about the missing
11746 "template" keyword. */
11748 cp_lexer_purge_tokens_after (parser->lexer, start);
11750 *is_identifier = true;
11754 /* If the "template" keyword is present, then there is generally
11755 no point in doing name-lookup, so we just return IDENTIFIER.
11756 But, if the qualifying scope is non-dependent then we can
11757 (and must) do name-lookup normally. */
11758 if (template_keyword_p
11760 || (TYPE_P (parser->scope)
11761 && dependent_type_p (parser->scope))))
11765 /* Look up the name. */
11766 decl = cp_parser_lookup_name (parser, identifier,
11768 /*is_template=*/true,
11769 /*is_namespace=*/false,
11770 check_dependency_p,
11771 /*ambiguous_decls=*/NULL,
11774 /* If DECL is a template, then the name was a template-name. */
11775 if (TREE_CODE (decl) == TEMPLATE_DECL)
11779 tree fn = NULL_TREE;
11781 /* The standard does not explicitly indicate whether a name that
11782 names a set of overloaded declarations, some of which are
11783 templates, is a template-name. However, such a name should
11784 be a template-name; otherwise, there is no way to form a
11785 template-id for the overloaded templates. */
11786 fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
11787 if (TREE_CODE (fns) == OVERLOAD)
11788 for (fn = fns; fn; fn = OVL_NEXT (fn))
11789 if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
11794 /* The name does not name a template. */
11795 cp_parser_error (parser, "expected template-name");
11796 return error_mark_node;
11800 /* If DECL is dependent, and refers to a function, then just return
11801 its name; we will look it up again during template instantiation. */
11802 if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
11804 tree scope = CP_DECL_CONTEXT (get_first_fn (decl));
11805 if (TYPE_P (scope) && dependent_type_p (scope))
11812 /* Parse a template-argument-list.
11814 template-argument-list:
11815 template-argument ... [opt]
11816 template-argument-list , template-argument ... [opt]
11818 Returns a TREE_VEC containing the arguments. */
11821 cp_parser_template_argument_list (cp_parser* parser)
11823 tree fixed_args[10];
11824 unsigned n_args = 0;
11825 unsigned alloced = 10;
11826 tree *arg_ary = fixed_args;
11828 bool saved_in_template_argument_list_p;
11830 bool saved_non_ice_p;
11832 saved_in_template_argument_list_p = parser->in_template_argument_list_p;
11833 parser->in_template_argument_list_p = true;
11834 /* Even if the template-id appears in an integral
11835 constant-expression, the contents of the argument list do
11837 saved_ice_p = parser->integral_constant_expression_p;
11838 parser->integral_constant_expression_p = false;
11839 saved_non_ice_p = parser->non_integral_constant_expression_p;
11840 parser->non_integral_constant_expression_p = false;
11841 /* Parse the arguments. */
11847 /* Consume the comma. */
11848 cp_lexer_consume_token (parser->lexer);
11850 /* Parse the template-argument. */
11851 argument = cp_parser_template_argument (parser);
11853 /* If the next token is an ellipsis, we're expanding a template
11855 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11857 if (argument == error_mark_node)
11859 cp_token *token = cp_lexer_peek_token (parser->lexer);
11860 error_at (token->location,
11861 "expected parameter pack before %<...%>");
11863 /* Consume the `...' token. */
11864 cp_lexer_consume_token (parser->lexer);
11866 /* Make the argument into a TYPE_PACK_EXPANSION or
11867 EXPR_PACK_EXPANSION. */
11868 argument = make_pack_expansion (argument);
11871 if (n_args == alloced)
11875 if (arg_ary == fixed_args)
11877 arg_ary = XNEWVEC (tree, alloced);
11878 memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
11881 arg_ary = XRESIZEVEC (tree, arg_ary, alloced);
11883 arg_ary[n_args++] = argument;
11885 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
11887 vec = make_tree_vec (n_args);
11890 TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];
11892 if (arg_ary != fixed_args)
11894 parser->non_integral_constant_expression_p = saved_non_ice_p;
11895 parser->integral_constant_expression_p = saved_ice_p;
11896 parser->in_template_argument_list_p = saved_in_template_argument_list_p;
11897 #ifdef ENABLE_CHECKING
11898 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
11903 /* Parse a template-argument.
11906 assignment-expression
11910 The representation is that of an assignment-expression, type-id, or
11911 id-expression -- except that the qualified id-expression is
11912 evaluated, so that the value returned is either a DECL or an
11915 Although the standard says "assignment-expression", it forbids
11916 throw-expressions or assignments in the template argument.
11917 Therefore, we use "conditional-expression" instead. */
11920 cp_parser_template_argument (cp_parser* parser)
11925 bool maybe_type_id = false;
11926 cp_token *token = NULL, *argument_start_token = NULL;
11929 /* There's really no way to know what we're looking at, so we just
11930 try each alternative in order.
11934 In a template-argument, an ambiguity between a type-id and an
11935 expression is resolved to a type-id, regardless of the form of
11936 the corresponding template-parameter.
11938 Therefore, we try a type-id first. */
11939 cp_parser_parse_tentatively (parser);
11940 argument = cp_parser_template_type_arg (parser);
11941 /* If there was no error parsing the type-id but the next token is a
11942 '>>', our behavior depends on which dialect of C++ we're
11943 parsing. In C++98, we probably found a typo for '> >'. But there
11944 are type-id which are also valid expressions. For instance:
11946 struct X { int operator >> (int); };
11947 template <int V> struct Foo {};
11950 Here 'X()' is a valid type-id of a function type, but the user just
11951 wanted to write the expression "X() >> 5". Thus, we remember that we
11952 found a valid type-id, but we still try to parse the argument as an
11953 expression to see what happens.
11955 In C++0x, the '>>' will be considered two separate '>'
11957 if (!cp_parser_error_occurred (parser)
11958 && cxx_dialect == cxx98
11959 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
11961 maybe_type_id = true;
11962 cp_parser_abort_tentative_parse (parser);
11966 /* If the next token isn't a `,' or a `>', then this argument wasn't
11967 really finished. This means that the argument is not a valid
11969 if (!cp_parser_next_token_ends_template_argument_p (parser))
11970 cp_parser_error (parser, "expected template-argument");
11971 /* If that worked, we're done. */
11972 if (cp_parser_parse_definitely (parser))
11975 /* We're still not sure what the argument will be. */
11976 cp_parser_parse_tentatively (parser);
11977 /* Try a template. */
11978 argument_start_token = cp_lexer_peek_token (parser->lexer);
11979 argument = cp_parser_id_expression (parser,
11980 /*template_keyword_p=*/false,
11981 /*check_dependency_p=*/true,
11983 /*declarator_p=*/false,
11984 /*optional_p=*/false);
11985 /* If the next token isn't a `,' or a `>', then this argument wasn't
11986 really finished. */
11987 if (!cp_parser_next_token_ends_template_argument_p (parser))
11988 cp_parser_error (parser, "expected template-argument");
11989 if (!cp_parser_error_occurred (parser))
11991 /* Figure out what is being referred to. If the id-expression
11992 was for a class template specialization, then we will have a
11993 TYPE_DECL at this point. There is no need to do name lookup
11994 at this point in that case. */
11995 if (TREE_CODE (argument) != TYPE_DECL)
11996 argument = cp_parser_lookup_name (parser, argument,
11998 /*is_template=*/template_p,
11999 /*is_namespace=*/false,
12000 /*check_dependency=*/true,
12001 /*ambiguous_decls=*/NULL,
12002 argument_start_token->location);
12003 if (TREE_CODE (argument) != TEMPLATE_DECL
12004 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
12005 cp_parser_error (parser, "expected template-name");
12007 if (cp_parser_parse_definitely (parser))
12009 /* It must be a non-type argument. There permitted cases are given
12010 in [temp.arg.nontype]:
12012 -- an integral constant-expression of integral or enumeration
12015 -- the name of a non-type template-parameter; or
12017 -- the name of an object or function with external linkage...
12019 -- the address of an object or function with external linkage...
12021 -- a pointer to member... */
12022 /* Look for a non-type template parameter. */
12023 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
12025 cp_parser_parse_tentatively (parser);
12026 argument = cp_parser_primary_expression (parser,
12027 /*address_p=*/false,
12029 /*template_arg_p=*/true,
12031 if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
12032 || !cp_parser_next_token_ends_template_argument_p (parser))
12033 cp_parser_simulate_error (parser);
12034 if (cp_parser_parse_definitely (parser))
12038 /* If the next token is "&", the argument must be the address of an
12039 object or function with external linkage. */
12040 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
12042 cp_lexer_consume_token (parser->lexer);
12043 /* See if we might have an id-expression. */
12044 token = cp_lexer_peek_token (parser->lexer);
12045 if (token->type == CPP_NAME
12046 || token->keyword == RID_OPERATOR
12047 || token->type == CPP_SCOPE
12048 || token->type == CPP_TEMPLATE_ID
12049 || token->type == CPP_NESTED_NAME_SPECIFIER)
12051 cp_parser_parse_tentatively (parser);
12052 argument = cp_parser_primary_expression (parser,
12055 /*template_arg_p=*/true,
12057 if (cp_parser_error_occurred (parser)
12058 || !cp_parser_next_token_ends_template_argument_p (parser))
12059 cp_parser_abort_tentative_parse (parser);
12064 if (TREE_CODE (argument) == INDIRECT_REF)
12066 gcc_assert (REFERENCE_REF_P (argument));
12067 argument = TREE_OPERAND (argument, 0);
12070 /* If we're in a template, we represent a qualified-id referring
12071 to a static data member as a SCOPE_REF even if the scope isn't
12072 dependent so that we can check access control later. */
12074 if (TREE_CODE (probe) == SCOPE_REF)
12075 probe = TREE_OPERAND (probe, 1);
12076 if (TREE_CODE (probe) == VAR_DECL)
12078 /* A variable without external linkage might still be a
12079 valid constant-expression, so no error is issued here
12080 if the external-linkage check fails. */
12081 if (!address_p && !DECL_EXTERNAL_LINKAGE_P (probe))
12082 cp_parser_simulate_error (parser);
12084 else if (is_overloaded_fn (argument))
12085 /* All overloaded functions are allowed; if the external
12086 linkage test does not pass, an error will be issued
12090 && (TREE_CODE (argument) == OFFSET_REF
12091 || TREE_CODE (argument) == SCOPE_REF))
12092 /* A pointer-to-member. */
12094 else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
12097 cp_parser_simulate_error (parser);
12099 if (cp_parser_parse_definitely (parser))
12102 argument = build_x_unary_op (ADDR_EXPR, argument,
12103 tf_warning_or_error);
12108 /* If the argument started with "&", there are no other valid
12109 alternatives at this point. */
12112 cp_parser_error (parser, "invalid non-type template argument");
12113 return error_mark_node;
12116 /* If the argument wasn't successfully parsed as a type-id followed
12117 by '>>', the argument can only be a constant expression now.
12118 Otherwise, we try parsing the constant-expression tentatively,
12119 because the argument could really be a type-id. */
12121 cp_parser_parse_tentatively (parser);
12122 argument = cp_parser_constant_expression (parser,
12123 /*allow_non_constant_p=*/false,
12124 /*non_constant_p=*/NULL);
12125 argument = fold_non_dependent_expr (argument);
12126 if (!maybe_type_id)
12128 if (!cp_parser_next_token_ends_template_argument_p (parser))
12129 cp_parser_error (parser, "expected template-argument");
12130 if (cp_parser_parse_definitely (parser))
12132 /* We did our best to parse the argument as a non type-id, but that
12133 was the only alternative that matched (albeit with a '>' after
12134 it). We can assume it's just a typo from the user, and a
12135 diagnostic will then be issued. */
12136 return cp_parser_template_type_arg (parser);
12139 /* Parse an explicit-instantiation.
12141 explicit-instantiation:
12142 template declaration
12144 Although the standard says `declaration', what it really means is:
12146 explicit-instantiation:
12147 template decl-specifier-seq [opt] declarator [opt] ;
12149 Things like `template int S<int>::i = 5, int S<double>::j;' are not
12150 supposed to be allowed. A defect report has been filed about this
12155 explicit-instantiation:
12156 storage-class-specifier template
12157 decl-specifier-seq [opt] declarator [opt] ;
12158 function-specifier template
12159 decl-specifier-seq [opt] declarator [opt] ; */
12162 cp_parser_explicit_instantiation (cp_parser* parser)
12164 int declares_class_or_enum;
12165 cp_decl_specifier_seq decl_specifiers;
12166 tree extension_specifier = NULL_TREE;
12168 timevar_push (TV_TEMPLATE_INST);
12170 /* Look for an (optional) storage-class-specifier or
12171 function-specifier. */
12172 if (cp_parser_allow_gnu_extensions_p (parser))
12174 extension_specifier
12175 = cp_parser_storage_class_specifier_opt (parser);
12176 if (!extension_specifier)
12177 extension_specifier
12178 = cp_parser_function_specifier_opt (parser,
12179 /*decl_specs=*/NULL);
12182 /* Look for the `template' keyword. */
12183 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
12184 /* Let the front end know that we are processing an explicit
12186 begin_explicit_instantiation ();
12187 /* [temp.explicit] says that we are supposed to ignore access
12188 control while processing explicit instantiation directives. */
12189 push_deferring_access_checks (dk_no_check);
12190 /* Parse a decl-specifier-seq. */
12191 cp_parser_decl_specifier_seq (parser,
12192 CP_PARSER_FLAGS_OPTIONAL,
12194 &declares_class_or_enum);
12195 /* If there was exactly one decl-specifier, and it declared a class,
12196 and there's no declarator, then we have an explicit type
12198 if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
12202 type = check_tag_decl (&decl_specifiers);
12203 /* Turn access control back on for names used during
12204 template instantiation. */
12205 pop_deferring_access_checks ();
12207 do_type_instantiation (type, extension_specifier,
12208 /*complain=*/tf_error);
12212 cp_declarator *declarator;
12215 /* Parse the declarator. */
12217 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
12218 /*ctor_dtor_or_conv_p=*/NULL,
12219 /*parenthesized_p=*/NULL,
12220 /*member_p=*/false);
12221 if (declares_class_or_enum & 2)
12222 cp_parser_check_for_definition_in_return_type (declarator,
12223 decl_specifiers.type,
12224 decl_specifiers.type_location);
12225 if (declarator != cp_error_declarator)
12227 if (decl_specifiers.specs[(int)ds_inline])
12228 permerror (input_location, "explicit instantiation shall not use"
12229 " %<inline%> specifier");
12230 if (decl_specifiers.specs[(int)ds_constexpr])
12231 permerror (input_location, "explicit instantiation shall not use"
12232 " %<constexpr%> specifier");
12234 decl = grokdeclarator (declarator, &decl_specifiers,
12235 NORMAL, 0, &decl_specifiers.attributes);
12236 /* Turn access control back on for names used during
12237 template instantiation. */
12238 pop_deferring_access_checks ();
12239 /* Do the explicit instantiation. */
12240 do_decl_instantiation (decl, extension_specifier);
12244 pop_deferring_access_checks ();
12245 /* Skip the body of the explicit instantiation. */
12246 cp_parser_skip_to_end_of_statement (parser);
12249 /* We're done with the instantiation. */
12250 end_explicit_instantiation ();
12252 cp_parser_consume_semicolon_at_end_of_statement (parser);
12254 timevar_pop (TV_TEMPLATE_INST);
12257 /* Parse an explicit-specialization.
12259 explicit-specialization:
12260 template < > declaration
12262 Although the standard says `declaration', what it really means is:
12264 explicit-specialization:
12265 template <> decl-specifier [opt] init-declarator [opt] ;
12266 template <> function-definition
12267 template <> explicit-specialization
12268 template <> template-declaration */
12271 cp_parser_explicit_specialization (cp_parser* parser)
12273 bool need_lang_pop;
12274 cp_token *token = cp_lexer_peek_token (parser->lexer);
12276 /* Look for the `template' keyword. */
12277 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
12278 /* Look for the `<'. */
12279 cp_parser_require (parser, CPP_LESS, RT_LESS);
12280 /* Look for the `>'. */
12281 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
12282 /* We have processed another parameter list. */
12283 ++parser->num_template_parameter_lists;
12286 A template ... explicit specialization ... shall not have C
12288 if (current_lang_name == lang_name_c)
12290 error_at (token->location, "template specialization with C linkage");
12291 /* Give it C++ linkage to avoid confusing other parts of the
12293 push_lang_context (lang_name_cplusplus);
12294 need_lang_pop = true;
12297 need_lang_pop = false;
12298 /* Let the front end know that we are beginning a specialization. */
12299 if (!begin_specialization ())
12301 end_specialization ();
12305 /* If the next keyword is `template', we need to figure out whether
12306 or not we're looking a template-declaration. */
12307 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
12309 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
12310 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
12311 cp_parser_template_declaration_after_export (parser,
12312 /*member_p=*/false);
12314 cp_parser_explicit_specialization (parser);
12317 /* Parse the dependent declaration. */
12318 cp_parser_single_declaration (parser,
12320 /*member_p=*/false,
12321 /*explicit_specialization_p=*/true,
12322 /*friend_p=*/NULL);
12323 /* We're done with the specialization. */
12324 end_specialization ();
12325 /* For the erroneous case of a template with C linkage, we pushed an
12326 implicit C++ linkage scope; exit that scope now. */
12328 pop_lang_context ();
12329 /* We're done with this parameter list. */
12330 --parser->num_template_parameter_lists;
12333 /* Parse a type-specifier.
12336 simple-type-specifier
12339 elaborated-type-specifier
12347 Returns a representation of the type-specifier. For a
12348 class-specifier, enum-specifier, or elaborated-type-specifier, a
12349 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
12351 The parser flags FLAGS is used to control type-specifier parsing.
12353 If IS_DECLARATION is TRUE, then this type-specifier is appearing
12354 in a decl-specifier-seq.
12356 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
12357 class-specifier, enum-specifier, or elaborated-type-specifier, then
12358 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
12359 if a type is declared; 2 if it is defined. Otherwise, it is set to
12362 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
12363 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
12364 is set to FALSE. */
12367 cp_parser_type_specifier (cp_parser* parser,
12368 cp_parser_flags flags,
12369 cp_decl_specifier_seq *decl_specs,
12370 bool is_declaration,
12371 int* declares_class_or_enum,
12372 bool* is_cv_qualifier)
12374 tree type_spec = NULL_TREE;
12377 cp_decl_spec ds = ds_last;
12379 /* Assume this type-specifier does not declare a new type. */
12380 if (declares_class_or_enum)
12381 *declares_class_or_enum = 0;
12382 /* And that it does not specify a cv-qualifier. */
12383 if (is_cv_qualifier)
12384 *is_cv_qualifier = false;
12385 /* Peek at the next token. */
12386 token = cp_lexer_peek_token (parser->lexer);
12388 /* If we're looking at a keyword, we can use that to guide the
12389 production we choose. */
12390 keyword = token->keyword;
12394 if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
12395 goto elaborated_type_specifier;
12397 /* Look for the enum-specifier. */
12398 type_spec = cp_parser_enum_specifier (parser);
12399 /* If that worked, we're done. */
12402 if (declares_class_or_enum)
12403 *declares_class_or_enum = 2;
12405 cp_parser_set_decl_spec_type (decl_specs,
12408 /*user_defined_p=*/true);
12412 goto elaborated_type_specifier;
12414 /* Any of these indicate either a class-specifier, or an
12415 elaborated-type-specifier. */
12419 if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
12420 goto elaborated_type_specifier;
12422 /* Parse tentatively so that we can back up if we don't find a
12423 class-specifier. */
12424 cp_parser_parse_tentatively (parser);
12425 /* Look for the class-specifier. */
12426 type_spec = cp_parser_class_specifier (parser);
12427 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, type_spec);
12428 /* If that worked, we're done. */
12429 if (cp_parser_parse_definitely (parser))
12431 if (declares_class_or_enum)
12432 *declares_class_or_enum = 2;
12434 cp_parser_set_decl_spec_type (decl_specs,
12437 /*user_defined_p=*/true);
12441 /* Fall through. */
12442 elaborated_type_specifier:
12443 /* We're declaring (not defining) a class or enum. */
12444 if (declares_class_or_enum)
12445 *declares_class_or_enum = 1;
12447 /* Fall through. */
12449 /* Look for an elaborated-type-specifier. */
12451 = (cp_parser_elaborated_type_specifier
12453 decl_specs && decl_specs->specs[(int) ds_friend],
12456 cp_parser_set_decl_spec_type (decl_specs,
12459 /*user_defined_p=*/true);
12464 if (is_cv_qualifier)
12465 *is_cv_qualifier = true;
12470 if (is_cv_qualifier)
12471 *is_cv_qualifier = true;
12476 if (is_cv_qualifier)
12477 *is_cv_qualifier = true;
12481 /* The `__complex__' keyword is a GNU extension. */
12489 /* Handle simple keywords. */
12494 ++decl_specs->specs[(int)ds];
12495 decl_specs->any_specifiers_p = true;
12497 return cp_lexer_consume_token (parser->lexer)->u.value;
12500 /* If we do not already have a type-specifier, assume we are looking
12501 at a simple-type-specifier. */
12502 type_spec = cp_parser_simple_type_specifier (parser,
12506 /* If we didn't find a type-specifier, and a type-specifier was not
12507 optional in this context, issue an error message. */
12508 if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
12510 cp_parser_error (parser, "expected type specifier");
12511 return error_mark_node;
12517 /* Parse a simple-type-specifier.
12519 simple-type-specifier:
12520 :: [opt] nested-name-specifier [opt] type-name
12521 :: [opt] nested-name-specifier template template-id
12536 simple-type-specifier:
12538 decltype ( expression )
12541 __underlying_type ( type-id )
12545 simple-type-specifier:
12547 __typeof__ unary-expression
12548 __typeof__ ( type-id )
12550 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
12551 appropriately updated. */
12554 cp_parser_simple_type_specifier (cp_parser* parser,
12555 cp_decl_specifier_seq *decl_specs,
12556 cp_parser_flags flags)
12558 tree type = NULL_TREE;
12561 /* Peek at the next token. */
12562 token = cp_lexer_peek_token (parser->lexer);
12564 /* If we're looking at a keyword, things are easy. */
12565 switch (token->keyword)
12569 decl_specs->explicit_char_p = true;
12570 type = char_type_node;
12573 type = char16_type_node;
12576 type = char32_type_node;
12579 type = wchar_type_node;
12582 type = boolean_type_node;
12586 ++decl_specs->specs[(int) ds_short];
12587 type = short_integer_type_node;
12591 decl_specs->explicit_int_p = true;
12592 type = integer_type_node;
12595 if (!int128_integer_type_node)
12598 decl_specs->explicit_int128_p = true;
12599 type = int128_integer_type_node;
12603 ++decl_specs->specs[(int) ds_long];
12604 type = long_integer_type_node;
12608 ++decl_specs->specs[(int) ds_signed];
12609 type = integer_type_node;
12613 ++decl_specs->specs[(int) ds_unsigned];
12614 type = unsigned_type_node;
12617 type = float_type_node;
12620 type = double_type_node;
12623 type = void_type_node;
12627 maybe_warn_cpp0x (CPP0X_AUTO);
12628 type = make_auto ();
12632 /* Parse the `decltype' type. */
12633 type = cp_parser_decltype (parser);
12636 cp_parser_set_decl_spec_type (decl_specs, type,
12638 /*user_defined_p=*/true);
12643 /* Consume the `typeof' token. */
12644 cp_lexer_consume_token (parser->lexer);
12645 /* Parse the operand to `typeof'. */
12646 type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
12647 /* If it is not already a TYPE, take its type. */
12648 if (!TYPE_P (type))
12649 type = finish_typeof (type);
12652 cp_parser_set_decl_spec_type (decl_specs, type,
12654 /*user_defined_p=*/true);
12658 case RID_UNDERLYING_TYPE:
12659 type = cp_parser_trait_expr (parser, RID_UNDERLYING_TYPE);
12662 cp_parser_set_decl_spec_type (decl_specs, type,
12664 /*user_defined_p=*/true);
12672 /* If the type-specifier was for a built-in type, we're done. */
12675 /* Record the type. */
12677 && (token->keyword != RID_SIGNED
12678 && token->keyword != RID_UNSIGNED
12679 && token->keyword != RID_SHORT
12680 && token->keyword != RID_LONG))
12681 cp_parser_set_decl_spec_type (decl_specs,
12684 /*user_defined=*/false);
12686 decl_specs->any_specifiers_p = true;
12688 /* Consume the token. */
12689 cp_lexer_consume_token (parser->lexer);
12691 /* There is no valid C++ program where a non-template type is
12692 followed by a "<". That usually indicates that the user thought
12693 that the type was a template. */
12694 cp_parser_check_for_invalid_template_id (parser, type, token->location);
12696 return TYPE_NAME (type);
12699 /* The type-specifier must be a user-defined type. */
12700 if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
12705 /* Don't gobble tokens or issue error messages if this is an
12706 optional type-specifier. */
12707 if (flags & CP_PARSER_FLAGS_OPTIONAL)
12708 cp_parser_parse_tentatively (parser);
12710 /* Look for the optional `::' operator. */
12712 = (cp_parser_global_scope_opt (parser,
12713 /*current_scope_valid_p=*/false)
12715 /* Look for the nested-name specifier. */
12717 = (cp_parser_nested_name_specifier_opt (parser,
12718 /*typename_keyword_p=*/false,
12719 /*check_dependency_p=*/true,
12721 /*is_declaration=*/false)
12723 token = cp_lexer_peek_token (parser->lexer);
12724 /* If we have seen a nested-name-specifier, and the next token
12725 is `template', then we are using the template-id production. */
12727 && cp_parser_optional_template_keyword (parser))
12729 /* Look for the template-id. */
12730 type = cp_parser_template_id (parser,
12731 /*template_keyword_p=*/true,
12732 /*check_dependency_p=*/true,
12733 /*is_declaration=*/false);
12734 /* If the template-id did not name a type, we are out of
12736 if (TREE_CODE (type) != TYPE_DECL)
12738 cp_parser_error (parser, "expected template-id for type");
12742 /* Otherwise, look for a type-name. */
12744 type = cp_parser_type_name (parser);
12745 /* Keep track of all name-lookups performed in class scopes. */
12749 && TREE_CODE (type) == TYPE_DECL
12750 && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
12751 maybe_note_name_used_in_class (DECL_NAME (type), type);
12752 /* If it didn't work out, we don't have a TYPE. */
12753 if ((flags & CP_PARSER_FLAGS_OPTIONAL)
12754 && !cp_parser_parse_definitely (parser))
12756 if (type && decl_specs)
12757 cp_parser_set_decl_spec_type (decl_specs, type,
12759 /*user_defined=*/true);
12762 /* If we didn't get a type-name, issue an error message. */
12763 if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
12765 cp_parser_error (parser, "expected type-name");
12766 return error_mark_node;
12769 if (type && type != error_mark_node)
12771 /* See if TYPE is an Objective-C type, and if so, parse and
12772 accept any protocol references following it. Do this before
12773 the cp_parser_check_for_invalid_template_id() call, because
12774 Objective-C types can be followed by '<...>' which would
12775 enclose protocol names rather than template arguments, and so
12776 everything is fine. */
12777 if (c_dialect_objc () && !parser->scope
12778 && (objc_is_id (type) || objc_is_class_name (type)))
12780 tree protos = cp_parser_objc_protocol_refs_opt (parser);
12781 tree qual_type = objc_get_protocol_qualified_type (type, protos);
12783 /* Clobber the "unqualified" type previously entered into
12784 DECL_SPECS with the new, improved protocol-qualified version. */
12786 decl_specs->type = qual_type;
12791 /* There is no valid C++ program where a non-template type is
12792 followed by a "<". That usually indicates that the user
12793 thought that the type was a template. */
12794 cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type),
12801 /* Parse a type-name.
12814 Returns a TYPE_DECL for the type. */
12817 cp_parser_type_name (cp_parser* parser)
12821 /* We can't know yet whether it is a class-name or not. */
12822 cp_parser_parse_tentatively (parser);
12823 /* Try a class-name. */
12824 type_decl = cp_parser_class_name (parser,
12825 /*typename_keyword_p=*/false,
12826 /*template_keyword_p=*/false,
12828 /*check_dependency_p=*/true,
12829 /*class_head_p=*/false,
12830 /*is_declaration=*/false);
12831 /* If it's not a class-name, keep looking. */
12832 if (!cp_parser_parse_definitely (parser))
12834 /* It must be a typedef-name or an enum-name. */
12835 return cp_parser_nonclass_name (parser);
12841 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
12849 Returns a TYPE_DECL for the type. */
12852 cp_parser_nonclass_name (cp_parser* parser)
12857 cp_token *token = cp_lexer_peek_token (parser->lexer);
12858 identifier = cp_parser_identifier (parser);
12859 if (identifier == error_mark_node)
12860 return error_mark_node;
12862 /* Look up the type-name. */
12863 type_decl = cp_parser_lookup_name_simple (parser, identifier, token->location);
12865 if (TREE_CODE (type_decl) != TYPE_DECL
12866 && (objc_is_id (identifier) || objc_is_class_name (identifier)))
12868 /* See if this is an Objective-C type. */
12869 tree protos = cp_parser_objc_protocol_refs_opt (parser);
12870 tree type = objc_get_protocol_qualified_type (identifier, protos);
12872 type_decl = TYPE_NAME (type);
12875 /* Issue an error if we did not find a type-name. */
12876 if (TREE_CODE (type_decl) != TYPE_DECL
12877 /* In Objective-C, we have the complication that class names are
12878 normally type names and start declarations (eg, the
12879 "NSObject" in "NSObject *object;"), but can be used in an
12880 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
12881 is an expression. So, a classname followed by a dot is not a
12882 valid type-name. */
12883 || (objc_is_class_name (TREE_TYPE (type_decl))
12884 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT))
12886 if (!cp_parser_simulate_error (parser))
12887 cp_parser_name_lookup_error (parser, identifier, type_decl,
12888 NLE_TYPE, token->location);
12889 return error_mark_node;
12891 /* Remember that the name was used in the definition of the
12892 current class so that we can check later to see if the
12893 meaning would have been different after the class was
12894 entirely defined. */
12895 else if (type_decl != error_mark_node
12897 maybe_note_name_used_in_class (identifier, type_decl);
12902 /* Parse an elaborated-type-specifier. Note that the grammar given
12903 here incorporates the resolution to DR68.
12905 elaborated-type-specifier:
12906 class-key :: [opt] nested-name-specifier [opt] identifier
12907 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
12908 enum-key :: [opt] nested-name-specifier [opt] identifier
12909 typename :: [opt] nested-name-specifier identifier
12910 typename :: [opt] nested-name-specifier template [opt]
12915 elaborated-type-specifier:
12916 class-key attributes :: [opt] nested-name-specifier [opt] identifier
12917 class-key attributes :: [opt] nested-name-specifier [opt]
12918 template [opt] template-id
12919 enum attributes :: [opt] nested-name-specifier [opt] identifier
12921 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
12922 declared `friend'. If IS_DECLARATION is TRUE, then this
12923 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
12924 something is being declared.
12926 Returns the TYPE specified. */
12929 cp_parser_elaborated_type_specifier (cp_parser* parser,
12931 bool is_declaration)
12933 enum tag_types tag_type;
12935 tree type = NULL_TREE;
12936 tree attributes = NULL_TREE;
12938 cp_token *token = NULL;
12940 /* See if we're looking at the `enum' keyword. */
12941 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
12943 /* Consume the `enum' token. */
12944 cp_lexer_consume_token (parser->lexer);
12945 /* Remember that it's an enumeration type. */
12946 tag_type = enum_type;
12947 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
12948 enums) is used here. */
12949 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
12950 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
12952 pedwarn (input_location, 0, "elaborated-type-specifier "
12953 "for a scoped enum must not use the %<%D%> keyword",
12954 cp_lexer_peek_token (parser->lexer)->u.value);
12955 /* Consume the `struct' or `class' and parse it anyway. */
12956 cp_lexer_consume_token (parser->lexer);
12958 /* Parse the attributes. */
12959 attributes = cp_parser_attributes_opt (parser);
12961 /* Or, it might be `typename'. */
12962 else if (cp_lexer_next_token_is_keyword (parser->lexer,
12965 /* Consume the `typename' token. */
12966 cp_lexer_consume_token (parser->lexer);
12967 /* Remember that it's a `typename' type. */
12968 tag_type = typename_type;
12970 /* Otherwise it must be a class-key. */
12973 tag_type = cp_parser_class_key (parser);
12974 if (tag_type == none_type)
12975 return error_mark_node;
12976 /* Parse the attributes. */
12977 attributes = cp_parser_attributes_opt (parser);
12980 /* Look for the `::' operator. */
12981 globalscope = cp_parser_global_scope_opt (parser,
12982 /*current_scope_valid_p=*/false);
12983 /* Look for the nested-name-specifier. */
12984 if (tag_type == typename_type && !globalscope)
12986 if (!cp_parser_nested_name_specifier (parser,
12987 /*typename_keyword_p=*/true,
12988 /*check_dependency_p=*/true,
12991 return error_mark_node;
12994 /* Even though `typename' is not present, the proposed resolution
12995 to Core Issue 180 says that in `class A<T>::B', `B' should be
12996 considered a type-name, even if `A<T>' is dependent. */
12997 cp_parser_nested_name_specifier_opt (parser,
12998 /*typename_keyword_p=*/true,
12999 /*check_dependency_p=*/true,
13002 /* For everything but enumeration types, consider a template-id.
13003 For an enumeration type, consider only a plain identifier. */
13004 if (tag_type != enum_type)
13006 bool template_p = false;
13009 /* Allow the `template' keyword. */
13010 template_p = cp_parser_optional_template_keyword (parser);
13011 /* If we didn't see `template', we don't know if there's a
13012 template-id or not. */
13014 cp_parser_parse_tentatively (parser);
13015 /* Parse the template-id. */
13016 token = cp_lexer_peek_token (parser->lexer);
13017 decl = cp_parser_template_id (parser, template_p,
13018 /*check_dependency_p=*/true,
13020 /* If we didn't find a template-id, look for an ordinary
13022 if (!template_p && !cp_parser_parse_definitely (parser))
13024 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
13025 in effect, then we must assume that, upon instantiation, the
13026 template will correspond to a class. */
13027 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
13028 && tag_type == typename_type)
13029 type = make_typename_type (parser->scope, decl,
13031 /*complain=*/tf_error);
13032 /* If the `typename' keyword is in effect and DECL is not a type
13033 decl. Then type is non existant. */
13034 else if (tag_type == typename_type && TREE_CODE (decl) != TYPE_DECL)
13037 type = TREE_TYPE (decl);
13042 token = cp_lexer_peek_token (parser->lexer);
13043 identifier = cp_parser_identifier (parser);
13045 if (identifier == error_mark_node)
13047 parser->scope = NULL_TREE;
13048 return error_mark_node;
13051 /* For a `typename', we needn't call xref_tag. */
13052 if (tag_type == typename_type
13053 && TREE_CODE (parser->scope) != NAMESPACE_DECL)
13054 return cp_parser_make_typename_type (parser, parser->scope,
13057 /* Look up a qualified name in the usual way. */
13061 tree ambiguous_decls;
13063 decl = cp_parser_lookup_name (parser, identifier,
13065 /*is_template=*/false,
13066 /*is_namespace=*/false,
13067 /*check_dependency=*/true,
13071 /* If the lookup was ambiguous, an error will already have been
13073 if (ambiguous_decls)
13074 return error_mark_node;
13076 /* If we are parsing friend declaration, DECL may be a
13077 TEMPLATE_DECL tree node here. However, we need to check
13078 whether this TEMPLATE_DECL results in valid code. Consider
13079 the following example:
13082 template <class T> class C {};
13085 template <class T> friend class N::C; // #1, valid code
13087 template <class T> class Y {
13088 friend class N::C; // #2, invalid code
13091 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
13092 name lookup of `N::C'. We see that friend declaration must
13093 be template for the code to be valid. Note that
13094 processing_template_decl does not work here since it is
13095 always 1 for the above two cases. */
13097 decl = (cp_parser_maybe_treat_template_as_class
13098 (decl, /*tag_name_p=*/is_friend
13099 && parser->num_template_parameter_lists));
13101 if (TREE_CODE (decl) != TYPE_DECL)
13103 cp_parser_diagnose_invalid_type_name (parser,
13107 return error_mark_node;
13110 if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
13112 bool allow_template = (parser->num_template_parameter_lists
13113 || DECL_SELF_REFERENCE_P (decl));
13114 type = check_elaborated_type_specifier (tag_type, decl,
13117 if (type == error_mark_node)
13118 return error_mark_node;
13121 /* Forward declarations of nested types, such as
13126 are invalid unless all components preceding the final '::'
13127 are complete. If all enclosing types are complete, these
13128 declarations become merely pointless.
13130 Invalid forward declarations of nested types are errors
13131 caught elsewhere in parsing. Those that are pointless arrive
13134 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
13135 && !is_friend && !processing_explicit_instantiation)
13136 warning (0, "declaration %qD does not declare anything", decl);
13138 type = TREE_TYPE (decl);
13142 /* An elaborated-type-specifier sometimes introduces a new type and
13143 sometimes names an existing type. Normally, the rule is that it
13144 introduces a new type only if there is not an existing type of
13145 the same name already in scope. For example, given:
13148 void f() { struct S s; }
13150 the `struct S' in the body of `f' is the same `struct S' as in
13151 the global scope; the existing definition is used. However, if
13152 there were no global declaration, this would introduce a new
13153 local class named `S'.
13155 An exception to this rule applies to the following code:
13157 namespace N { struct S; }
13159 Here, the elaborated-type-specifier names a new type
13160 unconditionally; even if there is already an `S' in the
13161 containing scope this declaration names a new type.
13162 This exception only applies if the elaborated-type-specifier
13163 forms the complete declaration:
13167 A declaration consisting solely of `class-key identifier ;' is
13168 either a redeclaration of the name in the current scope or a
13169 forward declaration of the identifier as a class name. It
13170 introduces the name into the current scope.
13172 We are in this situation precisely when the next token is a `;'.
13174 An exception to the exception is that a `friend' declaration does
13175 *not* name a new type; i.e., given:
13177 struct S { friend struct T; };
13179 `T' is not a new type in the scope of `S'.
13181 Also, `new struct S' or `sizeof (struct S)' never results in the
13182 definition of a new type; a new type can only be declared in a
13183 declaration context. */
13189 /* Friends have special name lookup rules. */
13190 ts = ts_within_enclosing_non_class;
13191 else if (is_declaration
13192 && cp_lexer_next_token_is (parser->lexer,
13194 /* This is a `class-key identifier ;' */
13200 (parser->num_template_parameter_lists
13201 && (cp_parser_next_token_starts_class_definition_p (parser)
13202 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
13203 /* An unqualified name was used to reference this type, so
13204 there were no qualifying templates. */
13205 if (!cp_parser_check_template_parameters (parser,
13206 /*num_templates=*/0,
13208 /*declarator=*/NULL))
13209 return error_mark_node;
13210 type = xref_tag (tag_type, identifier, ts, template_p);
13214 if (type == error_mark_node)
13215 return error_mark_node;
13217 /* Allow attributes on forward declarations of classes. */
13220 if (TREE_CODE (type) == TYPENAME_TYPE)
13221 warning (OPT_Wattributes,
13222 "attributes ignored on uninstantiated type");
13223 else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
13224 && ! processing_explicit_instantiation)
13225 warning (OPT_Wattributes,
13226 "attributes ignored on template instantiation");
13227 else if (is_declaration && cp_parser_declares_only_class_p (parser))
13228 cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
13230 warning (OPT_Wattributes,
13231 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
13234 if (tag_type != enum_type)
13235 cp_parser_check_class_key (tag_type, type);
13237 /* A "<" cannot follow an elaborated type specifier. If that
13238 happens, the user was probably trying to form a template-id. */
13239 cp_parser_check_for_invalid_template_id (parser, type, token->location);
13244 /* Parse an enum-specifier.
13247 enum-head { enumerator-list [opt] }
13250 enum-key identifier [opt] enum-base [opt]
13251 enum-key nested-name-specifier identifier enum-base [opt]
13256 enum struct [C++0x]
13259 : type-specifier-seq
13261 opaque-enum-specifier:
13262 enum-key identifier enum-base [opt] ;
13265 enum-key attributes[opt] identifier [opt] enum-base [opt]
13266 { enumerator-list [opt] }attributes[opt]
13268 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
13269 if the token stream isn't an enum-specifier after all. */
13272 cp_parser_enum_specifier (cp_parser* parser)
13275 tree type = NULL_TREE;
13277 tree nested_name_specifier = NULL_TREE;
13279 bool scoped_enum_p = false;
13280 bool has_underlying_type = false;
13281 bool nested_being_defined = false;
13282 bool new_value_list = false;
13283 bool is_new_type = false;
13284 bool is_anonymous = false;
13285 tree underlying_type = NULL_TREE;
13286 cp_token *type_start_token = NULL;
13287 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
13289 parser->colon_corrects_to_scope_p = false;
13291 /* Parse tentatively so that we can back up if we don't find a
13293 cp_parser_parse_tentatively (parser);
13295 /* Caller guarantees that the current token is 'enum', an identifier
13296 possibly follows, and the token after that is an opening brace.
13297 If we don't have an identifier, fabricate an anonymous name for
13298 the enumeration being defined. */
13299 cp_lexer_consume_token (parser->lexer);
13301 /* Parse the "class" or "struct", which indicates a scoped
13302 enumeration type in C++0x. */
13303 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
13304 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
13306 if (cxx_dialect < cxx0x)
13307 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
13309 /* Consume the `struct' or `class' token. */
13310 cp_lexer_consume_token (parser->lexer);
13312 scoped_enum_p = true;
13315 attributes = cp_parser_attributes_opt (parser);
13317 /* Clear the qualification. */
13318 parser->scope = NULL_TREE;
13319 parser->qualifying_scope = NULL_TREE;
13320 parser->object_scope = NULL_TREE;
13322 /* Figure out in what scope the declaration is being placed. */
13323 prev_scope = current_scope ();
13325 type_start_token = cp_lexer_peek_token (parser->lexer);
13327 push_deferring_access_checks (dk_no_check);
13328 nested_name_specifier
13329 = cp_parser_nested_name_specifier_opt (parser,
13330 /*typename_keyword_p=*/true,
13331 /*check_dependency_p=*/false,
13333 /*is_declaration=*/false);
13335 if (nested_name_specifier)
13339 identifier = cp_parser_identifier (parser);
13340 name = cp_parser_lookup_name (parser, identifier,
13342 /*is_template=*/false,
13343 /*is_namespace=*/false,
13344 /*check_dependency=*/true,
13345 /*ambiguous_decls=*/NULL,
13349 type = TREE_TYPE (name);
13350 if (TREE_CODE (type) == TYPENAME_TYPE)
13352 /* Are template enums allowed in ISO? */
13353 if (template_parm_scope_p ())
13354 pedwarn (type_start_token->location, OPT_pedantic,
13355 "%qD is an enumeration template", name);
13356 /* ignore a typename reference, for it will be solved by name
13362 error_at (type_start_token->location,
13363 "%qD is not an enumerator-name", identifier);
13367 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
13368 identifier = cp_parser_identifier (parser);
13371 identifier = make_anon_name ();
13372 is_anonymous = true;
13375 pop_deferring_access_checks ();
13377 /* Check for the `:' that denotes a specified underlying type in C++0x.
13378 Note that a ':' could also indicate a bitfield width, however. */
13379 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
13381 cp_decl_specifier_seq type_specifiers;
13383 /* Consume the `:'. */
13384 cp_lexer_consume_token (parser->lexer);
13386 /* Parse the type-specifier-seq. */
13387 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
13388 /*is_trailing_return=*/false,
13391 /* At this point this is surely not elaborated type specifier. */
13392 if (!cp_parser_parse_definitely (parser))
13395 if (cxx_dialect < cxx0x)
13396 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
13398 has_underlying_type = true;
13400 /* If that didn't work, stop. */
13401 if (type_specifiers.type != error_mark_node)
13403 underlying_type = grokdeclarator (NULL, &type_specifiers, TYPENAME,
13404 /*initialized=*/0, NULL);
13405 if (underlying_type == error_mark_node)
13406 underlying_type = NULL_TREE;
13410 /* Look for the `{' but don't consume it yet. */
13411 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13413 if (cxx_dialect < cxx0x || (!scoped_enum_p && !underlying_type))
13415 cp_parser_error (parser, "expected %<{%>");
13416 if (has_underlying_type)
13422 /* An opaque-enum-specifier must have a ';' here. */
13423 if ((scoped_enum_p || underlying_type)
13424 && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13426 cp_parser_error (parser, "expected %<;%> or %<{%>");
13427 if (has_underlying_type)
13435 if (!has_underlying_type && !cp_parser_parse_definitely (parser))
13438 if (nested_name_specifier)
13440 if (CLASS_TYPE_P (nested_name_specifier))
13442 nested_being_defined = TYPE_BEING_DEFINED (nested_name_specifier);
13443 TYPE_BEING_DEFINED (nested_name_specifier) = 1;
13444 push_scope (nested_name_specifier);
13446 else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
13448 push_nested_namespace (nested_name_specifier);
13452 /* Issue an error message if type-definitions are forbidden here. */
13453 if (!cp_parser_check_type_definition (parser))
13454 type = error_mark_node;
13456 /* Create the new type. We do this before consuming the opening
13457 brace so the enum will be recorded as being on the line of its
13458 tag (or the 'enum' keyword, if there is no tag). */
13459 type = start_enum (identifier, type, underlying_type,
13460 scoped_enum_p, &is_new_type);
13462 /* If the next token is not '{' it is an opaque-enum-specifier or an
13463 elaborated-type-specifier. */
13464 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13466 timevar_push (TV_PARSE_ENUM);
13467 if (nested_name_specifier)
13469 /* The following catches invalid code such as:
13470 enum class S<int>::E { A, B, C }; */
13471 if (!processing_specialization
13472 && CLASS_TYPE_P (nested_name_specifier)
13473 && CLASSTYPE_USE_TEMPLATE (nested_name_specifier))
13474 error_at (type_start_token->location, "cannot add an enumerator "
13475 "list to a template instantiation");
13477 /* If that scope does not contain the scope in which the
13478 class was originally declared, the program is invalid. */
13479 if (prev_scope && !is_ancestor (prev_scope, nested_name_specifier))
13481 if (at_namespace_scope_p ())
13482 error_at (type_start_token->location,
13483 "declaration of %qD in namespace %qD which does not "
13485 type, prev_scope, nested_name_specifier);
13487 error_at (type_start_token->location,
13488 "declaration of %qD in %qD which does not enclose %qD",
13489 type, prev_scope, nested_name_specifier);
13490 type = error_mark_node;
13495 begin_scope (sk_scoped_enum, type);
13497 /* Consume the opening brace. */
13498 cp_lexer_consume_token (parser->lexer);
13500 if (type == error_mark_node)
13501 ; /* Nothing to add */
13502 else if (OPAQUE_ENUM_P (type)
13503 || (cxx_dialect > cxx98 && processing_specialization))
13505 new_value_list = true;
13506 SET_OPAQUE_ENUM_P (type, false);
13507 DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
13511 error_at (type_start_token->location, "multiple definition of %q#T", type);
13512 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
13513 "previous definition here");
13514 type = error_mark_node;
13517 if (type == error_mark_node)
13518 cp_parser_skip_to_end_of_block_or_statement (parser);
13519 /* If the next token is not '}', then there are some enumerators. */
13520 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
13521 cp_parser_enumerator_list (parser, type);
13523 /* Consume the final '}'. */
13524 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
13528 timevar_pop (TV_PARSE_ENUM);
13532 /* If a ';' follows, then it is an opaque-enum-specifier
13533 and additional restrictions apply. */
13534 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13537 error_at (type_start_token->location,
13538 "opaque-enum-specifier without name");
13539 else if (nested_name_specifier)
13540 error_at (type_start_token->location,
13541 "opaque-enum-specifier must use a simple identifier");
13545 /* Look for trailing attributes to apply to this enumeration, and
13546 apply them if appropriate. */
13547 if (cp_parser_allow_gnu_extensions_p (parser))
13549 tree trailing_attr = cp_parser_attributes_opt (parser);
13550 trailing_attr = chainon (trailing_attr, attributes);
13551 cplus_decl_attributes (&type,
13553 (int) ATTR_FLAG_TYPE_IN_PLACE);
13556 /* Finish up the enumeration. */
13557 if (type != error_mark_node)
13559 if (new_value_list)
13560 finish_enum_value_list (type);
13562 finish_enum (type);
13565 if (nested_name_specifier)
13567 if (CLASS_TYPE_P (nested_name_specifier))
13569 TYPE_BEING_DEFINED (nested_name_specifier) = nested_being_defined;
13570 pop_scope (nested_name_specifier);
13572 else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
13574 pop_nested_namespace (nested_name_specifier);
13578 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
13582 /* Parse an enumerator-list. The enumerators all have the indicated
13586 enumerator-definition
13587 enumerator-list , enumerator-definition */
13590 cp_parser_enumerator_list (cp_parser* parser, tree type)
13594 /* Parse an enumerator-definition. */
13595 cp_parser_enumerator_definition (parser, type);
13597 /* If the next token is not a ',', we've reached the end of
13599 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
13601 /* Otherwise, consume the `,' and keep going. */
13602 cp_lexer_consume_token (parser->lexer);
13603 /* If the next token is a `}', there is a trailing comma. */
13604 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
13606 if (!in_system_header)
13607 pedwarn (input_location, OPT_pedantic, "comma at end of enumerator list");
13613 /* Parse an enumerator-definition. The enumerator has the indicated
13616 enumerator-definition:
13618 enumerator = constant-expression
13624 cp_parser_enumerator_definition (cp_parser* parser, tree type)
13630 /* Save the input location because we are interested in the location
13631 of the identifier and not the location of the explicit value. */
13632 loc = cp_lexer_peek_token (parser->lexer)->location;
13634 /* Look for the identifier. */
13635 identifier = cp_parser_identifier (parser);
13636 if (identifier == error_mark_node)
13639 /* If the next token is an '=', then there is an explicit value. */
13640 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13642 /* Consume the `=' token. */
13643 cp_lexer_consume_token (parser->lexer);
13644 /* Parse the value. */
13645 value = cp_parser_constant_expression (parser,
13646 /*allow_non_constant_p=*/false,
13652 /* If we are processing a template, make sure the initializer of the
13653 enumerator doesn't contain any bare template parameter pack. */
13654 if (check_for_bare_parameter_packs (value))
13655 value = error_mark_node;
13657 /* integral_constant_value will pull out this expression, so make sure
13658 it's folded as appropriate. */
13659 value = fold_non_dependent_expr (value);
13661 /* Create the enumerator. */
13662 build_enumerator (identifier, value, type, loc);
13665 /* Parse a namespace-name.
13668 original-namespace-name
13671 Returns the NAMESPACE_DECL for the namespace. */
13674 cp_parser_namespace_name (cp_parser* parser)
13677 tree namespace_decl;
13679 cp_token *token = cp_lexer_peek_token (parser->lexer);
13681 /* Get the name of the namespace. */
13682 identifier = cp_parser_identifier (parser);
13683 if (identifier == error_mark_node)
13684 return error_mark_node;
13686 /* Look up the identifier in the currently active scope. Look only
13687 for namespaces, due to:
13689 [basic.lookup.udir]
13691 When looking up a namespace-name in a using-directive or alias
13692 definition, only namespace names are considered.
13696 [basic.lookup.qual]
13698 During the lookup of a name preceding the :: scope resolution
13699 operator, object, function, and enumerator names are ignored.
13701 (Note that cp_parser_qualifying_entity only calls this
13702 function if the token after the name is the scope resolution
13704 namespace_decl = cp_parser_lookup_name (parser, identifier,
13706 /*is_template=*/false,
13707 /*is_namespace=*/true,
13708 /*check_dependency=*/true,
13709 /*ambiguous_decls=*/NULL,
13711 /* If it's not a namespace, issue an error. */
13712 if (namespace_decl == error_mark_node
13713 || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
13715 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
13716 error_at (token->location, "%qD is not a namespace-name", identifier);
13717 cp_parser_error (parser, "expected namespace-name");
13718 namespace_decl = error_mark_node;
13721 return namespace_decl;
13724 /* Parse a namespace-definition.
13726 namespace-definition:
13727 named-namespace-definition
13728 unnamed-namespace-definition
13730 named-namespace-definition:
13731 original-namespace-definition
13732 extension-namespace-definition
13734 original-namespace-definition:
13735 namespace identifier { namespace-body }
13737 extension-namespace-definition:
13738 namespace original-namespace-name { namespace-body }
13740 unnamed-namespace-definition:
13741 namespace { namespace-body } */
13744 cp_parser_namespace_definition (cp_parser* parser)
13746 tree identifier, attribs;
13747 bool has_visibility;
13750 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE))
13752 maybe_warn_cpp0x (CPP0X_INLINE_NAMESPACES);
13754 cp_lexer_consume_token (parser->lexer);
13759 /* Look for the `namespace' keyword. */
13760 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
13762 /* Get the name of the namespace. We do not attempt to distinguish
13763 between an original-namespace-definition and an
13764 extension-namespace-definition at this point. The semantic
13765 analysis routines are responsible for that. */
13766 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
13767 identifier = cp_parser_identifier (parser);
13769 identifier = NULL_TREE;
13771 /* Parse any specified attributes. */
13772 attribs = cp_parser_attributes_opt (parser);
13774 /* Look for the `{' to start the namespace. */
13775 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
13776 /* Start the namespace. */
13777 push_namespace (identifier);
13779 /* "inline namespace" is equivalent to a stub namespace definition
13780 followed by a strong using directive. */
13783 tree name_space = current_namespace;
13784 /* Set up namespace association. */
13785 DECL_NAMESPACE_ASSOCIATIONS (name_space)
13786 = tree_cons (CP_DECL_CONTEXT (name_space), NULL_TREE,
13787 DECL_NAMESPACE_ASSOCIATIONS (name_space));
13788 /* Import the contents of the inline namespace. */
13790 do_using_directive (name_space);
13791 push_namespace (identifier);
13794 has_visibility = handle_namespace_attrs (current_namespace, attribs);
13796 /* Parse the body of the namespace. */
13797 cp_parser_namespace_body (parser);
13799 if (has_visibility)
13800 pop_visibility (1);
13802 /* Finish the namespace. */
13804 /* Look for the final `}'. */
13805 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
13808 /* Parse a namespace-body.
13811 declaration-seq [opt] */
13814 cp_parser_namespace_body (cp_parser* parser)
13816 cp_parser_declaration_seq_opt (parser);
13819 /* Parse a namespace-alias-definition.
13821 namespace-alias-definition:
13822 namespace identifier = qualified-namespace-specifier ; */
13825 cp_parser_namespace_alias_definition (cp_parser* parser)
13828 tree namespace_specifier;
13830 cp_token *token = cp_lexer_peek_token (parser->lexer);
13832 /* Look for the `namespace' keyword. */
13833 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
13834 /* Look for the identifier. */
13835 identifier = cp_parser_identifier (parser);
13836 if (identifier == error_mark_node)
13838 /* Look for the `=' token. */
13839 if (!cp_parser_uncommitted_to_tentative_parse_p (parser)
13840 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13842 error_at (token->location, "%<namespace%> definition is not allowed here");
13843 /* Skip the definition. */
13844 cp_lexer_consume_token (parser->lexer);
13845 if (cp_parser_skip_to_closing_brace (parser))
13846 cp_lexer_consume_token (parser->lexer);
13849 cp_parser_require (parser, CPP_EQ, RT_EQ);
13850 /* Look for the qualified-namespace-specifier. */
13851 namespace_specifier
13852 = cp_parser_qualified_namespace_specifier (parser);
13853 /* Look for the `;' token. */
13854 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13856 /* Register the alias in the symbol table. */
13857 do_namespace_alias (identifier, namespace_specifier);
13860 /* Parse a qualified-namespace-specifier.
13862 qualified-namespace-specifier:
13863 :: [opt] nested-name-specifier [opt] namespace-name
13865 Returns a NAMESPACE_DECL corresponding to the specified
13869 cp_parser_qualified_namespace_specifier (cp_parser* parser)
13871 /* Look for the optional `::'. */
13872 cp_parser_global_scope_opt (parser,
13873 /*current_scope_valid_p=*/false);
13875 /* Look for the optional nested-name-specifier. */
13876 cp_parser_nested_name_specifier_opt (parser,
13877 /*typename_keyword_p=*/false,
13878 /*check_dependency_p=*/true,
13880 /*is_declaration=*/true);
13882 return cp_parser_namespace_name (parser);
13885 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
13886 access declaration.
13889 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
13890 using :: unqualified-id ;
13892 access-declaration:
13898 cp_parser_using_declaration (cp_parser* parser,
13899 bool access_declaration_p)
13902 bool typename_p = false;
13903 bool global_scope_p;
13908 if (access_declaration_p)
13909 cp_parser_parse_tentatively (parser);
13912 /* Look for the `using' keyword. */
13913 cp_parser_require_keyword (parser, RID_USING, RT_USING);
13915 /* Peek at the next token. */
13916 token = cp_lexer_peek_token (parser->lexer);
13917 /* See if it's `typename'. */
13918 if (token->keyword == RID_TYPENAME)
13920 /* Remember that we've seen it. */
13922 /* Consume the `typename' token. */
13923 cp_lexer_consume_token (parser->lexer);
13927 /* Look for the optional global scope qualification. */
13929 = (cp_parser_global_scope_opt (parser,
13930 /*current_scope_valid_p=*/false)
13933 /* If we saw `typename', or didn't see `::', then there must be a
13934 nested-name-specifier present. */
13935 if (typename_p || !global_scope_p)
13936 qscope = cp_parser_nested_name_specifier (parser, typename_p,
13937 /*check_dependency_p=*/true,
13939 /*is_declaration=*/true);
13940 /* Otherwise, we could be in either of the two productions. In that
13941 case, treat the nested-name-specifier as optional. */
13943 qscope = cp_parser_nested_name_specifier_opt (parser,
13944 /*typename_keyword_p=*/false,
13945 /*check_dependency_p=*/true,
13947 /*is_declaration=*/true);
13949 qscope = global_namespace;
13951 if (access_declaration_p && cp_parser_error_occurred (parser))
13952 /* Something has already gone wrong; there's no need to parse
13953 further. Since an error has occurred, the return value of
13954 cp_parser_parse_definitely will be false, as required. */
13955 return cp_parser_parse_definitely (parser);
13957 token = cp_lexer_peek_token (parser->lexer);
13958 /* Parse the unqualified-id. */
13959 identifier = cp_parser_unqualified_id (parser,
13960 /*template_keyword_p=*/false,
13961 /*check_dependency_p=*/true,
13962 /*declarator_p=*/true,
13963 /*optional_p=*/false);
13965 if (access_declaration_p)
13967 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13968 cp_parser_simulate_error (parser);
13969 if (!cp_parser_parse_definitely (parser))
13973 /* The function we call to handle a using-declaration is different
13974 depending on what scope we are in. */
13975 if (qscope == error_mark_node || identifier == error_mark_node)
13977 else if (TREE_CODE (identifier) != IDENTIFIER_NODE
13978 && TREE_CODE (identifier) != BIT_NOT_EXPR)
13979 /* [namespace.udecl]
13981 A using declaration shall not name a template-id. */
13982 error_at (token->location,
13983 "a template-id may not appear in a using-declaration");
13986 if (at_class_scope_p ())
13988 /* Create the USING_DECL. */
13989 decl = do_class_using_decl (parser->scope, identifier);
13991 if (check_for_bare_parameter_packs (decl))
13994 /* Add it to the list of members in this class. */
13995 finish_member_declaration (decl);
13999 decl = cp_parser_lookup_name_simple (parser,
14002 if (decl == error_mark_node)
14003 cp_parser_name_lookup_error (parser, identifier,
14006 else if (check_for_bare_parameter_packs (decl))
14008 else if (!at_namespace_scope_p ())
14009 do_local_using_decl (decl, qscope, identifier);
14011 do_toplevel_using_decl (decl, qscope, identifier);
14015 /* Look for the final `;'. */
14016 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14021 /* Parse a using-directive.
14024 using namespace :: [opt] nested-name-specifier [opt]
14025 namespace-name ; */
14028 cp_parser_using_directive (cp_parser* parser)
14030 tree namespace_decl;
14033 /* Look for the `using' keyword. */
14034 cp_parser_require_keyword (parser, RID_USING, RT_USING);
14035 /* And the `namespace' keyword. */
14036 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
14037 /* Look for the optional `::' operator. */
14038 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
14039 /* And the optional nested-name-specifier. */
14040 cp_parser_nested_name_specifier_opt (parser,
14041 /*typename_keyword_p=*/false,
14042 /*check_dependency_p=*/true,
14044 /*is_declaration=*/true);
14045 /* Get the namespace being used. */
14046 namespace_decl = cp_parser_namespace_name (parser);
14047 /* And any specified attributes. */
14048 attribs = cp_parser_attributes_opt (parser);
14049 /* Update the symbol table. */
14050 parse_using_directive (namespace_decl, attribs);
14051 /* Look for the final `;'. */
14052 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14055 /* Parse an asm-definition.
14058 asm ( string-literal ) ;
14063 asm volatile [opt] ( string-literal ) ;
14064 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
14065 asm volatile [opt] ( string-literal : asm-operand-list [opt]
14066 : asm-operand-list [opt] ) ;
14067 asm volatile [opt] ( string-literal : asm-operand-list [opt]
14068 : asm-operand-list [opt]
14069 : asm-clobber-list [opt] ) ;
14070 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
14071 : asm-clobber-list [opt]
14072 : asm-goto-list ) ; */
14075 cp_parser_asm_definition (cp_parser* parser)
14078 tree outputs = NULL_TREE;
14079 tree inputs = NULL_TREE;
14080 tree clobbers = NULL_TREE;
14081 tree labels = NULL_TREE;
14083 bool volatile_p = false;
14084 bool extended_p = false;
14085 bool invalid_inputs_p = false;
14086 bool invalid_outputs_p = false;
14087 bool goto_p = false;
14088 required_token missing = RT_NONE;
14090 /* Look for the `asm' keyword. */
14091 cp_parser_require_keyword (parser, RID_ASM, RT_ASM);
14092 /* See if the next token is `volatile'. */
14093 if (cp_parser_allow_gnu_extensions_p (parser)
14094 && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
14096 /* Remember that we saw the `volatile' keyword. */
14098 /* Consume the token. */
14099 cp_lexer_consume_token (parser->lexer);
14101 if (cp_parser_allow_gnu_extensions_p (parser)
14102 && parser->in_function_body
14103 && cp_lexer_next_token_is_keyword (parser->lexer, RID_GOTO))
14105 /* Remember that we saw the `goto' keyword. */
14107 /* Consume the token. */
14108 cp_lexer_consume_token (parser->lexer);
14110 /* Look for the opening `('. */
14111 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
14113 /* Look for the string. */
14114 string = cp_parser_string_literal (parser, false, false);
14115 if (string == error_mark_node)
14117 cp_parser_skip_to_closing_parenthesis (parser, true, false,
14118 /*consume_paren=*/true);
14122 /* If we're allowing GNU extensions, check for the extended assembly
14123 syntax. Unfortunately, the `:' tokens need not be separated by
14124 a space in C, and so, for compatibility, we tolerate that here
14125 too. Doing that means that we have to treat the `::' operator as
14127 if (cp_parser_allow_gnu_extensions_p (parser)
14128 && parser->in_function_body
14129 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
14130 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
14132 bool inputs_p = false;
14133 bool clobbers_p = false;
14134 bool labels_p = false;
14136 /* The extended syntax was used. */
14139 /* Look for outputs. */
14140 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14142 /* Consume the `:'. */
14143 cp_lexer_consume_token (parser->lexer);
14144 /* Parse the output-operands. */
14145 if (cp_lexer_next_token_is_not (parser->lexer,
14147 && cp_lexer_next_token_is_not (parser->lexer,
14149 && cp_lexer_next_token_is_not (parser->lexer,
14152 outputs = cp_parser_asm_operand_list (parser);
14154 if (outputs == error_mark_node)
14155 invalid_outputs_p = true;
14157 /* If the next token is `::', there are no outputs, and the
14158 next token is the beginning of the inputs. */
14159 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14160 /* The inputs are coming next. */
14163 /* Look for inputs. */
14165 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14167 /* Consume the `:' or `::'. */
14168 cp_lexer_consume_token (parser->lexer);
14169 /* Parse the output-operands. */
14170 if (cp_lexer_next_token_is_not (parser->lexer,
14172 && cp_lexer_next_token_is_not (parser->lexer,
14174 && cp_lexer_next_token_is_not (parser->lexer,
14176 inputs = cp_parser_asm_operand_list (parser);
14178 if (inputs == error_mark_node)
14179 invalid_inputs_p = true;
14181 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14182 /* The clobbers are coming next. */
14185 /* Look for clobbers. */
14187 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14190 /* Consume the `:' or `::'. */
14191 cp_lexer_consume_token (parser->lexer);
14192 /* Parse the clobbers. */
14193 if (cp_lexer_next_token_is_not (parser->lexer,
14195 && cp_lexer_next_token_is_not (parser->lexer,
14197 clobbers = cp_parser_asm_clobber_list (parser);
14200 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14201 /* The labels are coming next. */
14204 /* Look for labels. */
14206 || (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
14209 /* Consume the `:' or `::'. */
14210 cp_lexer_consume_token (parser->lexer);
14211 /* Parse the labels. */
14212 labels = cp_parser_asm_label_list (parser);
14215 if (goto_p && !labels_p)
14216 missing = clobbers_p ? RT_COLON : RT_COLON_SCOPE;
14219 missing = RT_COLON_SCOPE;
14221 /* Look for the closing `)'. */
14222 if (!cp_parser_require (parser, missing ? CPP_COLON : CPP_CLOSE_PAREN,
14223 missing ? missing : RT_CLOSE_PAREN))
14224 cp_parser_skip_to_closing_parenthesis (parser, true, false,
14225 /*consume_paren=*/true);
14226 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14228 if (!invalid_inputs_p && !invalid_outputs_p)
14230 /* Create the ASM_EXPR. */
14231 if (parser->in_function_body)
14233 asm_stmt = finish_asm_stmt (volatile_p, string, outputs,
14234 inputs, clobbers, labels);
14235 /* If the extended syntax was not used, mark the ASM_EXPR. */
14238 tree temp = asm_stmt;
14239 if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
14240 temp = TREE_OPERAND (temp, 0);
14242 ASM_INPUT_P (temp) = 1;
14246 cgraph_add_asm_node (string);
14250 /* Declarators [gram.dcl.decl] */
14252 /* Parse an init-declarator.
14255 declarator initializer [opt]
14260 declarator asm-specification [opt] attributes [opt] initializer [opt]
14262 function-definition:
14263 decl-specifier-seq [opt] declarator ctor-initializer [opt]
14265 decl-specifier-seq [opt] declarator function-try-block
14269 function-definition:
14270 __extension__ function-definition
14272 The DECL_SPECIFIERS apply to this declarator. Returns a
14273 representation of the entity declared. If MEMBER_P is TRUE, then
14274 this declarator appears in a class scope. The new DECL created by
14275 this declarator is returned.
14277 The CHECKS are access checks that should be performed once we know
14278 what entity is being declared (and, therefore, what classes have
14281 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
14282 for a function-definition here as well. If the declarator is a
14283 declarator for a function-definition, *FUNCTION_DEFINITION_P will
14284 be TRUE upon return. By that point, the function-definition will
14285 have been completely parsed.
14287 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
14290 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
14291 parsed declaration if it is an uninitialized single declarator not followed
14292 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
14293 if present, will not be consumed. If returned, this declarator will be
14294 created with SD_INITIALIZED but will not call cp_finish_decl. */
14297 cp_parser_init_declarator (cp_parser* parser,
14298 cp_decl_specifier_seq *decl_specifiers,
14299 VEC (deferred_access_check,gc)* checks,
14300 bool function_definition_allowed_p,
14302 int declares_class_or_enum,
14303 bool* function_definition_p,
14304 tree* maybe_range_for_decl)
14306 cp_token *token = NULL, *asm_spec_start_token = NULL,
14307 *attributes_start_token = NULL;
14308 cp_declarator *declarator;
14309 tree prefix_attributes;
14311 tree asm_specification;
14313 tree decl = NULL_TREE;
14315 int is_initialized;
14316 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
14317 initialized with "= ..", CPP_OPEN_PAREN if initialized with
14319 enum cpp_ttype initialization_kind;
14320 bool is_direct_init = false;
14321 bool is_non_constant_init;
14322 int ctor_dtor_or_conv_p;
14324 tree pushed_scope = NULL_TREE;
14325 bool range_for_decl_p = false;
14327 /* Gather the attributes that were provided with the
14328 decl-specifiers. */
14329 prefix_attributes = decl_specifiers->attributes;
14331 /* Assume that this is not the declarator for a function
14333 if (function_definition_p)
14334 *function_definition_p = false;
14336 /* Defer access checks while parsing the declarator; we cannot know
14337 what names are accessible until we know what is being
14339 resume_deferring_access_checks ();
14341 /* Parse the declarator. */
14342 token = cp_lexer_peek_token (parser->lexer);
14344 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
14345 &ctor_dtor_or_conv_p,
14346 /*parenthesized_p=*/NULL,
14347 /*member_p=*/false);
14348 /* Gather up the deferred checks. */
14349 stop_deferring_access_checks ();
14351 /* If the DECLARATOR was erroneous, there's no need to go
14353 if (declarator == cp_error_declarator)
14354 return error_mark_node;
14356 /* Check that the number of template-parameter-lists is OK. */
14357 if (!cp_parser_check_declarator_template_parameters (parser, declarator,
14359 return error_mark_node;
14361 if (declares_class_or_enum & 2)
14362 cp_parser_check_for_definition_in_return_type (declarator,
14363 decl_specifiers->type,
14364 decl_specifiers->type_location);
14366 /* Figure out what scope the entity declared by the DECLARATOR is
14367 located in. `grokdeclarator' sometimes changes the scope, so
14368 we compute it now. */
14369 scope = get_scope_of_declarator (declarator);
14371 /* Perform any lookups in the declared type which were thought to be
14372 dependent, but are not in the scope of the declarator. */
14373 decl_specifiers->type
14374 = maybe_update_decl_type (decl_specifiers->type, scope);
14376 /* If we're allowing GNU extensions, look for an asm-specification
14378 if (cp_parser_allow_gnu_extensions_p (parser))
14380 /* Look for an asm-specification. */
14381 asm_spec_start_token = cp_lexer_peek_token (parser->lexer);
14382 asm_specification = cp_parser_asm_specification_opt (parser);
14383 /* And attributes. */
14384 attributes_start_token = cp_lexer_peek_token (parser->lexer);
14385 attributes = cp_parser_attributes_opt (parser);
14389 asm_specification = NULL_TREE;
14390 attributes = NULL_TREE;
14393 /* Peek at the next token. */
14394 token = cp_lexer_peek_token (parser->lexer);
14395 /* Check to see if the token indicates the start of a
14396 function-definition. */
14397 if (function_declarator_p (declarator)
14398 && cp_parser_token_starts_function_definition_p (token))
14400 if (!function_definition_allowed_p)
14402 /* If a function-definition should not appear here, issue an
14404 cp_parser_error (parser,
14405 "a function-definition is not allowed here");
14406 return error_mark_node;
14410 location_t func_brace_location
14411 = cp_lexer_peek_token (parser->lexer)->location;
14413 /* Neither attributes nor an asm-specification are allowed
14414 on a function-definition. */
14415 if (asm_specification)
14416 error_at (asm_spec_start_token->location,
14417 "an asm-specification is not allowed "
14418 "on a function-definition");
14420 error_at (attributes_start_token->location,
14421 "attributes are not allowed on a function-definition");
14422 /* This is a function-definition. */
14423 *function_definition_p = true;
14425 /* Parse the function definition. */
14427 decl = cp_parser_save_member_function_body (parser,
14430 prefix_attributes);
14433 = (cp_parser_function_definition_from_specifiers_and_declarator
14434 (parser, decl_specifiers, prefix_attributes, declarator));
14436 if (decl != error_mark_node && DECL_STRUCT_FUNCTION (decl))
14438 /* This is where the prologue starts... */
14439 DECL_STRUCT_FUNCTION (decl)->function_start_locus
14440 = func_brace_location;
14449 Only in function declarations for constructors, destructors, and
14450 type conversions can the decl-specifier-seq be omitted.
14452 We explicitly postpone this check past the point where we handle
14453 function-definitions because we tolerate function-definitions
14454 that are missing their return types in some modes. */
14455 if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
14457 cp_parser_error (parser,
14458 "expected constructor, destructor, or type conversion");
14459 return error_mark_node;
14462 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
14463 if (token->type == CPP_EQ
14464 || token->type == CPP_OPEN_PAREN
14465 || token->type == CPP_OPEN_BRACE)
14467 is_initialized = SD_INITIALIZED;
14468 initialization_kind = token->type;
14469 if (maybe_range_for_decl)
14470 *maybe_range_for_decl = error_mark_node;
14472 if (token->type == CPP_EQ
14473 && function_declarator_p (declarator))
14475 cp_token *t2 = cp_lexer_peek_nth_token (parser->lexer, 2);
14476 if (t2->keyword == RID_DEFAULT)
14477 is_initialized = SD_DEFAULTED;
14478 else if (t2->keyword == RID_DELETE)
14479 is_initialized = SD_DELETED;
14484 /* If the init-declarator isn't initialized and isn't followed by a
14485 `,' or `;', it's not a valid init-declarator. */
14486 if (token->type != CPP_COMMA
14487 && token->type != CPP_SEMICOLON)
14489 if (maybe_range_for_decl && *maybe_range_for_decl != error_mark_node)
14490 range_for_decl_p = true;
14493 cp_parser_error (parser, "expected initializer");
14494 return error_mark_node;
14497 is_initialized = SD_UNINITIALIZED;
14498 initialization_kind = CPP_EOF;
14501 /* Because start_decl has side-effects, we should only call it if we
14502 know we're going ahead. By this point, we know that we cannot
14503 possibly be looking at any other construct. */
14504 cp_parser_commit_to_tentative_parse (parser);
14506 /* If the decl specifiers were bad, issue an error now that we're
14507 sure this was intended to be a declarator. Then continue
14508 declaring the variable(s), as int, to try to cut down on further
14510 if (decl_specifiers->any_specifiers_p
14511 && decl_specifiers->type == error_mark_node)
14513 cp_parser_error (parser, "invalid type in declaration");
14514 decl_specifiers->type = integer_type_node;
14517 /* Check to see whether or not this declaration is a friend. */
14518 friend_p = cp_parser_friend_p (decl_specifiers);
14520 /* Enter the newly declared entry in the symbol table. If we're
14521 processing a declaration in a class-specifier, we wait until
14522 after processing the initializer. */
14525 if (parser->in_unbraced_linkage_specification_p)
14526 decl_specifiers->storage_class = sc_extern;
14527 decl = start_decl (declarator, decl_specifiers,
14528 range_for_decl_p? SD_INITIALIZED : is_initialized,
14529 attributes, prefix_attributes,
14531 /* Adjust location of decl if declarator->id_loc is more appropriate:
14532 set, and decl wasn't merged with another decl, in which case its
14533 location would be different from input_location, and more accurate. */
14535 && declarator->id_loc != UNKNOWN_LOCATION
14536 && DECL_SOURCE_LOCATION (decl) == input_location)
14537 DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
14540 /* Enter the SCOPE. That way unqualified names appearing in the
14541 initializer will be looked up in SCOPE. */
14542 pushed_scope = push_scope (scope);
14544 /* Perform deferred access control checks, now that we know in which
14545 SCOPE the declared entity resides. */
14546 if (!member_p && decl)
14548 tree saved_current_function_decl = NULL_TREE;
14550 /* If the entity being declared is a function, pretend that we
14551 are in its scope. If it is a `friend', it may have access to
14552 things that would not otherwise be accessible. */
14553 if (TREE_CODE (decl) == FUNCTION_DECL)
14555 saved_current_function_decl = current_function_decl;
14556 current_function_decl = decl;
14559 /* Perform access checks for template parameters. */
14560 cp_parser_perform_template_parameter_access_checks (checks);
14562 /* Perform the access control checks for the declarator and the
14563 decl-specifiers. */
14564 perform_deferred_access_checks ();
14566 /* Restore the saved value. */
14567 if (TREE_CODE (decl) == FUNCTION_DECL)
14568 current_function_decl = saved_current_function_decl;
14571 /* Parse the initializer. */
14572 initializer = NULL_TREE;
14573 is_direct_init = false;
14574 is_non_constant_init = true;
14575 if (is_initialized)
14577 if (function_declarator_p (declarator))
14579 cp_token *initializer_start_token = cp_lexer_peek_token (parser->lexer);
14580 if (initialization_kind == CPP_EQ)
14581 initializer = cp_parser_pure_specifier (parser);
14584 /* If the declaration was erroneous, we don't really
14585 know what the user intended, so just silently
14586 consume the initializer. */
14587 if (decl != error_mark_node)
14588 error_at (initializer_start_token->location,
14589 "initializer provided for function");
14590 cp_parser_skip_to_closing_parenthesis (parser,
14591 /*recovering=*/true,
14592 /*or_comma=*/false,
14593 /*consume_paren=*/true);
14598 /* We want to record the extra mangling scope for in-class
14599 initializers of class members and initializers of static data
14600 member templates. The former is a C++0x feature which isn't
14601 implemented yet, and I expect it will involve deferring
14602 parsing of the initializer until end of class as with default
14603 arguments. So right here we only handle the latter. */
14604 if (!member_p && processing_template_decl)
14605 start_lambda_scope (decl);
14606 initializer = cp_parser_initializer (parser,
14608 &is_non_constant_init);
14609 if (!member_p && processing_template_decl)
14610 finish_lambda_scope ();
14614 /* The old parser allows attributes to appear after a parenthesized
14615 initializer. Mark Mitchell proposed removing this functionality
14616 on the GCC mailing lists on 2002-08-13. This parser accepts the
14617 attributes -- but ignores them. */
14618 if (cp_parser_allow_gnu_extensions_p (parser)
14619 && initialization_kind == CPP_OPEN_PAREN)
14620 if (cp_parser_attributes_opt (parser))
14621 warning (OPT_Wattributes,
14622 "attributes after parenthesized initializer ignored");
14624 /* For an in-class declaration, use `grokfield' to create the
14630 pop_scope (pushed_scope);
14631 pushed_scope = NULL_TREE;
14633 decl = grokfield (declarator, decl_specifiers,
14634 initializer, !is_non_constant_init,
14635 /*asmspec=*/NULL_TREE,
14636 prefix_attributes);
14637 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
14638 cp_parser_save_default_args (parser, decl);
14641 /* Finish processing the declaration. But, skip member
14643 if (!member_p && decl && decl != error_mark_node && !range_for_decl_p)
14645 cp_finish_decl (decl,
14646 initializer, !is_non_constant_init,
14648 /* If the initializer is in parentheses, then this is
14649 a direct-initialization, which means that an
14650 `explicit' constructor is OK. Otherwise, an
14651 `explicit' constructor cannot be used. */
14652 ((is_direct_init || !is_initialized)
14653 ? LOOKUP_NORMAL : LOOKUP_IMPLICIT));
14655 else if ((cxx_dialect != cxx98) && friend_p
14656 && decl && TREE_CODE (decl) == FUNCTION_DECL)
14657 /* Core issue #226 (C++0x only): A default template-argument
14658 shall not be specified in a friend class template
14660 check_default_tmpl_args (decl, current_template_parms, /*is_primary=*/1,
14661 /*is_partial=*/0, /*is_friend_decl=*/1);
14663 if (!friend_p && pushed_scope)
14664 pop_scope (pushed_scope);
14669 /* Parse a declarator.
14673 ptr-operator declarator
14675 abstract-declarator:
14676 ptr-operator abstract-declarator [opt]
14677 direct-abstract-declarator
14682 attributes [opt] direct-declarator
14683 attributes [opt] ptr-operator declarator
14685 abstract-declarator:
14686 attributes [opt] ptr-operator abstract-declarator [opt]
14687 attributes [opt] direct-abstract-declarator
14689 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
14690 detect constructor, destructor or conversion operators. It is set
14691 to -1 if the declarator is a name, and +1 if it is a
14692 function. Otherwise it is set to zero. Usually you just want to
14693 test for >0, but internally the negative value is used.
14695 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
14696 a decl-specifier-seq unless it declares a constructor, destructor,
14697 or conversion. It might seem that we could check this condition in
14698 semantic analysis, rather than parsing, but that makes it difficult
14699 to handle something like `f()'. We want to notice that there are
14700 no decl-specifiers, and therefore realize that this is an
14701 expression, not a declaration.)
14703 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
14704 the declarator is a direct-declarator of the form "(...)".
14706 MEMBER_P is true iff this declarator is a member-declarator. */
14708 static cp_declarator *
14709 cp_parser_declarator (cp_parser* parser,
14710 cp_parser_declarator_kind dcl_kind,
14711 int* ctor_dtor_or_conv_p,
14712 bool* parenthesized_p,
14715 cp_declarator *declarator;
14716 enum tree_code code;
14717 cp_cv_quals cv_quals;
14719 tree attributes = NULL_TREE;
14721 /* Assume this is not a constructor, destructor, or type-conversion
14723 if (ctor_dtor_or_conv_p)
14724 *ctor_dtor_or_conv_p = 0;
14726 if (cp_parser_allow_gnu_extensions_p (parser))
14727 attributes = cp_parser_attributes_opt (parser);
14729 /* Check for the ptr-operator production. */
14730 cp_parser_parse_tentatively (parser);
14731 /* Parse the ptr-operator. */
14732 code = cp_parser_ptr_operator (parser,
14735 /* If that worked, then we have a ptr-operator. */
14736 if (cp_parser_parse_definitely (parser))
14738 /* If a ptr-operator was found, then this declarator was not
14740 if (parenthesized_p)
14741 *parenthesized_p = true;
14742 /* The dependent declarator is optional if we are parsing an
14743 abstract-declarator. */
14744 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
14745 cp_parser_parse_tentatively (parser);
14747 /* Parse the dependent declarator. */
14748 declarator = cp_parser_declarator (parser, dcl_kind,
14749 /*ctor_dtor_or_conv_p=*/NULL,
14750 /*parenthesized_p=*/NULL,
14751 /*member_p=*/false);
14753 /* If we are parsing an abstract-declarator, we must handle the
14754 case where the dependent declarator is absent. */
14755 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
14756 && !cp_parser_parse_definitely (parser))
14759 declarator = cp_parser_make_indirect_declarator
14760 (code, class_type, cv_quals, declarator);
14762 /* Everything else is a direct-declarator. */
14765 if (parenthesized_p)
14766 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
14768 declarator = cp_parser_direct_declarator (parser, dcl_kind,
14769 ctor_dtor_or_conv_p,
14773 if (attributes && declarator && declarator != cp_error_declarator)
14774 declarator->attributes = attributes;
14779 /* Parse a direct-declarator or direct-abstract-declarator.
14783 direct-declarator ( parameter-declaration-clause )
14784 cv-qualifier-seq [opt]
14785 exception-specification [opt]
14786 direct-declarator [ constant-expression [opt] ]
14789 direct-abstract-declarator:
14790 direct-abstract-declarator [opt]
14791 ( parameter-declaration-clause )
14792 cv-qualifier-seq [opt]
14793 exception-specification [opt]
14794 direct-abstract-declarator [opt] [ constant-expression [opt] ]
14795 ( abstract-declarator )
14797 Returns a representation of the declarator. DCL_KIND is
14798 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
14799 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
14800 we are parsing a direct-declarator. It is
14801 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
14802 of ambiguity we prefer an abstract declarator, as per
14803 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
14804 cp_parser_declarator. */
14806 static cp_declarator *
14807 cp_parser_direct_declarator (cp_parser* parser,
14808 cp_parser_declarator_kind dcl_kind,
14809 int* ctor_dtor_or_conv_p,
14813 cp_declarator *declarator = NULL;
14814 tree scope = NULL_TREE;
14815 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
14816 bool saved_in_declarator_p = parser->in_declarator_p;
14818 tree pushed_scope = NULL_TREE;
14822 /* Peek at the next token. */
14823 token = cp_lexer_peek_token (parser->lexer);
14824 if (token->type == CPP_OPEN_PAREN)
14826 /* This is either a parameter-declaration-clause, or a
14827 parenthesized declarator. When we know we are parsing a
14828 named declarator, it must be a parenthesized declarator
14829 if FIRST is true. For instance, `(int)' is a
14830 parameter-declaration-clause, with an omitted
14831 direct-abstract-declarator. But `((*))', is a
14832 parenthesized abstract declarator. Finally, when T is a
14833 template parameter `(T)' is a
14834 parameter-declaration-clause, and not a parenthesized
14837 We first try and parse a parameter-declaration-clause,
14838 and then try a nested declarator (if FIRST is true).
14840 It is not an error for it not to be a
14841 parameter-declaration-clause, even when FIRST is
14847 The first is the declaration of a function while the
14848 second is the definition of a variable, including its
14851 Having seen only the parenthesis, we cannot know which of
14852 these two alternatives should be selected. Even more
14853 complex are examples like:
14858 The former is a function-declaration; the latter is a
14859 variable initialization.
14861 Thus again, we try a parameter-declaration-clause, and if
14862 that fails, we back out and return. */
14864 if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
14867 unsigned saved_num_template_parameter_lists;
14868 bool is_declarator = false;
14871 /* In a member-declarator, the only valid interpretation
14872 of a parenthesis is the start of a
14873 parameter-declaration-clause. (It is invalid to
14874 initialize a static data member with a parenthesized
14875 initializer; only the "=" form of initialization is
14878 cp_parser_parse_tentatively (parser);
14880 /* Consume the `('. */
14881 cp_lexer_consume_token (parser->lexer);
14884 /* If this is going to be an abstract declarator, we're
14885 in a declarator and we can't have default args. */
14886 parser->default_arg_ok_p = false;
14887 parser->in_declarator_p = true;
14890 /* Inside the function parameter list, surrounding
14891 template-parameter-lists do not apply. */
14892 saved_num_template_parameter_lists
14893 = parser->num_template_parameter_lists;
14894 parser->num_template_parameter_lists = 0;
14896 begin_scope (sk_function_parms, NULL_TREE);
14898 /* Parse the parameter-declaration-clause. */
14899 params = cp_parser_parameter_declaration_clause (parser);
14901 parser->num_template_parameter_lists
14902 = saved_num_template_parameter_lists;
14904 /* If all went well, parse the cv-qualifier-seq and the
14905 exception-specification. */
14906 if (member_p || cp_parser_parse_definitely (parser))
14908 cp_cv_quals cv_quals;
14909 cp_virt_specifiers virt_specifiers;
14910 tree exception_specification;
14913 is_declarator = true;
14915 if (ctor_dtor_or_conv_p)
14916 *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
14918 /* Consume the `)'. */
14919 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
14921 /* Parse the cv-qualifier-seq. */
14922 cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
14923 /* And the exception-specification. */
14924 exception_specification
14925 = cp_parser_exception_specification_opt (parser);
14926 /* Parse the virt-specifier-seq. */
14927 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
14930 = cp_parser_late_return_type_opt (parser);
14932 /* Create the function-declarator. */
14933 declarator = make_call_declarator (declarator,
14937 exception_specification,
14939 /* Any subsequent parameter lists are to do with
14940 return type, so are not those of the declared
14942 parser->default_arg_ok_p = false;
14945 /* Remove the function parms from scope. */
14946 for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
14947 pop_binding (DECL_NAME (t), t);
14951 /* Repeat the main loop. */
14955 /* If this is the first, we can try a parenthesized
14959 bool saved_in_type_id_in_expr_p;
14961 parser->default_arg_ok_p = saved_default_arg_ok_p;
14962 parser->in_declarator_p = saved_in_declarator_p;
14964 /* Consume the `('. */
14965 cp_lexer_consume_token (parser->lexer);
14966 /* Parse the nested declarator. */
14967 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
14968 parser->in_type_id_in_expr_p = true;
14970 = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
14971 /*parenthesized_p=*/NULL,
14973 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
14975 /* Expect a `)'. */
14976 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
14977 declarator = cp_error_declarator;
14978 if (declarator == cp_error_declarator)
14981 goto handle_declarator;
14983 /* Otherwise, we must be done. */
14987 else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
14988 && token->type == CPP_OPEN_SQUARE)
14990 /* Parse an array-declarator. */
14993 if (ctor_dtor_or_conv_p)
14994 *ctor_dtor_or_conv_p = 0;
14997 parser->default_arg_ok_p = false;
14998 parser->in_declarator_p = true;
14999 /* Consume the `['. */
15000 cp_lexer_consume_token (parser->lexer);
15001 /* Peek at the next token. */
15002 token = cp_lexer_peek_token (parser->lexer);
15003 /* If the next token is `]', then there is no
15004 constant-expression. */
15005 if (token->type != CPP_CLOSE_SQUARE)
15007 bool non_constant_p;
15010 = cp_parser_constant_expression (parser,
15011 /*allow_non_constant=*/true,
15013 if (!non_constant_p)
15015 /* Normally, the array bound must be an integral constant
15016 expression. However, as an extension, we allow VLAs
15017 in function scopes as long as they aren't part of a
15018 parameter declaration. */
15019 else if (!parser->in_function_body
15020 || current_binding_level->kind == sk_function_parms)
15022 cp_parser_error (parser,
15023 "array bound is not an integer constant");
15024 bounds = error_mark_node;
15026 else if (processing_template_decl && !error_operand_p (bounds))
15028 /* Remember this wasn't a constant-expression. */
15029 bounds = build_nop (TREE_TYPE (bounds), bounds);
15030 TREE_SIDE_EFFECTS (bounds) = 1;
15034 bounds = NULL_TREE;
15035 /* Look for the closing `]'. */
15036 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
15038 declarator = cp_error_declarator;
15042 declarator = make_array_declarator (declarator, bounds);
15044 else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
15047 tree qualifying_scope;
15048 tree unqualified_name;
15049 special_function_kind sfk;
15051 bool pack_expansion_p = false;
15052 cp_token *declarator_id_start_token;
15054 /* Parse a declarator-id */
15055 abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
15058 cp_parser_parse_tentatively (parser);
15060 /* If we see an ellipsis, we should be looking at a
15062 if (token->type == CPP_ELLIPSIS)
15064 /* Consume the `...' */
15065 cp_lexer_consume_token (parser->lexer);
15067 pack_expansion_p = true;
15071 declarator_id_start_token = cp_lexer_peek_token (parser->lexer);
15073 = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
15074 qualifying_scope = parser->scope;
15079 if (!unqualified_name && pack_expansion_p)
15081 /* Check whether an error occurred. */
15082 okay = !cp_parser_error_occurred (parser);
15084 /* We already consumed the ellipsis to mark a
15085 parameter pack, but we have no way to report it,
15086 so abort the tentative parse. We will be exiting
15087 immediately anyway. */
15088 cp_parser_abort_tentative_parse (parser);
15091 okay = cp_parser_parse_definitely (parser);
15094 unqualified_name = error_mark_node;
15095 else if (unqualified_name
15096 && (qualifying_scope
15097 || (TREE_CODE (unqualified_name)
15098 != IDENTIFIER_NODE)))
15100 cp_parser_error (parser, "expected unqualified-id");
15101 unqualified_name = error_mark_node;
15105 if (!unqualified_name)
15107 if (unqualified_name == error_mark_node)
15109 declarator = cp_error_declarator;
15110 pack_expansion_p = false;
15111 declarator->parameter_pack_p = false;
15115 if (qualifying_scope && at_namespace_scope_p ()
15116 && TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
15118 /* In the declaration of a member of a template class
15119 outside of the class itself, the SCOPE will sometimes
15120 be a TYPENAME_TYPE. For example, given:
15122 template <typename T>
15123 int S<T>::R::i = 3;
15125 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
15126 this context, we must resolve S<T>::R to an ordinary
15127 type, rather than a typename type.
15129 The reason we normally avoid resolving TYPENAME_TYPEs
15130 is that a specialization of `S' might render
15131 `S<T>::R' not a type. However, if `S' is
15132 specialized, then this `i' will not be used, so there
15133 is no harm in resolving the types here. */
15136 /* Resolve the TYPENAME_TYPE. */
15137 type = resolve_typename_type (qualifying_scope,
15138 /*only_current_p=*/false);
15139 /* If that failed, the declarator is invalid. */
15140 if (TREE_CODE (type) == TYPENAME_TYPE)
15142 if (typedef_variant_p (type))
15143 error_at (declarator_id_start_token->location,
15144 "cannot define member of dependent typedef "
15147 error_at (declarator_id_start_token->location,
15148 "%<%T::%E%> is not a type",
15149 TYPE_CONTEXT (qualifying_scope),
15150 TYPE_IDENTIFIER (qualifying_scope));
15152 qualifying_scope = type;
15157 if (unqualified_name)
15161 if (qualifying_scope
15162 && CLASS_TYPE_P (qualifying_scope))
15163 class_type = qualifying_scope;
15165 class_type = current_class_type;
15167 if (TREE_CODE (unqualified_name) == TYPE_DECL)
15169 tree name_type = TREE_TYPE (unqualified_name);
15170 if (class_type && same_type_p (name_type, class_type))
15172 if (qualifying_scope
15173 && CLASSTYPE_USE_TEMPLATE (name_type))
15175 error_at (declarator_id_start_token->location,
15176 "invalid use of constructor as a template");
15177 inform (declarator_id_start_token->location,
15178 "use %<%T::%D%> instead of %<%T::%D%> to "
15179 "name the constructor in a qualified name",
15181 DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
15182 class_type, name_type);
15183 declarator = cp_error_declarator;
15187 unqualified_name = constructor_name (class_type);
15191 /* We do not attempt to print the declarator
15192 here because we do not have enough
15193 information about its original syntactic
15195 cp_parser_error (parser, "invalid declarator");
15196 declarator = cp_error_declarator;
15203 if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
15204 sfk = sfk_destructor;
15205 else if (IDENTIFIER_TYPENAME_P (unqualified_name))
15206 sfk = sfk_conversion;
15207 else if (/* There's no way to declare a constructor
15208 for an anonymous type, even if the type
15209 got a name for linkage purposes. */
15210 !TYPE_WAS_ANONYMOUS (class_type)
15211 && constructor_name_p (unqualified_name,
15214 unqualified_name = constructor_name (class_type);
15215 sfk = sfk_constructor;
15217 else if (is_overloaded_fn (unqualified_name)
15218 && DECL_CONSTRUCTOR_P (get_first_fn
15219 (unqualified_name)))
15220 sfk = sfk_constructor;
15222 if (ctor_dtor_or_conv_p && sfk != sfk_none)
15223 *ctor_dtor_or_conv_p = -1;
15226 declarator = make_id_declarator (qualifying_scope,
15229 declarator->id_loc = token->location;
15230 declarator->parameter_pack_p = pack_expansion_p;
15232 if (pack_expansion_p)
15233 maybe_warn_variadic_templates ();
15236 handle_declarator:;
15237 scope = get_scope_of_declarator (declarator);
15239 /* Any names that appear after the declarator-id for a
15240 member are looked up in the containing scope. */
15241 pushed_scope = push_scope (scope);
15242 parser->in_declarator_p = true;
15243 if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
15244 || (declarator && declarator->kind == cdk_id))
15245 /* Default args are only allowed on function
15247 parser->default_arg_ok_p = saved_default_arg_ok_p;
15249 parser->default_arg_ok_p = false;
15258 /* For an abstract declarator, we might wind up with nothing at this
15259 point. That's an error; the declarator is not optional. */
15261 cp_parser_error (parser, "expected declarator");
15263 /* If we entered a scope, we must exit it now. */
15265 pop_scope (pushed_scope);
15267 parser->default_arg_ok_p = saved_default_arg_ok_p;
15268 parser->in_declarator_p = saved_in_declarator_p;
15273 /* Parse a ptr-operator.
15276 * cv-qualifier-seq [opt]
15278 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
15283 & cv-qualifier-seq [opt]
15285 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
15286 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
15287 an rvalue reference. In the case of a pointer-to-member, *TYPE is
15288 filled in with the TYPE containing the member. *CV_QUALS is
15289 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
15290 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
15291 Note that the tree codes returned by this function have nothing
15292 to do with the types of trees that will be eventually be created
15293 to represent the pointer or reference type being parsed. They are
15294 just constants with suggestive names. */
15295 static enum tree_code
15296 cp_parser_ptr_operator (cp_parser* parser,
15298 cp_cv_quals *cv_quals)
15300 enum tree_code code = ERROR_MARK;
15303 /* Assume that it's not a pointer-to-member. */
15305 /* And that there are no cv-qualifiers. */
15306 *cv_quals = TYPE_UNQUALIFIED;
15308 /* Peek at the next token. */
15309 token = cp_lexer_peek_token (parser->lexer);
15311 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
15312 if (token->type == CPP_MULT)
15313 code = INDIRECT_REF;
15314 else if (token->type == CPP_AND)
15316 else if ((cxx_dialect != cxx98) &&
15317 token->type == CPP_AND_AND) /* C++0x only */
15318 code = NON_LVALUE_EXPR;
15320 if (code != ERROR_MARK)
15322 /* Consume the `*', `&' or `&&'. */
15323 cp_lexer_consume_token (parser->lexer);
15325 /* A `*' can be followed by a cv-qualifier-seq, and so can a
15326 `&', if we are allowing GNU extensions. (The only qualifier
15327 that can legally appear after `&' is `restrict', but that is
15328 enforced during semantic analysis. */
15329 if (code == INDIRECT_REF
15330 || cp_parser_allow_gnu_extensions_p (parser))
15331 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
15335 /* Try the pointer-to-member case. */
15336 cp_parser_parse_tentatively (parser);
15337 /* Look for the optional `::' operator. */
15338 cp_parser_global_scope_opt (parser,
15339 /*current_scope_valid_p=*/false);
15340 /* Look for the nested-name specifier. */
15341 token = cp_lexer_peek_token (parser->lexer);
15342 cp_parser_nested_name_specifier (parser,
15343 /*typename_keyword_p=*/false,
15344 /*check_dependency_p=*/true,
15346 /*is_declaration=*/false);
15347 /* If we found it, and the next token is a `*', then we are
15348 indeed looking at a pointer-to-member operator. */
15349 if (!cp_parser_error_occurred (parser)
15350 && cp_parser_require (parser, CPP_MULT, RT_MULT))
15352 /* Indicate that the `*' operator was used. */
15353 code = INDIRECT_REF;
15355 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
15356 error_at (token->location, "%qD is a namespace", parser->scope);
15359 /* The type of which the member is a member is given by the
15361 *type = parser->scope;
15362 /* The next name will not be qualified. */
15363 parser->scope = NULL_TREE;
15364 parser->qualifying_scope = NULL_TREE;
15365 parser->object_scope = NULL_TREE;
15366 /* Look for the optional cv-qualifier-seq. */
15367 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
15370 /* If that didn't work we don't have a ptr-operator. */
15371 if (!cp_parser_parse_definitely (parser))
15372 cp_parser_error (parser, "expected ptr-operator");
15378 /* Parse an (optional) cv-qualifier-seq.
15381 cv-qualifier cv-qualifier-seq [opt]
15392 Returns a bitmask representing the cv-qualifiers. */
15395 cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
15397 cp_cv_quals cv_quals = TYPE_UNQUALIFIED;
15402 cp_cv_quals cv_qualifier;
15404 /* Peek at the next token. */
15405 token = cp_lexer_peek_token (parser->lexer);
15406 /* See if it's a cv-qualifier. */
15407 switch (token->keyword)
15410 cv_qualifier = TYPE_QUAL_CONST;
15414 cv_qualifier = TYPE_QUAL_VOLATILE;
15418 cv_qualifier = TYPE_QUAL_RESTRICT;
15422 cv_qualifier = TYPE_UNQUALIFIED;
15429 if (cv_quals & cv_qualifier)
15431 error_at (token->location, "duplicate cv-qualifier");
15432 cp_lexer_purge_token (parser->lexer);
15436 cp_lexer_consume_token (parser->lexer);
15437 cv_quals |= cv_qualifier;
15444 /* Parse an (optional) virt-specifier-seq.
15446 virt-specifier-seq:
15447 virt-specifier virt-specifier-seq [opt]
15453 Returns a bitmask representing the virt-specifiers. */
15455 static cp_virt_specifiers
15456 cp_parser_virt_specifier_seq_opt (cp_parser* parser)
15458 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
15463 cp_virt_specifiers virt_specifier;
15465 /* Peek at the next token. */
15466 token = cp_lexer_peek_token (parser->lexer);
15467 /* See if it's a virt-specifier-qualifier. */
15468 if (token->type != CPP_NAME)
15470 if (!strcmp (IDENTIFIER_POINTER(token->u.value), "override"))
15471 virt_specifier = VIRT_SPEC_OVERRIDE;
15472 else if (!strcmp (IDENTIFIER_POINTER(token->u.value), "final"))
15473 virt_specifier = VIRT_SPEC_FINAL;
15477 if (virt_specifiers & virt_specifier)
15479 error_at (token->location, "duplicate virt-specifier");
15480 cp_lexer_purge_token (parser->lexer);
15484 cp_lexer_consume_token (parser->lexer);
15485 virt_specifiers |= virt_specifier;
15488 return virt_specifiers;
15491 /* Parse a late-specified return type, if any. This is not a separate
15492 non-terminal, but part of a function declarator, which looks like
15494 -> trailing-type-specifier-seq abstract-declarator(opt)
15496 Returns the type indicated by the type-id. */
15499 cp_parser_late_return_type_opt (cp_parser* parser)
15503 /* Peek at the next token. */
15504 token = cp_lexer_peek_token (parser->lexer);
15505 /* A late-specified return type is indicated by an initial '->'. */
15506 if (token->type != CPP_DEREF)
15509 /* Consume the ->. */
15510 cp_lexer_consume_token (parser->lexer);
15512 return cp_parser_trailing_type_id (parser);
15515 /* Parse a declarator-id.
15519 :: [opt] nested-name-specifier [opt] type-name
15521 In the `id-expression' case, the value returned is as for
15522 cp_parser_id_expression if the id-expression was an unqualified-id.
15523 If the id-expression was a qualified-id, then a SCOPE_REF is
15524 returned. The first operand is the scope (either a NAMESPACE_DECL
15525 or TREE_TYPE), but the second is still just a representation of an
15529 cp_parser_declarator_id (cp_parser* parser, bool optional_p)
15532 /* The expression must be an id-expression. Assume that qualified
15533 names are the names of types so that:
15536 int S<T>::R::i = 3;
15538 will work; we must treat `S<T>::R' as the name of a type.
15539 Similarly, assume that qualified names are templates, where
15543 int S<T>::R<T>::i = 3;
15546 id = cp_parser_id_expression (parser,
15547 /*template_keyword_p=*/false,
15548 /*check_dependency_p=*/false,
15549 /*template_p=*/NULL,
15550 /*declarator_p=*/true,
15552 if (id && BASELINK_P (id))
15553 id = BASELINK_FUNCTIONS (id);
15557 /* Parse a type-id.
15560 type-specifier-seq abstract-declarator [opt]
15562 Returns the TYPE specified. */
15565 cp_parser_type_id_1 (cp_parser* parser, bool is_template_arg,
15566 bool is_trailing_return)
15568 cp_decl_specifier_seq type_specifier_seq;
15569 cp_declarator *abstract_declarator;
15571 /* Parse the type-specifier-seq. */
15572 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
15573 is_trailing_return,
15574 &type_specifier_seq);
15575 if (type_specifier_seq.type == error_mark_node)
15576 return error_mark_node;
15578 /* There might or might not be an abstract declarator. */
15579 cp_parser_parse_tentatively (parser);
15580 /* Look for the declarator. */
15581 abstract_declarator
15582 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
15583 /*parenthesized_p=*/NULL,
15584 /*member_p=*/false);
15585 /* Check to see if there really was a declarator. */
15586 if (!cp_parser_parse_definitely (parser))
15587 abstract_declarator = NULL;
15589 if (type_specifier_seq.type
15590 && type_uses_auto (type_specifier_seq.type))
15592 /* A type-id with type 'auto' is only ok if the abstract declarator
15593 is a function declarator with a late-specified return type. */
15594 if (abstract_declarator
15595 && abstract_declarator->kind == cdk_function
15596 && abstract_declarator->u.function.late_return_type)
15600 error ("invalid use of %<auto%>");
15601 return error_mark_node;
15605 return groktypename (&type_specifier_seq, abstract_declarator,
15609 static tree cp_parser_type_id (cp_parser *parser)
15611 return cp_parser_type_id_1 (parser, false, false);
15614 static tree cp_parser_template_type_arg (cp_parser *parser)
15617 const char *saved_message = parser->type_definition_forbidden_message;
15618 parser->type_definition_forbidden_message
15619 = G_("types may not be defined in template arguments");
15620 r = cp_parser_type_id_1 (parser, true, false);
15621 parser->type_definition_forbidden_message = saved_message;
15625 static tree cp_parser_trailing_type_id (cp_parser *parser)
15627 return cp_parser_type_id_1 (parser, false, true);
15630 /* Parse a type-specifier-seq.
15632 type-specifier-seq:
15633 type-specifier type-specifier-seq [opt]
15637 type-specifier-seq:
15638 attributes type-specifier-seq [opt]
15640 If IS_DECLARATION is true, we are at the start of a "condition" or
15641 exception-declaration, so we might be followed by a declarator-id.
15643 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
15644 i.e. we've just seen "->".
15646 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
15649 cp_parser_type_specifier_seq (cp_parser* parser,
15650 bool is_declaration,
15651 bool is_trailing_return,
15652 cp_decl_specifier_seq *type_specifier_seq)
15654 bool seen_type_specifier = false;
15655 cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;
15656 cp_token *start_token = NULL;
15658 /* Clear the TYPE_SPECIFIER_SEQ. */
15659 clear_decl_specs (type_specifier_seq);
15661 /* In the context of a trailing return type, enum E { } is an
15662 elaborated-type-specifier followed by a function-body, not an
15664 if (is_trailing_return)
15665 flags |= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS;
15667 /* Parse the type-specifiers and attributes. */
15670 tree type_specifier;
15671 bool is_cv_qualifier;
15673 /* Check for attributes first. */
15674 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
15676 type_specifier_seq->attributes =
15677 chainon (type_specifier_seq->attributes,
15678 cp_parser_attributes_opt (parser));
15682 /* record the token of the beginning of the type specifier seq,
15683 for error reporting purposes*/
15685 start_token = cp_lexer_peek_token (parser->lexer);
15687 /* Look for the type-specifier. */
15688 type_specifier = cp_parser_type_specifier (parser,
15690 type_specifier_seq,
15691 /*is_declaration=*/false,
15694 if (!type_specifier)
15696 /* If the first type-specifier could not be found, this is not a
15697 type-specifier-seq at all. */
15698 if (!seen_type_specifier)
15700 cp_parser_error (parser, "expected type-specifier");
15701 type_specifier_seq->type = error_mark_node;
15704 /* If subsequent type-specifiers could not be found, the
15705 type-specifier-seq is complete. */
15709 seen_type_specifier = true;
15710 /* The standard says that a condition can be:
15712 type-specifier-seq declarator = assignment-expression
15719 we should treat the "S" as a declarator, not as a
15720 type-specifier. The standard doesn't say that explicitly for
15721 type-specifier-seq, but it does say that for
15722 decl-specifier-seq in an ordinary declaration. Perhaps it
15723 would be clearer just to allow a decl-specifier-seq here, and
15724 then add a semantic restriction that if any decl-specifiers
15725 that are not type-specifiers appear, the program is invalid. */
15726 if (is_declaration && !is_cv_qualifier)
15727 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
15730 cp_parser_check_decl_spec (type_specifier_seq, start_token->location);
15733 /* Parse a parameter-declaration-clause.
15735 parameter-declaration-clause:
15736 parameter-declaration-list [opt] ... [opt]
15737 parameter-declaration-list , ...
15739 Returns a representation for the parameter declarations. A return
15740 value of NULL indicates a parameter-declaration-clause consisting
15741 only of an ellipsis. */
15744 cp_parser_parameter_declaration_clause (cp_parser* parser)
15751 /* Peek at the next token. */
15752 token = cp_lexer_peek_token (parser->lexer);
15753 /* Check for trivial parameter-declaration-clauses. */
15754 if (token->type == CPP_ELLIPSIS)
15756 /* Consume the `...' token. */
15757 cp_lexer_consume_token (parser->lexer);
15760 else if (token->type == CPP_CLOSE_PAREN)
15761 /* There are no parameters. */
15763 #ifndef NO_IMPLICIT_EXTERN_C
15764 if (in_system_header && current_class_type == NULL
15765 && current_lang_name == lang_name_c)
15769 return void_list_node;
15771 /* Check for `(void)', too, which is a special case. */
15772 else if (token->keyword == RID_VOID
15773 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
15774 == CPP_CLOSE_PAREN))
15776 /* Consume the `void' token. */
15777 cp_lexer_consume_token (parser->lexer);
15778 /* There are no parameters. */
15779 return void_list_node;
15782 /* Parse the parameter-declaration-list. */
15783 parameters = cp_parser_parameter_declaration_list (parser, &is_error);
15784 /* If a parse error occurred while parsing the
15785 parameter-declaration-list, then the entire
15786 parameter-declaration-clause is erroneous. */
15790 /* Peek at the next token. */
15791 token = cp_lexer_peek_token (parser->lexer);
15792 /* If it's a `,', the clause should terminate with an ellipsis. */
15793 if (token->type == CPP_COMMA)
15795 /* Consume the `,'. */
15796 cp_lexer_consume_token (parser->lexer);
15797 /* Expect an ellipsis. */
15799 = (cp_parser_require (parser, CPP_ELLIPSIS, RT_ELLIPSIS) != NULL);
15801 /* It might also be `...' if the optional trailing `,' was
15803 else if (token->type == CPP_ELLIPSIS)
15805 /* Consume the `...' token. */
15806 cp_lexer_consume_token (parser->lexer);
15807 /* And remember that we saw it. */
15811 ellipsis_p = false;
15813 /* Finish the parameter list. */
15815 parameters = chainon (parameters, void_list_node);
15820 /* Parse a parameter-declaration-list.
15822 parameter-declaration-list:
15823 parameter-declaration
15824 parameter-declaration-list , parameter-declaration
15826 Returns a representation of the parameter-declaration-list, as for
15827 cp_parser_parameter_declaration_clause. However, the
15828 `void_list_node' is never appended to the list. Upon return,
15829 *IS_ERROR will be true iff an error occurred. */
15832 cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error)
15834 tree parameters = NULL_TREE;
15835 tree *tail = ¶meters;
15836 bool saved_in_unbraced_linkage_specification_p;
15839 /* Assume all will go well. */
15841 /* The special considerations that apply to a function within an
15842 unbraced linkage specifications do not apply to the parameters
15843 to the function. */
15844 saved_in_unbraced_linkage_specification_p
15845 = parser->in_unbraced_linkage_specification_p;
15846 parser->in_unbraced_linkage_specification_p = false;
15848 /* Look for more parameters. */
15851 cp_parameter_declarator *parameter;
15852 tree decl = error_mark_node;
15853 bool parenthesized_p;
15854 /* Parse the parameter. */
15856 = cp_parser_parameter_declaration (parser,
15857 /*template_parm_p=*/false,
15860 /* We don't know yet if the enclosing context is deprecated, so wait
15861 and warn in grokparms if appropriate. */
15862 deprecated_state = DEPRECATED_SUPPRESS;
15865 decl = grokdeclarator (parameter->declarator,
15866 ¶meter->decl_specifiers,
15868 parameter->default_argument != NULL_TREE,
15869 ¶meter->decl_specifiers.attributes);
15871 deprecated_state = DEPRECATED_NORMAL;
15873 /* If a parse error occurred parsing the parameter declaration,
15874 then the entire parameter-declaration-list is erroneous. */
15875 if (decl == error_mark_node)
15878 parameters = error_mark_node;
15882 if (parameter->decl_specifiers.attributes)
15883 cplus_decl_attributes (&decl,
15884 parameter->decl_specifiers.attributes,
15886 if (DECL_NAME (decl))
15887 decl = pushdecl (decl);
15889 if (decl != error_mark_node)
15891 retrofit_lang_decl (decl);
15892 DECL_PARM_INDEX (decl) = ++index;
15893 DECL_PARM_LEVEL (decl) = function_parm_depth ();
15896 /* Add the new parameter to the list. */
15897 *tail = build_tree_list (parameter->default_argument, decl);
15898 tail = &TREE_CHAIN (*tail);
15900 /* Peek at the next token. */
15901 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
15902 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
15903 /* These are for Objective-C++ */
15904 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
15905 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15906 /* The parameter-declaration-list is complete. */
15908 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
15912 /* Peek at the next token. */
15913 token = cp_lexer_peek_nth_token (parser->lexer, 2);
15914 /* If it's an ellipsis, then the list is complete. */
15915 if (token->type == CPP_ELLIPSIS)
15917 /* Otherwise, there must be more parameters. Consume the
15919 cp_lexer_consume_token (parser->lexer);
15920 /* When parsing something like:
15922 int i(float f, double d)
15924 we can tell after seeing the declaration for "f" that we
15925 are not looking at an initialization of a variable "i",
15926 but rather at the declaration of a function "i".
15928 Due to the fact that the parsing of template arguments
15929 (as specified to a template-id) requires backtracking we
15930 cannot use this technique when inside a template argument
15932 if (!parser->in_template_argument_list_p
15933 && !parser->in_type_id_in_expr_p
15934 && cp_parser_uncommitted_to_tentative_parse_p (parser)
15935 /* However, a parameter-declaration of the form
15936 "foat(f)" (which is a valid declaration of a
15937 parameter "f") can also be interpreted as an
15938 expression (the conversion of "f" to "float"). */
15939 && !parenthesized_p)
15940 cp_parser_commit_to_tentative_parse (parser);
15944 cp_parser_error (parser, "expected %<,%> or %<...%>");
15945 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
15946 cp_parser_skip_to_closing_parenthesis (parser,
15947 /*recovering=*/true,
15948 /*or_comma=*/false,
15949 /*consume_paren=*/false);
15954 parser->in_unbraced_linkage_specification_p
15955 = saved_in_unbraced_linkage_specification_p;
15960 /* Parse a parameter declaration.
15962 parameter-declaration:
15963 decl-specifier-seq ... [opt] declarator
15964 decl-specifier-seq declarator = assignment-expression
15965 decl-specifier-seq ... [opt] abstract-declarator [opt]
15966 decl-specifier-seq abstract-declarator [opt] = assignment-expression
15968 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
15969 declares a template parameter. (In that case, a non-nested `>'
15970 token encountered during the parsing of the assignment-expression
15971 is not interpreted as a greater-than operator.)
15973 Returns a representation of the parameter, or NULL if an error
15974 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
15975 true iff the declarator is of the form "(p)". */
15977 static cp_parameter_declarator *
15978 cp_parser_parameter_declaration (cp_parser *parser,
15979 bool template_parm_p,
15980 bool *parenthesized_p)
15982 int declares_class_or_enum;
15983 cp_decl_specifier_seq decl_specifiers;
15984 cp_declarator *declarator;
15985 tree default_argument;
15986 cp_token *token = NULL, *declarator_token_start = NULL;
15987 const char *saved_message;
15989 /* In a template parameter, `>' is not an operator.
15993 When parsing a default template-argument for a non-type
15994 template-parameter, the first non-nested `>' is taken as the end
15995 of the template parameter-list rather than a greater-than
15998 /* Type definitions may not appear in parameter types. */
15999 saved_message = parser->type_definition_forbidden_message;
16000 parser->type_definition_forbidden_message
16001 = G_("types may not be defined in parameter types");
16003 /* Parse the declaration-specifiers. */
16004 cp_parser_decl_specifier_seq (parser,
16005 CP_PARSER_FLAGS_NONE,
16007 &declares_class_or_enum);
16009 /* Complain about missing 'typename' or other invalid type names. */
16010 if (!decl_specifiers.any_type_specifiers_p)
16011 cp_parser_parse_and_diagnose_invalid_type_name (parser);
16013 /* If an error occurred, there's no reason to attempt to parse the
16014 rest of the declaration. */
16015 if (cp_parser_error_occurred (parser))
16017 parser->type_definition_forbidden_message = saved_message;
16021 /* Peek at the next token. */
16022 token = cp_lexer_peek_token (parser->lexer);
16024 /* If the next token is a `)', `,', `=', `>', or `...', then there
16025 is no declarator. However, when variadic templates are enabled,
16026 there may be a declarator following `...'. */
16027 if (token->type == CPP_CLOSE_PAREN
16028 || token->type == CPP_COMMA
16029 || token->type == CPP_EQ
16030 || token->type == CPP_GREATER)
16033 if (parenthesized_p)
16034 *parenthesized_p = false;
16036 /* Otherwise, there should be a declarator. */
16039 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
16040 parser->default_arg_ok_p = false;
16042 /* After seeing a decl-specifier-seq, if the next token is not a
16043 "(", there is no possibility that the code is a valid
16044 expression. Therefore, if parsing tentatively, we commit at
16046 if (!parser->in_template_argument_list_p
16047 /* In an expression context, having seen:
16051 we cannot be sure whether we are looking at a
16052 function-type (taking a "char" as a parameter) or a cast
16053 of some object of type "char" to "int". */
16054 && !parser->in_type_id_in_expr_p
16055 && cp_parser_uncommitted_to_tentative_parse_p (parser)
16056 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
16057 cp_parser_commit_to_tentative_parse (parser);
16058 /* Parse the declarator. */
16059 declarator_token_start = token;
16060 declarator = cp_parser_declarator (parser,
16061 CP_PARSER_DECLARATOR_EITHER,
16062 /*ctor_dtor_or_conv_p=*/NULL,
16064 /*member_p=*/false);
16065 parser->default_arg_ok_p = saved_default_arg_ok_p;
16066 /* After the declarator, allow more attributes. */
16067 decl_specifiers.attributes
16068 = chainon (decl_specifiers.attributes,
16069 cp_parser_attributes_opt (parser));
16072 /* If the next token is an ellipsis, and we have not seen a
16073 declarator name, and the type of the declarator contains parameter
16074 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
16075 a parameter pack expansion expression. Otherwise, leave the
16076 ellipsis for a C-style variadic function. */
16077 token = cp_lexer_peek_token (parser->lexer);
16078 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16080 tree type = decl_specifiers.type;
16082 if (type && DECL_P (type))
16083 type = TREE_TYPE (type);
16086 && TREE_CODE (type) != TYPE_PACK_EXPANSION
16087 && declarator_can_be_parameter_pack (declarator)
16088 && (!declarator || !declarator->parameter_pack_p)
16089 && uses_parameter_packs (type))
16091 /* Consume the `...'. */
16092 cp_lexer_consume_token (parser->lexer);
16093 maybe_warn_variadic_templates ();
16095 /* Build a pack expansion type */
16097 declarator->parameter_pack_p = true;
16099 decl_specifiers.type = make_pack_expansion (type);
16103 /* The restriction on defining new types applies only to the type
16104 of the parameter, not to the default argument. */
16105 parser->type_definition_forbidden_message = saved_message;
16107 /* If the next token is `=', then process a default argument. */
16108 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
16110 /* Consume the `='. */
16111 cp_lexer_consume_token (parser->lexer);
16113 /* If we are defining a class, then the tokens that make up the
16114 default argument must be saved and processed later. */
16115 if (!template_parm_p && at_class_scope_p ()
16116 && TYPE_BEING_DEFINED (current_class_type)
16117 && !LAMBDA_TYPE_P (current_class_type))
16119 unsigned depth = 0;
16120 int maybe_template_id = 0;
16121 cp_token *first_token;
16124 /* Add tokens until we have processed the entire default
16125 argument. We add the range [first_token, token). */
16126 first_token = cp_lexer_peek_token (parser->lexer);
16131 /* Peek at the next token. */
16132 token = cp_lexer_peek_token (parser->lexer);
16133 /* What we do depends on what token we have. */
16134 switch (token->type)
16136 /* In valid code, a default argument must be
16137 immediately followed by a `,' `)', or `...'. */
16139 if (depth == 0 && maybe_template_id)
16141 /* If we've seen a '<', we might be in a
16142 template-argument-list. Until Core issue 325 is
16143 resolved, we don't know how this situation ought
16144 to be handled, so try to DTRT. We check whether
16145 what comes after the comma is a valid parameter
16146 declaration list. If it is, then the comma ends
16147 the default argument; otherwise the default
16148 argument continues. */
16149 bool error = false;
16152 /* Set ITALP so cp_parser_parameter_declaration_list
16153 doesn't decide to commit to this parse. */
16154 bool saved_italp = parser->in_template_argument_list_p;
16155 parser->in_template_argument_list_p = true;
16157 cp_parser_parse_tentatively (parser);
16158 cp_lexer_consume_token (parser->lexer);
16159 begin_scope (sk_function_parms, NULL_TREE);
16160 cp_parser_parameter_declaration_list (parser, &error);
16161 for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
16162 pop_binding (DECL_NAME (t), t);
16164 if (!cp_parser_error_occurred (parser) && !error)
16166 cp_parser_abort_tentative_parse (parser);
16168 parser->in_template_argument_list_p = saved_italp;
16171 case CPP_CLOSE_PAREN:
16173 /* If we run into a non-nested `;', `}', or `]',
16174 then the code is invalid -- but the default
16175 argument is certainly over. */
16176 case CPP_SEMICOLON:
16177 case CPP_CLOSE_BRACE:
16178 case CPP_CLOSE_SQUARE:
16181 /* Update DEPTH, if necessary. */
16182 else if (token->type == CPP_CLOSE_PAREN
16183 || token->type == CPP_CLOSE_BRACE
16184 || token->type == CPP_CLOSE_SQUARE)
16188 case CPP_OPEN_PAREN:
16189 case CPP_OPEN_SQUARE:
16190 case CPP_OPEN_BRACE:
16196 /* This might be the comparison operator, or it might
16197 start a template argument list. */
16198 ++maybe_template_id;
16202 if (cxx_dialect == cxx98)
16204 /* Fall through for C++0x, which treats the `>>'
16205 operator like two `>' tokens in certain
16211 /* This might be an operator, or it might close a
16212 template argument list. But if a previous '<'
16213 started a template argument list, this will have
16214 closed it, so we can't be in one anymore. */
16215 maybe_template_id -= 1 + (token->type == CPP_RSHIFT);
16216 if (maybe_template_id < 0)
16217 maybe_template_id = 0;
16221 /* If we run out of tokens, issue an error message. */
16223 case CPP_PRAGMA_EOL:
16224 error_at (token->location, "file ends in default argument");
16230 /* In these cases, we should look for template-ids.
16231 For example, if the default argument is
16232 `X<int, double>()', we need to do name lookup to
16233 figure out whether or not `X' is a template; if
16234 so, the `,' does not end the default argument.
16236 That is not yet done. */
16243 /* If we've reached the end, stop. */
16247 /* Add the token to the token block. */
16248 token = cp_lexer_consume_token (parser->lexer);
16251 /* Create a DEFAULT_ARG to represent the unparsed default
16253 default_argument = make_node (DEFAULT_ARG);
16254 DEFARG_TOKENS (default_argument)
16255 = cp_token_cache_new (first_token, token);
16256 DEFARG_INSTANTIATIONS (default_argument) = NULL;
16258 /* Outside of a class definition, we can just parse the
16259 assignment-expression. */
16262 token = cp_lexer_peek_token (parser->lexer);
16264 = cp_parser_default_argument (parser, template_parm_p);
16267 if (!parser->default_arg_ok_p)
16269 if (flag_permissive)
16270 warning (0, "deprecated use of default argument for parameter of non-function");
16273 error_at (token->location,
16274 "default arguments are only "
16275 "permitted for function parameters");
16276 default_argument = NULL_TREE;
16279 else if ((declarator && declarator->parameter_pack_p)
16280 || (decl_specifiers.type
16281 && PACK_EXPANSION_P (decl_specifiers.type)))
16283 /* Find the name of the parameter pack. */
16284 cp_declarator *id_declarator = declarator;
16285 while (id_declarator && id_declarator->kind != cdk_id)
16286 id_declarator = id_declarator->declarator;
16288 if (id_declarator && id_declarator->kind == cdk_id)
16289 error_at (declarator_token_start->location,
16291 ? "template parameter pack %qD"
16292 " cannot have a default argument"
16293 : "parameter pack %qD cannot have a default argument",
16294 id_declarator->u.id.unqualified_name);
16296 error_at (declarator_token_start->location,
16298 ? "template parameter pack cannot have a default argument"
16299 : "parameter pack cannot have a default argument");
16301 default_argument = NULL_TREE;
16305 default_argument = NULL_TREE;
16307 return make_parameter_declarator (&decl_specifiers,
16312 /* Parse a default argument and return it.
16314 TEMPLATE_PARM_P is true if this is a default argument for a
16315 non-type template parameter. */
16317 cp_parser_default_argument (cp_parser *parser, bool template_parm_p)
16319 tree default_argument = NULL_TREE;
16320 bool saved_greater_than_is_operator_p;
16321 bool saved_local_variables_forbidden_p;
16323 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
16325 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
16326 parser->greater_than_is_operator_p = !template_parm_p;
16327 /* Local variable names (and the `this' keyword) may not
16328 appear in a default argument. */
16329 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
16330 parser->local_variables_forbidden_p = true;
16331 /* Parse the assignment-expression. */
16332 if (template_parm_p)
16333 push_deferring_access_checks (dk_no_deferred);
16335 = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
16336 if (template_parm_p)
16337 pop_deferring_access_checks ();
16338 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
16339 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
16341 return default_argument;
16344 /* Parse a function-body.
16347 compound_statement */
16350 cp_parser_function_body (cp_parser *parser)
16352 cp_parser_compound_statement (parser, NULL, false, true);
16355 /* Parse a ctor-initializer-opt followed by a function-body. Return
16356 true if a ctor-initializer was present. */
16359 cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser)
16362 bool ctor_initializer_p;
16363 const bool check_body_p =
16364 DECL_CONSTRUCTOR_P (current_function_decl)
16365 && DECL_DECLARED_CONSTEXPR_P (current_function_decl);
16368 /* Begin the function body. */
16369 body = begin_function_body ();
16370 /* Parse the optional ctor-initializer. */
16371 ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
16373 /* If we're parsing a constexpr constructor definition, we need
16374 to check that the constructor body is indeed empty. However,
16375 before we get to cp_parser_function_body lot of junk has been
16376 generated, so we can't just check that we have an empty block.
16377 Rather we take a snapshot of the outermost block, and check whether
16378 cp_parser_function_body changed its state. */
16382 if (TREE_CODE (list) == BIND_EXPR)
16383 list = BIND_EXPR_BODY (list);
16384 if (TREE_CODE (list) == STATEMENT_LIST
16385 && STATEMENT_LIST_TAIL (list) != NULL)
16386 last = STATEMENT_LIST_TAIL (list)->stmt;
16388 /* Parse the function-body. */
16389 cp_parser_function_body (parser);
16391 check_constexpr_ctor_body (last, list);
16392 /* Finish the function body. */
16393 finish_function_body (body);
16395 return ctor_initializer_p;
16398 /* Parse an initializer.
16401 = initializer-clause
16402 ( expression-list )
16404 Returns an expression representing the initializer. If no
16405 initializer is present, NULL_TREE is returned.
16407 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
16408 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
16409 set to TRUE if there is no initializer present. If there is an
16410 initializer, and it is not a constant-expression, *NON_CONSTANT_P
16411 is set to true; otherwise it is set to false. */
16414 cp_parser_initializer (cp_parser* parser, bool* is_direct_init,
16415 bool* non_constant_p)
16420 /* Peek at the next token. */
16421 token = cp_lexer_peek_token (parser->lexer);
16423 /* Let our caller know whether or not this initializer was
16425 *is_direct_init = (token->type != CPP_EQ);
16426 /* Assume that the initializer is constant. */
16427 *non_constant_p = false;
16429 if (token->type == CPP_EQ)
16431 /* Consume the `='. */
16432 cp_lexer_consume_token (parser->lexer);
16433 /* Parse the initializer-clause. */
16434 init = cp_parser_initializer_clause (parser, non_constant_p);
16436 else if (token->type == CPP_OPEN_PAREN)
16439 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
16441 /*allow_expansion_p=*/true,
16444 return error_mark_node;
16445 init = build_tree_list_vec (vec);
16446 release_tree_vector (vec);
16448 else if (token->type == CPP_OPEN_BRACE)
16450 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
16451 init = cp_parser_braced_list (parser, non_constant_p);
16452 CONSTRUCTOR_IS_DIRECT_INIT (init) = 1;
16456 /* Anything else is an error. */
16457 cp_parser_error (parser, "expected initializer");
16458 init = error_mark_node;
16464 /* Parse an initializer-clause.
16466 initializer-clause:
16467 assignment-expression
16470 Returns an expression representing the initializer.
16472 If the `assignment-expression' production is used the value
16473 returned is simply a representation for the expression.
16475 Otherwise, calls cp_parser_braced_list. */
16478 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
16482 /* Assume the expression is constant. */
16483 *non_constant_p = false;
16485 /* If it is not a `{', then we are looking at an
16486 assignment-expression. */
16487 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
16490 = cp_parser_constant_expression (parser,
16491 /*allow_non_constant_p=*/true,
16493 if (!*non_constant_p)
16495 /* We only want to fold if this is really a constant
16496 expression. FIXME Actually, we don't want to fold here, but in
16498 tree folded = fold_non_dependent_expr (initializer);
16499 folded = maybe_constant_value (folded);
16500 if (TREE_CONSTANT (folded))
16501 initializer = folded;
16505 initializer = cp_parser_braced_list (parser, non_constant_p);
16507 return initializer;
16510 /* Parse a brace-enclosed initializer list.
16513 { initializer-list , [opt] }
16516 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
16517 the elements of the initializer-list (or NULL, if the last
16518 production is used). The TREE_TYPE for the CONSTRUCTOR will be
16519 NULL_TREE. There is no way to detect whether or not the optional
16520 trailing `,' was provided. NON_CONSTANT_P is as for
16521 cp_parser_initializer. */
16524 cp_parser_braced_list (cp_parser* parser, bool* non_constant_p)
16528 /* Consume the `{' token. */
16529 cp_lexer_consume_token (parser->lexer);
16530 /* Create a CONSTRUCTOR to represent the braced-initializer. */
16531 initializer = make_node (CONSTRUCTOR);
16532 /* If it's not a `}', then there is a non-trivial initializer. */
16533 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
16535 /* Parse the initializer list. */
16536 CONSTRUCTOR_ELTS (initializer)
16537 = cp_parser_initializer_list (parser, non_constant_p);
16538 /* A trailing `,' token is allowed. */
16539 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
16540 cp_lexer_consume_token (parser->lexer);
16542 /* Now, there should be a trailing `}'. */
16543 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
16544 TREE_TYPE (initializer) = init_list_type_node;
16545 return initializer;
16548 /* Parse an initializer-list.
16551 initializer-clause ... [opt]
16552 initializer-list , initializer-clause ... [opt]
16557 identifier : initializer-clause
16558 initializer-list, identifier : initializer-clause
16560 Returns a VEC of constructor_elt. The VALUE of each elt is an expression
16561 for the initializer. If the INDEX of the elt is non-NULL, it is the
16562 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
16563 as for cp_parser_initializer. */
16565 static VEC(constructor_elt,gc) *
16566 cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
16568 VEC(constructor_elt,gc) *v = NULL;
16570 /* Assume all of the expressions are constant. */
16571 *non_constant_p = false;
16573 /* Parse the rest of the list. */
16579 bool clause_non_constant_p;
16581 /* If the next token is an identifier and the following one is a
16582 colon, we are looking at the GNU designated-initializer
16584 if (cp_parser_allow_gnu_extensions_p (parser)
16585 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
16586 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
16588 /* Warn the user that they are using an extension. */
16589 pedwarn (input_location, OPT_pedantic,
16590 "ISO C++ does not allow designated initializers");
16591 /* Consume the identifier. */
16592 identifier = cp_lexer_consume_token (parser->lexer)->u.value;
16593 /* Consume the `:'. */
16594 cp_lexer_consume_token (parser->lexer);
16597 identifier = NULL_TREE;
16599 /* Parse the initializer. */
16600 initializer = cp_parser_initializer_clause (parser,
16601 &clause_non_constant_p);
16602 /* If any clause is non-constant, so is the entire initializer. */
16603 if (clause_non_constant_p)
16604 *non_constant_p = true;
16606 /* If we have an ellipsis, this is an initializer pack
16608 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16610 /* Consume the `...'. */
16611 cp_lexer_consume_token (parser->lexer);
16613 /* Turn the initializer into an initializer expansion. */
16614 initializer = make_pack_expansion (initializer);
16617 /* Add it to the vector. */
16618 CONSTRUCTOR_APPEND_ELT(v, identifier, initializer);
16620 /* If the next token is not a comma, we have reached the end of
16622 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16625 /* Peek at the next token. */
16626 token = cp_lexer_peek_nth_token (parser->lexer, 2);
16627 /* If the next token is a `}', then we're still done. An
16628 initializer-clause can have a trailing `,' after the
16629 initializer-list and before the closing `}'. */
16630 if (token->type == CPP_CLOSE_BRACE)
16633 /* Consume the `,' token. */
16634 cp_lexer_consume_token (parser->lexer);
16640 /* Classes [gram.class] */
16642 /* Parse a class-name.
16648 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
16649 to indicate that names looked up in dependent types should be
16650 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
16651 keyword has been used to indicate that the name that appears next
16652 is a template. TAG_TYPE indicates the explicit tag given before
16653 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
16654 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
16655 is the class being defined in a class-head.
16657 Returns the TYPE_DECL representing the class. */
16660 cp_parser_class_name (cp_parser *parser,
16661 bool typename_keyword_p,
16662 bool template_keyword_p,
16663 enum tag_types tag_type,
16664 bool check_dependency_p,
16666 bool is_declaration)
16672 tree identifier = NULL_TREE;
16674 /* All class-names start with an identifier. */
16675 token = cp_lexer_peek_token (parser->lexer);
16676 if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
16678 cp_parser_error (parser, "expected class-name");
16679 return error_mark_node;
16682 /* PARSER->SCOPE can be cleared when parsing the template-arguments
16683 to a template-id, so we save it here. */
16684 scope = parser->scope;
16685 if (scope == error_mark_node)
16686 return error_mark_node;
16688 /* Any name names a type if we're following the `typename' keyword
16689 in a qualified name where the enclosing scope is type-dependent. */
16690 typename_p = (typename_keyword_p && scope && TYPE_P (scope)
16691 && dependent_type_p (scope));
16692 /* Handle the common case (an identifier, but not a template-id)
16694 if (token->type == CPP_NAME
16695 && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
16697 cp_token *identifier_token;
16700 /* Look for the identifier. */
16701 identifier_token = cp_lexer_peek_token (parser->lexer);
16702 ambiguous_p = identifier_token->ambiguous_p;
16703 identifier = cp_parser_identifier (parser);
16704 /* If the next token isn't an identifier, we are certainly not
16705 looking at a class-name. */
16706 if (identifier == error_mark_node)
16707 decl = error_mark_node;
16708 /* If we know this is a type-name, there's no need to look it
16710 else if (typename_p)
16714 tree ambiguous_decls;
16715 /* If we already know that this lookup is ambiguous, then
16716 we've already issued an error message; there's no reason
16720 cp_parser_simulate_error (parser);
16721 return error_mark_node;
16723 /* If the next token is a `::', then the name must be a type
16726 [basic.lookup.qual]
16728 During the lookup for a name preceding the :: scope
16729 resolution operator, object, function, and enumerator
16730 names are ignored. */
16731 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16732 tag_type = typename_type;
16733 /* Look up the name. */
16734 decl = cp_parser_lookup_name (parser, identifier,
16736 /*is_template=*/false,
16737 /*is_namespace=*/false,
16738 check_dependency_p,
16740 identifier_token->location);
16741 if (ambiguous_decls)
16743 if (cp_parser_parsing_tentatively (parser))
16744 cp_parser_simulate_error (parser);
16745 return error_mark_node;
16751 /* Try a template-id. */
16752 decl = cp_parser_template_id (parser, template_keyword_p,
16753 check_dependency_p,
16755 if (decl == error_mark_node)
16756 return error_mark_node;
16759 decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
16761 /* If this is a typename, create a TYPENAME_TYPE. */
16762 if (typename_p && decl != error_mark_node)
16764 decl = make_typename_type (scope, decl, typename_type,
16765 /*complain=*/tf_error);
16766 if (decl != error_mark_node)
16767 decl = TYPE_NAME (decl);
16770 /* Check to see that it is really the name of a class. */
16771 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
16772 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
16773 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16774 /* Situations like this:
16776 template <typename T> struct A {
16777 typename T::template X<int>::I i;
16780 are problematic. Is `T::template X<int>' a class-name? The
16781 standard does not seem to be definitive, but there is no other
16782 valid interpretation of the following `::'. Therefore, those
16783 names are considered class-names. */
16785 decl = make_typename_type (scope, decl, tag_type, tf_error);
16786 if (decl != error_mark_node)
16787 decl = TYPE_NAME (decl);
16789 else if (TREE_CODE (decl) != TYPE_DECL
16790 || TREE_TYPE (decl) == error_mark_node
16791 || !MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))
16792 /* In Objective-C 2.0, a classname followed by '.' starts a
16793 dot-syntax expression, and it's not a type-name. */
16794 || (c_dialect_objc ()
16795 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
16796 && objc_is_class_name (decl)))
16797 decl = error_mark_node;
16799 if (decl == error_mark_node)
16800 cp_parser_error (parser, "expected class-name");
16801 else if (identifier && !parser->scope)
16802 maybe_note_name_used_in_class (identifier, decl);
16807 /* Parse a class-specifier.
16810 class-head { member-specification [opt] }
16812 Returns the TREE_TYPE representing the class. */
16815 cp_parser_class_specifier_1 (cp_parser* parser)
16818 tree attributes = NULL_TREE;
16819 bool nested_name_specifier_p;
16820 unsigned saved_num_template_parameter_lists;
16821 bool saved_in_function_body;
16822 bool saved_in_unbraced_linkage_specification_p;
16823 tree old_scope = NULL_TREE;
16824 tree scope = NULL_TREE;
16826 cp_token *closing_brace;
16828 push_deferring_access_checks (dk_no_deferred);
16830 /* Parse the class-head. */
16831 type = cp_parser_class_head (parser,
16832 &nested_name_specifier_p,
16835 /* If the class-head was a semantic disaster, skip the entire body
16839 cp_parser_skip_to_end_of_block_or_statement (parser);
16840 pop_deferring_access_checks ();
16841 return error_mark_node;
16844 /* Look for the `{'. */
16845 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
16847 pop_deferring_access_checks ();
16848 return error_mark_node;
16851 /* Process the base classes. If they're invalid, skip the
16852 entire class body. */
16853 if (!xref_basetypes (type, bases))
16855 /* Consuming the closing brace yields better error messages
16857 if (cp_parser_skip_to_closing_brace (parser))
16858 cp_lexer_consume_token (parser->lexer);
16859 pop_deferring_access_checks ();
16860 return error_mark_node;
16863 /* Issue an error message if type-definitions are forbidden here. */
16864 cp_parser_check_type_definition (parser);
16865 /* Remember that we are defining one more class. */
16866 ++parser->num_classes_being_defined;
16867 /* Inside the class, surrounding template-parameter-lists do not
16869 saved_num_template_parameter_lists
16870 = parser->num_template_parameter_lists;
16871 parser->num_template_parameter_lists = 0;
16872 /* We are not in a function body. */
16873 saved_in_function_body = parser->in_function_body;
16874 parser->in_function_body = false;
16875 /* We are not immediately inside an extern "lang" block. */
16876 saved_in_unbraced_linkage_specification_p
16877 = parser->in_unbraced_linkage_specification_p;
16878 parser->in_unbraced_linkage_specification_p = false;
16880 /* Start the class. */
16881 if (nested_name_specifier_p)
16883 scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
16884 old_scope = push_inner_scope (scope);
16886 type = begin_class_definition (type, attributes);
16888 if (type == error_mark_node)
16889 /* If the type is erroneous, skip the entire body of the class. */
16890 cp_parser_skip_to_closing_brace (parser);
16892 /* Parse the member-specification. */
16893 cp_parser_member_specification_opt (parser);
16895 /* Look for the trailing `}'. */
16896 closing_brace = cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
16897 /* Look for trailing attributes to apply to this class. */
16898 if (cp_parser_allow_gnu_extensions_p (parser))
16899 attributes = cp_parser_attributes_opt (parser);
16900 if (type != error_mark_node)
16901 type = finish_struct (type, attributes);
16902 if (nested_name_specifier_p)
16903 pop_inner_scope (old_scope, scope);
16905 /* We've finished a type definition. Check for the common syntax
16906 error of forgetting a semicolon after the definition. We need to
16907 be careful, as we can't just check for not-a-semicolon and be done
16908 with it; the user might have typed:
16910 class X { } c = ...;
16911 class X { } *p = ...;
16913 and so forth. Instead, enumerate all the possible tokens that
16914 might follow this production; if we don't see one of them, then
16915 complain and silently insert the semicolon. */
16917 cp_token *token = cp_lexer_peek_token (parser->lexer);
16918 bool want_semicolon = true;
16920 switch (token->type)
16923 case CPP_SEMICOLON:
16926 case CPP_OPEN_PAREN:
16927 case CPP_CLOSE_PAREN:
16929 want_semicolon = false;
16932 /* While it's legal for type qualifiers and storage class
16933 specifiers to follow type definitions in the grammar, only
16934 compiler testsuites contain code like that. Assume that if
16935 we see such code, then what we're really seeing is a case
16939 const <type> var = ...;
16944 static <type> func (...) ...
16946 i.e. the qualifier or specifier applies to the next
16947 declaration. To do so, however, we need to look ahead one
16948 more token to see if *that* token is a type specifier.
16950 This code could be improved to handle:
16953 static const <type> var = ...; */
16955 if (keyword_is_decl_specifier (token->keyword))
16957 cp_token *lookahead = cp_lexer_peek_nth_token (parser->lexer, 2);
16959 /* Handling user-defined types here would be nice, but very
16962 = (lookahead->type == CPP_KEYWORD
16963 && keyword_begins_type_specifier (lookahead->keyword));
16970 /* If we don't have a type, then something is very wrong and we
16971 shouldn't try to do anything clever. Likewise for not seeing the
16973 if (closing_brace && TYPE_P (type) && want_semicolon)
16975 cp_token_position prev
16976 = cp_lexer_previous_token_position (parser->lexer);
16977 cp_token *prev_token = cp_lexer_token_at (parser->lexer, prev);
16978 location_t loc = prev_token->location;
16980 if (CLASSTYPE_DECLARED_CLASS (type))
16981 error_at (loc, "expected %<;%> after class definition");
16982 else if (TREE_CODE (type) == RECORD_TYPE)
16983 error_at (loc, "expected %<;%> after struct definition");
16984 else if (TREE_CODE (type) == UNION_TYPE)
16985 error_at (loc, "expected %<;%> after union definition");
16987 gcc_unreachable ();
16989 /* Unget one token and smash it to look as though we encountered
16990 a semicolon in the input stream. */
16991 cp_lexer_set_token_position (parser->lexer, prev);
16992 token = cp_lexer_peek_token (parser->lexer);
16993 token->type = CPP_SEMICOLON;
16994 token->keyword = RID_MAX;
16998 /* If this class is not itself within the scope of another class,
16999 then we need to parse the bodies of all of the queued function
17000 definitions. Note that the queued functions defined in a class
17001 are not always processed immediately following the
17002 class-specifier for that class. Consider:
17005 struct B { void f() { sizeof (A); } };
17008 If `f' were processed before the processing of `A' were
17009 completed, there would be no way to compute the size of `A'.
17010 Note that the nesting we are interested in here is lexical --
17011 not the semantic nesting given by TYPE_CONTEXT. In particular,
17014 struct A { struct B; };
17015 struct A::B { void f() { } };
17017 there is no need to delay the parsing of `A::B::f'. */
17018 if (--parser->num_classes_being_defined == 0)
17021 tree class_type = NULL_TREE;
17022 tree pushed_scope = NULL_TREE;
17024 cp_default_arg_entry *e;
17026 /* In a first pass, parse default arguments to the functions.
17027 Then, in a second pass, parse the bodies of the functions.
17028 This two-phased approach handles cases like:
17036 FOR_EACH_VEC_ELT (cp_default_arg_entry, unparsed_funs_with_default_args,
17040 /* If there are default arguments that have not yet been processed,
17041 take care of them now. */
17042 if (class_type != e->class_type)
17045 pop_scope (pushed_scope);
17046 class_type = e->class_type;
17047 pushed_scope = push_scope (class_type);
17049 /* Make sure that any template parameters are in scope. */
17050 maybe_begin_member_template_processing (fn);
17051 /* Parse the default argument expressions. */
17052 cp_parser_late_parsing_default_args (parser, fn);
17053 /* Remove any template parameters from the symbol table. */
17054 maybe_end_member_template_processing ();
17057 pop_scope (pushed_scope);
17058 VEC_truncate (cp_default_arg_entry, unparsed_funs_with_default_args, 0);
17059 /* Now parse the body of the functions. */
17060 FOR_EACH_VEC_ELT (tree, unparsed_funs_with_definitions, ix, fn)
17061 cp_parser_late_parsing_for_member (parser, fn);
17062 VEC_truncate (tree, unparsed_funs_with_definitions, 0);
17065 /* Put back any saved access checks. */
17066 pop_deferring_access_checks ();
17068 /* Restore saved state. */
17069 parser->in_function_body = saved_in_function_body;
17070 parser->num_template_parameter_lists
17071 = saved_num_template_parameter_lists;
17072 parser->in_unbraced_linkage_specification_p
17073 = saved_in_unbraced_linkage_specification_p;
17079 cp_parser_class_specifier (cp_parser* parser)
17082 timevar_push (TV_PARSE_STRUCT);
17083 ret = cp_parser_class_specifier_1 (parser);
17084 timevar_pop (TV_PARSE_STRUCT);
17088 /* Parse a class-head.
17091 class-key identifier [opt] base-clause [opt]
17092 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
17093 class-key nested-name-specifier [opt] template-id
17096 class-virt-specifier:
17100 class-key attributes identifier [opt] base-clause [opt]
17101 class-key attributes nested-name-specifier identifier base-clause [opt]
17102 class-key attributes nested-name-specifier [opt] template-id
17105 Upon return BASES is initialized to the list of base classes (or
17106 NULL, if there are none) in the same form returned by
17107 cp_parser_base_clause.
17109 Returns the TYPE of the indicated class. Sets
17110 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
17111 involving a nested-name-specifier was used, and FALSE otherwise.
17113 Returns error_mark_node if this is not a class-head.
17115 Returns NULL_TREE if the class-head is syntactically valid, but
17116 semantically invalid in a way that means we should skip the entire
17117 body of the class. */
17120 cp_parser_class_head (cp_parser* parser,
17121 bool* nested_name_specifier_p,
17122 tree *attributes_p,
17125 tree nested_name_specifier;
17126 enum tag_types class_key;
17127 tree id = NULL_TREE;
17128 tree type = NULL_TREE;
17130 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
17131 bool template_id_p = false;
17132 bool qualified_p = false;
17133 bool invalid_nested_name_p = false;
17134 bool invalid_explicit_specialization_p = false;
17135 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
17136 tree pushed_scope = NULL_TREE;
17137 unsigned num_templates;
17138 cp_token *type_start_token = NULL, *nested_name_specifier_token_start = NULL;
17139 /* Assume no nested-name-specifier will be present. */
17140 *nested_name_specifier_p = false;
17141 /* Assume no template parameter lists will be used in defining the
17144 parser->colon_corrects_to_scope_p = false;
17146 *bases = NULL_TREE;
17148 /* Look for the class-key. */
17149 class_key = cp_parser_class_key (parser);
17150 if (class_key == none_type)
17151 return error_mark_node;
17153 /* Parse the attributes. */
17154 attributes = cp_parser_attributes_opt (parser);
17156 /* If the next token is `::', that is invalid -- but sometimes
17157 people do try to write:
17161 Handle this gracefully by accepting the extra qualifier, and then
17162 issuing an error about it later if this really is a
17163 class-head. If it turns out just to be an elaborated type
17164 specifier, remain silent. */
17165 if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
17166 qualified_p = true;
17168 push_deferring_access_checks (dk_no_check);
17170 /* Determine the name of the class. Begin by looking for an
17171 optional nested-name-specifier. */
17172 nested_name_specifier_token_start = cp_lexer_peek_token (parser->lexer);
17173 nested_name_specifier
17174 = cp_parser_nested_name_specifier_opt (parser,
17175 /*typename_keyword_p=*/false,
17176 /*check_dependency_p=*/false,
17178 /*is_declaration=*/false);
17179 /* If there was a nested-name-specifier, then there *must* be an
17181 if (nested_name_specifier)
17183 type_start_token = cp_lexer_peek_token (parser->lexer);
17184 /* Although the grammar says `identifier', it really means
17185 `class-name' or `template-name'. You are only allowed to
17186 define a class that has already been declared with this
17189 The proposed resolution for Core Issue 180 says that wherever
17190 you see `class T::X' you should treat `X' as a type-name.
17192 It is OK to define an inaccessible class; for example:
17194 class A { class B; };
17197 We do not know if we will see a class-name, or a
17198 template-name. We look for a class-name first, in case the
17199 class-name is a template-id; if we looked for the
17200 template-name first we would stop after the template-name. */
17201 cp_parser_parse_tentatively (parser);
17202 type = cp_parser_class_name (parser,
17203 /*typename_keyword_p=*/false,
17204 /*template_keyword_p=*/false,
17206 /*check_dependency_p=*/false,
17207 /*class_head_p=*/true,
17208 /*is_declaration=*/false);
17209 /* If that didn't work, ignore the nested-name-specifier. */
17210 if (!cp_parser_parse_definitely (parser))
17212 invalid_nested_name_p = true;
17213 type_start_token = cp_lexer_peek_token (parser->lexer);
17214 id = cp_parser_identifier (parser);
17215 if (id == error_mark_node)
17218 /* If we could not find a corresponding TYPE, treat this
17219 declaration like an unqualified declaration. */
17220 if (type == error_mark_node)
17221 nested_name_specifier = NULL_TREE;
17222 /* Otherwise, count the number of templates used in TYPE and its
17223 containing scopes. */
17228 for (scope = TREE_TYPE (type);
17229 scope && TREE_CODE (scope) != NAMESPACE_DECL;
17230 scope = (TYPE_P (scope)
17231 ? TYPE_CONTEXT (scope)
17232 : DECL_CONTEXT (scope)))
17234 && CLASS_TYPE_P (scope)
17235 && CLASSTYPE_TEMPLATE_INFO (scope)
17236 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
17237 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope))
17241 /* Otherwise, the identifier is optional. */
17244 /* We don't know whether what comes next is a template-id,
17245 an identifier, or nothing at all. */
17246 cp_parser_parse_tentatively (parser);
17247 /* Check for a template-id. */
17248 type_start_token = cp_lexer_peek_token (parser->lexer);
17249 id = cp_parser_template_id (parser,
17250 /*template_keyword_p=*/false,
17251 /*check_dependency_p=*/true,
17252 /*is_declaration=*/true);
17253 /* If that didn't work, it could still be an identifier. */
17254 if (!cp_parser_parse_definitely (parser))
17256 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
17258 type_start_token = cp_lexer_peek_token (parser->lexer);
17259 id = cp_parser_identifier (parser);
17266 template_id_p = true;
17271 pop_deferring_access_checks ();
17275 cp_parser_check_for_invalid_template_id (parser, id,
17276 type_start_token->location);
17277 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
17280 /* If it's not a `:' or a `{' then we can't really be looking at a
17281 class-head, since a class-head only appears as part of a
17282 class-specifier. We have to detect this situation before calling
17283 xref_tag, since that has irreversible side-effects. */
17284 if (!cp_parser_next_token_starts_class_definition_p (parser))
17286 cp_parser_error (parser, "expected %<{%> or %<:%>");
17287 type = error_mark_node;
17291 /* At this point, we're going ahead with the class-specifier, even
17292 if some other problem occurs. */
17293 cp_parser_commit_to_tentative_parse (parser);
17294 if (virt_specifiers & VIRT_SPEC_OVERRIDE)
17296 cp_parser_error (parser,
17297 "cannot specify %<override%> for a class");
17298 type = error_mark_node;
17301 /* Issue the error about the overly-qualified name now. */
17304 cp_parser_error (parser,
17305 "global qualification of class name is invalid");
17306 type = error_mark_node;
17309 else if (invalid_nested_name_p)
17311 cp_parser_error (parser,
17312 "qualified name does not name a class");
17313 type = error_mark_node;
17316 else if (nested_name_specifier)
17320 /* Reject typedef-names in class heads. */
17321 if (!DECL_IMPLICIT_TYPEDEF_P (type))
17323 error_at (type_start_token->location,
17324 "invalid class name in declaration of %qD",
17330 /* Figure out in what scope the declaration is being placed. */
17331 scope = current_scope ();
17332 /* If that scope does not contain the scope in which the
17333 class was originally declared, the program is invalid. */
17334 if (scope && !is_ancestor (scope, nested_name_specifier))
17336 if (at_namespace_scope_p ())
17337 error_at (type_start_token->location,
17338 "declaration of %qD in namespace %qD which does not "
17340 type, scope, nested_name_specifier);
17342 error_at (type_start_token->location,
17343 "declaration of %qD in %qD which does not enclose %qD",
17344 type, scope, nested_name_specifier);
17350 A declarator-id shall not be qualified except for the
17351 definition of a ... nested class outside of its class
17352 ... [or] the definition or explicit instantiation of a
17353 class member of a namespace outside of its namespace. */
17354 if (scope == nested_name_specifier)
17356 permerror (nested_name_specifier_token_start->location,
17357 "extra qualification not allowed");
17358 nested_name_specifier = NULL_TREE;
17362 /* An explicit-specialization must be preceded by "template <>". If
17363 it is not, try to recover gracefully. */
17364 if (at_namespace_scope_p ()
17365 && parser->num_template_parameter_lists == 0
17368 error_at (type_start_token->location,
17369 "an explicit specialization must be preceded by %<template <>%>");
17370 invalid_explicit_specialization_p = true;
17371 /* Take the same action that would have been taken by
17372 cp_parser_explicit_specialization. */
17373 ++parser->num_template_parameter_lists;
17374 begin_specialization ();
17376 /* There must be no "return" statements between this point and the
17377 end of this function; set "type "to the correct return value and
17378 use "goto done;" to return. */
17379 /* Make sure that the right number of template parameters were
17381 if (!cp_parser_check_template_parameters (parser, num_templates,
17382 type_start_token->location,
17383 /*declarator=*/NULL))
17385 /* If something went wrong, there is no point in even trying to
17386 process the class-definition. */
17391 /* Look up the type. */
17394 if (TREE_CODE (id) == TEMPLATE_ID_EXPR
17395 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id, 0))
17396 || TREE_CODE (TREE_OPERAND (id, 0)) == OVERLOAD))
17398 error_at (type_start_token->location,
17399 "function template %qD redeclared as a class template", id);
17400 type = error_mark_node;
17404 type = TREE_TYPE (id);
17405 type = maybe_process_partial_specialization (type);
17407 if (nested_name_specifier)
17408 pushed_scope = push_scope (nested_name_specifier);
17410 else if (nested_name_specifier)
17416 template <typename T> struct S { struct T };
17417 template <typename T> struct S<T>::T { };
17419 we will get a TYPENAME_TYPE when processing the definition of
17420 `S::T'. We need to resolve it to the actual type before we
17421 try to define it. */
17422 if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
17424 class_type = resolve_typename_type (TREE_TYPE (type),
17425 /*only_current_p=*/false);
17426 if (TREE_CODE (class_type) != TYPENAME_TYPE)
17427 type = TYPE_NAME (class_type);
17430 cp_parser_error (parser, "could not resolve typename type");
17431 type = error_mark_node;
17435 if (maybe_process_partial_specialization (TREE_TYPE (type))
17436 == error_mark_node)
17442 class_type = current_class_type;
17443 /* Enter the scope indicated by the nested-name-specifier. */
17444 pushed_scope = push_scope (nested_name_specifier);
17445 /* Get the canonical version of this type. */
17446 type = TYPE_MAIN_DECL (TREE_TYPE (type));
17447 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
17448 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
17450 type = push_template_decl (type);
17451 if (type == error_mark_node)
17458 type = TREE_TYPE (type);
17459 *nested_name_specifier_p = true;
17461 else /* The name is not a nested name. */
17463 /* If the class was unnamed, create a dummy name. */
17465 id = make_anon_name ();
17466 type = xref_tag (class_key, id, /*tag_scope=*/ts_current,
17467 parser->num_template_parameter_lists);
17470 /* Indicate whether this class was declared as a `class' or as a
17472 if (TREE_CODE (type) == RECORD_TYPE)
17473 CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
17474 cp_parser_check_class_key (class_key, type);
17476 /* If this type was already complete, and we see another definition,
17477 that's an error. */
17478 if (type != error_mark_node && COMPLETE_TYPE_P (type))
17480 error_at (type_start_token->location, "redefinition of %q#T",
17482 error_at (type_start_token->location, "previous definition of %q+#T",
17487 else if (type == error_mark_node)
17490 /* We will have entered the scope containing the class; the names of
17491 base classes should be looked up in that context. For example:
17493 struct A { struct B {}; struct C; };
17494 struct A::C : B {};
17498 /* Get the list of base-classes, if there is one. */
17499 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
17500 *bases = cp_parser_base_clause (parser);
17503 /* Leave the scope given by the nested-name-specifier. We will
17504 enter the class scope itself while processing the members. */
17506 pop_scope (pushed_scope);
17508 if (invalid_explicit_specialization_p)
17510 end_specialization ();
17511 --parser->num_template_parameter_lists;
17515 DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
17516 *attributes_p = attributes;
17517 if (type && (virt_specifiers & VIRT_SPEC_FINAL))
17518 CLASSTYPE_FINAL (type) = 1;
17520 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
17524 /* Parse a class-key.
17531 Returns the kind of class-key specified, or none_type to indicate
17534 static enum tag_types
17535 cp_parser_class_key (cp_parser* parser)
17538 enum tag_types tag_type;
17540 /* Look for the class-key. */
17541 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_KEY);
17545 /* Check to see if the TOKEN is a class-key. */
17546 tag_type = cp_parser_token_is_class_key (token);
17548 cp_parser_error (parser, "expected class-key");
17552 /* Parse an (optional) member-specification.
17554 member-specification:
17555 member-declaration member-specification [opt]
17556 access-specifier : member-specification [opt] */
17559 cp_parser_member_specification_opt (cp_parser* parser)
17566 /* Peek at the next token. */
17567 token = cp_lexer_peek_token (parser->lexer);
17568 /* If it's a `}', or EOF then we've seen all the members. */
17569 if (token->type == CPP_CLOSE_BRACE
17570 || token->type == CPP_EOF
17571 || token->type == CPP_PRAGMA_EOL)
17574 /* See if this token is a keyword. */
17575 keyword = token->keyword;
17579 case RID_PROTECTED:
17581 /* Consume the access-specifier. */
17582 cp_lexer_consume_token (parser->lexer);
17583 /* Remember which access-specifier is active. */
17584 current_access_specifier = token->u.value;
17585 /* Look for the `:'. */
17586 cp_parser_require (parser, CPP_COLON, RT_COLON);
17590 /* Accept #pragmas at class scope. */
17591 if (token->type == CPP_PRAGMA)
17593 cp_parser_pragma (parser, pragma_external);
17597 /* Otherwise, the next construction must be a
17598 member-declaration. */
17599 cp_parser_member_declaration (parser);
17604 /* Parse a member-declaration.
17606 member-declaration:
17607 decl-specifier-seq [opt] member-declarator-list [opt] ;
17608 function-definition ; [opt]
17609 :: [opt] nested-name-specifier template [opt] unqualified-id ;
17611 template-declaration
17613 member-declarator-list:
17615 member-declarator-list , member-declarator
17618 declarator pure-specifier [opt]
17619 declarator constant-initializer [opt]
17620 identifier [opt] : constant-expression
17624 member-declaration:
17625 __extension__ member-declaration
17628 declarator attributes [opt] pure-specifier [opt]
17629 declarator attributes [opt] constant-initializer [opt]
17630 identifier [opt] attributes [opt] : constant-expression
17634 member-declaration:
17635 static_assert-declaration */
17638 cp_parser_member_declaration (cp_parser* parser)
17640 cp_decl_specifier_seq decl_specifiers;
17641 tree prefix_attributes;
17643 int declares_class_or_enum;
17645 cp_token *token = NULL;
17646 cp_token *decl_spec_token_start = NULL;
17647 cp_token *initializer_token_start = NULL;
17648 int saved_pedantic;
17649 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
17651 /* Check for the `__extension__' keyword. */
17652 if (cp_parser_extension_opt (parser, &saved_pedantic))
17655 cp_parser_member_declaration (parser);
17656 /* Restore the old value of the PEDANTIC flag. */
17657 pedantic = saved_pedantic;
17662 /* Check for a template-declaration. */
17663 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
17665 /* An explicit specialization here is an error condition, and we
17666 expect the specialization handler to detect and report this. */
17667 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
17668 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
17669 cp_parser_explicit_specialization (parser);
17671 cp_parser_template_declaration (parser, /*member_p=*/true);
17676 /* Check for a using-declaration. */
17677 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
17679 /* Parse the using-declaration. */
17680 cp_parser_using_declaration (parser,
17681 /*access_declaration_p=*/false);
17685 /* Check for @defs. */
17686 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
17689 tree ivar_chains = cp_parser_objc_defs_expression (parser);
17690 ivar = ivar_chains;
17694 ivar = TREE_CHAIN (member);
17695 TREE_CHAIN (member) = NULL_TREE;
17696 finish_member_declaration (member);
17701 /* If the next token is `static_assert' we have a static assertion. */
17702 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
17704 cp_parser_static_assert (parser, /*member_p=*/true);
17708 parser->colon_corrects_to_scope_p = false;
17710 if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
17713 /* Parse the decl-specifier-seq. */
17714 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
17715 cp_parser_decl_specifier_seq (parser,
17716 CP_PARSER_FLAGS_OPTIONAL,
17718 &declares_class_or_enum);
17719 prefix_attributes = decl_specifiers.attributes;
17720 decl_specifiers.attributes = NULL_TREE;
17721 /* Check for an invalid type-name. */
17722 if (!decl_specifiers.any_type_specifiers_p
17723 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
17725 /* If there is no declarator, then the decl-specifier-seq should
17727 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
17729 /* If there was no decl-specifier-seq, and the next token is a
17730 `;', then we have something like:
17736 Each member-declaration shall declare at least one member
17737 name of the class. */
17738 if (!decl_specifiers.any_specifiers_p)
17740 cp_token *token = cp_lexer_peek_token (parser->lexer);
17741 if (!in_system_header_at (token->location))
17742 pedwarn (token->location, OPT_pedantic, "extra %<;%>");
17748 /* See if this declaration is a friend. */
17749 friend_p = cp_parser_friend_p (&decl_specifiers);
17750 /* If there were decl-specifiers, check to see if there was
17751 a class-declaration. */
17752 type = check_tag_decl (&decl_specifiers);
17753 /* Nested classes have already been added to the class, but
17754 a `friend' needs to be explicitly registered. */
17757 /* If the `friend' keyword was present, the friend must
17758 be introduced with a class-key. */
17759 if (!declares_class_or_enum)
17760 error_at (decl_spec_token_start->location,
17761 "a class-key must be used when declaring a friend");
17764 template <typename T> struct A {
17765 friend struct A<T>::B;
17768 A<T>::B will be represented by a TYPENAME_TYPE, and
17769 therefore not recognized by check_tag_decl. */
17771 && decl_specifiers.type
17772 && TYPE_P (decl_specifiers.type))
17773 type = decl_specifiers.type;
17774 if (!type || !TYPE_P (type))
17775 error_at (decl_spec_token_start->location,
17776 "friend declaration does not name a class or "
17779 make_friend_class (current_class_type, type,
17780 /*complain=*/true);
17782 /* If there is no TYPE, an error message will already have
17784 else if (!type || type == error_mark_node)
17786 /* An anonymous aggregate has to be handled specially; such
17787 a declaration really declares a data member (with a
17788 particular type), as opposed to a nested class. */
17789 else if (ANON_AGGR_TYPE_P (type))
17791 /* Remove constructors and such from TYPE, now that we
17792 know it is an anonymous aggregate. */
17793 fixup_anonymous_aggr (type);
17794 /* And make the corresponding data member. */
17795 decl = build_decl (decl_spec_token_start->location,
17796 FIELD_DECL, NULL_TREE, type);
17797 /* Add it to the class. */
17798 finish_member_declaration (decl);
17801 cp_parser_check_access_in_redeclaration
17803 decl_spec_token_start->location);
17808 bool assume_semicolon = false;
17810 /* See if these declarations will be friends. */
17811 friend_p = cp_parser_friend_p (&decl_specifiers);
17813 /* Keep going until we hit the `;' at the end of the
17815 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
17817 tree attributes = NULL_TREE;
17818 tree first_attribute;
17820 /* Peek at the next token. */
17821 token = cp_lexer_peek_token (parser->lexer);
17823 /* Check for a bitfield declaration. */
17824 if (token->type == CPP_COLON
17825 || (token->type == CPP_NAME
17826 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
17832 /* Get the name of the bitfield. Note that we cannot just
17833 check TOKEN here because it may have been invalidated by
17834 the call to cp_lexer_peek_nth_token above. */
17835 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
17836 identifier = cp_parser_identifier (parser);
17838 identifier = NULL_TREE;
17840 /* Consume the `:' token. */
17841 cp_lexer_consume_token (parser->lexer);
17842 /* Get the width of the bitfield. */
17844 = cp_parser_constant_expression (parser,
17845 /*allow_non_constant=*/false,
17848 /* Look for attributes that apply to the bitfield. */
17849 attributes = cp_parser_attributes_opt (parser);
17850 /* Remember which attributes are prefix attributes and
17852 first_attribute = attributes;
17853 /* Combine the attributes. */
17854 attributes = chainon (prefix_attributes, attributes);
17856 /* Create the bitfield declaration. */
17857 decl = grokbitfield (identifier
17858 ? make_id_declarator (NULL_TREE,
17868 cp_declarator *declarator;
17870 tree asm_specification;
17871 int ctor_dtor_or_conv_p;
17873 /* Parse the declarator. */
17875 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
17876 &ctor_dtor_or_conv_p,
17877 /*parenthesized_p=*/NULL,
17878 /*member_p=*/true);
17880 /* If something went wrong parsing the declarator, make sure
17881 that we at least consume some tokens. */
17882 if (declarator == cp_error_declarator)
17884 /* Skip to the end of the statement. */
17885 cp_parser_skip_to_end_of_statement (parser);
17886 /* If the next token is not a semicolon, that is
17887 probably because we just skipped over the body of
17888 a function. So, we consume a semicolon if
17889 present, but do not issue an error message if it
17891 if (cp_lexer_next_token_is (parser->lexer,
17893 cp_lexer_consume_token (parser->lexer);
17897 if (declares_class_or_enum & 2)
17898 cp_parser_check_for_definition_in_return_type
17899 (declarator, decl_specifiers.type,
17900 decl_specifiers.type_location);
17902 /* Look for an asm-specification. */
17903 asm_specification = cp_parser_asm_specification_opt (parser);
17904 /* Look for attributes that apply to the declaration. */
17905 attributes = cp_parser_attributes_opt (parser);
17906 /* Remember which attributes are prefix attributes and
17908 first_attribute = attributes;
17909 /* Combine the attributes. */
17910 attributes = chainon (prefix_attributes, attributes);
17912 /* If it's an `=', then we have a constant-initializer or a
17913 pure-specifier. It is not correct to parse the
17914 initializer before registering the member declaration
17915 since the member declaration should be in scope while
17916 its initializer is processed. However, the rest of the
17917 front end does not yet provide an interface that allows
17918 us to handle this correctly. */
17919 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
17923 A pure-specifier shall be used only in the declaration of
17924 a virtual function.
17926 A member-declarator can contain a constant-initializer
17927 only if it declares a static member of integral or
17930 Therefore, if the DECLARATOR is for a function, we look
17931 for a pure-specifier; otherwise, we look for a
17932 constant-initializer. When we call `grokfield', it will
17933 perform more stringent semantics checks. */
17934 initializer_token_start = cp_lexer_peek_token (parser->lexer);
17935 if (function_declarator_p (declarator))
17936 initializer = cp_parser_pure_specifier (parser);
17938 /* Parse the initializer. */
17939 initializer = cp_parser_constant_initializer (parser);
17941 /* Otherwise, there is no initializer. */
17943 initializer = NULL_TREE;
17945 /* See if we are probably looking at a function
17946 definition. We are certainly not looking at a
17947 member-declarator. Calling `grokfield' has
17948 side-effects, so we must not do it unless we are sure
17949 that we are looking at a member-declarator. */
17950 if (cp_parser_token_starts_function_definition_p
17951 (cp_lexer_peek_token (parser->lexer)))
17953 /* The grammar does not allow a pure-specifier to be
17954 used when a member function is defined. (It is
17955 possible that this fact is an oversight in the
17956 standard, since a pure function may be defined
17957 outside of the class-specifier. */
17959 error_at (initializer_token_start->location,
17960 "pure-specifier on function-definition");
17961 decl = cp_parser_save_member_function_body (parser,
17965 /* If the member was not a friend, declare it here. */
17967 finish_member_declaration (decl);
17968 /* Peek at the next token. */
17969 token = cp_lexer_peek_token (parser->lexer);
17970 /* If the next token is a semicolon, consume it. */
17971 if (token->type == CPP_SEMICOLON)
17972 cp_lexer_consume_token (parser->lexer);
17976 if (declarator->kind == cdk_function)
17977 declarator->id_loc = token->location;
17978 /* Create the declaration. */
17979 decl = grokfield (declarator, &decl_specifiers,
17980 initializer, /*init_const_expr_p=*/true,
17985 /* Reset PREFIX_ATTRIBUTES. */
17986 while (attributes && TREE_CHAIN (attributes) != first_attribute)
17987 attributes = TREE_CHAIN (attributes);
17989 TREE_CHAIN (attributes) = NULL_TREE;
17991 /* If there is any qualification still in effect, clear it
17992 now; we will be starting fresh with the next declarator. */
17993 parser->scope = NULL_TREE;
17994 parser->qualifying_scope = NULL_TREE;
17995 parser->object_scope = NULL_TREE;
17996 /* If it's a `,', then there are more declarators. */
17997 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
17998 cp_lexer_consume_token (parser->lexer);
17999 /* If the next token isn't a `;', then we have a parse error. */
18000 else if (cp_lexer_next_token_is_not (parser->lexer,
18003 /* The next token might be a ways away from where the
18004 actual semicolon is missing. Find the previous token
18005 and use that for our error position. */
18006 cp_token *token = cp_lexer_previous_token (parser->lexer);
18007 error_at (token->location,
18008 "expected %<;%> at end of member declaration");
18010 /* Assume that the user meant to provide a semicolon. If
18011 we were to cp_parser_skip_to_end_of_statement, we might
18012 skip to a semicolon inside a member function definition
18013 and issue nonsensical error messages. */
18014 assume_semicolon = true;
18019 /* Add DECL to the list of members. */
18021 finish_member_declaration (decl);
18023 if (TREE_CODE (decl) == FUNCTION_DECL)
18024 cp_parser_save_default_args (parser, decl);
18027 if (assume_semicolon)
18032 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
18034 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
18037 /* Parse a pure-specifier.
18042 Returns INTEGER_ZERO_NODE if a pure specifier is found.
18043 Otherwise, ERROR_MARK_NODE is returned. */
18046 cp_parser_pure_specifier (cp_parser* parser)
18050 /* Look for the `=' token. */
18051 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
18052 return error_mark_node;
18053 /* Look for the `0' token. */
18054 token = cp_lexer_peek_token (parser->lexer);
18056 if (token->type == CPP_EOF
18057 || token->type == CPP_PRAGMA_EOL)
18058 return error_mark_node;
18060 cp_lexer_consume_token (parser->lexer);
18062 /* Accept = default or = delete in c++0x mode. */
18063 if (token->keyword == RID_DEFAULT
18064 || token->keyword == RID_DELETE)
18066 maybe_warn_cpp0x (CPP0X_DEFAULTED_DELETED);
18067 return token->u.value;
18070 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
18071 if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO))
18073 cp_parser_error (parser,
18074 "invalid pure specifier (only %<= 0%> is allowed)");
18075 cp_parser_skip_to_end_of_statement (parser);
18076 return error_mark_node;
18078 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
18080 error_at (token->location, "templates may not be %<virtual%>");
18081 return error_mark_node;
18084 return integer_zero_node;
18087 /* Parse a constant-initializer.
18089 constant-initializer:
18090 = constant-expression
18092 Returns a representation of the constant-expression. */
18095 cp_parser_constant_initializer (cp_parser* parser)
18097 /* Look for the `=' token. */
18098 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
18099 return error_mark_node;
18101 /* It is invalid to write:
18103 struct S { static const int i = { 7 }; };
18106 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
18108 cp_parser_error (parser,
18109 "a brace-enclosed initializer is not allowed here");
18110 /* Consume the opening brace. */
18111 cp_lexer_consume_token (parser->lexer);
18112 /* Skip the initializer. */
18113 cp_parser_skip_to_closing_brace (parser);
18114 /* Look for the trailing `}'. */
18115 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
18117 return error_mark_node;
18120 return cp_parser_constant_expression (parser,
18121 /*allow_non_constant=*/false,
18125 /* Derived classes [gram.class.derived] */
18127 /* Parse a base-clause.
18130 : base-specifier-list
18132 base-specifier-list:
18133 base-specifier ... [opt]
18134 base-specifier-list , base-specifier ... [opt]
18136 Returns a TREE_LIST representing the base-classes, in the order in
18137 which they were declared. The representation of each node is as
18138 described by cp_parser_base_specifier.
18140 In the case that no bases are specified, this function will return
18141 NULL_TREE, not ERROR_MARK_NODE. */
18144 cp_parser_base_clause (cp_parser* parser)
18146 tree bases = NULL_TREE;
18148 /* Look for the `:' that begins the list. */
18149 cp_parser_require (parser, CPP_COLON, RT_COLON);
18151 /* Scan the base-specifier-list. */
18156 bool pack_expansion_p = false;
18158 /* Look for the base-specifier. */
18159 base = cp_parser_base_specifier (parser);
18160 /* Look for the (optional) ellipsis. */
18161 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18163 /* Consume the `...'. */
18164 cp_lexer_consume_token (parser->lexer);
18166 pack_expansion_p = true;
18169 /* Add BASE to the front of the list. */
18170 if (base != error_mark_node)
18172 if (pack_expansion_p)
18173 /* Make this a pack expansion type. */
18174 TREE_VALUE (base) = make_pack_expansion (TREE_VALUE (base));
18177 if (!check_for_bare_parameter_packs (TREE_VALUE (base)))
18179 TREE_CHAIN (base) = bases;
18183 /* Peek at the next token. */
18184 token = cp_lexer_peek_token (parser->lexer);
18185 /* If it's not a comma, then the list is complete. */
18186 if (token->type != CPP_COMMA)
18188 /* Consume the `,'. */
18189 cp_lexer_consume_token (parser->lexer);
18192 /* PARSER->SCOPE may still be non-NULL at this point, if the last
18193 base class had a qualified name. However, the next name that
18194 appears is certainly not qualified. */
18195 parser->scope = NULL_TREE;
18196 parser->qualifying_scope = NULL_TREE;
18197 parser->object_scope = NULL_TREE;
18199 return nreverse (bases);
18202 /* Parse a base-specifier.
18205 :: [opt] nested-name-specifier [opt] class-name
18206 virtual access-specifier [opt] :: [opt] nested-name-specifier
18208 access-specifier virtual [opt] :: [opt] nested-name-specifier
18211 Returns a TREE_LIST. The TREE_PURPOSE will be one of
18212 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
18213 indicate the specifiers provided. The TREE_VALUE will be a TYPE
18214 (or the ERROR_MARK_NODE) indicating the type that was specified. */
18217 cp_parser_base_specifier (cp_parser* parser)
18221 bool virtual_p = false;
18222 bool duplicate_virtual_error_issued_p = false;
18223 bool duplicate_access_error_issued_p = false;
18224 bool class_scope_p, template_p;
18225 tree access = access_default_node;
18228 /* Process the optional `virtual' and `access-specifier'. */
18231 /* Peek at the next token. */
18232 token = cp_lexer_peek_token (parser->lexer);
18233 /* Process `virtual'. */
18234 switch (token->keyword)
18237 /* If `virtual' appears more than once, issue an error. */
18238 if (virtual_p && !duplicate_virtual_error_issued_p)
18240 cp_parser_error (parser,
18241 "%<virtual%> specified more than once in base-specified");
18242 duplicate_virtual_error_issued_p = true;
18247 /* Consume the `virtual' token. */
18248 cp_lexer_consume_token (parser->lexer);
18253 case RID_PROTECTED:
18255 /* If more than one access specifier appears, issue an
18257 if (access != access_default_node
18258 && !duplicate_access_error_issued_p)
18260 cp_parser_error (parser,
18261 "more than one access specifier in base-specified");
18262 duplicate_access_error_issued_p = true;
18265 access = ridpointers[(int) token->keyword];
18267 /* Consume the access-specifier. */
18268 cp_lexer_consume_token (parser->lexer);
18277 /* It is not uncommon to see programs mechanically, erroneously, use
18278 the 'typename' keyword to denote (dependent) qualified types
18279 as base classes. */
18280 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
18282 token = cp_lexer_peek_token (parser->lexer);
18283 if (!processing_template_decl)
18284 error_at (token->location,
18285 "keyword %<typename%> not allowed outside of templates");
18287 error_at (token->location,
18288 "keyword %<typename%> not allowed in this context "
18289 "(the base class is implicitly a type)");
18290 cp_lexer_consume_token (parser->lexer);
18293 /* Look for the optional `::' operator. */
18294 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
18295 /* Look for the nested-name-specifier. The simplest way to
18300 The keyword `typename' is not permitted in a base-specifier or
18301 mem-initializer; in these contexts a qualified name that
18302 depends on a template-parameter is implicitly assumed to be a
18305 is to pretend that we have seen the `typename' keyword at this
18307 cp_parser_nested_name_specifier_opt (parser,
18308 /*typename_keyword_p=*/true,
18309 /*check_dependency_p=*/true,
18311 /*is_declaration=*/true);
18312 /* If the base class is given by a qualified name, assume that names
18313 we see are type names or templates, as appropriate. */
18314 class_scope_p = (parser->scope && TYPE_P (parser->scope));
18315 template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
18317 /* Finally, look for the class-name. */
18318 type = cp_parser_class_name (parser,
18322 /*check_dependency_p=*/true,
18323 /*class_head_p=*/false,
18324 /*is_declaration=*/true);
18326 if (type == error_mark_node)
18327 return error_mark_node;
18329 return finish_base_specifier (TREE_TYPE (type), access, virtual_p);
18332 /* Exception handling [gram.exception] */
18334 /* Parse an (optional) exception-specification.
18336 exception-specification:
18337 throw ( type-id-list [opt] )
18339 Returns a TREE_LIST representing the exception-specification. The
18340 TREE_VALUE of each node is a type. */
18343 cp_parser_exception_specification_opt (cp_parser* parser)
18347 const char *saved_message;
18349 /* Peek at the next token. */
18350 token = cp_lexer_peek_token (parser->lexer);
18352 /* Is it a noexcept-specification? */
18353 if (cp_parser_is_keyword (token, RID_NOEXCEPT))
18356 cp_lexer_consume_token (parser->lexer);
18358 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
18360 cp_lexer_consume_token (parser->lexer);
18362 /* Types may not be defined in an exception-specification. */
18363 saved_message = parser->type_definition_forbidden_message;
18364 parser->type_definition_forbidden_message
18365 = G_("types may not be defined in an exception-specification");
18367 expr = cp_parser_constant_expression (parser, false, NULL);
18369 /* Restore the saved message. */
18370 parser->type_definition_forbidden_message = saved_message;
18372 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18375 expr = boolean_true_node;
18377 return build_noexcept_spec (expr, tf_warning_or_error);
18380 /* If it's not `throw', then there's no exception-specification. */
18381 if (!cp_parser_is_keyword (token, RID_THROW))
18385 /* Enable this once a lot of code has transitioned to noexcept? */
18386 if (cxx_dialect == cxx0x && !in_system_header)
18387 warning (OPT_Wdeprecated, "dynamic exception specifications are "
18388 "deprecated in C++0x; use %<noexcept%> instead");
18391 /* Consume the `throw'. */
18392 cp_lexer_consume_token (parser->lexer);
18394 /* Look for the `('. */
18395 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18397 /* Peek at the next token. */
18398 token = cp_lexer_peek_token (parser->lexer);
18399 /* If it's not a `)', then there is a type-id-list. */
18400 if (token->type != CPP_CLOSE_PAREN)
18402 /* Types may not be defined in an exception-specification. */
18403 saved_message = parser->type_definition_forbidden_message;
18404 parser->type_definition_forbidden_message
18405 = G_("types may not be defined in an exception-specification");
18406 /* Parse the type-id-list. */
18407 type_id_list = cp_parser_type_id_list (parser);
18408 /* Restore the saved message. */
18409 parser->type_definition_forbidden_message = saved_message;
18412 type_id_list = empty_except_spec;
18414 /* Look for the `)'. */
18415 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18417 return type_id_list;
18420 /* Parse an (optional) type-id-list.
18424 type-id-list , type-id ... [opt]
18426 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
18427 in the order that the types were presented. */
18430 cp_parser_type_id_list (cp_parser* parser)
18432 tree types = NULL_TREE;
18439 /* Get the next type-id. */
18440 type = cp_parser_type_id (parser);
18441 /* Parse the optional ellipsis. */
18442 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18444 /* Consume the `...'. */
18445 cp_lexer_consume_token (parser->lexer);
18447 /* Turn the type into a pack expansion expression. */
18448 type = make_pack_expansion (type);
18450 /* Add it to the list. */
18451 types = add_exception_specifier (types, type, /*complain=*/1);
18452 /* Peek at the next token. */
18453 token = cp_lexer_peek_token (parser->lexer);
18454 /* If it is not a `,', we are done. */
18455 if (token->type != CPP_COMMA)
18457 /* Consume the `,'. */
18458 cp_lexer_consume_token (parser->lexer);
18461 return nreverse (types);
18464 /* Parse a try-block.
18467 try compound-statement handler-seq */
18470 cp_parser_try_block (cp_parser* parser)
18474 cp_parser_require_keyword (parser, RID_TRY, RT_TRY);
18475 try_block = begin_try_block ();
18476 cp_parser_compound_statement (parser, NULL, true, false);
18477 finish_try_block (try_block);
18478 cp_parser_handler_seq (parser);
18479 finish_handler_sequence (try_block);
18484 /* Parse a function-try-block.
18486 function-try-block:
18487 try ctor-initializer [opt] function-body handler-seq */
18490 cp_parser_function_try_block (cp_parser* parser)
18492 tree compound_stmt;
18494 bool ctor_initializer_p;
18496 /* Look for the `try' keyword. */
18497 if (!cp_parser_require_keyword (parser, RID_TRY, RT_TRY))
18499 /* Let the rest of the front end know where we are. */
18500 try_block = begin_function_try_block (&compound_stmt);
18501 /* Parse the function-body. */
18503 = cp_parser_ctor_initializer_opt_and_function_body (parser);
18504 /* We're done with the `try' part. */
18505 finish_function_try_block (try_block);
18506 /* Parse the handlers. */
18507 cp_parser_handler_seq (parser);
18508 /* We're done with the handlers. */
18509 finish_function_handler_sequence (try_block, compound_stmt);
18511 return ctor_initializer_p;
18514 /* Parse a handler-seq.
18517 handler handler-seq [opt] */
18520 cp_parser_handler_seq (cp_parser* parser)
18526 /* Parse the handler. */
18527 cp_parser_handler (parser);
18528 /* Peek at the next token. */
18529 token = cp_lexer_peek_token (parser->lexer);
18530 /* If it's not `catch' then there are no more handlers. */
18531 if (!cp_parser_is_keyword (token, RID_CATCH))
18536 /* Parse a handler.
18539 catch ( exception-declaration ) compound-statement */
18542 cp_parser_handler (cp_parser* parser)
18547 cp_parser_require_keyword (parser, RID_CATCH, RT_CATCH);
18548 handler = begin_handler ();
18549 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18550 declaration = cp_parser_exception_declaration (parser);
18551 finish_handler_parms (declaration, handler);
18552 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18553 cp_parser_compound_statement (parser, NULL, false, false);
18554 finish_handler (handler);
18557 /* Parse an exception-declaration.
18559 exception-declaration:
18560 type-specifier-seq declarator
18561 type-specifier-seq abstract-declarator
18565 Returns a VAR_DECL for the declaration, or NULL_TREE if the
18566 ellipsis variant is used. */
18569 cp_parser_exception_declaration (cp_parser* parser)
18571 cp_decl_specifier_seq type_specifiers;
18572 cp_declarator *declarator;
18573 const char *saved_message;
18575 /* If it's an ellipsis, it's easy to handle. */
18576 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18578 /* Consume the `...' token. */
18579 cp_lexer_consume_token (parser->lexer);
18583 /* Types may not be defined in exception-declarations. */
18584 saved_message = parser->type_definition_forbidden_message;
18585 parser->type_definition_forbidden_message
18586 = G_("types may not be defined in exception-declarations");
18588 /* Parse the type-specifier-seq. */
18589 cp_parser_type_specifier_seq (parser, /*is_declaration=*/true,
18590 /*is_trailing_return=*/false,
18592 /* If it's a `)', then there is no declarator. */
18593 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
18596 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
18597 /*ctor_dtor_or_conv_p=*/NULL,
18598 /*parenthesized_p=*/NULL,
18599 /*member_p=*/false);
18601 /* Restore the saved message. */
18602 parser->type_definition_forbidden_message = saved_message;
18604 if (!type_specifiers.any_specifiers_p)
18605 return error_mark_node;
18607 return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL);
18610 /* Parse a throw-expression.
18613 throw assignment-expression [opt]
18615 Returns a THROW_EXPR representing the throw-expression. */
18618 cp_parser_throw_expression (cp_parser* parser)
18623 cp_parser_require_keyword (parser, RID_THROW, RT_THROW);
18624 token = cp_lexer_peek_token (parser->lexer);
18625 /* Figure out whether or not there is an assignment-expression
18626 following the "throw" keyword. */
18627 if (token->type == CPP_COMMA
18628 || token->type == CPP_SEMICOLON
18629 || token->type == CPP_CLOSE_PAREN
18630 || token->type == CPP_CLOSE_SQUARE
18631 || token->type == CPP_CLOSE_BRACE
18632 || token->type == CPP_COLON)
18633 expression = NULL_TREE;
18635 expression = cp_parser_assignment_expression (parser,
18636 /*cast_p=*/false, NULL);
18638 return build_throw (expression);
18641 /* GNU Extensions */
18643 /* Parse an (optional) asm-specification.
18646 asm ( string-literal )
18648 If the asm-specification is present, returns a STRING_CST
18649 corresponding to the string-literal. Otherwise, returns
18653 cp_parser_asm_specification_opt (cp_parser* parser)
18656 tree asm_specification;
18658 /* Peek at the next token. */
18659 token = cp_lexer_peek_token (parser->lexer);
18660 /* If the next token isn't the `asm' keyword, then there's no
18661 asm-specification. */
18662 if (!cp_parser_is_keyword (token, RID_ASM))
18665 /* Consume the `asm' token. */
18666 cp_lexer_consume_token (parser->lexer);
18667 /* Look for the `('. */
18668 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18670 /* Look for the string-literal. */
18671 asm_specification = cp_parser_string_literal (parser, false, false);
18673 /* Look for the `)'. */
18674 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18676 return asm_specification;
18679 /* Parse an asm-operand-list.
18683 asm-operand-list , asm-operand
18686 string-literal ( expression )
18687 [ string-literal ] string-literal ( expression )
18689 Returns a TREE_LIST representing the operands. The TREE_VALUE of
18690 each node is the expression. The TREE_PURPOSE is itself a
18691 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
18692 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
18693 is a STRING_CST for the string literal before the parenthesis. Returns
18694 ERROR_MARK_NODE if any of the operands are invalid. */
18697 cp_parser_asm_operand_list (cp_parser* parser)
18699 tree asm_operands = NULL_TREE;
18700 bool invalid_operands = false;
18704 tree string_literal;
18708 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
18710 /* Consume the `[' token. */
18711 cp_lexer_consume_token (parser->lexer);
18712 /* Read the operand name. */
18713 name = cp_parser_identifier (parser);
18714 if (name != error_mark_node)
18715 name = build_string (IDENTIFIER_LENGTH (name),
18716 IDENTIFIER_POINTER (name));
18717 /* Look for the closing `]'. */
18718 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
18722 /* Look for the string-literal. */
18723 string_literal = cp_parser_string_literal (parser, false, false);
18725 /* Look for the `('. */
18726 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18727 /* Parse the expression. */
18728 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
18729 /* Look for the `)'. */
18730 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18732 if (name == error_mark_node
18733 || string_literal == error_mark_node
18734 || expression == error_mark_node)
18735 invalid_operands = true;
18737 /* Add this operand to the list. */
18738 asm_operands = tree_cons (build_tree_list (name, string_literal),
18741 /* If the next token is not a `,', there are no more
18743 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18745 /* Consume the `,'. */
18746 cp_lexer_consume_token (parser->lexer);
18749 return invalid_operands ? error_mark_node : nreverse (asm_operands);
18752 /* Parse an asm-clobber-list.
18756 asm-clobber-list , string-literal
18758 Returns a TREE_LIST, indicating the clobbers in the order that they
18759 appeared. The TREE_VALUE of each node is a STRING_CST. */
18762 cp_parser_asm_clobber_list (cp_parser* parser)
18764 tree clobbers = NULL_TREE;
18768 tree string_literal;
18770 /* Look for the string literal. */
18771 string_literal = cp_parser_string_literal (parser, false, false);
18772 /* Add it to the list. */
18773 clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
18774 /* If the next token is not a `,', then the list is
18776 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18778 /* Consume the `,' token. */
18779 cp_lexer_consume_token (parser->lexer);
18785 /* Parse an asm-label-list.
18789 asm-label-list , identifier
18791 Returns a TREE_LIST, indicating the labels in the order that they
18792 appeared. The TREE_VALUE of each node is a label. */
18795 cp_parser_asm_label_list (cp_parser* parser)
18797 tree labels = NULL_TREE;
18801 tree identifier, label, name;
18803 /* Look for the identifier. */
18804 identifier = cp_parser_identifier (parser);
18805 if (!error_operand_p (identifier))
18807 label = lookup_label (identifier);
18808 if (TREE_CODE (label) == LABEL_DECL)
18810 TREE_USED (label) = 1;
18811 check_goto (label);
18812 name = build_string (IDENTIFIER_LENGTH (identifier),
18813 IDENTIFIER_POINTER (identifier));
18814 labels = tree_cons (name, label, labels);
18817 /* If the next token is not a `,', then the list is
18819 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18821 /* Consume the `,' token. */
18822 cp_lexer_consume_token (parser->lexer);
18825 return nreverse (labels);
18828 /* Parse an (optional) series of attributes.
18831 attributes attribute
18834 __attribute__ (( attribute-list [opt] ))
18836 The return value is as for cp_parser_attribute_list. */
18839 cp_parser_attributes_opt (cp_parser* parser)
18841 tree attributes = NULL_TREE;
18846 tree attribute_list;
18848 /* Peek at the next token. */
18849 token = cp_lexer_peek_token (parser->lexer);
18850 /* If it's not `__attribute__', then we're done. */
18851 if (token->keyword != RID_ATTRIBUTE)
18854 /* Consume the `__attribute__' keyword. */
18855 cp_lexer_consume_token (parser->lexer);
18856 /* Look for the two `(' tokens. */
18857 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18858 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18860 /* Peek at the next token. */
18861 token = cp_lexer_peek_token (parser->lexer);
18862 if (token->type != CPP_CLOSE_PAREN)
18863 /* Parse the attribute-list. */
18864 attribute_list = cp_parser_attribute_list (parser);
18866 /* If the next token is a `)', then there is no attribute
18868 attribute_list = NULL;
18870 /* Look for the two `)' tokens. */
18871 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18872 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18874 /* Add these new attributes to the list. */
18875 attributes = chainon (attributes, attribute_list);
18881 /* Parse an attribute-list.
18885 attribute-list , attribute
18889 identifier ( identifier )
18890 identifier ( identifier , expression-list )
18891 identifier ( expression-list )
18893 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
18894 to an attribute. The TREE_PURPOSE of each node is the identifier
18895 indicating which attribute is in use. The TREE_VALUE represents
18896 the arguments, if any. */
18899 cp_parser_attribute_list (cp_parser* parser)
18901 tree attribute_list = NULL_TREE;
18902 bool save_translate_strings_p = parser->translate_strings_p;
18904 parser->translate_strings_p = false;
18911 /* Look for the identifier. We also allow keywords here; for
18912 example `__attribute__ ((const))' is legal. */
18913 token = cp_lexer_peek_token (parser->lexer);
18914 if (token->type == CPP_NAME
18915 || token->type == CPP_KEYWORD)
18917 tree arguments = NULL_TREE;
18919 /* Consume the token. */
18920 token = cp_lexer_consume_token (parser->lexer);
18922 /* Save away the identifier that indicates which attribute
18924 identifier = (token->type == CPP_KEYWORD)
18925 /* For keywords, use the canonical spelling, not the
18926 parsed identifier. */
18927 ? ridpointers[(int) token->keyword]
18930 attribute = build_tree_list (identifier, NULL_TREE);
18932 /* Peek at the next token. */
18933 token = cp_lexer_peek_token (parser->lexer);
18934 /* If it's an `(', then parse the attribute arguments. */
18935 if (token->type == CPP_OPEN_PAREN)
18938 int attr_flag = (attribute_takes_identifier_p (identifier)
18939 ? id_attr : normal_attr);
18940 vec = cp_parser_parenthesized_expression_list
18941 (parser, attr_flag, /*cast_p=*/false,
18942 /*allow_expansion_p=*/false,
18943 /*non_constant_p=*/NULL);
18945 arguments = error_mark_node;
18948 arguments = build_tree_list_vec (vec);
18949 release_tree_vector (vec);
18951 /* Save the arguments away. */
18952 TREE_VALUE (attribute) = arguments;
18955 if (arguments != error_mark_node)
18957 /* Add this attribute to the list. */
18958 TREE_CHAIN (attribute) = attribute_list;
18959 attribute_list = attribute;
18962 token = cp_lexer_peek_token (parser->lexer);
18964 /* Now, look for more attributes. If the next token isn't a
18965 `,', we're done. */
18966 if (token->type != CPP_COMMA)
18969 /* Consume the comma and keep going. */
18970 cp_lexer_consume_token (parser->lexer);
18972 parser->translate_strings_p = save_translate_strings_p;
18974 /* We built up the list in reverse order. */
18975 return nreverse (attribute_list);
18978 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
18979 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
18980 current value of the PEDANTIC flag, regardless of whether or not
18981 the `__extension__' keyword is present. The caller is responsible
18982 for restoring the value of the PEDANTIC flag. */
18985 cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
18987 /* Save the old value of the PEDANTIC flag. */
18988 *saved_pedantic = pedantic;
18990 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
18992 /* Consume the `__extension__' token. */
18993 cp_lexer_consume_token (parser->lexer);
18994 /* We're not being pedantic while the `__extension__' keyword is
19004 /* Parse a label declaration.
19007 __label__ label-declarator-seq ;
19009 label-declarator-seq:
19010 identifier , label-declarator-seq
19014 cp_parser_label_declaration (cp_parser* parser)
19016 /* Look for the `__label__' keyword. */
19017 cp_parser_require_keyword (parser, RID_LABEL, RT_LABEL);
19023 /* Look for an identifier. */
19024 identifier = cp_parser_identifier (parser);
19025 /* If we failed, stop. */
19026 if (identifier == error_mark_node)
19028 /* Declare it as a label. */
19029 finish_label_decl (identifier);
19030 /* If the next token is a `;', stop. */
19031 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
19033 /* Look for the `,' separating the label declarations. */
19034 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
19037 /* Look for the final `;'. */
19038 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
19041 /* Support Functions */
19043 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
19044 NAME should have one of the representations used for an
19045 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
19046 is returned. If PARSER->SCOPE is a dependent type, then a
19047 SCOPE_REF is returned.
19049 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
19050 returned; the name was already resolved when the TEMPLATE_ID_EXPR
19051 was formed. Abstractly, such entities should not be passed to this
19052 function, because they do not need to be looked up, but it is
19053 simpler to check for this special case here, rather than at the
19056 In cases not explicitly covered above, this function returns a
19057 DECL, OVERLOAD, or baselink representing the result of the lookup.
19058 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
19061 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
19062 (e.g., "struct") that was used. In that case bindings that do not
19063 refer to types are ignored.
19065 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
19068 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
19071 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
19074 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
19075 TREE_LIST of candidates if name-lookup results in an ambiguity, and
19076 NULL_TREE otherwise. */
19079 cp_parser_lookup_name (cp_parser *parser, tree name,
19080 enum tag_types tag_type,
19083 bool check_dependency,
19084 tree *ambiguous_decls,
19085 location_t name_location)
19089 tree object_type = parser->context->object_type;
19091 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
19092 flags |= LOOKUP_COMPLAIN;
19094 /* Assume that the lookup will be unambiguous. */
19095 if (ambiguous_decls)
19096 *ambiguous_decls = NULL_TREE;
19098 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
19099 no longer valid. Note that if we are parsing tentatively, and
19100 the parse fails, OBJECT_TYPE will be automatically restored. */
19101 parser->context->object_type = NULL_TREE;
19103 if (name == error_mark_node)
19104 return error_mark_node;
19106 /* A template-id has already been resolved; there is no lookup to
19108 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
19110 if (BASELINK_P (name))
19112 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
19113 == TEMPLATE_ID_EXPR);
19117 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
19118 it should already have been checked to make sure that the name
19119 used matches the type being destroyed. */
19120 if (TREE_CODE (name) == BIT_NOT_EXPR)
19124 /* Figure out to which type this destructor applies. */
19126 type = parser->scope;
19127 else if (object_type)
19128 type = object_type;
19130 type = current_class_type;
19131 /* If that's not a class type, there is no destructor. */
19132 if (!type || !CLASS_TYPE_P (type))
19133 return error_mark_node;
19134 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
19135 lazily_declare_fn (sfk_destructor, type);
19136 if (!CLASSTYPE_DESTRUCTORS (type))
19137 return error_mark_node;
19138 /* If it was a class type, return the destructor. */
19139 return CLASSTYPE_DESTRUCTORS (type);
19142 /* By this point, the NAME should be an ordinary identifier. If
19143 the id-expression was a qualified name, the qualifying scope is
19144 stored in PARSER->SCOPE at this point. */
19145 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
19147 /* Perform the lookup. */
19152 if (parser->scope == error_mark_node)
19153 return error_mark_node;
19155 /* If the SCOPE is dependent, the lookup must be deferred until
19156 the template is instantiated -- unless we are explicitly
19157 looking up names in uninstantiated templates. Even then, we
19158 cannot look up the name if the scope is not a class type; it
19159 might, for example, be a template type parameter. */
19160 dependent_p = (TYPE_P (parser->scope)
19161 && dependent_scope_p (parser->scope));
19162 if ((check_dependency || !CLASS_TYPE_P (parser->scope))
19164 /* Defer lookup. */
19165 decl = error_mark_node;
19168 tree pushed_scope = NULL_TREE;
19170 /* If PARSER->SCOPE is a dependent type, then it must be a
19171 class type, and we must not be checking dependencies;
19172 otherwise, we would have processed this lookup above. So
19173 that PARSER->SCOPE is not considered a dependent base by
19174 lookup_member, we must enter the scope here. */
19176 pushed_scope = push_scope (parser->scope);
19178 /* If the PARSER->SCOPE is a template specialization, it
19179 may be instantiated during name lookup. In that case,
19180 errors may be issued. Even if we rollback the current
19181 tentative parse, those errors are valid. */
19182 decl = lookup_qualified_name (parser->scope, name,
19183 tag_type != none_type,
19184 /*complain=*/true);
19186 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
19187 lookup result and the nested-name-specifier nominates a class C:
19188 * if the name specified after the nested-name-specifier, when
19189 looked up in C, is the injected-class-name of C (Clause 9), or
19190 * if the name specified after the nested-name-specifier is the
19191 same as the identifier or the simple-template-id's template-
19192 name in the last component of the nested-name-specifier,
19193 the name is instead considered to name the constructor of
19194 class C. [ Note: for example, the constructor is not an
19195 acceptable lookup result in an elaborated-type-specifier so
19196 the constructor would not be used in place of the
19197 injected-class-name. --end note ] Such a constructor name
19198 shall be used only in the declarator-id of a declaration that
19199 names a constructor or in a using-declaration. */
19200 if (tag_type == none_type
19201 && DECL_SELF_REFERENCE_P (decl)
19202 && same_type_p (DECL_CONTEXT (decl), parser->scope))
19203 decl = lookup_qualified_name (parser->scope, ctor_identifier,
19204 tag_type != none_type,
19205 /*complain=*/true);
19207 /* If we have a single function from a using decl, pull it out. */
19208 if (TREE_CODE (decl) == OVERLOAD
19209 && !really_overloaded_fn (decl))
19210 decl = OVL_FUNCTION (decl);
19213 pop_scope (pushed_scope);
19216 /* If the scope is a dependent type and either we deferred lookup or
19217 we did lookup but didn't find the name, rememeber the name. */
19218 if (decl == error_mark_node && TYPE_P (parser->scope)
19219 && dependent_type_p (parser->scope))
19225 /* The resolution to Core Issue 180 says that `struct
19226 A::B' should be considered a type-name, even if `A'
19228 type = make_typename_type (parser->scope, name, tag_type,
19229 /*complain=*/tf_error);
19230 decl = TYPE_NAME (type);
19232 else if (is_template
19233 && (cp_parser_next_token_ends_template_argument_p (parser)
19234 || cp_lexer_next_token_is (parser->lexer,
19236 decl = make_unbound_class_template (parser->scope,
19238 /*complain=*/tf_error);
19240 decl = build_qualified_name (/*type=*/NULL_TREE,
19241 parser->scope, name,
19244 parser->qualifying_scope = parser->scope;
19245 parser->object_scope = NULL_TREE;
19247 else if (object_type)
19249 tree object_decl = NULL_TREE;
19250 /* Look up the name in the scope of the OBJECT_TYPE, unless the
19251 OBJECT_TYPE is not a class. */
19252 if (CLASS_TYPE_P (object_type))
19253 /* If the OBJECT_TYPE is a template specialization, it may
19254 be instantiated during name lookup. In that case, errors
19255 may be issued. Even if we rollback the current tentative
19256 parse, those errors are valid. */
19257 object_decl = lookup_member (object_type,
19260 tag_type != none_type);
19261 /* Look it up in the enclosing context, too. */
19262 decl = lookup_name_real (name, tag_type != none_type,
19264 /*block_p=*/true, is_namespace, flags);
19265 parser->object_scope = object_type;
19266 parser->qualifying_scope = NULL_TREE;
19268 decl = object_decl;
19272 decl = lookup_name_real (name, tag_type != none_type,
19274 /*block_p=*/true, is_namespace, flags);
19275 parser->qualifying_scope = NULL_TREE;
19276 parser->object_scope = NULL_TREE;
19279 /* If the lookup failed, let our caller know. */
19280 if (!decl || decl == error_mark_node)
19281 return error_mark_node;
19283 /* Pull out the template from an injected-class-name (or multiple). */
19285 decl = maybe_get_template_decl_from_type_decl (decl);
19287 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
19288 if (TREE_CODE (decl) == TREE_LIST)
19290 if (ambiguous_decls)
19291 *ambiguous_decls = decl;
19292 /* The error message we have to print is too complicated for
19293 cp_parser_error, so we incorporate its actions directly. */
19294 if (!cp_parser_simulate_error (parser))
19296 error_at (name_location, "reference to %qD is ambiguous",
19298 print_candidates (decl);
19300 return error_mark_node;
19303 gcc_assert (DECL_P (decl)
19304 || TREE_CODE (decl) == OVERLOAD
19305 || TREE_CODE (decl) == SCOPE_REF
19306 || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
19307 || BASELINK_P (decl));
19309 /* If we have resolved the name of a member declaration, check to
19310 see if the declaration is accessible. When the name resolves to
19311 set of overloaded functions, accessibility is checked when
19312 overload resolution is done.
19314 During an explicit instantiation, access is not checked at all,
19315 as per [temp.explicit]. */
19317 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
19322 /* Like cp_parser_lookup_name, but for use in the typical case where
19323 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
19324 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
19327 cp_parser_lookup_name_simple (cp_parser* parser, tree name, location_t location)
19329 return cp_parser_lookup_name (parser, name,
19331 /*is_template=*/false,
19332 /*is_namespace=*/false,
19333 /*check_dependency=*/true,
19334 /*ambiguous_decls=*/NULL,
19338 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
19339 the current context, return the TYPE_DECL. If TAG_NAME_P is
19340 true, the DECL indicates the class being defined in a class-head,
19341 or declared in an elaborated-type-specifier.
19343 Otherwise, return DECL. */
19346 cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
19348 /* If the TEMPLATE_DECL is being declared as part of a class-head,
19349 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
19352 template <typename T> struct B;
19355 template <typename T> struct A::B {};
19357 Similarly, in an elaborated-type-specifier:
19359 namespace N { struct X{}; }
19362 template <typename T> friend struct N::X;
19365 However, if the DECL refers to a class type, and we are in
19366 the scope of the class, then the name lookup automatically
19367 finds the TYPE_DECL created by build_self_reference rather
19368 than a TEMPLATE_DECL. For example, in:
19370 template <class T> struct S {
19374 there is no need to handle such case. */
19376 if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
19377 return DECL_TEMPLATE_RESULT (decl);
19382 /* If too many, or too few, template-parameter lists apply to the
19383 declarator, issue an error message. Returns TRUE if all went well,
19384 and FALSE otherwise. */
19387 cp_parser_check_declarator_template_parameters (cp_parser* parser,
19388 cp_declarator *declarator,
19389 location_t declarator_location)
19391 unsigned num_templates;
19393 /* We haven't seen any classes that involve template parameters yet. */
19396 switch (declarator->kind)
19399 if (declarator->u.id.qualifying_scope)
19403 scope = declarator->u.id.qualifying_scope;
19405 while (scope && CLASS_TYPE_P (scope))
19407 /* You're supposed to have one `template <...>'
19408 for every template class, but you don't need one
19409 for a full specialization. For example:
19411 template <class T> struct S{};
19412 template <> struct S<int> { void f(); };
19413 void S<int>::f () {}
19415 is correct; there shouldn't be a `template <>' for
19416 the definition of `S<int>::f'. */
19417 if (!CLASSTYPE_TEMPLATE_INFO (scope))
19418 /* If SCOPE does not have template information of any
19419 kind, then it is not a template, nor is it nested
19420 within a template. */
19422 if (explicit_class_specialization_p (scope))
19424 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
19427 scope = TYPE_CONTEXT (scope);
19430 else if (TREE_CODE (declarator->u.id.unqualified_name)
19431 == TEMPLATE_ID_EXPR)
19432 /* If the DECLARATOR has the form `X<y>' then it uses one
19433 additional level of template parameters. */
19436 return cp_parser_check_template_parameters
19437 (parser, num_templates, declarator_location, declarator);
19443 case cdk_reference:
19445 return (cp_parser_check_declarator_template_parameters
19446 (parser, declarator->declarator, declarator_location));
19452 gcc_unreachable ();
19457 /* NUM_TEMPLATES were used in the current declaration. If that is
19458 invalid, return FALSE and issue an error messages. Otherwise,
19459 return TRUE. If DECLARATOR is non-NULL, then we are checking a
19460 declarator and we can print more accurate diagnostics. */
19463 cp_parser_check_template_parameters (cp_parser* parser,
19464 unsigned num_templates,
19465 location_t location,
19466 cp_declarator *declarator)
19468 /* If there are the same number of template classes and parameter
19469 lists, that's OK. */
19470 if (parser->num_template_parameter_lists == num_templates)
19472 /* If there are more, but only one more, then we are referring to a
19473 member template. That's OK too. */
19474 if (parser->num_template_parameter_lists == num_templates + 1)
19476 /* If there are more template classes than parameter lists, we have
19479 template <class T> void S<T>::R<T>::f (); */
19480 if (parser->num_template_parameter_lists < num_templates)
19482 if (declarator && !current_function_decl)
19483 error_at (location, "specializing member %<%T::%E%> "
19484 "requires %<template<>%> syntax",
19485 declarator->u.id.qualifying_scope,
19486 declarator->u.id.unqualified_name);
19487 else if (declarator)
19488 error_at (location, "invalid declaration of %<%T::%E%>",
19489 declarator->u.id.qualifying_scope,
19490 declarator->u.id.unqualified_name);
19492 error_at (location, "too few template-parameter-lists");
19495 /* Otherwise, there are too many template parameter lists. We have
19498 template <class T> template <class U> void S::f(); */
19499 error_at (location, "too many template-parameter-lists");
19503 /* Parse an optional `::' token indicating that the following name is
19504 from the global namespace. If so, PARSER->SCOPE is set to the
19505 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
19506 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
19507 Returns the new value of PARSER->SCOPE, if the `::' token is
19508 present, and NULL_TREE otherwise. */
19511 cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
19515 /* Peek at the next token. */
19516 token = cp_lexer_peek_token (parser->lexer);
19517 /* If we're looking at a `::' token then we're starting from the
19518 global namespace, not our current location. */
19519 if (token->type == CPP_SCOPE)
19521 /* Consume the `::' token. */
19522 cp_lexer_consume_token (parser->lexer);
19523 /* Set the SCOPE so that we know where to start the lookup. */
19524 parser->scope = global_namespace;
19525 parser->qualifying_scope = global_namespace;
19526 parser->object_scope = NULL_TREE;
19528 return parser->scope;
19530 else if (!current_scope_valid_p)
19532 parser->scope = NULL_TREE;
19533 parser->qualifying_scope = NULL_TREE;
19534 parser->object_scope = NULL_TREE;
19540 /* Returns TRUE if the upcoming token sequence is the start of a
19541 constructor declarator. If FRIEND_P is true, the declarator is
19542 preceded by the `friend' specifier. */
19545 cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
19547 bool constructor_p;
19548 tree nested_name_specifier;
19549 cp_token *next_token;
19551 /* The common case is that this is not a constructor declarator, so
19552 try to avoid doing lots of work if at all possible. It's not
19553 valid declare a constructor at function scope. */
19554 if (parser->in_function_body)
19556 /* And only certain tokens can begin a constructor declarator. */
19557 next_token = cp_lexer_peek_token (parser->lexer);
19558 if (next_token->type != CPP_NAME
19559 && next_token->type != CPP_SCOPE
19560 && next_token->type != CPP_NESTED_NAME_SPECIFIER
19561 && next_token->type != CPP_TEMPLATE_ID)
19564 /* Parse tentatively; we are going to roll back all of the tokens
19566 cp_parser_parse_tentatively (parser);
19567 /* Assume that we are looking at a constructor declarator. */
19568 constructor_p = true;
19570 /* Look for the optional `::' operator. */
19571 cp_parser_global_scope_opt (parser,
19572 /*current_scope_valid_p=*/false);
19573 /* Look for the nested-name-specifier. */
19574 nested_name_specifier
19575 = (cp_parser_nested_name_specifier_opt (parser,
19576 /*typename_keyword_p=*/false,
19577 /*check_dependency_p=*/false,
19579 /*is_declaration=*/false));
19580 /* Outside of a class-specifier, there must be a
19581 nested-name-specifier. */
19582 if (!nested_name_specifier &&
19583 (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type)
19585 constructor_p = false;
19586 else if (nested_name_specifier == error_mark_node)
19587 constructor_p = false;
19589 /* If we have a class scope, this is easy; DR 147 says that S::S always
19590 names the constructor, and no other qualified name could. */
19591 if (constructor_p && nested_name_specifier
19592 && CLASS_TYPE_P (nested_name_specifier))
19594 tree id = cp_parser_unqualified_id (parser,
19595 /*template_keyword_p=*/false,
19596 /*check_dependency_p=*/false,
19597 /*declarator_p=*/true,
19598 /*optional_p=*/false);
19599 if (is_overloaded_fn (id))
19600 id = DECL_NAME (get_first_fn (id));
19601 if (!constructor_name_p (id, nested_name_specifier))
19602 constructor_p = false;
19604 /* If we still think that this might be a constructor-declarator,
19605 look for a class-name. */
19606 else if (constructor_p)
19610 template <typename T> struct S {
19614 we must recognize that the nested `S' names a class. */
19616 type_decl = cp_parser_class_name (parser,
19617 /*typename_keyword_p=*/false,
19618 /*template_keyword_p=*/false,
19620 /*check_dependency_p=*/false,
19621 /*class_head_p=*/false,
19622 /*is_declaration=*/false);
19623 /* If there was no class-name, then this is not a constructor. */
19624 constructor_p = !cp_parser_error_occurred (parser);
19626 /* If we're still considering a constructor, we have to see a `(',
19627 to begin the parameter-declaration-clause, followed by either a
19628 `)', an `...', or a decl-specifier. We need to check for a
19629 type-specifier to avoid being fooled into thinking that:
19633 is a constructor. (It is actually a function named `f' that
19634 takes one parameter (of type `int') and returns a value of type
19637 && !cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
19638 constructor_p = false;
19641 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
19642 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
19643 /* A parameter declaration begins with a decl-specifier,
19644 which is either the "attribute" keyword, a storage class
19645 specifier, or (usually) a type-specifier. */
19646 && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
19649 tree pushed_scope = NULL_TREE;
19650 unsigned saved_num_template_parameter_lists;
19652 /* Names appearing in the type-specifier should be looked up
19653 in the scope of the class. */
19654 if (current_class_type)
19658 type = TREE_TYPE (type_decl);
19659 if (TREE_CODE (type) == TYPENAME_TYPE)
19661 type = resolve_typename_type (type,
19662 /*only_current_p=*/false);
19663 if (TREE_CODE (type) == TYPENAME_TYPE)
19665 cp_parser_abort_tentative_parse (parser);
19669 pushed_scope = push_scope (type);
19672 /* Inside the constructor parameter list, surrounding
19673 template-parameter-lists do not apply. */
19674 saved_num_template_parameter_lists
19675 = parser->num_template_parameter_lists;
19676 parser->num_template_parameter_lists = 0;
19678 /* Look for the type-specifier. */
19679 cp_parser_type_specifier (parser,
19680 CP_PARSER_FLAGS_NONE,
19681 /*decl_specs=*/NULL,
19682 /*is_declarator=*/true,
19683 /*declares_class_or_enum=*/NULL,
19684 /*is_cv_qualifier=*/NULL);
19686 parser->num_template_parameter_lists
19687 = saved_num_template_parameter_lists;
19689 /* Leave the scope of the class. */
19691 pop_scope (pushed_scope);
19693 constructor_p = !cp_parser_error_occurred (parser);
19697 /* We did not really want to consume any tokens. */
19698 cp_parser_abort_tentative_parse (parser);
19700 return constructor_p;
19703 /* Parse the definition of the function given by the DECL_SPECIFIERS,
19704 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
19705 they must be performed once we are in the scope of the function.
19707 Returns the function defined. */
19710 cp_parser_function_definition_from_specifiers_and_declarator
19711 (cp_parser* parser,
19712 cp_decl_specifier_seq *decl_specifiers,
19714 const cp_declarator *declarator)
19719 /* Begin the function-definition. */
19720 success_p = start_function (decl_specifiers, declarator, attributes);
19722 /* The things we're about to see are not directly qualified by any
19723 template headers we've seen thus far. */
19724 reset_specialization ();
19726 /* If there were names looked up in the decl-specifier-seq that we
19727 did not check, check them now. We must wait until we are in the
19728 scope of the function to perform the checks, since the function
19729 might be a friend. */
19730 perform_deferred_access_checks ();
19734 /* Skip the entire function. */
19735 cp_parser_skip_to_end_of_block_or_statement (parser);
19736 fn = error_mark_node;
19738 else if (DECL_INITIAL (current_function_decl) != error_mark_node)
19740 /* Seen already, skip it. An error message has already been output. */
19741 cp_parser_skip_to_end_of_block_or_statement (parser);
19742 fn = current_function_decl;
19743 current_function_decl = NULL_TREE;
19744 /* If this is a function from a class, pop the nested class. */
19745 if (current_class_name)
19746 pop_nested_class ();
19751 if (DECL_DECLARED_INLINE_P (current_function_decl))
19752 tv = TV_PARSE_INLINE;
19754 tv = TV_PARSE_FUNC;
19756 fn = cp_parser_function_definition_after_declarator (parser,
19757 /*inline_p=*/false);
19764 /* Parse the part of a function-definition that follows the
19765 declarator. INLINE_P is TRUE iff this function is an inline
19766 function defined within a class-specifier.
19768 Returns the function defined. */
19771 cp_parser_function_definition_after_declarator (cp_parser* parser,
19775 bool ctor_initializer_p = false;
19776 bool saved_in_unbraced_linkage_specification_p;
19777 bool saved_in_function_body;
19778 unsigned saved_num_template_parameter_lists;
19781 saved_in_function_body = parser->in_function_body;
19782 parser->in_function_body = true;
19783 /* If the next token is `return', then the code may be trying to
19784 make use of the "named return value" extension that G++ used to
19786 token = cp_lexer_peek_token (parser->lexer);
19787 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
19789 /* Consume the `return' keyword. */
19790 cp_lexer_consume_token (parser->lexer);
19791 /* Look for the identifier that indicates what value is to be
19793 cp_parser_identifier (parser);
19794 /* Issue an error message. */
19795 error_at (token->location,
19796 "named return values are no longer supported");
19797 /* Skip tokens until we reach the start of the function body. */
19800 cp_token *token = cp_lexer_peek_token (parser->lexer);
19801 if (token->type == CPP_OPEN_BRACE
19802 || token->type == CPP_EOF
19803 || token->type == CPP_PRAGMA_EOL)
19805 cp_lexer_consume_token (parser->lexer);
19808 /* The `extern' in `extern "C" void f () { ... }' does not apply to
19809 anything declared inside `f'. */
19810 saved_in_unbraced_linkage_specification_p
19811 = parser->in_unbraced_linkage_specification_p;
19812 parser->in_unbraced_linkage_specification_p = false;
19813 /* Inside the function, surrounding template-parameter-lists do not
19815 saved_num_template_parameter_lists
19816 = parser->num_template_parameter_lists;
19817 parser->num_template_parameter_lists = 0;
19819 start_lambda_scope (current_function_decl);
19821 /* If the next token is `try', then we are looking at a
19822 function-try-block. */
19823 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
19824 ctor_initializer_p = cp_parser_function_try_block (parser);
19825 /* A function-try-block includes the function-body, so we only do
19826 this next part if we're not processing a function-try-block. */
19829 = cp_parser_ctor_initializer_opt_and_function_body (parser);
19831 finish_lambda_scope ();
19833 /* Finish the function. */
19834 fn = finish_function ((ctor_initializer_p ? 1 : 0) |
19835 (inline_p ? 2 : 0));
19836 /* Generate code for it, if necessary. */
19837 expand_or_defer_fn (fn);
19838 /* Restore the saved values. */
19839 parser->in_unbraced_linkage_specification_p
19840 = saved_in_unbraced_linkage_specification_p;
19841 parser->num_template_parameter_lists
19842 = saved_num_template_parameter_lists;
19843 parser->in_function_body = saved_in_function_body;
19848 /* Parse a template-declaration, assuming that the `export' (and
19849 `extern') keywords, if present, has already been scanned. MEMBER_P
19850 is as for cp_parser_template_declaration. */
19853 cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
19855 tree decl = NULL_TREE;
19856 VEC (deferred_access_check,gc) *checks;
19857 tree parameter_list;
19858 bool friend_p = false;
19859 bool need_lang_pop;
19862 /* Look for the `template' keyword. */
19863 token = cp_lexer_peek_token (parser->lexer);
19864 if (!cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE))
19868 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
19870 if (at_class_scope_p () && current_function_decl)
19872 /* 14.5.2.2 [temp.mem]
19874 A local class shall not have member templates. */
19875 error_at (token->location,
19876 "invalid declaration of member template in local class");
19877 cp_parser_skip_to_end_of_block_or_statement (parser);
19882 A template ... shall not have C linkage. */
19883 if (current_lang_name == lang_name_c)
19885 error_at (token->location, "template with C linkage");
19886 /* Give it C++ linkage to avoid confusing other parts of the
19888 push_lang_context (lang_name_cplusplus);
19889 need_lang_pop = true;
19892 need_lang_pop = false;
19894 /* We cannot perform access checks on the template parameter
19895 declarations until we know what is being declared, just as we
19896 cannot check the decl-specifier list. */
19897 push_deferring_access_checks (dk_deferred);
19899 /* If the next token is `>', then we have an invalid
19900 specialization. Rather than complain about an invalid template
19901 parameter, issue an error message here. */
19902 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
19904 cp_parser_error (parser, "invalid explicit specialization");
19905 begin_specialization ();
19906 parameter_list = NULL_TREE;
19910 /* Parse the template parameters. */
19911 parameter_list = cp_parser_template_parameter_list (parser);
19912 fixup_template_parms ();
19915 /* Get the deferred access checks from the parameter list. These
19916 will be checked once we know what is being declared, as for a
19917 member template the checks must be performed in the scope of the
19918 class containing the member. */
19919 checks = get_deferred_access_checks ();
19921 /* Look for the `>'. */
19922 cp_parser_skip_to_end_of_template_parameter_list (parser);
19923 /* We just processed one more parameter list. */
19924 ++parser->num_template_parameter_lists;
19925 /* If the next token is `template', there are more template
19927 if (cp_lexer_next_token_is_keyword (parser->lexer,
19929 cp_parser_template_declaration_after_export (parser, member_p);
19932 /* There are no access checks when parsing a template, as we do not
19933 know if a specialization will be a friend. */
19934 push_deferring_access_checks (dk_no_check);
19935 token = cp_lexer_peek_token (parser->lexer);
19936 decl = cp_parser_single_declaration (parser,
19939 /*explicit_specialization_p=*/false,
19941 pop_deferring_access_checks ();
19943 /* If this is a member template declaration, let the front
19945 if (member_p && !friend_p && decl)
19947 if (TREE_CODE (decl) == TYPE_DECL)
19948 cp_parser_check_access_in_redeclaration (decl, token->location);
19950 decl = finish_member_template_decl (decl);
19952 else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL)
19953 make_friend_class (current_class_type, TREE_TYPE (decl),
19954 /*complain=*/true);
19956 /* We are done with the current parameter list. */
19957 --parser->num_template_parameter_lists;
19959 pop_deferring_access_checks ();
19962 finish_template_decl (parameter_list);
19964 /* Register member declarations. */
19965 if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
19966 finish_member_declaration (decl);
19967 /* For the erroneous case of a template with C linkage, we pushed an
19968 implicit C++ linkage scope; exit that scope now. */
19970 pop_lang_context ();
19971 /* If DECL is a function template, we must return to parse it later.
19972 (Even though there is no definition, there might be default
19973 arguments that need handling.) */
19974 if (member_p && decl
19975 && (TREE_CODE (decl) == FUNCTION_DECL
19976 || DECL_FUNCTION_TEMPLATE_P (decl)))
19977 VEC_safe_push (tree, gc, unparsed_funs_with_definitions, decl);
19980 /* Perform the deferred access checks from a template-parameter-list.
19981 CHECKS is a TREE_LIST of access checks, as returned by
19982 get_deferred_access_checks. */
19985 cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check,gc)* checks)
19987 ++processing_template_parmlist;
19988 perform_access_checks (checks);
19989 --processing_template_parmlist;
19992 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
19993 `function-definition' sequence. MEMBER_P is true, this declaration
19994 appears in a class scope.
19996 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
19997 *FRIEND_P is set to TRUE iff the declaration is a friend. */
20000 cp_parser_single_declaration (cp_parser* parser,
20001 VEC (deferred_access_check,gc)* checks,
20003 bool explicit_specialization_p,
20006 int declares_class_or_enum;
20007 tree decl = NULL_TREE;
20008 cp_decl_specifier_seq decl_specifiers;
20009 bool function_definition_p = false;
20010 cp_token *decl_spec_token_start;
20012 /* This function is only used when processing a template
20014 gcc_assert (innermost_scope_kind () == sk_template_parms
20015 || innermost_scope_kind () == sk_template_spec);
20017 /* Defer access checks until we know what is being declared. */
20018 push_deferring_access_checks (dk_deferred);
20020 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
20022 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
20023 cp_parser_decl_specifier_seq (parser,
20024 CP_PARSER_FLAGS_OPTIONAL,
20026 &declares_class_or_enum);
20028 *friend_p = cp_parser_friend_p (&decl_specifiers);
20030 /* There are no template typedefs. */
20031 if (decl_specifiers.specs[(int) ds_typedef])
20033 error_at (decl_spec_token_start->location,
20034 "template declaration of %<typedef%>");
20035 decl = error_mark_node;
20038 /* Gather up the access checks that occurred the
20039 decl-specifier-seq. */
20040 stop_deferring_access_checks ();
20042 /* Check for the declaration of a template class. */
20043 if (declares_class_or_enum)
20045 if (cp_parser_declares_only_class_p (parser))
20047 decl = shadow_tag (&decl_specifiers);
20052 friend template <typename T> struct A<T>::B;
20055 A<T>::B will be represented by a TYPENAME_TYPE, and
20056 therefore not recognized by shadow_tag. */
20057 if (friend_p && *friend_p
20059 && decl_specifiers.type
20060 && TYPE_P (decl_specifiers.type))
20061 decl = decl_specifiers.type;
20063 if (decl && decl != error_mark_node)
20064 decl = TYPE_NAME (decl);
20066 decl = error_mark_node;
20068 /* Perform access checks for template parameters. */
20069 cp_parser_perform_template_parameter_access_checks (checks);
20073 /* Complain about missing 'typename' or other invalid type names. */
20074 if (!decl_specifiers.any_type_specifiers_p
20075 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
20077 /* cp_parser_parse_and_diagnose_invalid_type_name calls
20078 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
20079 the rest of this declaration. */
20080 decl = error_mark_node;
20084 /* If it's not a template class, try for a template function. If
20085 the next token is a `;', then this declaration does not declare
20086 anything. But, if there were errors in the decl-specifiers, then
20087 the error might well have come from an attempted class-specifier.
20088 In that case, there's no need to warn about a missing declarator. */
20090 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
20091 || decl_specifiers.type != error_mark_node))
20093 decl = cp_parser_init_declarator (parser,
20096 /*function_definition_allowed_p=*/true,
20098 declares_class_or_enum,
20099 &function_definition_p,
20102 /* 7.1.1-1 [dcl.stc]
20104 A storage-class-specifier shall not be specified in an explicit
20105 specialization... */
20107 && explicit_specialization_p
20108 && decl_specifiers.storage_class != sc_none)
20110 error_at (decl_spec_token_start->location,
20111 "explicit template specialization cannot have a storage class");
20112 decl = error_mark_node;
20116 /* Look for a trailing `;' after the declaration. */
20117 if (!function_definition_p
20118 && (decl == error_mark_node
20119 || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON)))
20120 cp_parser_skip_to_end_of_block_or_statement (parser);
20123 pop_deferring_access_checks ();
20125 /* Clear any current qualification; whatever comes next is the start
20126 of something new. */
20127 parser->scope = NULL_TREE;
20128 parser->qualifying_scope = NULL_TREE;
20129 parser->object_scope = NULL_TREE;
20134 /* Parse a cast-expression that is not the operand of a unary "&". */
20137 cp_parser_simple_cast_expression (cp_parser *parser)
20139 return cp_parser_cast_expression (parser, /*address_p=*/false,
20140 /*cast_p=*/false, NULL);
20143 /* Parse a functional cast to TYPE. Returns an expression
20144 representing the cast. */
20147 cp_parser_functional_cast (cp_parser* parser, tree type)
20150 tree expression_list;
20154 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
20156 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
20157 expression_list = cp_parser_braced_list (parser, &nonconst_p);
20158 CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
20159 if (TREE_CODE (type) == TYPE_DECL)
20160 type = TREE_TYPE (type);
20161 return finish_compound_literal (type, expression_list,
20162 tf_warning_or_error);
20166 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
20168 /*allow_expansion_p=*/true,
20169 /*non_constant_p=*/NULL);
20171 expression_list = error_mark_node;
20174 expression_list = build_tree_list_vec (vec);
20175 release_tree_vector (vec);
20178 cast = build_functional_cast (type, expression_list,
20179 tf_warning_or_error);
20180 /* [expr.const]/1: In an integral constant expression "only type
20181 conversions to integral or enumeration type can be used". */
20182 if (TREE_CODE (type) == TYPE_DECL)
20183 type = TREE_TYPE (type);
20184 if (cast != error_mark_node
20185 && !cast_valid_in_integral_constant_expression_p (type)
20186 && cp_parser_non_integral_constant_expression (parser,
20188 return error_mark_node;
20192 /* Save the tokens that make up the body of a member function defined
20193 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
20194 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
20195 specifiers applied to the declaration. Returns the FUNCTION_DECL
20196 for the member function. */
20199 cp_parser_save_member_function_body (cp_parser* parser,
20200 cp_decl_specifier_seq *decl_specifiers,
20201 cp_declarator *declarator,
20208 /* Create the FUNCTION_DECL. */
20209 fn = grokmethod (decl_specifiers, declarator, attributes);
20210 /* If something went badly wrong, bail out now. */
20211 if (fn == error_mark_node)
20213 /* If there's a function-body, skip it. */
20214 if (cp_parser_token_starts_function_definition_p
20215 (cp_lexer_peek_token (parser->lexer)))
20216 cp_parser_skip_to_end_of_block_or_statement (parser);
20217 return error_mark_node;
20220 /* Remember it, if there default args to post process. */
20221 cp_parser_save_default_args (parser, fn);
20223 /* Save away the tokens that make up the body of the
20225 first = parser->lexer->next_token;
20226 /* We can have braced-init-list mem-initializers before the fn body. */
20227 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20229 cp_lexer_consume_token (parser->lexer);
20230 while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
20231 && cp_lexer_next_token_is_not_keyword (parser->lexer, RID_TRY))
20233 /* cache_group will stop after an un-nested { } pair, too. */
20234 if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
20237 /* variadic mem-inits have ... after the ')'. */
20238 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
20239 cp_lexer_consume_token (parser->lexer);
20242 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
20243 /* Handle function try blocks. */
20244 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
20245 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
20246 last = parser->lexer->next_token;
20248 /* Save away the inline definition; we will process it when the
20249 class is complete. */
20250 DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
20251 DECL_PENDING_INLINE_P (fn) = 1;
20253 /* We need to know that this was defined in the class, so that
20254 friend templates are handled correctly. */
20255 DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
20257 /* Add FN to the queue of functions to be parsed later. */
20258 VEC_safe_push (tree, gc, unparsed_funs_with_definitions, fn);
20263 /* Parse a template-argument-list, as well as the trailing ">" (but
20264 not the opening ">"). See cp_parser_template_argument_list for the
20268 cp_parser_enclosed_template_argument_list (cp_parser* parser)
20272 tree saved_qualifying_scope;
20273 tree saved_object_scope;
20274 bool saved_greater_than_is_operator_p;
20275 int saved_unevaluated_operand;
20276 int saved_inhibit_evaluation_warnings;
20280 When parsing a template-id, the first non-nested `>' is taken as
20281 the end of the template-argument-list rather than a greater-than
20283 saved_greater_than_is_operator_p
20284 = parser->greater_than_is_operator_p;
20285 parser->greater_than_is_operator_p = false;
20286 /* Parsing the argument list may modify SCOPE, so we save it
20288 saved_scope = parser->scope;
20289 saved_qualifying_scope = parser->qualifying_scope;
20290 saved_object_scope = parser->object_scope;
20291 /* We need to evaluate the template arguments, even though this
20292 template-id may be nested within a "sizeof". */
20293 saved_unevaluated_operand = cp_unevaluated_operand;
20294 cp_unevaluated_operand = 0;
20295 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
20296 c_inhibit_evaluation_warnings = 0;
20297 /* Parse the template-argument-list itself. */
20298 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
20299 || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
20300 arguments = NULL_TREE;
20302 arguments = cp_parser_template_argument_list (parser);
20303 /* Look for the `>' that ends the template-argument-list. If we find
20304 a '>>' instead, it's probably just a typo. */
20305 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
20307 if (cxx_dialect != cxx98)
20309 /* In C++0x, a `>>' in a template argument list or cast
20310 expression is considered to be two separate `>'
20311 tokens. So, change the current token to a `>', but don't
20312 consume it: it will be consumed later when the outer
20313 template argument list (or cast expression) is parsed.
20314 Note that this replacement of `>' for `>>' is necessary
20315 even if we are parsing tentatively: in the tentative
20316 case, after calling
20317 cp_parser_enclosed_template_argument_list we will always
20318 throw away all of the template arguments and the first
20319 closing `>', either because the template argument list
20320 was erroneous or because we are replacing those tokens
20321 with a CPP_TEMPLATE_ID token. The second `>' (which will
20322 not have been thrown away) is needed either to close an
20323 outer template argument list or to complete a new-style
20325 cp_token *token = cp_lexer_peek_token (parser->lexer);
20326 token->type = CPP_GREATER;
20328 else if (!saved_greater_than_is_operator_p)
20330 /* If we're in a nested template argument list, the '>>' has
20331 to be a typo for '> >'. We emit the error message, but we
20332 continue parsing and we push a '>' as next token, so that
20333 the argument list will be parsed correctly. Note that the
20334 global source location is still on the token before the
20335 '>>', so we need to say explicitly where we want it. */
20336 cp_token *token = cp_lexer_peek_token (parser->lexer);
20337 error_at (token->location, "%<>>%> should be %<> >%> "
20338 "within a nested template argument list");
20340 token->type = CPP_GREATER;
20344 /* If this is not a nested template argument list, the '>>'
20345 is a typo for '>'. Emit an error message and continue.
20346 Same deal about the token location, but here we can get it
20347 right by consuming the '>>' before issuing the diagnostic. */
20348 cp_token *token = cp_lexer_consume_token (parser->lexer);
20349 error_at (token->location,
20350 "spurious %<>>%>, use %<>%> to terminate "
20351 "a template argument list");
20355 cp_parser_skip_to_end_of_template_parameter_list (parser);
20356 /* The `>' token might be a greater-than operator again now. */
20357 parser->greater_than_is_operator_p
20358 = saved_greater_than_is_operator_p;
20359 /* Restore the SAVED_SCOPE. */
20360 parser->scope = saved_scope;
20361 parser->qualifying_scope = saved_qualifying_scope;
20362 parser->object_scope = saved_object_scope;
20363 cp_unevaluated_operand = saved_unevaluated_operand;
20364 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
20369 /* MEMBER_FUNCTION is a member function, or a friend. If default
20370 arguments, or the body of the function have not yet been parsed,
20374 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
20376 timevar_push (TV_PARSE_INMETH);
20377 /* If this member is a template, get the underlying
20379 if (DECL_FUNCTION_TEMPLATE_P (member_function))
20380 member_function = DECL_TEMPLATE_RESULT (member_function);
20382 /* There should not be any class definitions in progress at this
20383 point; the bodies of members are only parsed outside of all class
20385 gcc_assert (parser->num_classes_being_defined == 0);
20386 /* While we're parsing the member functions we might encounter more
20387 classes. We want to handle them right away, but we don't want
20388 them getting mixed up with functions that are currently in the
20390 push_unparsed_function_queues (parser);
20392 /* Make sure that any template parameters are in scope. */
20393 maybe_begin_member_template_processing (member_function);
20395 /* If the body of the function has not yet been parsed, parse it
20397 if (DECL_PENDING_INLINE_P (member_function))
20399 tree function_scope;
20400 cp_token_cache *tokens;
20402 /* The function is no longer pending; we are processing it. */
20403 tokens = DECL_PENDING_INLINE_INFO (member_function);
20404 DECL_PENDING_INLINE_INFO (member_function) = NULL;
20405 DECL_PENDING_INLINE_P (member_function) = 0;
20407 /* If this is a local class, enter the scope of the containing
20409 function_scope = current_function_decl;
20410 if (function_scope)
20411 push_function_context ();
20413 /* Push the body of the function onto the lexer stack. */
20414 cp_parser_push_lexer_for_tokens (parser, tokens);
20416 /* Let the front end know that we going to be defining this
20418 start_preparsed_function (member_function, NULL_TREE,
20419 SF_PRE_PARSED | SF_INCLASS_INLINE);
20421 /* Don't do access checking if it is a templated function. */
20422 if (processing_template_decl)
20423 push_deferring_access_checks (dk_no_check);
20425 /* Now, parse the body of the function. */
20426 cp_parser_function_definition_after_declarator (parser,
20427 /*inline_p=*/true);
20429 if (processing_template_decl)
20430 pop_deferring_access_checks ();
20432 /* Leave the scope of the containing function. */
20433 if (function_scope)
20434 pop_function_context ();
20435 cp_parser_pop_lexer (parser);
20438 /* Remove any template parameters from the symbol table. */
20439 maybe_end_member_template_processing ();
20441 /* Restore the queue. */
20442 pop_unparsed_function_queues (parser);
20443 timevar_pop (TV_PARSE_INMETH);
20446 /* If DECL contains any default args, remember it on the unparsed
20447 functions queue. */
20450 cp_parser_save_default_args (cp_parser* parser, tree decl)
20454 for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
20456 probe = TREE_CHAIN (probe))
20457 if (TREE_PURPOSE (probe))
20459 cp_default_arg_entry *entry
20460 = VEC_safe_push (cp_default_arg_entry, gc,
20461 unparsed_funs_with_default_args, NULL);
20462 entry->class_type = current_class_type;
20463 entry->decl = decl;
20468 /* FN is a FUNCTION_DECL which may contains a parameter with an
20469 unparsed DEFAULT_ARG. Parse the default args now. This function
20470 assumes that the current scope is the scope in which the default
20471 argument should be processed. */
20474 cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
20476 bool saved_local_variables_forbidden_p;
20477 tree parm, parmdecl;
20479 /* While we're parsing the default args, we might (due to the
20480 statement expression extension) encounter more classes. We want
20481 to handle them right away, but we don't want them getting mixed
20482 up with default args that are currently in the queue. */
20483 push_unparsed_function_queues (parser);
20485 /* Local variable names (and the `this' keyword) may not appear
20486 in a default argument. */
20487 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
20488 parser->local_variables_forbidden_p = true;
20490 push_defarg_context (fn);
20492 for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn)),
20493 parmdecl = DECL_ARGUMENTS (fn);
20494 parm && parm != void_list_node;
20495 parm = TREE_CHAIN (parm),
20496 parmdecl = DECL_CHAIN (parmdecl))
20498 cp_token_cache *tokens;
20499 tree default_arg = TREE_PURPOSE (parm);
20501 VEC(tree,gc) *insts;
20508 if (TREE_CODE (default_arg) != DEFAULT_ARG)
20509 /* This can happen for a friend declaration for a function
20510 already declared with default arguments. */
20513 /* Push the saved tokens for the default argument onto the parser's
20515 tokens = DEFARG_TOKENS (default_arg);
20516 cp_parser_push_lexer_for_tokens (parser, tokens);
20518 start_lambda_scope (parmdecl);
20520 /* Parse the assignment-expression. */
20521 parsed_arg = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
20522 if (parsed_arg == error_mark_node)
20524 cp_parser_pop_lexer (parser);
20528 if (!processing_template_decl)
20529 parsed_arg = check_default_argument (TREE_VALUE (parm), parsed_arg);
20531 TREE_PURPOSE (parm) = parsed_arg;
20533 /* Update any instantiations we've already created. */
20534 for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0;
20535 VEC_iterate (tree, insts, ix, copy); ix++)
20536 TREE_PURPOSE (copy) = parsed_arg;
20538 finish_lambda_scope ();
20540 /* If the token stream has not been completely used up, then
20541 there was extra junk after the end of the default
20543 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
20544 cp_parser_error (parser, "expected %<,%>");
20546 /* Revert to the main lexer. */
20547 cp_parser_pop_lexer (parser);
20550 pop_defarg_context ();
20552 /* Make sure no default arg is missing. */
20553 check_default_args (fn);
20555 /* Restore the state of local_variables_forbidden_p. */
20556 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
20558 /* Restore the queue. */
20559 pop_unparsed_function_queues (parser);
20562 /* Parse the operand of `sizeof' (or a similar operator). Returns
20563 either a TYPE or an expression, depending on the form of the
20564 input. The KEYWORD indicates which kind of expression we have
20568 cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
20570 tree expr = NULL_TREE;
20571 const char *saved_message;
20573 bool saved_integral_constant_expression_p;
20574 bool saved_non_integral_constant_expression_p;
20575 bool pack_expansion_p = false;
20577 /* Types cannot be defined in a `sizeof' expression. Save away the
20579 saved_message = parser->type_definition_forbidden_message;
20580 /* And create the new one. */
20581 tmp = concat ("types may not be defined in %<",
20582 IDENTIFIER_POINTER (ridpointers[keyword]),
20583 "%> expressions", NULL);
20584 parser->type_definition_forbidden_message = tmp;
20586 /* The restrictions on constant-expressions do not apply inside
20587 sizeof expressions. */
20588 saved_integral_constant_expression_p
20589 = parser->integral_constant_expression_p;
20590 saved_non_integral_constant_expression_p
20591 = parser->non_integral_constant_expression_p;
20592 parser->integral_constant_expression_p = false;
20594 /* If it's a `...', then we are computing the length of a parameter
20596 if (keyword == RID_SIZEOF
20597 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
20599 /* Consume the `...'. */
20600 cp_lexer_consume_token (parser->lexer);
20601 maybe_warn_variadic_templates ();
20603 /* Note that this is an expansion. */
20604 pack_expansion_p = true;
20607 /* Do not actually evaluate the expression. */
20608 ++cp_unevaluated_operand;
20609 ++c_inhibit_evaluation_warnings;
20610 /* If it's a `(', then we might be looking at the type-id
20612 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
20615 bool saved_in_type_id_in_expr_p;
20617 /* We can't be sure yet whether we're looking at a type-id or an
20619 cp_parser_parse_tentatively (parser);
20620 /* Consume the `('. */
20621 cp_lexer_consume_token (parser->lexer);
20622 /* Parse the type-id. */
20623 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
20624 parser->in_type_id_in_expr_p = true;
20625 type = cp_parser_type_id (parser);
20626 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
20627 /* Now, look for the trailing `)'. */
20628 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
20629 /* If all went well, then we're done. */
20630 if (cp_parser_parse_definitely (parser))
20632 cp_decl_specifier_seq decl_specs;
20634 /* Build a trivial decl-specifier-seq. */
20635 clear_decl_specs (&decl_specs);
20636 decl_specs.type = type;
20638 /* Call grokdeclarator to figure out what type this is. */
20639 expr = grokdeclarator (NULL,
20643 /*attrlist=*/NULL);
20647 /* If the type-id production did not work out, then we must be
20648 looking at the unary-expression production. */
20650 expr = cp_parser_unary_expression (parser, /*address_p=*/false,
20651 /*cast_p=*/false, NULL);
20653 if (pack_expansion_p)
20654 /* Build a pack expansion. */
20655 expr = make_pack_expansion (expr);
20657 /* Go back to evaluating expressions. */
20658 --cp_unevaluated_operand;
20659 --c_inhibit_evaluation_warnings;
20661 /* Free the message we created. */
20663 /* And restore the old one. */
20664 parser->type_definition_forbidden_message = saved_message;
20665 parser->integral_constant_expression_p
20666 = saved_integral_constant_expression_p;
20667 parser->non_integral_constant_expression_p
20668 = saved_non_integral_constant_expression_p;
20673 /* If the current declaration has no declarator, return true. */
20676 cp_parser_declares_only_class_p (cp_parser *parser)
20678 /* If the next token is a `;' or a `,' then there is no
20680 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
20681 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
20684 /* Update the DECL_SPECS to reflect the storage class indicated by
20688 cp_parser_set_storage_class (cp_parser *parser,
20689 cp_decl_specifier_seq *decl_specs,
20691 location_t location)
20693 cp_storage_class storage_class;
20695 if (parser->in_unbraced_linkage_specification_p)
20697 error_at (location, "invalid use of %qD in linkage specification",
20698 ridpointers[keyword]);
20701 else if (decl_specs->storage_class != sc_none)
20703 decl_specs->conflicting_specifiers_p = true;
20707 if ((keyword == RID_EXTERN || keyword == RID_STATIC)
20708 && decl_specs->specs[(int) ds_thread])
20710 error_at (location, "%<__thread%> before %qD", ridpointers[keyword]);
20711 decl_specs->specs[(int) ds_thread] = 0;
20717 storage_class = sc_auto;
20720 storage_class = sc_register;
20723 storage_class = sc_static;
20726 storage_class = sc_extern;
20729 storage_class = sc_mutable;
20732 gcc_unreachable ();
20734 decl_specs->storage_class = storage_class;
20736 /* A storage class specifier cannot be applied alongside a typedef
20737 specifier. If there is a typedef specifier present then set
20738 conflicting_specifiers_p which will trigger an error later
20739 on in grokdeclarator. */
20740 if (decl_specs->specs[(int)ds_typedef])
20741 decl_specs->conflicting_specifiers_p = true;
20744 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P
20745 is true, the type is a user-defined type; otherwise it is a
20746 built-in type specified by a keyword. */
20749 cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
20751 location_t location,
20752 bool user_defined_p)
20754 decl_specs->any_specifiers_p = true;
20756 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
20757 (with, for example, in "typedef int wchar_t;") we remember that
20758 this is what happened. In system headers, we ignore these
20759 declarations so that G++ can work with system headers that are not
20761 if (decl_specs->specs[(int) ds_typedef]
20763 && (type_spec == boolean_type_node
20764 || type_spec == char16_type_node
20765 || type_spec == char32_type_node
20766 || type_spec == wchar_type_node)
20767 && (decl_specs->type
20768 || decl_specs->specs[(int) ds_long]
20769 || decl_specs->specs[(int) ds_short]
20770 || decl_specs->specs[(int) ds_unsigned]
20771 || decl_specs->specs[(int) ds_signed]))
20773 decl_specs->redefined_builtin_type = type_spec;
20774 if (!decl_specs->type)
20776 decl_specs->type = type_spec;
20777 decl_specs->user_defined_type_p = false;
20778 decl_specs->type_location = location;
20781 else if (decl_specs->type)
20782 decl_specs->multiple_types_p = true;
20785 decl_specs->type = type_spec;
20786 decl_specs->user_defined_type_p = user_defined_p;
20787 decl_specs->redefined_builtin_type = NULL_TREE;
20788 decl_specs->type_location = location;
20792 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
20793 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
20796 cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
20798 return decl_specifiers->specs[(int) ds_friend] != 0;
20801 /* Issue an error message indicating that TOKEN_DESC was expected.
20802 If KEYWORD is true, it indicated this function is called by
20803 cp_parser_require_keword and the required token can only be
20804 a indicated keyword. */
20807 cp_parser_required_error (cp_parser *parser,
20808 required_token token_desc,
20811 switch (token_desc)
20814 cp_parser_error (parser, "expected %<new%>");
20817 cp_parser_error (parser, "expected %<delete%>");
20820 cp_parser_error (parser, "expected %<return%>");
20823 cp_parser_error (parser, "expected %<while%>");
20826 cp_parser_error (parser, "expected %<extern%>");
20828 case RT_STATIC_ASSERT:
20829 cp_parser_error (parser, "expected %<static_assert%>");
20832 cp_parser_error (parser, "expected %<decltype%>");
20835 cp_parser_error (parser, "expected %<operator%>");
20838 cp_parser_error (parser, "expected %<class%>");
20841 cp_parser_error (parser, "expected %<template%>");
20844 cp_parser_error (parser, "expected %<namespace%>");
20847 cp_parser_error (parser, "expected %<using%>");
20850 cp_parser_error (parser, "expected %<asm%>");
20853 cp_parser_error (parser, "expected %<try%>");
20856 cp_parser_error (parser, "expected %<catch%>");
20859 cp_parser_error (parser, "expected %<throw%>");
20862 cp_parser_error (parser, "expected %<__label__%>");
20865 cp_parser_error (parser, "expected %<@try%>");
20867 case RT_AT_SYNCHRONIZED:
20868 cp_parser_error (parser, "expected %<@synchronized%>");
20871 cp_parser_error (parser, "expected %<@throw%>");
20878 switch (token_desc)
20881 cp_parser_error (parser, "expected %<;%>");
20883 case RT_OPEN_PAREN:
20884 cp_parser_error (parser, "expected %<(%>");
20886 case RT_CLOSE_BRACE:
20887 cp_parser_error (parser, "expected %<}%>");
20889 case RT_OPEN_BRACE:
20890 cp_parser_error (parser, "expected %<{%>");
20892 case RT_CLOSE_SQUARE:
20893 cp_parser_error (parser, "expected %<]%>");
20895 case RT_OPEN_SQUARE:
20896 cp_parser_error (parser, "expected %<[%>");
20899 cp_parser_error (parser, "expected %<,%>");
20902 cp_parser_error (parser, "expected %<::%>");
20905 cp_parser_error (parser, "expected %<<%>");
20908 cp_parser_error (parser, "expected %<>%>");
20911 cp_parser_error (parser, "expected %<=%>");
20914 cp_parser_error (parser, "expected %<...%>");
20917 cp_parser_error (parser, "expected %<*%>");
20920 cp_parser_error (parser, "expected %<~%>");
20923 cp_parser_error (parser, "expected %<:%>");
20925 case RT_COLON_SCOPE:
20926 cp_parser_error (parser, "expected %<:%> or %<::%>");
20928 case RT_CLOSE_PAREN:
20929 cp_parser_error (parser, "expected %<)%>");
20931 case RT_COMMA_CLOSE_PAREN:
20932 cp_parser_error (parser, "expected %<,%> or %<)%>");
20934 case RT_PRAGMA_EOL:
20935 cp_parser_error (parser, "expected end of line");
20938 cp_parser_error (parser, "expected identifier");
20941 cp_parser_error (parser, "expected selection-statement");
20943 case RT_INTERATION:
20944 cp_parser_error (parser, "expected iteration-statement");
20947 cp_parser_error (parser, "expected jump-statement");
20950 cp_parser_error (parser, "expected class-key");
20952 case RT_CLASS_TYPENAME_TEMPLATE:
20953 cp_parser_error (parser,
20954 "expected %<class%>, %<typename%>, or %<template%>");
20957 gcc_unreachable ();
20961 gcc_unreachable ();
20966 /* If the next token is of the indicated TYPE, consume it. Otherwise,
20967 issue an error message indicating that TOKEN_DESC was expected.
20969 Returns the token consumed, if the token had the appropriate type.
20970 Otherwise, returns NULL. */
20973 cp_parser_require (cp_parser* parser,
20974 enum cpp_ttype type,
20975 required_token token_desc)
20977 if (cp_lexer_next_token_is (parser->lexer, type))
20978 return cp_lexer_consume_token (parser->lexer);
20981 /* Output the MESSAGE -- unless we're parsing tentatively. */
20982 if (!cp_parser_simulate_error (parser))
20983 cp_parser_required_error (parser, token_desc, /*keyword=*/false);
20988 /* An error message is produced if the next token is not '>'.
20989 All further tokens are skipped until the desired token is
20990 found or '{', '}', ';' or an unbalanced ')' or ']'. */
20993 cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
20995 /* Current level of '< ... >'. */
20996 unsigned level = 0;
20997 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
20998 unsigned nesting_depth = 0;
21000 /* Are we ready, yet? If not, issue error message. */
21001 if (cp_parser_require (parser, CPP_GREATER, RT_GREATER))
21004 /* Skip tokens until the desired token is found. */
21007 /* Peek at the next token. */
21008 switch (cp_lexer_peek_token (parser->lexer)->type)
21011 if (!nesting_depth)
21016 if (cxx_dialect == cxx98)
21017 /* C++0x views the `>>' operator as two `>' tokens, but
21020 else if (!nesting_depth && level-- == 0)
21022 /* We've hit a `>>' where the first `>' closes the
21023 template argument list, and the second `>' is
21024 spurious. Just consume the `>>' and stop; we've
21025 already produced at least one error. */
21026 cp_lexer_consume_token (parser->lexer);
21029 /* Fall through for C++0x, so we handle the second `>' in
21033 if (!nesting_depth && level-- == 0)
21035 /* We've reached the token we want, consume it and stop. */
21036 cp_lexer_consume_token (parser->lexer);
21041 case CPP_OPEN_PAREN:
21042 case CPP_OPEN_SQUARE:
21046 case CPP_CLOSE_PAREN:
21047 case CPP_CLOSE_SQUARE:
21048 if (nesting_depth-- == 0)
21053 case CPP_PRAGMA_EOL:
21054 case CPP_SEMICOLON:
21055 case CPP_OPEN_BRACE:
21056 case CPP_CLOSE_BRACE:
21057 /* The '>' was probably forgotten, don't look further. */
21064 /* Consume this token. */
21065 cp_lexer_consume_token (parser->lexer);
21069 /* If the next token is the indicated keyword, consume it. Otherwise,
21070 issue an error message indicating that TOKEN_DESC was expected.
21072 Returns the token consumed, if the token had the appropriate type.
21073 Otherwise, returns NULL. */
21076 cp_parser_require_keyword (cp_parser* parser,
21078 required_token token_desc)
21080 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
21082 if (token && token->keyword != keyword)
21084 cp_parser_required_error (parser, token_desc, /*keyword=*/true);
21091 /* Returns TRUE iff TOKEN is a token that can begin the body of a
21092 function-definition. */
21095 cp_parser_token_starts_function_definition_p (cp_token* token)
21097 return (/* An ordinary function-body begins with an `{'. */
21098 token->type == CPP_OPEN_BRACE
21099 /* A ctor-initializer begins with a `:'. */
21100 || token->type == CPP_COLON
21101 /* A function-try-block begins with `try'. */
21102 || token->keyword == RID_TRY
21103 /* The named return value extension begins with `return'. */
21104 || token->keyword == RID_RETURN);
21107 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
21111 cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
21115 token = cp_lexer_peek_token (parser->lexer);
21116 return (token->type == CPP_OPEN_BRACE || token->type == CPP_COLON);
21119 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
21120 C++0x) ending a template-argument. */
21123 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
21127 token = cp_lexer_peek_token (parser->lexer);
21128 return (token->type == CPP_COMMA
21129 || token->type == CPP_GREATER
21130 || token->type == CPP_ELLIPSIS
21131 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT));
21134 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
21135 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
21138 cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
21143 token = cp_lexer_peek_nth_token (parser->lexer, n);
21144 if (token->type == CPP_LESS)
21146 /* Check for the sequence `<::' in the original code. It would be lexed as
21147 `[:', where `[' is a digraph, and there is no whitespace before
21149 if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
21152 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
21153 if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
21159 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
21160 or none_type otherwise. */
21162 static enum tag_types
21163 cp_parser_token_is_class_key (cp_token* token)
21165 switch (token->keyword)
21170 return record_type;
21179 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
21182 cp_parser_check_class_key (enum tag_types class_key, tree type)
21184 if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
21185 permerror (input_location, "%qs tag used in naming %q#T",
21186 class_key == union_type ? "union"
21187 : class_key == record_type ? "struct" : "class",
21191 /* Issue an error message if DECL is redeclared with different
21192 access than its original declaration [class.access.spec/3].
21193 This applies to nested classes and nested class templates.
21197 cp_parser_check_access_in_redeclaration (tree decl, location_t location)
21199 if (!decl || !CLASS_TYPE_P (TREE_TYPE (decl)))
21202 if ((TREE_PRIVATE (decl)
21203 != (current_access_specifier == access_private_node))
21204 || (TREE_PROTECTED (decl)
21205 != (current_access_specifier == access_protected_node)))
21206 error_at (location, "%qD redeclared with different access", decl);
21209 /* Look for the `template' keyword, as a syntactic disambiguator.
21210 Return TRUE iff it is present, in which case it will be
21214 cp_parser_optional_template_keyword (cp_parser *parser)
21216 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
21218 /* The `template' keyword can only be used within templates;
21219 outside templates the parser can always figure out what is a
21220 template and what is not. */
21221 if (!processing_template_decl)
21223 cp_token *token = cp_lexer_peek_token (parser->lexer);
21224 error_at (token->location,
21225 "%<template%> (as a disambiguator) is only allowed "
21226 "within templates");
21227 /* If this part of the token stream is rescanned, the same
21228 error message would be generated. So, we purge the token
21229 from the stream. */
21230 cp_lexer_purge_token (parser->lexer);
21235 /* Consume the `template' keyword. */
21236 cp_lexer_consume_token (parser->lexer);
21244 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
21245 set PARSER->SCOPE, and perform other related actions. */
21248 cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
21251 struct tree_check *check_value;
21252 deferred_access_check *chk;
21253 VEC (deferred_access_check,gc) *checks;
21255 /* Get the stored value. */
21256 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
21257 /* Perform any access checks that were deferred. */
21258 checks = check_value->checks;
21261 FOR_EACH_VEC_ELT (deferred_access_check, checks, i, chk)
21262 perform_or_defer_access_check (chk->binfo,
21266 /* Set the scope from the stored value. */
21267 parser->scope = check_value->value;
21268 parser->qualifying_scope = check_value->qualifying_scope;
21269 parser->object_scope = NULL_TREE;
21272 /* Consume tokens up through a non-nested END token. Returns TRUE if we
21273 encounter the end of a block before what we were looking for. */
21276 cp_parser_cache_group (cp_parser *parser,
21277 enum cpp_ttype end,
21282 cp_token *token = cp_lexer_peek_token (parser->lexer);
21284 /* Abort a parenthesized expression if we encounter a semicolon. */
21285 if ((end == CPP_CLOSE_PAREN || depth == 0)
21286 && token->type == CPP_SEMICOLON)
21288 /* If we've reached the end of the file, stop. */
21289 if (token->type == CPP_EOF
21290 || (end != CPP_PRAGMA_EOL
21291 && token->type == CPP_PRAGMA_EOL))
21293 if (token->type == CPP_CLOSE_BRACE && depth == 0)
21294 /* We've hit the end of an enclosing block, so there's been some
21295 kind of syntax error. */
21298 /* Consume the token. */
21299 cp_lexer_consume_token (parser->lexer);
21300 /* See if it starts a new group. */
21301 if (token->type == CPP_OPEN_BRACE)
21303 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
21304 /* In theory this should probably check end == '}', but
21305 cp_parser_save_member_function_body needs it to exit
21306 after either '}' or ')' when called with ')'. */
21310 else if (token->type == CPP_OPEN_PAREN)
21312 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
21313 if (depth == 0 && end == CPP_CLOSE_PAREN)
21316 else if (token->type == CPP_PRAGMA)
21317 cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
21318 else if (token->type == end)
21323 /* Begin parsing tentatively. We always save tokens while parsing
21324 tentatively so that if the tentative parsing fails we can restore the
21328 cp_parser_parse_tentatively (cp_parser* parser)
21330 /* Enter a new parsing context. */
21331 parser->context = cp_parser_context_new (parser->context);
21332 /* Begin saving tokens. */
21333 cp_lexer_save_tokens (parser->lexer);
21334 /* In order to avoid repetitive access control error messages,
21335 access checks are queued up until we are no longer parsing
21337 push_deferring_access_checks (dk_deferred);
21340 /* Commit to the currently active tentative parse. */
21343 cp_parser_commit_to_tentative_parse (cp_parser* parser)
21345 cp_parser_context *context;
21348 /* Mark all of the levels as committed. */
21349 lexer = parser->lexer;
21350 for (context = parser->context; context->next; context = context->next)
21352 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
21354 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
21355 while (!cp_lexer_saving_tokens (lexer))
21356 lexer = lexer->next;
21357 cp_lexer_commit_tokens (lexer);
21361 /* Abort the currently active tentative parse. All consumed tokens
21362 will be rolled back, and no diagnostics will be issued. */
21365 cp_parser_abort_tentative_parse (cp_parser* parser)
21367 gcc_assert (parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED
21368 || errorcount > 0);
21369 cp_parser_simulate_error (parser);
21370 /* Now, pretend that we want to see if the construct was
21371 successfully parsed. */
21372 cp_parser_parse_definitely (parser);
21375 /* Stop parsing tentatively. If a parse error has occurred, restore the
21376 token stream. Otherwise, commit to the tokens we have consumed.
21377 Returns true if no error occurred; false otherwise. */
21380 cp_parser_parse_definitely (cp_parser* parser)
21382 bool error_occurred;
21383 cp_parser_context *context;
21385 /* Remember whether or not an error occurred, since we are about to
21386 destroy that information. */
21387 error_occurred = cp_parser_error_occurred (parser);
21388 /* Remove the topmost context from the stack. */
21389 context = parser->context;
21390 parser->context = context->next;
21391 /* If no parse errors occurred, commit to the tentative parse. */
21392 if (!error_occurred)
21394 /* Commit to the tokens read tentatively, unless that was
21396 if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
21397 cp_lexer_commit_tokens (parser->lexer);
21399 pop_to_parent_deferring_access_checks ();
21401 /* Otherwise, if errors occurred, roll back our state so that things
21402 are just as they were before we began the tentative parse. */
21405 cp_lexer_rollback_tokens (parser->lexer);
21406 pop_deferring_access_checks ();
21408 /* Add the context to the front of the free list. */
21409 context->next = cp_parser_context_free_list;
21410 cp_parser_context_free_list = context;
21412 return !error_occurred;
21415 /* Returns true if we are parsing tentatively and are not committed to
21416 this tentative parse. */
21419 cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
21421 return (cp_parser_parsing_tentatively (parser)
21422 && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
21425 /* Returns nonzero iff an error has occurred during the most recent
21426 tentative parse. */
21429 cp_parser_error_occurred (cp_parser* parser)
21431 return (cp_parser_parsing_tentatively (parser)
21432 && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
21435 /* Returns nonzero if GNU extensions are allowed. */
21438 cp_parser_allow_gnu_extensions_p (cp_parser* parser)
21440 return parser->allow_gnu_extensions_p;
21443 /* Objective-C++ Productions */
21446 /* Parse an Objective-C expression, which feeds into a primary-expression
21450 objc-message-expression
21451 objc-string-literal
21452 objc-encode-expression
21453 objc-protocol-expression
21454 objc-selector-expression
21456 Returns a tree representation of the expression. */
21459 cp_parser_objc_expression (cp_parser* parser)
21461 /* Try to figure out what kind of declaration is present. */
21462 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
21466 case CPP_OPEN_SQUARE:
21467 return cp_parser_objc_message_expression (parser);
21469 case CPP_OBJC_STRING:
21470 kwd = cp_lexer_consume_token (parser->lexer);
21471 return objc_build_string_object (kwd->u.value);
21474 switch (kwd->keyword)
21476 case RID_AT_ENCODE:
21477 return cp_parser_objc_encode_expression (parser);
21479 case RID_AT_PROTOCOL:
21480 return cp_parser_objc_protocol_expression (parser);
21482 case RID_AT_SELECTOR:
21483 return cp_parser_objc_selector_expression (parser);
21489 error_at (kwd->location,
21490 "misplaced %<@%D%> Objective-C++ construct",
21492 cp_parser_skip_to_end_of_block_or_statement (parser);
21495 return error_mark_node;
21498 /* Parse an Objective-C message expression.
21500 objc-message-expression:
21501 [ objc-message-receiver objc-message-args ]
21503 Returns a representation of an Objective-C message. */
21506 cp_parser_objc_message_expression (cp_parser* parser)
21508 tree receiver, messageargs;
21510 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
21511 receiver = cp_parser_objc_message_receiver (parser);
21512 messageargs = cp_parser_objc_message_args (parser);
21513 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
21515 return objc_build_message_expr (receiver, messageargs);
21518 /* Parse an objc-message-receiver.
21520 objc-message-receiver:
21522 simple-type-specifier
21524 Returns a representation of the type or expression. */
21527 cp_parser_objc_message_receiver (cp_parser* parser)
21531 /* An Objective-C message receiver may be either (1) a type
21532 or (2) an expression. */
21533 cp_parser_parse_tentatively (parser);
21534 rcv = cp_parser_expression (parser, false, NULL);
21536 if (cp_parser_parse_definitely (parser))
21539 rcv = cp_parser_simple_type_specifier (parser,
21540 /*decl_specs=*/NULL,
21541 CP_PARSER_FLAGS_NONE);
21543 return objc_get_class_reference (rcv);
21546 /* Parse the arguments and selectors comprising an Objective-C message.
21551 objc-selector-args , objc-comma-args
21553 objc-selector-args:
21554 objc-selector [opt] : assignment-expression
21555 objc-selector-args objc-selector [opt] : assignment-expression
21558 assignment-expression
21559 objc-comma-args , assignment-expression
21561 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
21562 selector arguments and TREE_VALUE containing a list of comma
21566 cp_parser_objc_message_args (cp_parser* parser)
21568 tree sel_args = NULL_TREE, addl_args = NULL_TREE;
21569 bool maybe_unary_selector_p = true;
21570 cp_token *token = cp_lexer_peek_token (parser->lexer);
21572 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
21574 tree selector = NULL_TREE, arg;
21576 if (token->type != CPP_COLON)
21577 selector = cp_parser_objc_selector (parser);
21579 /* Detect if we have a unary selector. */
21580 if (maybe_unary_selector_p
21581 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
21582 return build_tree_list (selector, NULL_TREE);
21584 maybe_unary_selector_p = false;
21585 cp_parser_require (parser, CPP_COLON, RT_COLON);
21586 arg = cp_parser_assignment_expression (parser, false, NULL);
21589 = chainon (sel_args,
21590 build_tree_list (selector, arg));
21592 token = cp_lexer_peek_token (parser->lexer);
21595 /* Handle non-selector arguments, if any. */
21596 while (token->type == CPP_COMMA)
21600 cp_lexer_consume_token (parser->lexer);
21601 arg = cp_parser_assignment_expression (parser, false, NULL);
21604 = chainon (addl_args,
21605 build_tree_list (NULL_TREE, arg));
21607 token = cp_lexer_peek_token (parser->lexer);
21610 if (sel_args == NULL_TREE && addl_args == NULL_TREE)
21612 cp_parser_error (parser, "objective-c++ message argument(s) are expected");
21613 return build_tree_list (error_mark_node, error_mark_node);
21616 return build_tree_list (sel_args, addl_args);
21619 /* Parse an Objective-C encode expression.
21621 objc-encode-expression:
21622 @encode objc-typename
21624 Returns an encoded representation of the type argument. */
21627 cp_parser_objc_encode_expression (cp_parser* parser)
21632 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
21633 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21634 token = cp_lexer_peek_token (parser->lexer);
21635 type = complete_type (cp_parser_type_id (parser));
21636 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21640 error_at (token->location,
21641 "%<@encode%> must specify a type as an argument");
21642 return error_mark_node;
21645 /* This happens if we find @encode(T) (where T is a template
21646 typename or something dependent on a template typename) when
21647 parsing a template. In that case, we can't compile it
21648 immediately, but we rather create an AT_ENCODE_EXPR which will
21649 need to be instantiated when the template is used.
21651 if (dependent_type_p (type))
21653 tree value = build_min (AT_ENCODE_EXPR, size_type_node, type);
21654 TREE_READONLY (value) = 1;
21658 return objc_build_encode_expr (type);
21661 /* Parse an Objective-C @defs expression. */
21664 cp_parser_objc_defs_expression (cp_parser *parser)
21668 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
21669 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21670 name = cp_parser_identifier (parser);
21671 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21673 return objc_get_class_ivars (name);
21676 /* Parse an Objective-C protocol expression.
21678 objc-protocol-expression:
21679 @protocol ( identifier )
21681 Returns a representation of the protocol expression. */
21684 cp_parser_objc_protocol_expression (cp_parser* parser)
21688 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
21689 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21690 proto = cp_parser_identifier (parser);
21691 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21693 return objc_build_protocol_expr (proto);
21696 /* Parse an Objective-C selector expression.
21698 objc-selector-expression:
21699 @selector ( objc-method-signature )
21701 objc-method-signature:
21707 objc-selector-seq objc-selector :
21709 Returns a representation of the method selector. */
21712 cp_parser_objc_selector_expression (cp_parser* parser)
21714 tree sel_seq = NULL_TREE;
21715 bool maybe_unary_selector_p = true;
21717 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
21719 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
21720 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21721 token = cp_lexer_peek_token (parser->lexer);
21723 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON
21724 || token->type == CPP_SCOPE)
21726 tree selector = NULL_TREE;
21728 if (token->type != CPP_COLON
21729 || token->type == CPP_SCOPE)
21730 selector = cp_parser_objc_selector (parser);
21732 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
21733 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
21735 /* Detect if we have a unary selector. */
21736 if (maybe_unary_selector_p)
21738 sel_seq = selector;
21739 goto finish_selector;
21743 cp_parser_error (parser, "expected %<:%>");
21746 maybe_unary_selector_p = false;
21747 token = cp_lexer_consume_token (parser->lexer);
21749 if (token->type == CPP_SCOPE)
21752 = chainon (sel_seq,
21753 build_tree_list (selector, NULL_TREE));
21755 = chainon (sel_seq,
21756 build_tree_list (NULL_TREE, NULL_TREE));
21760 = chainon (sel_seq,
21761 build_tree_list (selector, NULL_TREE));
21763 token = cp_lexer_peek_token (parser->lexer);
21767 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21769 return objc_build_selector_expr (loc, sel_seq);
21772 /* Parse a list of identifiers.
21774 objc-identifier-list:
21776 objc-identifier-list , identifier
21778 Returns a TREE_LIST of identifier nodes. */
21781 cp_parser_objc_identifier_list (cp_parser* parser)
21787 identifier = cp_parser_identifier (parser);
21788 if (identifier == error_mark_node)
21789 return error_mark_node;
21791 list = build_tree_list (NULL_TREE, identifier);
21792 sep = cp_lexer_peek_token (parser->lexer);
21794 while (sep->type == CPP_COMMA)
21796 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
21797 identifier = cp_parser_identifier (parser);
21798 if (identifier == error_mark_node)
21801 list = chainon (list, build_tree_list (NULL_TREE,
21803 sep = cp_lexer_peek_token (parser->lexer);
21809 /* Parse an Objective-C alias declaration.
21811 objc-alias-declaration:
21812 @compatibility_alias identifier identifier ;
21814 This function registers the alias mapping with the Objective-C front end.
21815 It returns nothing. */
21818 cp_parser_objc_alias_declaration (cp_parser* parser)
21822 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
21823 alias = cp_parser_identifier (parser);
21824 orig = cp_parser_identifier (parser);
21825 objc_declare_alias (alias, orig);
21826 cp_parser_consume_semicolon_at_end_of_statement (parser);
21829 /* Parse an Objective-C class forward-declaration.
21831 objc-class-declaration:
21832 @class objc-identifier-list ;
21834 The function registers the forward declarations with the Objective-C
21835 front end. It returns nothing. */
21838 cp_parser_objc_class_declaration (cp_parser* parser)
21840 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
21845 id = cp_parser_identifier (parser);
21846 if (id == error_mark_node)
21849 objc_declare_class (id);
21851 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
21852 cp_lexer_consume_token (parser->lexer);
21856 cp_parser_consume_semicolon_at_end_of_statement (parser);
21859 /* Parse a list of Objective-C protocol references.
21861 objc-protocol-refs-opt:
21862 objc-protocol-refs [opt]
21864 objc-protocol-refs:
21865 < objc-identifier-list >
21867 Returns a TREE_LIST of identifiers, if any. */
21870 cp_parser_objc_protocol_refs_opt (cp_parser* parser)
21872 tree protorefs = NULL_TREE;
21874 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
21876 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
21877 protorefs = cp_parser_objc_identifier_list (parser);
21878 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
21884 /* Parse a Objective-C visibility specification. */
21887 cp_parser_objc_visibility_spec (cp_parser* parser)
21889 cp_token *vis = cp_lexer_peek_token (parser->lexer);
21891 switch (vis->keyword)
21893 case RID_AT_PRIVATE:
21894 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE);
21896 case RID_AT_PROTECTED:
21897 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED);
21899 case RID_AT_PUBLIC:
21900 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC);
21902 case RID_AT_PACKAGE:
21903 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE);
21909 /* Eat '@private'/'@protected'/'@public'. */
21910 cp_lexer_consume_token (parser->lexer);
21913 /* Parse an Objective-C method type. Return 'true' if it is a class
21914 (+) method, and 'false' if it is an instance (-) method. */
21917 cp_parser_objc_method_type (cp_parser* parser)
21919 if (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS)
21925 /* Parse an Objective-C protocol qualifier. */
21928 cp_parser_objc_protocol_qualifiers (cp_parser* parser)
21930 tree quals = NULL_TREE, node;
21931 cp_token *token = cp_lexer_peek_token (parser->lexer);
21933 node = token->u.value;
21935 while (node && TREE_CODE (node) == IDENTIFIER_NODE
21936 && (node == ridpointers [(int) RID_IN]
21937 || node == ridpointers [(int) RID_OUT]
21938 || node == ridpointers [(int) RID_INOUT]
21939 || node == ridpointers [(int) RID_BYCOPY]
21940 || node == ridpointers [(int) RID_BYREF]
21941 || node == ridpointers [(int) RID_ONEWAY]))
21943 quals = tree_cons (NULL_TREE, node, quals);
21944 cp_lexer_consume_token (parser->lexer);
21945 token = cp_lexer_peek_token (parser->lexer);
21946 node = token->u.value;
21952 /* Parse an Objective-C typename. */
21955 cp_parser_objc_typename (cp_parser* parser)
21957 tree type_name = NULL_TREE;
21959 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
21961 tree proto_quals, cp_type = NULL_TREE;
21963 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
21964 proto_quals = cp_parser_objc_protocol_qualifiers (parser);
21966 /* An ObjC type name may consist of just protocol qualifiers, in which
21967 case the type shall default to 'id'. */
21968 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
21970 cp_type = cp_parser_type_id (parser);
21972 /* If the type could not be parsed, an error has already
21973 been produced. For error recovery, behave as if it had
21974 not been specified, which will use the default type
21976 if (cp_type == error_mark_node)
21978 cp_type = NULL_TREE;
21979 /* We need to skip to the closing parenthesis as
21980 cp_parser_type_id() does not seem to do it for
21982 cp_parser_skip_to_closing_parenthesis (parser,
21983 /*recovering=*/true,
21984 /*or_comma=*/false,
21985 /*consume_paren=*/false);
21989 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21990 type_name = build_tree_list (proto_quals, cp_type);
21996 /* Check to see if TYPE refers to an Objective-C selector name. */
21999 cp_parser_objc_selector_p (enum cpp_ttype type)
22001 return (type == CPP_NAME || type == CPP_KEYWORD
22002 || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND
22003 || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT
22004 || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ
22005 || type == CPP_XOR || type == CPP_XOR_EQ);
22008 /* Parse an Objective-C selector. */
22011 cp_parser_objc_selector (cp_parser* parser)
22013 cp_token *token = cp_lexer_consume_token (parser->lexer);
22015 if (!cp_parser_objc_selector_p (token->type))
22017 error_at (token->location, "invalid Objective-C++ selector name");
22018 return error_mark_node;
22021 /* C++ operator names are allowed to appear in ObjC selectors. */
22022 switch (token->type)
22024 case CPP_AND_AND: return get_identifier ("and");
22025 case CPP_AND_EQ: return get_identifier ("and_eq");
22026 case CPP_AND: return get_identifier ("bitand");
22027 case CPP_OR: return get_identifier ("bitor");
22028 case CPP_COMPL: return get_identifier ("compl");
22029 case CPP_NOT: return get_identifier ("not");
22030 case CPP_NOT_EQ: return get_identifier ("not_eq");
22031 case CPP_OR_OR: return get_identifier ("or");
22032 case CPP_OR_EQ: return get_identifier ("or_eq");
22033 case CPP_XOR: return get_identifier ("xor");
22034 case CPP_XOR_EQ: return get_identifier ("xor_eq");
22035 default: return token->u.value;
22039 /* Parse an Objective-C params list. */
22042 cp_parser_objc_method_keyword_params (cp_parser* parser, tree* attributes)
22044 tree params = NULL_TREE;
22045 bool maybe_unary_selector_p = true;
22046 cp_token *token = cp_lexer_peek_token (parser->lexer);
22048 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
22050 tree selector = NULL_TREE, type_name, identifier;
22051 tree parm_attr = NULL_TREE;
22053 if (token->keyword == RID_ATTRIBUTE)
22056 if (token->type != CPP_COLON)
22057 selector = cp_parser_objc_selector (parser);
22059 /* Detect if we have a unary selector. */
22060 if (maybe_unary_selector_p
22061 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
22063 params = selector; /* Might be followed by attributes. */
22067 maybe_unary_selector_p = false;
22068 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
22070 /* Something went quite wrong. There should be a colon
22071 here, but there is not. Stop parsing parameters. */
22074 type_name = cp_parser_objc_typename (parser);
22075 /* New ObjC allows attributes on parameters too. */
22076 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
22077 parm_attr = cp_parser_attributes_opt (parser);
22078 identifier = cp_parser_identifier (parser);
22082 objc_build_keyword_decl (selector,
22087 token = cp_lexer_peek_token (parser->lexer);
22090 if (params == NULL_TREE)
22092 cp_parser_error (parser, "objective-c++ method declaration is expected");
22093 return error_mark_node;
22096 /* We allow tail attributes for the method. */
22097 if (token->keyword == RID_ATTRIBUTE)
22099 *attributes = cp_parser_attributes_opt (parser);
22100 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
22101 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22103 cp_parser_error (parser,
22104 "method attributes must be specified at the end");
22105 return error_mark_node;
22108 if (params == NULL_TREE)
22110 cp_parser_error (parser, "objective-c++ method declaration is expected");
22111 return error_mark_node;
22116 /* Parse the non-keyword Objective-C params. */
22119 cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp,
22122 tree params = make_node (TREE_LIST);
22123 cp_token *token = cp_lexer_peek_token (parser->lexer);
22124 *ellipsisp = false; /* Initially, assume no ellipsis. */
22126 while (token->type == CPP_COMMA)
22128 cp_parameter_declarator *parmdecl;
22131 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
22132 token = cp_lexer_peek_token (parser->lexer);
22134 if (token->type == CPP_ELLIPSIS)
22136 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
22138 token = cp_lexer_peek_token (parser->lexer);
22142 /* TODO: parse attributes for tail parameters. */
22143 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
22144 parm = grokdeclarator (parmdecl->declarator,
22145 &parmdecl->decl_specifiers,
22146 PARM, /*initialized=*/0,
22147 /*attrlist=*/NULL);
22149 chainon (params, build_tree_list (NULL_TREE, parm));
22150 token = cp_lexer_peek_token (parser->lexer);
22153 /* We allow tail attributes for the method. */
22154 if (token->keyword == RID_ATTRIBUTE)
22156 if (*attributes == NULL_TREE)
22158 *attributes = cp_parser_attributes_opt (parser);
22159 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
22160 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22164 /* We have an error, but parse the attributes, so that we can
22166 *attributes = cp_parser_attributes_opt (parser);
22168 cp_parser_error (parser,
22169 "method attributes must be specified at the end");
22170 return error_mark_node;
22176 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
22179 cp_parser_objc_interstitial_code (cp_parser* parser)
22181 cp_token *token = cp_lexer_peek_token (parser->lexer);
22183 /* If the next token is `extern' and the following token is a string
22184 literal, then we have a linkage specification. */
22185 if (token->keyword == RID_EXTERN
22186 && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2)))
22187 cp_parser_linkage_specification (parser);
22188 /* Handle #pragma, if any. */
22189 else if (token->type == CPP_PRAGMA)
22190 cp_parser_pragma (parser, pragma_external);
22191 /* Allow stray semicolons. */
22192 else if (token->type == CPP_SEMICOLON)
22193 cp_lexer_consume_token (parser->lexer);
22194 /* Mark methods as optional or required, when building protocols. */
22195 else if (token->keyword == RID_AT_OPTIONAL)
22197 cp_lexer_consume_token (parser->lexer);
22198 objc_set_method_opt (true);
22200 else if (token->keyword == RID_AT_REQUIRED)
22202 cp_lexer_consume_token (parser->lexer);
22203 objc_set_method_opt (false);
22205 else if (token->keyword == RID_NAMESPACE)
22206 cp_parser_namespace_definition (parser);
22207 /* Other stray characters must generate errors. */
22208 else if (token->type == CPP_OPEN_BRACE || token->type == CPP_CLOSE_BRACE)
22210 cp_lexer_consume_token (parser->lexer);
22211 error ("stray %qs between Objective-C++ methods",
22212 token->type == CPP_OPEN_BRACE ? "{" : "}");
22214 /* Finally, try to parse a block-declaration, or a function-definition. */
22216 cp_parser_block_declaration (parser, /*statement_p=*/false);
22219 /* Parse a method signature. */
22222 cp_parser_objc_method_signature (cp_parser* parser, tree* attributes)
22224 tree rettype, kwdparms, optparms;
22225 bool ellipsis = false;
22226 bool is_class_method;
22228 is_class_method = cp_parser_objc_method_type (parser);
22229 rettype = cp_parser_objc_typename (parser);
22230 *attributes = NULL_TREE;
22231 kwdparms = cp_parser_objc_method_keyword_params (parser, attributes);
22232 if (kwdparms == error_mark_node)
22233 return error_mark_node;
22234 optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis, attributes);
22235 if (optparms == error_mark_node)
22236 return error_mark_node;
22238 return objc_build_method_signature (is_class_method, rettype, kwdparms, optparms, ellipsis);
22242 cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser* parser)
22245 cp_lexer_save_tokens (parser->lexer);
22246 tattr = cp_parser_attributes_opt (parser);
22247 gcc_assert (tattr) ;
22249 /* If the attributes are followed by a method introducer, this is not allowed.
22250 Dump the attributes and flag the situation. */
22251 if (cp_lexer_next_token_is (parser->lexer, CPP_PLUS)
22252 || cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
22255 /* Otherwise, the attributes introduce some interstitial code, possibly so
22256 rewind to allow that check. */
22257 cp_lexer_rollback_tokens (parser->lexer);
22261 /* Parse an Objective-C method prototype list. */
22264 cp_parser_objc_method_prototype_list (cp_parser* parser)
22266 cp_token *token = cp_lexer_peek_token (parser->lexer);
22268 while (token->keyword != RID_AT_END && token->type != CPP_EOF)
22270 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
22272 tree attributes, sig;
22273 bool is_class_method;
22274 if (token->type == CPP_PLUS)
22275 is_class_method = true;
22277 is_class_method = false;
22278 sig = cp_parser_objc_method_signature (parser, &attributes);
22279 if (sig == error_mark_node)
22281 cp_parser_skip_to_end_of_block_or_statement (parser);
22282 token = cp_lexer_peek_token (parser->lexer);
22285 objc_add_method_declaration (is_class_method, sig, attributes);
22286 cp_parser_consume_semicolon_at_end_of_statement (parser);
22288 else if (token->keyword == RID_AT_PROPERTY)
22289 cp_parser_objc_at_property_declaration (parser);
22290 else if (token->keyword == RID_ATTRIBUTE
22291 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
22292 warning_at (cp_lexer_peek_token (parser->lexer)->location,
22294 "prefix attributes are ignored for methods");
22296 /* Allow for interspersed non-ObjC++ code. */
22297 cp_parser_objc_interstitial_code (parser);
22299 token = cp_lexer_peek_token (parser->lexer);
22302 if (token->type != CPP_EOF)
22303 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
22305 cp_parser_error (parser, "expected %<@end%>");
22307 objc_finish_interface ();
22310 /* Parse an Objective-C method definition list. */
22313 cp_parser_objc_method_definition_list (cp_parser* parser)
22315 cp_token *token = cp_lexer_peek_token (parser->lexer);
22317 while (token->keyword != RID_AT_END && token->type != CPP_EOF)
22321 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
22324 tree sig, attribute;
22325 bool is_class_method;
22326 if (token->type == CPP_PLUS)
22327 is_class_method = true;
22329 is_class_method = false;
22330 push_deferring_access_checks (dk_deferred);
22331 sig = cp_parser_objc_method_signature (parser, &attribute);
22332 if (sig == error_mark_node)
22334 cp_parser_skip_to_end_of_block_or_statement (parser);
22335 token = cp_lexer_peek_token (parser->lexer);
22338 objc_start_method_definition (is_class_method, sig, attribute,
22341 /* For historical reasons, we accept an optional semicolon. */
22342 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
22343 cp_lexer_consume_token (parser->lexer);
22345 ptk = cp_lexer_peek_token (parser->lexer);
22346 if (!(ptk->type == CPP_PLUS || ptk->type == CPP_MINUS
22347 || ptk->type == CPP_EOF || ptk->keyword == RID_AT_END))
22349 perform_deferred_access_checks ();
22350 stop_deferring_access_checks ();
22351 meth = cp_parser_function_definition_after_declarator (parser,
22353 pop_deferring_access_checks ();
22354 objc_finish_method_definition (meth);
22357 /* The following case will be removed once @synthesize is
22358 completely implemented. */
22359 else if (token->keyword == RID_AT_PROPERTY)
22360 cp_parser_objc_at_property_declaration (parser);
22361 else if (token->keyword == RID_AT_SYNTHESIZE)
22362 cp_parser_objc_at_synthesize_declaration (parser);
22363 else if (token->keyword == RID_AT_DYNAMIC)
22364 cp_parser_objc_at_dynamic_declaration (parser);
22365 else if (token->keyword == RID_ATTRIBUTE
22366 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
22367 warning_at (token->location, OPT_Wattributes,
22368 "prefix attributes are ignored for methods");
22370 /* Allow for interspersed non-ObjC++ code. */
22371 cp_parser_objc_interstitial_code (parser);
22373 token = cp_lexer_peek_token (parser->lexer);
22376 if (token->type != CPP_EOF)
22377 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
22379 cp_parser_error (parser, "expected %<@end%>");
22381 objc_finish_implementation ();
22384 /* Parse Objective-C ivars. */
22387 cp_parser_objc_class_ivars (cp_parser* parser)
22389 cp_token *token = cp_lexer_peek_token (parser->lexer);
22391 if (token->type != CPP_OPEN_BRACE)
22392 return; /* No ivars specified. */
22394 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
22395 token = cp_lexer_peek_token (parser->lexer);
22397 while (token->type != CPP_CLOSE_BRACE
22398 && token->keyword != RID_AT_END && token->type != CPP_EOF)
22400 cp_decl_specifier_seq declspecs;
22401 int decl_class_or_enum_p;
22402 tree prefix_attributes;
22404 cp_parser_objc_visibility_spec (parser);
22406 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
22409 cp_parser_decl_specifier_seq (parser,
22410 CP_PARSER_FLAGS_OPTIONAL,
22412 &decl_class_or_enum_p);
22414 /* auto, register, static, extern, mutable. */
22415 if (declspecs.storage_class != sc_none)
22417 cp_parser_error (parser, "invalid type for instance variable");
22418 declspecs.storage_class = sc_none;
22422 if (declspecs.specs[(int) ds_thread])
22424 cp_parser_error (parser, "invalid type for instance variable");
22425 declspecs.specs[(int) ds_thread] = 0;
22429 if (declspecs.specs[(int) ds_typedef])
22431 cp_parser_error (parser, "invalid type for instance variable");
22432 declspecs.specs[(int) ds_typedef] = 0;
22435 prefix_attributes = declspecs.attributes;
22436 declspecs.attributes = NULL_TREE;
22438 /* Keep going until we hit the `;' at the end of the
22440 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
22442 tree width = NULL_TREE, attributes, first_attribute, decl;
22443 cp_declarator *declarator = NULL;
22444 int ctor_dtor_or_conv_p;
22446 /* Check for a (possibly unnamed) bitfield declaration. */
22447 token = cp_lexer_peek_token (parser->lexer);
22448 if (token->type == CPP_COLON)
22451 if (token->type == CPP_NAME
22452 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
22455 /* Get the name of the bitfield. */
22456 declarator = make_id_declarator (NULL_TREE,
22457 cp_parser_identifier (parser),
22461 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
22462 /* Get the width of the bitfield. */
22464 = cp_parser_constant_expression (parser,
22465 /*allow_non_constant=*/false,
22470 /* Parse the declarator. */
22472 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
22473 &ctor_dtor_or_conv_p,
22474 /*parenthesized_p=*/NULL,
22475 /*member_p=*/false);
22478 /* Look for attributes that apply to the ivar. */
22479 attributes = cp_parser_attributes_opt (parser);
22480 /* Remember which attributes are prefix attributes and
22482 first_attribute = attributes;
22483 /* Combine the attributes. */
22484 attributes = chainon (prefix_attributes, attributes);
22487 /* Create the bitfield declaration. */
22488 decl = grokbitfield (declarator, &declspecs,
22492 decl = grokfield (declarator, &declspecs,
22493 NULL_TREE, /*init_const_expr_p=*/false,
22494 NULL_TREE, attributes);
22496 /* Add the instance variable. */
22497 if (decl != error_mark_node && decl != NULL_TREE)
22498 objc_add_instance_variable (decl);
22500 /* Reset PREFIX_ATTRIBUTES. */
22501 while (attributes && TREE_CHAIN (attributes) != first_attribute)
22502 attributes = TREE_CHAIN (attributes);
22504 TREE_CHAIN (attributes) = NULL_TREE;
22506 token = cp_lexer_peek_token (parser->lexer);
22508 if (token->type == CPP_COMMA)
22510 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
22516 cp_parser_consume_semicolon_at_end_of_statement (parser);
22517 token = cp_lexer_peek_token (parser->lexer);
22520 if (token->keyword == RID_AT_END)
22521 cp_parser_error (parser, "expected %<}%>");
22523 /* Do not consume the RID_AT_END, so it will be read again as terminating
22524 the @interface of @implementation. */
22525 if (token->keyword != RID_AT_END && token->type != CPP_EOF)
22526 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
22528 /* For historical reasons, we accept an optional semicolon. */
22529 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
22530 cp_lexer_consume_token (parser->lexer);
22533 /* Parse an Objective-C protocol declaration. */
22536 cp_parser_objc_protocol_declaration (cp_parser* parser, tree attributes)
22538 tree proto, protorefs;
22541 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
22542 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
22544 tok = cp_lexer_peek_token (parser->lexer);
22545 error_at (tok->location, "identifier expected after %<@protocol%>");
22546 cp_parser_consume_semicolon_at_end_of_statement (parser);
22550 /* See if we have a forward declaration or a definition. */
22551 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
22553 /* Try a forward declaration first. */
22554 if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON)
22560 id = cp_parser_identifier (parser);
22561 if (id == error_mark_node)
22564 objc_declare_protocol (id, attributes);
22566 if(cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
22567 cp_lexer_consume_token (parser->lexer);
22571 cp_parser_consume_semicolon_at_end_of_statement (parser);
22574 /* Ok, we got a full-fledged definition (or at least should). */
22577 proto = cp_parser_identifier (parser);
22578 protorefs = cp_parser_objc_protocol_refs_opt (parser);
22579 objc_start_protocol (proto, protorefs, attributes);
22580 cp_parser_objc_method_prototype_list (parser);
22584 /* Parse an Objective-C superclass or category. */
22587 cp_parser_objc_superclass_or_category (cp_parser *parser,
22590 tree *categ, bool *is_class_extension)
22592 cp_token *next = cp_lexer_peek_token (parser->lexer);
22594 *super = *categ = NULL_TREE;
22595 *is_class_extension = false;
22596 if (next->type == CPP_COLON)
22598 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
22599 *super = cp_parser_identifier (parser);
22601 else if (next->type == CPP_OPEN_PAREN)
22603 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
22605 /* If there is no category name, and this is an @interface, we
22606 have a class extension. */
22607 if (iface_p && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
22609 *categ = NULL_TREE;
22610 *is_class_extension = true;
22613 *categ = cp_parser_identifier (parser);
22615 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
22619 /* Parse an Objective-C class interface. */
22622 cp_parser_objc_class_interface (cp_parser* parser, tree attributes)
22624 tree name, super, categ, protos;
22625 bool is_class_extension;
22627 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
22628 name = cp_parser_identifier (parser);
22629 if (name == error_mark_node)
22631 /* It's hard to recover because even if valid @interface stuff
22632 is to follow, we can't compile it (or validate it) if we
22633 don't even know which class it refers to. Let's assume this
22634 was a stray '@interface' token in the stream and skip it.
22638 cp_parser_objc_superclass_or_category (parser, true, &super, &categ,
22639 &is_class_extension);
22640 protos = cp_parser_objc_protocol_refs_opt (parser);
22642 /* We have either a class or a category on our hands. */
22643 if (categ || is_class_extension)
22644 objc_start_category_interface (name, categ, protos, attributes);
22647 objc_start_class_interface (name, super, protos, attributes);
22648 /* Handle instance variable declarations, if any. */
22649 cp_parser_objc_class_ivars (parser);
22650 objc_continue_interface ();
22653 cp_parser_objc_method_prototype_list (parser);
22656 /* Parse an Objective-C class implementation. */
22659 cp_parser_objc_class_implementation (cp_parser* parser)
22661 tree name, super, categ;
22662 bool is_class_extension;
22664 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
22665 name = cp_parser_identifier (parser);
22666 if (name == error_mark_node)
22668 /* It's hard to recover because even if valid @implementation
22669 stuff is to follow, we can't compile it (or validate it) if
22670 we don't even know which class it refers to. Let's assume
22671 this was a stray '@implementation' token in the stream and
22676 cp_parser_objc_superclass_or_category (parser, false, &super, &categ,
22677 &is_class_extension);
22679 /* We have either a class or a category on our hands. */
22681 objc_start_category_implementation (name, categ);
22684 objc_start_class_implementation (name, super);
22685 /* Handle instance variable declarations, if any. */
22686 cp_parser_objc_class_ivars (parser);
22687 objc_continue_implementation ();
22690 cp_parser_objc_method_definition_list (parser);
22693 /* Consume the @end token and finish off the implementation. */
22696 cp_parser_objc_end_implementation (cp_parser* parser)
22698 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
22699 objc_finish_implementation ();
22702 /* Parse an Objective-C declaration. */
22705 cp_parser_objc_declaration (cp_parser* parser, tree attributes)
22707 /* Try to figure out what kind of declaration is present. */
22708 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
22711 switch (kwd->keyword)
22716 error_at (kwd->location, "attributes may not be specified before"
22717 " the %<@%D%> Objective-C++ keyword",
22721 case RID_AT_IMPLEMENTATION:
22722 warning_at (kwd->location, OPT_Wattributes,
22723 "prefix attributes are ignored before %<@%D%>",
22730 switch (kwd->keyword)
22733 cp_parser_objc_alias_declaration (parser);
22736 cp_parser_objc_class_declaration (parser);
22738 case RID_AT_PROTOCOL:
22739 cp_parser_objc_protocol_declaration (parser, attributes);
22741 case RID_AT_INTERFACE:
22742 cp_parser_objc_class_interface (parser, attributes);
22744 case RID_AT_IMPLEMENTATION:
22745 cp_parser_objc_class_implementation (parser);
22748 cp_parser_objc_end_implementation (parser);
22751 error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
22753 cp_parser_skip_to_end_of_block_or_statement (parser);
22757 /* Parse an Objective-C try-catch-finally statement.
22759 objc-try-catch-finally-stmt:
22760 @try compound-statement objc-catch-clause-seq [opt]
22761 objc-finally-clause [opt]
22763 objc-catch-clause-seq:
22764 objc-catch-clause objc-catch-clause-seq [opt]
22767 @catch ( objc-exception-declaration ) compound-statement
22769 objc-finally-clause:
22770 @finally compound-statement
22772 objc-exception-declaration:
22773 parameter-declaration
22776 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
22780 PS: This function is identical to c_parser_objc_try_catch_finally_statement
22781 for C. Keep them in sync. */
22784 cp_parser_objc_try_catch_finally_statement (cp_parser *parser)
22786 location_t location;
22789 cp_parser_require_keyword (parser, RID_AT_TRY, RT_AT_TRY);
22790 location = cp_lexer_peek_token (parser->lexer)->location;
22791 objc_maybe_warn_exceptions (location);
22792 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
22793 node, lest it get absorbed into the surrounding block. */
22794 stmt = push_stmt_list ();
22795 cp_parser_compound_statement (parser, NULL, false, false);
22796 objc_begin_try_stmt (location, pop_stmt_list (stmt));
22798 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
22800 cp_parameter_declarator *parm;
22801 tree parameter_declaration = error_mark_node;
22802 bool seen_open_paren = false;
22804 cp_lexer_consume_token (parser->lexer);
22805 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
22806 seen_open_paren = true;
22807 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
22809 /* We have "@catch (...)" (where the '...' are literally
22810 what is in the code). Skip the '...'.
22811 parameter_declaration is set to NULL_TREE, and
22812 objc_being_catch_clauses() knows that that means
22814 cp_lexer_consume_token (parser->lexer);
22815 parameter_declaration = NULL_TREE;
22819 /* We have "@catch (NSException *exception)" or something
22820 like that. Parse the parameter declaration. */
22821 parm = cp_parser_parameter_declaration (parser, false, NULL);
22823 parameter_declaration = error_mark_node;
22825 parameter_declaration = grokdeclarator (parm->declarator,
22826 &parm->decl_specifiers,
22827 PARM, /*initialized=*/0,
22828 /*attrlist=*/NULL);
22830 if (seen_open_paren)
22831 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
22834 /* If there was no open parenthesis, we are recovering from
22835 an error, and we are trying to figure out what mistake
22836 the user has made. */
22838 /* If there is an immediate closing parenthesis, the user
22839 probably forgot the opening one (ie, they typed "@catch
22840 NSException *e)". Parse the closing parenthesis and keep
22842 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
22843 cp_lexer_consume_token (parser->lexer);
22845 /* If these is no immediate closing parenthesis, the user
22846 probably doesn't know that parenthesis are required at
22847 all (ie, they typed "@catch NSException *e"). So, just
22848 forget about the closing parenthesis and keep going. */
22850 objc_begin_catch_clause (parameter_declaration);
22851 cp_parser_compound_statement (parser, NULL, false, false);
22852 objc_finish_catch_clause ();
22854 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
22856 cp_lexer_consume_token (parser->lexer);
22857 location = cp_lexer_peek_token (parser->lexer)->location;
22858 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
22859 node, lest it get absorbed into the surrounding block. */
22860 stmt = push_stmt_list ();
22861 cp_parser_compound_statement (parser, NULL, false, false);
22862 objc_build_finally_clause (location, pop_stmt_list (stmt));
22865 return objc_finish_try_stmt ();
22868 /* Parse an Objective-C synchronized statement.
22870 objc-synchronized-stmt:
22871 @synchronized ( expression ) compound-statement
22873 Returns NULL_TREE. */
22876 cp_parser_objc_synchronized_statement (cp_parser *parser)
22878 location_t location;
22881 cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, RT_AT_SYNCHRONIZED);
22883 location = cp_lexer_peek_token (parser->lexer)->location;
22884 objc_maybe_warn_exceptions (location);
22885 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
22886 lock = cp_parser_expression (parser, false, NULL);
22887 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
22889 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
22890 node, lest it get absorbed into the surrounding block. */
22891 stmt = push_stmt_list ();
22892 cp_parser_compound_statement (parser, NULL, false, false);
22894 return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
22897 /* Parse an Objective-C throw statement.
22900 @throw assignment-expression [opt] ;
22902 Returns a constructed '@throw' statement. */
22905 cp_parser_objc_throw_statement (cp_parser *parser)
22907 tree expr = NULL_TREE;
22908 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
22910 cp_parser_require_keyword (parser, RID_AT_THROW, RT_AT_THROW);
22912 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
22913 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
22915 cp_parser_consume_semicolon_at_end_of_statement (parser);
22917 return objc_build_throw_stmt (loc, expr);
22920 /* Parse an Objective-C statement. */
22923 cp_parser_objc_statement (cp_parser * parser)
22925 /* Try to figure out what kind of declaration is present. */
22926 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
22928 switch (kwd->keyword)
22931 return cp_parser_objc_try_catch_finally_statement (parser);
22932 case RID_AT_SYNCHRONIZED:
22933 return cp_parser_objc_synchronized_statement (parser);
22935 return cp_parser_objc_throw_statement (parser);
22937 error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
22939 cp_parser_skip_to_end_of_block_or_statement (parser);
22942 return error_mark_node;
22945 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
22946 look ahead to see if an objc keyword follows the attributes. This
22947 is to detect the use of prefix attributes on ObjC @interface and
22951 cp_parser_objc_valid_prefix_attributes (cp_parser* parser, tree *attrib)
22953 cp_lexer_save_tokens (parser->lexer);
22954 *attrib = cp_parser_attributes_opt (parser);
22955 gcc_assert (*attrib);
22956 if (OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser->lexer)->keyword))
22958 cp_lexer_commit_tokens (parser->lexer);
22961 cp_lexer_rollback_tokens (parser->lexer);
22965 /* This routine is a minimal replacement for
22966 c_parser_struct_declaration () used when parsing the list of
22967 types/names or ObjC++ properties. For example, when parsing the
22970 @property (readonly) int a, b, c;
22972 this function is responsible for parsing "int a, int b, int c" and
22973 returning the declarations as CHAIN of DECLs.
22975 TODO: Share this code with cp_parser_objc_class_ivars. It's very
22976 similar parsing. */
22978 cp_parser_objc_struct_declaration (cp_parser *parser)
22980 tree decls = NULL_TREE;
22981 cp_decl_specifier_seq declspecs;
22982 int decl_class_or_enum_p;
22983 tree prefix_attributes;
22985 cp_parser_decl_specifier_seq (parser,
22986 CP_PARSER_FLAGS_NONE,
22988 &decl_class_or_enum_p);
22990 if (declspecs.type == error_mark_node)
22991 return error_mark_node;
22993 /* auto, register, static, extern, mutable. */
22994 if (declspecs.storage_class != sc_none)
22996 cp_parser_error (parser, "invalid type for property");
22997 declspecs.storage_class = sc_none;
23001 if (declspecs.specs[(int) ds_thread])
23003 cp_parser_error (parser, "invalid type for property");
23004 declspecs.specs[(int) ds_thread] = 0;
23008 if (declspecs.specs[(int) ds_typedef])
23010 cp_parser_error (parser, "invalid type for property");
23011 declspecs.specs[(int) ds_typedef] = 0;
23014 prefix_attributes = declspecs.attributes;
23015 declspecs.attributes = NULL_TREE;
23017 /* Keep going until we hit the `;' at the end of the declaration. */
23018 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
23020 tree attributes, first_attribute, decl;
23021 cp_declarator *declarator;
23024 /* Parse the declarator. */
23025 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
23026 NULL, NULL, false);
23028 /* Look for attributes that apply to the ivar. */
23029 attributes = cp_parser_attributes_opt (parser);
23030 /* Remember which attributes are prefix attributes and
23032 first_attribute = attributes;
23033 /* Combine the attributes. */
23034 attributes = chainon (prefix_attributes, attributes);
23036 decl = grokfield (declarator, &declspecs,
23037 NULL_TREE, /*init_const_expr_p=*/false,
23038 NULL_TREE, attributes);
23040 if (decl == error_mark_node || decl == NULL_TREE)
23041 return error_mark_node;
23043 /* Reset PREFIX_ATTRIBUTES. */
23044 while (attributes && TREE_CHAIN (attributes) != first_attribute)
23045 attributes = TREE_CHAIN (attributes);
23047 TREE_CHAIN (attributes) = NULL_TREE;
23049 DECL_CHAIN (decl) = decls;
23052 token = cp_lexer_peek_token (parser->lexer);
23053 if (token->type == CPP_COMMA)
23055 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
23064 /* Parse an Objective-C @property declaration. The syntax is:
23066 objc-property-declaration:
23067 '@property' objc-property-attributes[opt] struct-declaration ;
23069 objc-property-attributes:
23070 '(' objc-property-attribute-list ')'
23072 objc-property-attribute-list:
23073 objc-property-attribute
23074 objc-property-attribute-list, objc-property-attribute
23076 objc-property-attribute
23077 'getter' = identifier
23078 'setter' = identifier
23087 @property NSString *name;
23088 @property (readonly) id object;
23089 @property (retain, nonatomic, getter=getTheName) id name;
23090 @property int a, b, c;
23092 PS: This function is identical to
23093 c_parser_objc_at_property_declaration for C. Keep them in sync. */
23095 cp_parser_objc_at_property_declaration (cp_parser *parser)
23097 /* The following variables hold the attributes of the properties as
23098 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
23099 seen. When we see an attribute, we set them to 'true' (if they
23100 are boolean properties) or to the identifier (if they have an
23101 argument, ie, for getter and setter). Note that here we only
23102 parse the list of attributes, check the syntax and accumulate the
23103 attributes that we find. objc_add_property_declaration() will
23104 then process the information. */
23105 bool property_assign = false;
23106 bool property_copy = false;
23107 tree property_getter_ident = NULL_TREE;
23108 bool property_nonatomic = false;
23109 bool property_readonly = false;
23110 bool property_readwrite = false;
23111 bool property_retain = false;
23112 tree property_setter_ident = NULL_TREE;
23114 /* 'properties' is the list of properties that we read. Usually a
23115 single one, but maybe more (eg, in "@property int a, b, c;" there
23120 loc = cp_lexer_peek_token (parser->lexer)->location;
23122 cp_lexer_consume_token (parser->lexer); /* Eat '@property'. */
23124 /* Parse the optional attribute list... */
23125 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
23128 cp_lexer_consume_token (parser->lexer);
23132 bool syntax_error = false;
23133 cp_token *token = cp_lexer_peek_token (parser->lexer);
23136 if (token->type != CPP_NAME)
23138 cp_parser_error (parser, "expected identifier");
23141 keyword = C_RID_CODE (token->u.value);
23142 cp_lexer_consume_token (parser->lexer);
23145 case RID_ASSIGN: property_assign = true; break;
23146 case RID_COPY: property_copy = true; break;
23147 case RID_NONATOMIC: property_nonatomic = true; break;
23148 case RID_READONLY: property_readonly = true; break;
23149 case RID_READWRITE: property_readwrite = true; break;
23150 case RID_RETAIN: property_retain = true; break;
23154 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
23156 if (keyword == RID_GETTER)
23157 cp_parser_error (parser,
23158 "missing %<=%> (after %<getter%> attribute)");
23160 cp_parser_error (parser,
23161 "missing %<=%> (after %<setter%> attribute)");
23162 syntax_error = true;
23165 cp_lexer_consume_token (parser->lexer); /* eat the = */
23166 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
23168 cp_parser_error (parser, "expected identifier");
23169 syntax_error = true;
23172 if (keyword == RID_SETTER)
23174 if (property_setter_ident != NULL_TREE)
23175 cp_parser_error (parser, "the %<setter%> attribute may only be specified once");
23177 property_setter_ident = cp_lexer_peek_token (parser->lexer)->u.value;
23178 cp_lexer_consume_token (parser->lexer);
23179 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
23180 cp_parser_error (parser, "setter name must terminate with %<:%>");
23182 cp_lexer_consume_token (parser->lexer);
23186 if (property_getter_ident != NULL_TREE)
23187 cp_parser_error (parser, "the %<getter%> attribute may only be specified once");
23189 property_getter_ident = cp_lexer_peek_token (parser->lexer)->u.value;
23190 cp_lexer_consume_token (parser->lexer);
23194 cp_parser_error (parser, "unknown property attribute");
23195 syntax_error = true;
23202 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23203 cp_lexer_consume_token (parser->lexer);
23208 /* FIXME: "@property (setter, assign);" will generate a spurious
23209 "error: expected ‘)’ before ‘,’ token". This is because
23210 cp_parser_require, unlike the C counterpart, will produce an
23211 error even if we are in error recovery. */
23212 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23214 cp_parser_skip_to_closing_parenthesis (parser,
23215 /*recovering=*/true,
23216 /*or_comma=*/false,
23217 /*consume_paren=*/true);
23221 /* ... and the property declaration(s). */
23222 properties = cp_parser_objc_struct_declaration (parser);
23224 if (properties == error_mark_node)
23226 cp_parser_skip_to_end_of_statement (parser);
23227 /* If the next token is now a `;', consume it. */
23228 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
23229 cp_lexer_consume_token (parser->lexer);
23233 if (properties == NULL_TREE)
23234 cp_parser_error (parser, "expected identifier");
23237 /* Comma-separated properties are chained together in
23238 reverse order; add them one by one. */
23239 properties = nreverse (properties);
23241 for (; properties; properties = TREE_CHAIN (properties))
23242 objc_add_property_declaration (loc, copy_node (properties),
23243 property_readonly, property_readwrite,
23244 property_assign, property_retain,
23245 property_copy, property_nonatomic,
23246 property_getter_ident, property_setter_ident);
23249 cp_parser_consume_semicolon_at_end_of_statement (parser);
23252 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
23254 objc-synthesize-declaration:
23255 @synthesize objc-synthesize-identifier-list ;
23257 objc-synthesize-identifier-list:
23258 objc-synthesize-identifier
23259 objc-synthesize-identifier-list, objc-synthesize-identifier
23261 objc-synthesize-identifier
23263 identifier = identifier
23266 @synthesize MyProperty;
23267 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
23269 PS: This function is identical to c_parser_objc_at_synthesize_declaration
23270 for C. Keep them in sync.
23273 cp_parser_objc_at_synthesize_declaration (cp_parser *parser)
23275 tree list = NULL_TREE;
23277 loc = cp_lexer_peek_token (parser->lexer)->location;
23279 cp_lexer_consume_token (parser->lexer); /* Eat '@synthesize'. */
23282 tree property, ivar;
23283 property = cp_parser_identifier (parser);
23284 if (property == error_mark_node)
23286 cp_parser_consume_semicolon_at_end_of_statement (parser);
23289 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
23291 cp_lexer_consume_token (parser->lexer);
23292 ivar = cp_parser_identifier (parser);
23293 if (ivar == error_mark_node)
23295 cp_parser_consume_semicolon_at_end_of_statement (parser);
23301 list = chainon (list, build_tree_list (ivar, property));
23302 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23303 cp_lexer_consume_token (parser->lexer);
23307 cp_parser_consume_semicolon_at_end_of_statement (parser);
23308 objc_add_synthesize_declaration (loc, list);
23311 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
23313 objc-dynamic-declaration:
23314 @dynamic identifier-list ;
23317 @dynamic MyProperty;
23318 @dynamic MyProperty, AnotherProperty;
23320 PS: This function is identical to c_parser_objc_at_dynamic_declaration
23321 for C. Keep them in sync.
23324 cp_parser_objc_at_dynamic_declaration (cp_parser *parser)
23326 tree list = NULL_TREE;
23328 loc = cp_lexer_peek_token (parser->lexer)->location;
23330 cp_lexer_consume_token (parser->lexer); /* Eat '@dynamic'. */
23334 property = cp_parser_identifier (parser);
23335 if (property == error_mark_node)
23337 cp_parser_consume_semicolon_at_end_of_statement (parser);
23340 list = chainon (list, build_tree_list (NULL, property));
23341 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23342 cp_lexer_consume_token (parser->lexer);
23346 cp_parser_consume_semicolon_at_end_of_statement (parser);
23347 objc_add_dynamic_declaration (loc, list);
23351 /* OpenMP 2.5 parsing routines. */
23353 /* Returns name of the next clause.
23354 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
23355 the token is not consumed. Otherwise appropriate pragma_omp_clause is
23356 returned and the token is consumed. */
23358 static pragma_omp_clause
23359 cp_parser_omp_clause_name (cp_parser *parser)
23361 pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
23363 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
23364 result = PRAGMA_OMP_CLAUSE_IF;
23365 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
23366 result = PRAGMA_OMP_CLAUSE_DEFAULT;
23367 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
23368 result = PRAGMA_OMP_CLAUSE_PRIVATE;
23369 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
23371 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
23372 const char *p = IDENTIFIER_POINTER (id);
23377 if (!strcmp ("collapse", p))
23378 result = PRAGMA_OMP_CLAUSE_COLLAPSE;
23379 else if (!strcmp ("copyin", p))
23380 result = PRAGMA_OMP_CLAUSE_COPYIN;
23381 else if (!strcmp ("copyprivate", p))
23382 result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
23385 if (!strcmp ("firstprivate", p))
23386 result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
23389 if (!strcmp ("lastprivate", p))
23390 result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
23393 if (!strcmp ("nowait", p))
23394 result = PRAGMA_OMP_CLAUSE_NOWAIT;
23395 else if (!strcmp ("num_threads", p))
23396 result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
23399 if (!strcmp ("ordered", p))
23400 result = PRAGMA_OMP_CLAUSE_ORDERED;
23403 if (!strcmp ("reduction", p))
23404 result = PRAGMA_OMP_CLAUSE_REDUCTION;
23407 if (!strcmp ("schedule", p))
23408 result = PRAGMA_OMP_CLAUSE_SCHEDULE;
23409 else if (!strcmp ("shared", p))
23410 result = PRAGMA_OMP_CLAUSE_SHARED;
23413 if (!strcmp ("untied", p))
23414 result = PRAGMA_OMP_CLAUSE_UNTIED;
23419 if (result != PRAGMA_OMP_CLAUSE_NONE)
23420 cp_lexer_consume_token (parser->lexer);
23425 /* Validate that a clause of the given type does not already exist. */
23428 check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
23429 const char *name, location_t location)
23433 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
23434 if (OMP_CLAUSE_CODE (c) == code)
23436 error_at (location, "too many %qs clauses", name);
23444 variable-list , identifier
23446 In addition, we match a closing parenthesis. An opening parenthesis
23447 will have been consumed by the caller.
23449 If KIND is nonzero, create the appropriate node and install the decl
23450 in OMP_CLAUSE_DECL and add the node to the head of the list.
23452 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
23453 return the list created. */
23456 cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
23464 token = cp_lexer_peek_token (parser->lexer);
23465 name = cp_parser_id_expression (parser, /*template_p=*/false,
23466 /*check_dependency_p=*/true,
23467 /*template_p=*/NULL,
23468 /*declarator_p=*/false,
23469 /*optional_p=*/false);
23470 if (name == error_mark_node)
23473 decl = cp_parser_lookup_name_simple (parser, name, token->location);
23474 if (decl == error_mark_node)
23475 cp_parser_name_lookup_error (parser, name, decl, NLE_NULL,
23477 else if (kind != 0)
23479 tree u = build_omp_clause (token->location, kind);
23480 OMP_CLAUSE_DECL (u) = decl;
23481 OMP_CLAUSE_CHAIN (u) = list;
23485 list = tree_cons (decl, NULL_TREE, list);
23488 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
23490 cp_lexer_consume_token (parser->lexer);
23493 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23497 /* Try to resync to an unnested comma. Copied from
23498 cp_parser_parenthesized_expression_list. */
23500 ending = cp_parser_skip_to_closing_parenthesis (parser,
23501 /*recovering=*/true,
23503 /*consume_paren=*/true);
23511 /* Similarly, but expect leading and trailing parenthesis. This is a very
23512 common case for omp clauses. */
23515 cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list)
23517 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23518 return cp_parser_omp_var_list_no_open (parser, kind, list);
23523 collapse ( constant-expression ) */
23526 cp_parser_omp_clause_collapse (cp_parser *parser, tree list, location_t location)
23532 loc = cp_lexer_peek_token (parser->lexer)->location;
23533 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23536 num = cp_parser_constant_expression (parser, false, NULL);
23538 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23539 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23540 /*or_comma=*/false,
23541 /*consume_paren=*/true);
23543 if (num == error_mark_node)
23545 num = fold_non_dependent_expr (num);
23546 if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
23547 || !host_integerp (num, 0)
23548 || (n = tree_low_cst (num, 0)) <= 0
23551 error_at (loc, "collapse argument needs positive constant integer expression");
23555 check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse", location);
23556 c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
23557 OMP_CLAUSE_CHAIN (c) = list;
23558 OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
23564 default ( shared | none ) */
23567 cp_parser_omp_clause_default (cp_parser *parser, tree list, location_t location)
23569 enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
23572 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23574 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
23576 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
23577 const char *p = IDENTIFIER_POINTER (id);
23582 if (strcmp ("none", p) != 0)
23584 kind = OMP_CLAUSE_DEFAULT_NONE;
23588 if (strcmp ("shared", p) != 0)
23590 kind = OMP_CLAUSE_DEFAULT_SHARED;
23597 cp_lexer_consume_token (parser->lexer);
23602 cp_parser_error (parser, "expected %<none%> or %<shared%>");
23605 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23606 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23607 /*or_comma=*/false,
23608 /*consume_paren=*/true);
23610 if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
23613 check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default", location);
23614 c = build_omp_clause (location, OMP_CLAUSE_DEFAULT);
23615 OMP_CLAUSE_CHAIN (c) = list;
23616 OMP_CLAUSE_DEFAULT_KIND (c) = kind;
23622 if ( expression ) */
23625 cp_parser_omp_clause_if (cp_parser *parser, tree list, location_t location)
23629 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23632 t = cp_parser_condition (parser);
23634 if (t == error_mark_node
23635 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23636 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23637 /*or_comma=*/false,
23638 /*consume_paren=*/true);
23640 check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if", location);
23642 c = build_omp_clause (location, OMP_CLAUSE_IF);
23643 OMP_CLAUSE_IF_EXPR (c) = t;
23644 OMP_CLAUSE_CHAIN (c) = list;
23653 cp_parser_omp_clause_nowait (cp_parser *parser ATTRIBUTE_UNUSED,
23654 tree list, location_t location)
23658 check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait", location);
23660 c = build_omp_clause (location, OMP_CLAUSE_NOWAIT);
23661 OMP_CLAUSE_CHAIN (c) = list;
23666 num_threads ( expression ) */
23669 cp_parser_omp_clause_num_threads (cp_parser *parser, tree list,
23670 location_t location)
23674 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23677 t = cp_parser_expression (parser, false, NULL);
23679 if (t == error_mark_node
23680 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23681 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23682 /*or_comma=*/false,
23683 /*consume_paren=*/true);
23685 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS,
23686 "num_threads", location);
23688 c = build_omp_clause (location, OMP_CLAUSE_NUM_THREADS);
23689 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
23690 OMP_CLAUSE_CHAIN (c) = list;
23699 cp_parser_omp_clause_ordered (cp_parser *parser ATTRIBUTE_UNUSED,
23700 tree list, location_t location)
23704 check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED,
23705 "ordered", location);
23707 c = build_omp_clause (location, OMP_CLAUSE_ORDERED);
23708 OMP_CLAUSE_CHAIN (c) = list;
23713 reduction ( reduction-operator : variable-list )
23715 reduction-operator:
23716 One of: + * - & ^ | && || */
23719 cp_parser_omp_clause_reduction (cp_parser *parser, tree list)
23721 enum tree_code code;
23724 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23727 switch (cp_lexer_peek_token (parser->lexer)->type)
23739 code = BIT_AND_EXPR;
23742 code = BIT_XOR_EXPR;
23745 code = BIT_IOR_EXPR;
23748 code = TRUTH_ANDIF_EXPR;
23751 code = TRUTH_ORIF_EXPR;
23754 cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
23755 "%<|%>, %<&&%>, or %<||%>");
23757 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23758 /*or_comma=*/false,
23759 /*consume_paren=*/true);
23762 cp_lexer_consume_token (parser->lexer);
23764 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
23767 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list);
23768 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
23769 OMP_CLAUSE_REDUCTION_CODE (c) = code;
23775 schedule ( schedule-kind )
23776 schedule ( schedule-kind , expression )
23779 static | dynamic | guided | runtime | auto */
23782 cp_parser_omp_clause_schedule (cp_parser *parser, tree list, location_t location)
23786 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23789 c = build_omp_clause (location, OMP_CLAUSE_SCHEDULE);
23791 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
23793 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
23794 const char *p = IDENTIFIER_POINTER (id);
23799 if (strcmp ("dynamic", p) != 0)
23801 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
23805 if (strcmp ("guided", p) != 0)
23807 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
23811 if (strcmp ("runtime", p) != 0)
23813 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
23820 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
23821 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
23822 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
23823 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
23826 cp_lexer_consume_token (parser->lexer);
23828 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23831 cp_lexer_consume_token (parser->lexer);
23833 token = cp_lexer_peek_token (parser->lexer);
23834 t = cp_parser_assignment_expression (parser, false, NULL);
23836 if (t == error_mark_node)
23838 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
23839 error_at (token->location, "schedule %<runtime%> does not take "
23840 "a %<chunk_size%> parameter");
23841 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
23842 error_at (token->location, "schedule %<auto%> does not take "
23843 "a %<chunk_size%> parameter");
23845 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
23847 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23850 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
23853 check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule", location);
23854 OMP_CLAUSE_CHAIN (c) = list;
23858 cp_parser_error (parser, "invalid schedule kind");
23860 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23861 /*or_comma=*/false,
23862 /*consume_paren=*/true);
23870 cp_parser_omp_clause_untied (cp_parser *parser ATTRIBUTE_UNUSED,
23871 tree list, location_t location)
23875 check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied", location);
23877 c = build_omp_clause (location, OMP_CLAUSE_UNTIED);
23878 OMP_CLAUSE_CHAIN (c) = list;
23882 /* Parse all OpenMP clauses. The set clauses allowed by the directive
23883 is a bitmask in MASK. Return the list of clauses found; the result
23884 of clause default goes in *pdefault. */
23887 cp_parser_omp_all_clauses (cp_parser *parser, unsigned int mask,
23888 const char *where, cp_token *pragma_tok)
23890 tree clauses = NULL;
23892 cp_token *token = NULL;
23894 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
23896 pragma_omp_clause c_kind;
23897 const char *c_name;
23898 tree prev = clauses;
23900 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23901 cp_lexer_consume_token (parser->lexer);
23903 token = cp_lexer_peek_token (parser->lexer);
23904 c_kind = cp_parser_omp_clause_name (parser);
23909 case PRAGMA_OMP_CLAUSE_COLLAPSE:
23910 clauses = cp_parser_omp_clause_collapse (parser, clauses,
23912 c_name = "collapse";
23914 case PRAGMA_OMP_CLAUSE_COPYIN:
23915 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
23918 case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
23919 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
23921 c_name = "copyprivate";
23923 case PRAGMA_OMP_CLAUSE_DEFAULT:
23924 clauses = cp_parser_omp_clause_default (parser, clauses,
23926 c_name = "default";
23928 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
23929 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
23931 c_name = "firstprivate";
23933 case PRAGMA_OMP_CLAUSE_IF:
23934 clauses = cp_parser_omp_clause_if (parser, clauses, token->location);
23937 case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
23938 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
23940 c_name = "lastprivate";
23942 case PRAGMA_OMP_CLAUSE_NOWAIT:
23943 clauses = cp_parser_omp_clause_nowait (parser, clauses, token->location);
23946 case PRAGMA_OMP_CLAUSE_NUM_THREADS:
23947 clauses = cp_parser_omp_clause_num_threads (parser, clauses,
23949 c_name = "num_threads";
23951 case PRAGMA_OMP_CLAUSE_ORDERED:
23952 clauses = cp_parser_omp_clause_ordered (parser, clauses,
23954 c_name = "ordered";
23956 case PRAGMA_OMP_CLAUSE_PRIVATE:
23957 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
23959 c_name = "private";
23961 case PRAGMA_OMP_CLAUSE_REDUCTION:
23962 clauses = cp_parser_omp_clause_reduction (parser, clauses);
23963 c_name = "reduction";
23965 case PRAGMA_OMP_CLAUSE_SCHEDULE:
23966 clauses = cp_parser_omp_clause_schedule (parser, clauses,
23968 c_name = "schedule";
23970 case PRAGMA_OMP_CLAUSE_SHARED:
23971 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
23975 case PRAGMA_OMP_CLAUSE_UNTIED:
23976 clauses = cp_parser_omp_clause_untied (parser, clauses,
23981 cp_parser_error (parser, "expected %<#pragma omp%> clause");
23985 if (((mask >> c_kind) & 1) == 0)
23987 /* Remove the invalid clause(s) from the list to avoid
23988 confusing the rest of the compiler. */
23990 error_at (token->location, "%qs is not valid for %qs", c_name, where);
23994 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
23995 return finish_omp_clauses (clauses);
24002 In practice, we're also interested in adding the statement to an
24003 outer node. So it is convenient if we work around the fact that
24004 cp_parser_statement calls add_stmt. */
24007 cp_parser_begin_omp_structured_block (cp_parser *parser)
24009 unsigned save = parser->in_statement;
24011 /* Only move the values to IN_OMP_BLOCK if they weren't false.
24012 This preserves the "not within loop or switch" style error messages
24013 for nonsense cases like
24019 if (parser->in_statement)
24020 parser->in_statement = IN_OMP_BLOCK;
24026 cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
24028 parser->in_statement = save;
24032 cp_parser_omp_structured_block (cp_parser *parser)
24034 tree stmt = begin_omp_structured_block ();
24035 unsigned int save = cp_parser_begin_omp_structured_block (parser);
24037 cp_parser_statement (parser, NULL_TREE, false, NULL);
24039 cp_parser_end_omp_structured_block (parser, save);
24040 return finish_omp_structured_block (stmt);
24044 # pragma omp atomic new-line
24048 x binop= expr | x++ | ++x | x-- | --x
24050 +, *, -, /, &, ^, |, <<, >>
24052 where x is an lvalue expression with scalar type. */
24055 cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok)
24058 enum tree_code code;
24060 cp_parser_require_pragma_eol (parser, pragma_tok);
24062 lhs = cp_parser_unary_expression (parser, /*address_p=*/false,
24063 /*cast_p=*/false, NULL);
24064 switch (TREE_CODE (lhs))
24069 case PREINCREMENT_EXPR:
24070 case POSTINCREMENT_EXPR:
24071 lhs = TREE_OPERAND (lhs, 0);
24073 rhs = integer_one_node;
24076 case PREDECREMENT_EXPR:
24077 case POSTDECREMENT_EXPR:
24078 lhs = TREE_OPERAND (lhs, 0);
24080 rhs = integer_one_node;
24083 case COMPOUND_EXPR:
24084 if (TREE_CODE (TREE_OPERAND (lhs, 0)) == SAVE_EXPR
24085 && TREE_CODE (TREE_OPERAND (lhs, 1)) == COMPOUND_EXPR
24086 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs, 1), 0)) == MODIFY_EXPR
24087 && TREE_OPERAND (TREE_OPERAND (lhs, 1), 1) == TREE_OPERAND (lhs, 0)
24088 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
24089 (TREE_OPERAND (lhs, 1), 0), 0)))
24091 /* Undo effects of boolean_increment for post {in,de}crement. */
24092 lhs = TREE_OPERAND (TREE_OPERAND (lhs, 1), 0);
24095 if (TREE_CODE (lhs) == MODIFY_EXPR
24096 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) == BOOLEAN_TYPE)
24098 /* Undo effects of boolean_increment. */
24099 if (integer_onep (TREE_OPERAND (lhs, 1)))
24101 /* This is pre or post increment. */
24102 rhs = TREE_OPERAND (lhs, 1);
24103 lhs = TREE_OPERAND (lhs, 0);
24110 switch (cp_lexer_peek_token (parser->lexer)->type)
24116 code = TRUNC_DIV_EXPR;
24124 case CPP_LSHIFT_EQ:
24125 code = LSHIFT_EXPR;
24127 case CPP_RSHIFT_EQ:
24128 code = RSHIFT_EXPR;
24131 code = BIT_AND_EXPR;
24134 code = BIT_IOR_EXPR;
24137 code = BIT_XOR_EXPR;
24140 cp_parser_error (parser,
24141 "invalid operator for %<#pragma omp atomic%>");
24144 cp_lexer_consume_token (parser->lexer);
24146 rhs = cp_parser_expression (parser, false, NULL);
24147 if (rhs == error_mark_node)
24151 finish_omp_atomic (code, lhs, rhs);
24152 cp_parser_consume_semicolon_at_end_of_statement (parser);
24156 cp_parser_skip_to_end_of_block_or_statement (parser);
24161 # pragma omp barrier new-line */
24164 cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
24166 cp_parser_require_pragma_eol (parser, pragma_tok);
24167 finish_omp_barrier ();
24171 # pragma omp critical [(name)] new-line
24172 structured-block */
24175 cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok)
24177 tree stmt, name = NULL;
24179 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
24181 cp_lexer_consume_token (parser->lexer);
24183 name = cp_parser_identifier (parser);
24185 if (name == error_mark_node
24186 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
24187 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
24188 /*or_comma=*/false,
24189 /*consume_paren=*/true);
24190 if (name == error_mark_node)
24193 cp_parser_require_pragma_eol (parser, pragma_tok);
24195 stmt = cp_parser_omp_structured_block (parser);
24196 return c_finish_omp_critical (input_location, stmt, name);
24200 # pragma omp flush flush-vars[opt] new-line
24203 ( variable-list ) */
24206 cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
24208 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
24209 (void) cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
24210 cp_parser_require_pragma_eol (parser, pragma_tok);
24212 finish_omp_flush ();
24215 /* Helper function, to parse omp for increment expression. */
24218 cp_parser_omp_for_cond (cp_parser *parser, tree decl)
24220 tree cond = cp_parser_binary_expression (parser, false, true,
24221 PREC_NOT_OPERATOR, NULL);
24224 if (cond == error_mark_node
24225 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
24227 cp_parser_skip_to_end_of_statement (parser);
24228 return error_mark_node;
24231 switch (TREE_CODE (cond))
24239 return error_mark_node;
24242 /* If decl is an iterator, preserve LHS and RHS of the relational
24243 expr until finish_omp_for. */
24245 && (type_dependent_expression_p (decl)
24246 || CLASS_TYPE_P (TREE_TYPE (decl))))
24249 return build_x_binary_op (TREE_CODE (cond),
24250 TREE_OPERAND (cond, 0), ERROR_MARK,
24251 TREE_OPERAND (cond, 1), ERROR_MARK,
24252 &overloaded_p, tf_warning_or_error);
24255 /* Helper function, to parse omp for increment expression. */
24258 cp_parser_omp_for_incr (cp_parser *parser, tree decl)
24260 cp_token *token = cp_lexer_peek_token (parser->lexer);
24266 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
24268 op = (token->type == CPP_PLUS_PLUS
24269 ? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
24270 cp_lexer_consume_token (parser->lexer);
24271 lhs = cp_parser_cast_expression (parser, false, false, NULL);
24273 return error_mark_node;
24274 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
24277 lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
24279 return error_mark_node;
24281 token = cp_lexer_peek_token (parser->lexer);
24282 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
24284 op = (token->type == CPP_PLUS_PLUS
24285 ? POSTINCREMENT_EXPR : POSTDECREMENT_EXPR);
24286 cp_lexer_consume_token (parser->lexer);
24287 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
24290 op = cp_parser_assignment_operator_opt (parser);
24291 if (op == ERROR_MARK)
24292 return error_mark_node;
24294 if (op != NOP_EXPR)
24296 rhs = cp_parser_assignment_expression (parser, false, NULL);
24297 rhs = build2 (op, TREE_TYPE (decl), decl, rhs);
24298 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
24301 lhs = cp_parser_binary_expression (parser, false, false,
24302 PREC_ADDITIVE_EXPRESSION, NULL);
24303 token = cp_lexer_peek_token (parser->lexer);
24304 decl_first = lhs == decl;
24307 if (token->type != CPP_PLUS
24308 && token->type != CPP_MINUS)
24309 return error_mark_node;
24313 op = token->type == CPP_PLUS ? PLUS_EXPR : MINUS_EXPR;
24314 cp_lexer_consume_token (parser->lexer);
24315 rhs = cp_parser_binary_expression (parser, false, false,
24316 PREC_ADDITIVE_EXPRESSION, NULL);
24317 token = cp_lexer_peek_token (parser->lexer);
24318 if (token->type == CPP_PLUS || token->type == CPP_MINUS || decl_first)
24320 if (lhs == NULL_TREE)
24322 if (op == PLUS_EXPR)
24325 lhs = build_x_unary_op (NEGATE_EXPR, rhs, tf_warning_or_error);
24328 lhs = build_x_binary_op (op, lhs, ERROR_MARK, rhs, ERROR_MARK,
24329 NULL, tf_warning_or_error);
24332 while (token->type == CPP_PLUS || token->type == CPP_MINUS);
24336 if (rhs != decl || op == MINUS_EXPR)
24337 return error_mark_node;
24338 rhs = build2 (op, TREE_TYPE (decl), lhs, decl);
24341 rhs = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, lhs);
24343 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
24346 /* Parse the restricted form of the for statement allowed by OpenMP. */
24349 cp_parser_omp_for_loop (cp_parser *parser, tree clauses, tree *par_clauses)
24351 tree init, cond, incr, body, decl, pre_body = NULL_TREE, ret;
24352 tree real_decl, initv, condv, incrv, declv;
24353 tree this_pre_body, cl;
24354 location_t loc_first;
24355 bool collapse_err = false;
24356 int i, collapse = 1, nbraces = 0;
24357 VEC(tree,gc) *for_block = make_tree_vector ();
24359 for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
24360 if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
24361 collapse = tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl), 0);
24363 gcc_assert (collapse >= 1);
24365 declv = make_tree_vec (collapse);
24366 initv = make_tree_vec (collapse);
24367 condv = make_tree_vec (collapse);
24368 incrv = make_tree_vec (collapse);
24370 loc_first = cp_lexer_peek_token (parser->lexer)->location;
24372 for (i = 0; i < collapse; i++)
24374 int bracecount = 0;
24375 bool add_private_clause = false;
24378 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
24380 cp_parser_error (parser, "for statement expected");
24383 loc = cp_lexer_consume_token (parser->lexer)->location;
24385 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
24388 init = decl = real_decl = NULL;
24389 this_pre_body = push_stmt_list ();
24390 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
24392 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
24396 integer-type var = lb
24397 random-access-iterator-type var = lb
24398 pointer-type var = lb
24400 cp_decl_specifier_seq type_specifiers;
24402 /* First, try to parse as an initialized declaration. See
24403 cp_parser_condition, from whence the bulk of this is copied. */
24405 cp_parser_parse_tentatively (parser);
24406 cp_parser_type_specifier_seq (parser, /*is_declaration=*/true,
24407 /*is_trailing_return=*/false,
24409 if (cp_parser_parse_definitely (parser))
24411 /* If parsing a type specifier seq succeeded, then this
24412 MUST be a initialized declaration. */
24413 tree asm_specification, attributes;
24414 cp_declarator *declarator;
24416 declarator = cp_parser_declarator (parser,
24417 CP_PARSER_DECLARATOR_NAMED,
24418 /*ctor_dtor_or_conv_p=*/NULL,
24419 /*parenthesized_p=*/NULL,
24420 /*member_p=*/false);
24421 attributes = cp_parser_attributes_opt (parser);
24422 asm_specification = cp_parser_asm_specification_opt (parser);
24424 if (declarator == cp_error_declarator)
24425 cp_parser_skip_to_end_of_statement (parser);
24429 tree pushed_scope, auto_node;
24431 decl = start_decl (declarator, &type_specifiers,
24432 SD_INITIALIZED, attributes,
24433 /*prefix_attributes=*/NULL_TREE,
24436 auto_node = type_uses_auto (TREE_TYPE (decl));
24437 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
24439 if (cp_lexer_next_token_is (parser->lexer,
24441 error ("parenthesized initialization is not allowed in "
24442 "OpenMP %<for%> loop");
24444 /* Trigger an error. */
24445 cp_parser_require (parser, CPP_EQ, RT_EQ);
24447 init = error_mark_node;
24448 cp_parser_skip_to_end_of_statement (parser);
24450 else if (CLASS_TYPE_P (TREE_TYPE (decl))
24451 || type_dependent_expression_p (decl)
24454 bool is_direct_init, is_non_constant_init;
24456 init = cp_parser_initializer (parser,
24458 &is_non_constant_init);
24460 if (auto_node && describable_type (init))
24463 = do_auto_deduction (TREE_TYPE (decl), init,
24466 if (!CLASS_TYPE_P (TREE_TYPE (decl))
24467 && !type_dependent_expression_p (decl))
24471 cp_finish_decl (decl, init, !is_non_constant_init,
24473 LOOKUP_ONLYCONVERTING);
24474 if (CLASS_TYPE_P (TREE_TYPE (decl)))
24476 VEC_safe_push (tree, gc, for_block, this_pre_body);
24480 init = pop_stmt_list (this_pre_body);
24481 this_pre_body = NULL_TREE;
24486 cp_lexer_consume_token (parser->lexer);
24487 init = cp_parser_assignment_expression (parser, false, NULL);
24490 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
24491 init = error_mark_node;
24493 cp_finish_decl (decl, NULL_TREE,
24494 /*init_const_expr_p=*/false,
24496 LOOKUP_ONLYCONVERTING);
24500 pop_scope (pushed_scope);
24506 /* If parsing a type specifier sequence failed, then
24507 this MUST be a simple expression. */
24508 cp_parser_parse_tentatively (parser);
24509 decl = cp_parser_primary_expression (parser, false, false,
24511 if (!cp_parser_error_occurred (parser)
24514 && CLASS_TYPE_P (TREE_TYPE (decl)))
24518 cp_parser_parse_definitely (parser);
24519 cp_parser_require (parser, CPP_EQ, RT_EQ);
24520 rhs = cp_parser_assignment_expression (parser, false, NULL);
24521 finish_expr_stmt (build_x_modify_expr (decl, NOP_EXPR,
24523 tf_warning_or_error));
24524 add_private_clause = true;
24529 cp_parser_abort_tentative_parse (parser);
24530 init = cp_parser_expression (parser, false, NULL);
24533 if (TREE_CODE (init) == MODIFY_EXPR
24534 || TREE_CODE (init) == MODOP_EXPR)
24535 real_decl = TREE_OPERAND (init, 0);
24540 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
24543 this_pre_body = pop_stmt_list (this_pre_body);
24547 pre_body = push_stmt_list ();
24549 add_stmt (this_pre_body);
24550 pre_body = pop_stmt_list (pre_body);
24553 pre_body = this_pre_body;
24558 if (par_clauses != NULL && real_decl != NULL_TREE)
24561 for (c = par_clauses; *c ; )
24562 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE
24563 && OMP_CLAUSE_DECL (*c) == real_decl)
24565 error_at (loc, "iteration variable %qD"
24566 " should not be firstprivate", real_decl);
24567 *c = OMP_CLAUSE_CHAIN (*c);
24569 else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_LASTPRIVATE
24570 && OMP_CLAUSE_DECL (*c) == real_decl)
24572 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
24573 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
24574 tree l = build_omp_clause (loc, OMP_CLAUSE_LASTPRIVATE);
24575 OMP_CLAUSE_DECL (l) = real_decl;
24576 OMP_CLAUSE_CHAIN (l) = clauses;
24577 CP_OMP_CLAUSE_INFO (l) = CP_OMP_CLAUSE_INFO (*c);
24579 OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
24580 CP_OMP_CLAUSE_INFO (*c) = NULL;
24581 add_private_clause = false;
24585 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_PRIVATE
24586 && OMP_CLAUSE_DECL (*c) == real_decl)
24587 add_private_clause = false;
24588 c = &OMP_CLAUSE_CHAIN (*c);
24592 if (add_private_clause)
24595 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
24597 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
24598 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
24599 && OMP_CLAUSE_DECL (c) == decl)
24601 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
24602 && OMP_CLAUSE_DECL (c) == decl)
24603 error_at (loc, "iteration variable %qD "
24604 "should not be firstprivate",
24606 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
24607 && OMP_CLAUSE_DECL (c) == decl)
24608 error_at (loc, "iteration variable %qD should not be reduction",
24613 c = build_omp_clause (loc, OMP_CLAUSE_PRIVATE);
24614 OMP_CLAUSE_DECL (c) = decl;
24615 c = finish_omp_clauses (c);
24618 OMP_CLAUSE_CHAIN (c) = clauses;
24625 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
24626 cond = cp_parser_omp_for_cond (parser, decl);
24627 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
24630 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
24632 /* If decl is an iterator, preserve the operator on decl
24633 until finish_omp_for. */
24635 && ((type_dependent_expression_p (decl)
24636 && !POINTER_TYPE_P (TREE_TYPE (decl)))
24637 || CLASS_TYPE_P (TREE_TYPE (decl))))
24638 incr = cp_parser_omp_for_incr (parser, decl);
24640 incr = cp_parser_expression (parser, false, NULL);
24643 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
24644 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
24645 /*or_comma=*/false,
24646 /*consume_paren=*/true);
24648 TREE_VEC_ELT (declv, i) = decl;
24649 TREE_VEC_ELT (initv, i) = init;
24650 TREE_VEC_ELT (condv, i) = cond;
24651 TREE_VEC_ELT (incrv, i) = incr;
24653 if (i == collapse - 1)
24656 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
24657 in between the collapsed for loops to be still considered perfectly
24658 nested. Hopefully the final version clarifies this.
24659 For now handle (multiple) {'s and empty statements. */
24660 cp_parser_parse_tentatively (parser);
24663 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
24665 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
24667 cp_lexer_consume_token (parser->lexer);
24670 else if (bracecount
24671 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
24672 cp_lexer_consume_token (parser->lexer);
24675 loc = cp_lexer_peek_token (parser->lexer)->location;
24676 error_at (loc, "not enough collapsed for loops");
24677 collapse_err = true;
24678 cp_parser_abort_tentative_parse (parser);
24687 cp_parser_parse_definitely (parser);
24688 nbraces += bracecount;
24692 /* Note that we saved the original contents of this flag when we entered
24693 the structured block, and so we don't need to re-save it here. */
24694 parser->in_statement = IN_OMP_FOR;
24696 /* Note that the grammar doesn't call for a structured block here,
24697 though the loop as a whole is a structured block. */
24698 body = push_stmt_list ();
24699 cp_parser_statement (parser, NULL_TREE, false, NULL);
24700 body = pop_stmt_list (body);
24702 if (declv == NULL_TREE)
24705 ret = finish_omp_for (loc_first, declv, initv, condv, incrv, body,
24706 pre_body, clauses);
24710 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
24712 cp_lexer_consume_token (parser->lexer);
24715 else if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
24716 cp_lexer_consume_token (parser->lexer);
24721 error_at (cp_lexer_peek_token (parser->lexer)->location,
24722 "collapsed loops not perfectly nested");
24724 collapse_err = true;
24725 cp_parser_statement_seq_opt (parser, NULL);
24726 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
24731 while (!VEC_empty (tree, for_block))
24732 add_stmt (pop_stmt_list (VEC_pop (tree, for_block)));
24733 release_tree_vector (for_block);
24739 #pragma omp for for-clause[optseq] new-line
24742 #define OMP_FOR_CLAUSE_MASK \
24743 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
24744 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
24745 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
24746 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
24747 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
24748 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
24749 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT) \
24750 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE))
24753 cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok)
24755 tree clauses, sb, ret;
24758 clauses = cp_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
24759 "#pragma omp for", pragma_tok);
24761 sb = begin_omp_structured_block ();
24762 save = cp_parser_begin_omp_structured_block (parser);
24764 ret = cp_parser_omp_for_loop (parser, clauses, NULL);
24766 cp_parser_end_omp_structured_block (parser, save);
24767 add_stmt (finish_omp_structured_block (sb));
24773 # pragma omp master new-line
24774 structured-block */
24777 cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok)
24779 cp_parser_require_pragma_eol (parser, pragma_tok);
24780 return c_finish_omp_master (input_location,
24781 cp_parser_omp_structured_block (parser));
24785 # pragma omp ordered new-line
24786 structured-block */
24789 cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok)
24791 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
24792 cp_parser_require_pragma_eol (parser, pragma_tok);
24793 return c_finish_omp_ordered (loc, cp_parser_omp_structured_block (parser));
24799 { section-sequence }
24802 section-directive[opt] structured-block
24803 section-sequence section-directive structured-block */
24806 cp_parser_omp_sections_scope (cp_parser *parser)
24808 tree stmt, substmt;
24809 bool error_suppress = false;
24812 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
24815 stmt = push_stmt_list ();
24817 if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
24821 substmt = begin_omp_structured_block ();
24822 save = cp_parser_begin_omp_structured_block (parser);
24826 cp_parser_statement (parser, NULL_TREE, false, NULL);
24828 tok = cp_lexer_peek_token (parser->lexer);
24829 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
24831 if (tok->type == CPP_CLOSE_BRACE)
24833 if (tok->type == CPP_EOF)
24837 cp_parser_end_omp_structured_block (parser, save);
24838 substmt = finish_omp_structured_block (substmt);
24839 substmt = build1 (OMP_SECTION, void_type_node, substmt);
24840 add_stmt (substmt);
24845 tok = cp_lexer_peek_token (parser->lexer);
24846 if (tok->type == CPP_CLOSE_BRACE)
24848 if (tok->type == CPP_EOF)
24851 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
24853 cp_lexer_consume_token (parser->lexer);
24854 cp_parser_require_pragma_eol (parser, tok);
24855 error_suppress = false;
24857 else if (!error_suppress)
24859 cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
24860 error_suppress = true;
24863 substmt = cp_parser_omp_structured_block (parser);
24864 substmt = build1 (OMP_SECTION, void_type_node, substmt);
24865 add_stmt (substmt);
24867 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
24869 substmt = pop_stmt_list (stmt);
24871 stmt = make_node (OMP_SECTIONS);
24872 TREE_TYPE (stmt) = void_type_node;
24873 OMP_SECTIONS_BODY (stmt) = substmt;
24880 # pragma omp sections sections-clause[optseq] newline
24883 #define OMP_SECTIONS_CLAUSE_MASK \
24884 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
24885 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
24886 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
24887 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
24888 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
24891 cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok)
24895 clauses = cp_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
24896 "#pragma omp sections", pragma_tok);
24898 ret = cp_parser_omp_sections_scope (parser);
24900 OMP_SECTIONS_CLAUSES (ret) = clauses;
24906 # pragma parallel parallel-clause new-line
24907 # pragma parallel for parallel-for-clause new-line
24908 # pragma parallel sections parallel-sections-clause new-line */
24910 #define OMP_PARALLEL_CLAUSE_MASK \
24911 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
24912 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
24913 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
24914 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
24915 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
24916 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
24917 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
24918 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
24921 cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok)
24923 enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
24924 const char *p_name = "#pragma omp parallel";
24925 tree stmt, clauses, par_clause, ws_clause, block;
24926 unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
24928 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
24930 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
24932 cp_lexer_consume_token (parser->lexer);
24933 p_kind = PRAGMA_OMP_PARALLEL_FOR;
24934 p_name = "#pragma omp parallel for";
24935 mask |= OMP_FOR_CLAUSE_MASK;
24936 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
24938 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
24940 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
24941 const char *p = IDENTIFIER_POINTER (id);
24942 if (strcmp (p, "sections") == 0)
24944 cp_lexer_consume_token (parser->lexer);
24945 p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
24946 p_name = "#pragma omp parallel sections";
24947 mask |= OMP_SECTIONS_CLAUSE_MASK;
24948 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
24952 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
24953 block = begin_omp_parallel ();
24954 save = cp_parser_begin_omp_structured_block (parser);
24958 case PRAGMA_OMP_PARALLEL:
24959 cp_parser_statement (parser, NULL_TREE, false, NULL);
24960 par_clause = clauses;
24963 case PRAGMA_OMP_PARALLEL_FOR:
24964 c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
24965 cp_parser_omp_for_loop (parser, ws_clause, &par_clause);
24968 case PRAGMA_OMP_PARALLEL_SECTIONS:
24969 c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
24970 stmt = cp_parser_omp_sections_scope (parser);
24972 OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
24976 gcc_unreachable ();
24979 cp_parser_end_omp_structured_block (parser, save);
24980 stmt = finish_omp_parallel (par_clause, block);
24981 if (p_kind != PRAGMA_OMP_PARALLEL)
24982 OMP_PARALLEL_COMBINED (stmt) = 1;
24987 # pragma omp single single-clause[optseq] new-line
24988 structured-block */
24990 #define OMP_SINGLE_CLAUSE_MASK \
24991 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
24992 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
24993 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
24994 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
24997 cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok)
24999 tree stmt = make_node (OMP_SINGLE);
25000 TREE_TYPE (stmt) = void_type_node;
25002 OMP_SINGLE_CLAUSES (stmt)
25003 = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
25004 "#pragma omp single", pragma_tok);
25005 OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser);
25007 return add_stmt (stmt);
25011 # pragma omp task task-clause[optseq] new-line
25012 structured-block */
25014 #define OMP_TASK_CLAUSE_MASK \
25015 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
25016 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
25017 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
25018 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
25019 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25020 | (1u << PRAGMA_OMP_CLAUSE_SHARED))
25023 cp_parser_omp_task (cp_parser *parser, cp_token *pragma_tok)
25025 tree clauses, block;
25028 clauses = cp_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
25029 "#pragma omp task", pragma_tok);
25030 block = begin_omp_task ();
25031 save = cp_parser_begin_omp_structured_block (parser);
25032 cp_parser_statement (parser, NULL_TREE, false, NULL);
25033 cp_parser_end_omp_structured_block (parser, save);
25034 return finish_omp_task (clauses, block);
25038 # pragma omp taskwait new-line */
25041 cp_parser_omp_taskwait (cp_parser *parser, cp_token *pragma_tok)
25043 cp_parser_require_pragma_eol (parser, pragma_tok);
25044 finish_omp_taskwait ();
25048 # pragma omp threadprivate (variable-list) */
25051 cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
25055 vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
25056 cp_parser_require_pragma_eol (parser, pragma_tok);
25058 finish_omp_threadprivate (vars);
25061 /* Main entry point to OpenMP statement pragmas. */
25064 cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
25068 switch (pragma_tok->pragma_kind)
25070 case PRAGMA_OMP_ATOMIC:
25071 cp_parser_omp_atomic (parser, pragma_tok);
25073 case PRAGMA_OMP_CRITICAL:
25074 stmt = cp_parser_omp_critical (parser, pragma_tok);
25076 case PRAGMA_OMP_FOR:
25077 stmt = cp_parser_omp_for (parser, pragma_tok);
25079 case PRAGMA_OMP_MASTER:
25080 stmt = cp_parser_omp_master (parser, pragma_tok);
25082 case PRAGMA_OMP_ORDERED:
25083 stmt = cp_parser_omp_ordered (parser, pragma_tok);
25085 case PRAGMA_OMP_PARALLEL:
25086 stmt = cp_parser_omp_parallel (parser, pragma_tok);
25088 case PRAGMA_OMP_SECTIONS:
25089 stmt = cp_parser_omp_sections (parser, pragma_tok);
25091 case PRAGMA_OMP_SINGLE:
25092 stmt = cp_parser_omp_single (parser, pragma_tok);
25094 case PRAGMA_OMP_TASK:
25095 stmt = cp_parser_omp_task (parser, pragma_tok);
25098 gcc_unreachable ();
25102 SET_EXPR_LOCATION (stmt, pragma_tok->location);
25107 static GTY (()) cp_parser *the_parser;
25110 /* Special handling for the first token or line in the file. The first
25111 thing in the file might be #pragma GCC pch_preprocess, which loads a
25112 PCH file, which is a GC collection point. So we need to handle this
25113 first pragma without benefit of an existing lexer structure.
25115 Always returns one token to the caller in *FIRST_TOKEN. This is
25116 either the true first token of the file, or the first token after
25117 the initial pragma. */
25120 cp_parser_initial_pragma (cp_token *first_token)
25124 cp_lexer_get_preprocessor_token (NULL, first_token);
25125 if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS)
25128 cp_lexer_get_preprocessor_token (NULL, first_token);
25129 if (first_token->type == CPP_STRING)
25131 name = first_token->u.value;
25133 cp_lexer_get_preprocessor_token (NULL, first_token);
25134 if (first_token->type != CPP_PRAGMA_EOL)
25135 error_at (first_token->location,
25136 "junk at end of %<#pragma GCC pch_preprocess%>");
25139 error_at (first_token->location, "expected string literal");
25141 /* Skip to the end of the pragma. */
25142 while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF)
25143 cp_lexer_get_preprocessor_token (NULL, first_token);
25145 /* Now actually load the PCH file. */
25147 c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
25149 /* Read one more token to return to our caller. We have to do this
25150 after reading the PCH file in, since its pointers have to be
25152 cp_lexer_get_preprocessor_token (NULL, first_token);
25155 /* Normal parsing of a pragma token. Here we can (and must) use the
25159 cp_parser_pragma (cp_parser *parser, enum pragma_context context)
25161 cp_token *pragma_tok;
25164 pragma_tok = cp_lexer_consume_token (parser->lexer);
25165 gcc_assert (pragma_tok->type == CPP_PRAGMA);
25166 parser->lexer->in_pragma = true;
25168 id = pragma_tok->pragma_kind;
25171 case PRAGMA_GCC_PCH_PREPROCESS:
25172 error_at (pragma_tok->location,
25173 "%<#pragma GCC pch_preprocess%> must be first");
25176 case PRAGMA_OMP_BARRIER:
25179 case pragma_compound:
25180 cp_parser_omp_barrier (parser, pragma_tok);
25183 error_at (pragma_tok->location, "%<#pragma omp barrier%> may only be "
25184 "used in compound statements");
25191 case PRAGMA_OMP_FLUSH:
25194 case pragma_compound:
25195 cp_parser_omp_flush (parser, pragma_tok);
25198 error_at (pragma_tok->location, "%<#pragma omp flush%> may only be "
25199 "used in compound statements");
25206 case PRAGMA_OMP_TASKWAIT:
25209 case pragma_compound:
25210 cp_parser_omp_taskwait (parser, pragma_tok);
25213 error_at (pragma_tok->location,
25214 "%<#pragma omp taskwait%> may only be "
25215 "used in compound statements");
25222 case PRAGMA_OMP_THREADPRIVATE:
25223 cp_parser_omp_threadprivate (parser, pragma_tok);
25226 case PRAGMA_OMP_ATOMIC:
25227 case PRAGMA_OMP_CRITICAL:
25228 case PRAGMA_OMP_FOR:
25229 case PRAGMA_OMP_MASTER:
25230 case PRAGMA_OMP_ORDERED:
25231 case PRAGMA_OMP_PARALLEL:
25232 case PRAGMA_OMP_SECTIONS:
25233 case PRAGMA_OMP_SINGLE:
25234 case PRAGMA_OMP_TASK:
25235 if (context == pragma_external)
25237 cp_parser_omp_construct (parser, pragma_tok);
25240 case PRAGMA_OMP_SECTION:
25241 error_at (pragma_tok->location,
25242 "%<#pragma omp section%> may only be used in "
25243 "%<#pragma omp sections%> construct");
25247 gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
25248 c_invoke_pragma_handler (id);
25252 cp_parser_error (parser, "expected declaration specifiers");
25256 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
25260 /* The interface the pragma parsers have to the lexer. */
25263 pragma_lex (tree *value)
25266 enum cpp_ttype ret;
25268 tok = cp_lexer_peek_token (the_parser->lexer);
25271 *value = tok->u.value;
25273 if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
25275 else if (ret == CPP_STRING)
25276 *value = cp_parser_string_literal (the_parser, false, false);
25279 cp_lexer_consume_token (the_parser->lexer);
25280 if (ret == CPP_KEYWORD)
25288 /* External interface. */
25290 /* Parse one entire translation unit. */
25293 c_parse_file (void)
25295 static bool already_called = false;
25297 if (already_called)
25299 sorry ("inter-module optimizations not implemented for C++");
25302 already_called = true;
25304 the_parser = cp_parser_new ();
25305 push_deferring_access_checks (flag_access_control
25306 ? dk_no_deferred : dk_no_check);
25307 cp_parser_translation_unit (the_parser);
25311 #include "gt-cp-parser.h"