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 /* Returns TRUE iff the token T begins a decltype type. */
669 token_is_decltype (cp_token *t)
671 return (t->keyword == RID_DECLTYPE
672 || t->type == CPP_DECLTYPE);
675 /* Returns TRUE iff the next token begins a decltype type. */
678 cp_lexer_next_token_is_decltype (cp_lexer *lexer)
680 cp_token *t = cp_lexer_peek_token (lexer);
681 return token_is_decltype (t);
684 /* Return a pointer to the Nth token in the token stream. If N is 1,
685 then this is precisely equivalent to cp_lexer_peek_token (except
686 that it is not inline). One would like to disallow that case, but
687 there is one case (cp_parser_nth_token_starts_template_id) where
688 the caller passes a variable for N and it might be 1. */
691 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
695 /* N is 1-based, not zero-based. */
698 if (cp_lexer_debugging_p (lexer))
699 fprintf (cp_lexer_debug_stream,
700 "cp_lexer: peeking ahead %ld at token: ", (long)n);
703 token = lexer->next_token;
704 gcc_assert (!n || token != &eof_token);
708 if (token == lexer->last_token)
714 if (!token->purged_p)
718 if (cp_lexer_debugging_p (lexer))
720 cp_lexer_print_token (cp_lexer_debug_stream, token);
721 putc ('\n', cp_lexer_debug_stream);
727 /* Return the next token, and advance the lexer's next_token pointer
728 to point to the next non-purged token. */
731 cp_lexer_consume_token (cp_lexer* lexer)
733 cp_token *token = lexer->next_token;
735 gcc_assert (token != &eof_token);
736 gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
741 if (lexer->next_token == lexer->last_token)
743 lexer->next_token = &eof_token;
748 while (lexer->next_token->purged_p);
750 cp_lexer_set_source_position_from_token (token);
752 /* Provide debugging output. */
753 if (cp_lexer_debugging_p (lexer))
755 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
756 cp_lexer_print_token (cp_lexer_debug_stream, token);
757 putc ('\n', cp_lexer_debug_stream);
763 /* Permanently remove the next token from the token stream, and
764 advance the next_token pointer to refer to the next non-purged
768 cp_lexer_purge_token (cp_lexer *lexer)
770 cp_token *tok = lexer->next_token;
772 gcc_assert (tok != &eof_token);
773 tok->purged_p = true;
774 tok->location = UNKNOWN_LOCATION;
775 tok->u.value = NULL_TREE;
776 tok->keyword = RID_MAX;
781 if (tok == lexer->last_token)
787 while (tok->purged_p);
788 lexer->next_token = tok;
791 /* Permanently remove all tokens after TOK, up to, but not
792 including, the token that will be returned next by
793 cp_lexer_peek_token. */
796 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
798 cp_token *peek = lexer->next_token;
800 if (peek == &eof_token)
801 peek = lexer->last_token;
803 gcc_assert (tok < peek);
805 for ( tok += 1; tok != peek; tok += 1)
807 tok->purged_p = true;
808 tok->location = UNKNOWN_LOCATION;
809 tok->u.value = NULL_TREE;
810 tok->keyword = RID_MAX;
814 /* Begin saving tokens. All tokens consumed after this point will be
818 cp_lexer_save_tokens (cp_lexer* lexer)
820 /* Provide debugging output. */
821 if (cp_lexer_debugging_p (lexer))
822 fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
824 VEC_safe_push (cp_token_position, heap,
825 lexer->saved_tokens, lexer->next_token);
828 /* Commit to the portion of the token stream most recently saved. */
831 cp_lexer_commit_tokens (cp_lexer* lexer)
833 /* Provide debugging output. */
834 if (cp_lexer_debugging_p (lexer))
835 fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
837 VEC_pop (cp_token_position, lexer->saved_tokens);
840 /* Return all tokens saved since the last call to cp_lexer_save_tokens
841 to the token stream. Stop saving tokens. */
844 cp_lexer_rollback_tokens (cp_lexer* lexer)
846 /* Provide debugging output. */
847 if (cp_lexer_debugging_p (lexer))
848 fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
850 lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens);
853 /* Print a representation of the TOKEN on the STREAM. */
855 #ifdef ENABLE_CHECKING
858 cp_lexer_print_token (FILE * stream, cp_token *token)
860 /* We don't use cpp_type2name here because the parser defines
861 a few tokens of its own. */
862 static const char *const token_names[] = {
863 /* cpplib-defined token types */
869 /* C++ parser token types - see "Manifest constants", above. */
872 "NESTED_NAME_SPECIFIER",
875 /* For some tokens, print the associated data. */
879 /* Some keywords have a value that is not an IDENTIFIER_NODE.
880 For example, `struct' is mapped to an INTEGER_CST. */
881 if (TREE_CODE (token->u.value) != IDENTIFIER_NODE)
883 /* else fall through */
885 fputs (IDENTIFIER_POINTER (token->u.value), stream);
893 fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
897 print_generic_expr (stream, token->u.value, 0);
901 /* If we have a name for the token, print it out. Otherwise, we
902 simply give the numeric code. */
903 if (token->type < ARRAY_SIZE(token_names))
904 fputs (token_names[token->type], stream);
906 fprintf (stream, "[%d]", token->type);
911 /* Start emitting debugging information. */
914 cp_lexer_start_debugging (cp_lexer* lexer)
916 lexer->debugging_p = true;
919 /* Stop emitting debugging information. */
922 cp_lexer_stop_debugging (cp_lexer* lexer)
924 lexer->debugging_p = false;
927 #endif /* ENABLE_CHECKING */
929 /* Create a new cp_token_cache, representing a range of tokens. */
931 static cp_token_cache *
932 cp_token_cache_new (cp_token *first, cp_token *last)
934 cp_token_cache *cache = ggc_alloc_cp_token_cache ();
935 cache->first = first;
941 /* Decl-specifiers. */
943 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
946 clear_decl_specs (cp_decl_specifier_seq *decl_specs)
948 memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
953 /* Nothing other than the parser should be creating declarators;
954 declarators are a semi-syntactic representation of C++ entities.
955 Other parts of the front end that need to create entities (like
956 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
958 static cp_declarator *make_call_declarator
959 (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, tree, tree);
960 static cp_declarator *make_array_declarator
961 (cp_declarator *, tree);
962 static cp_declarator *make_pointer_declarator
963 (cp_cv_quals, cp_declarator *);
964 static cp_declarator *make_reference_declarator
965 (cp_cv_quals, cp_declarator *, bool);
966 static cp_parameter_declarator *make_parameter_declarator
967 (cp_decl_specifier_seq *, cp_declarator *, tree);
968 static cp_declarator *make_ptrmem_declarator
969 (cp_cv_quals, tree, cp_declarator *);
971 /* An erroneous declarator. */
972 static cp_declarator *cp_error_declarator;
974 /* The obstack on which declarators and related data structures are
976 static struct obstack declarator_obstack;
978 /* Alloc BYTES from the declarator memory pool. */
981 alloc_declarator (size_t bytes)
983 return obstack_alloc (&declarator_obstack, bytes);
986 /* Allocate a declarator of the indicated KIND. Clear fields that are
987 common to all declarators. */
989 static cp_declarator *
990 make_declarator (cp_declarator_kind kind)
992 cp_declarator *declarator;
994 declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
995 declarator->kind = kind;
996 declarator->attributes = NULL_TREE;
997 declarator->declarator = NULL;
998 declarator->parameter_pack_p = false;
999 declarator->id_loc = UNKNOWN_LOCATION;
1004 /* Make a declarator for a generalized identifier. If
1005 QUALIFYING_SCOPE is non-NULL, the identifier is
1006 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1007 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1010 static cp_declarator *
1011 make_id_declarator (tree qualifying_scope, tree unqualified_name,
1012 special_function_kind sfk)
1014 cp_declarator *declarator;
1016 /* It is valid to write:
1018 class C { void f(); };
1022 The standard is not clear about whether `typedef const C D' is
1023 legal; as of 2002-09-15 the committee is considering that
1024 question. EDG 3.0 allows that syntax. Therefore, we do as
1026 if (qualifying_scope && TYPE_P (qualifying_scope))
1027 qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
1029 gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE
1030 || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
1031 || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
1033 declarator = make_declarator (cdk_id);
1034 declarator->u.id.qualifying_scope = qualifying_scope;
1035 declarator->u.id.unqualified_name = unqualified_name;
1036 declarator->u.id.sfk = sfk;
1041 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1042 of modifiers such as const or volatile to apply to the pointer
1043 type, represented as identifiers. */
1046 make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target)
1048 cp_declarator *declarator;
1050 declarator = make_declarator (cdk_pointer);
1051 declarator->declarator = target;
1052 declarator->u.pointer.qualifiers = cv_qualifiers;
1053 declarator->u.pointer.class_type = NULL_TREE;
1056 declarator->id_loc = target->id_loc;
1057 declarator->parameter_pack_p = target->parameter_pack_p;
1058 target->parameter_pack_p = false;
1061 declarator->parameter_pack_p = false;
1066 /* Like make_pointer_declarator -- but for references. */
1069 make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1072 cp_declarator *declarator;
1074 declarator = make_declarator (cdk_reference);
1075 declarator->declarator = target;
1076 declarator->u.reference.qualifiers = cv_qualifiers;
1077 declarator->u.reference.rvalue_ref = rvalue_ref;
1080 declarator->id_loc = target->id_loc;
1081 declarator->parameter_pack_p = target->parameter_pack_p;
1082 target->parameter_pack_p = false;
1085 declarator->parameter_pack_p = false;
1090 /* Like make_pointer_declarator -- but for a pointer to a non-static
1091 member of CLASS_TYPE. */
1094 make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
1095 cp_declarator *pointee)
1097 cp_declarator *declarator;
1099 declarator = make_declarator (cdk_ptrmem);
1100 declarator->declarator = pointee;
1101 declarator->u.pointer.qualifiers = cv_qualifiers;
1102 declarator->u.pointer.class_type = class_type;
1106 declarator->parameter_pack_p = pointee->parameter_pack_p;
1107 pointee->parameter_pack_p = false;
1110 declarator->parameter_pack_p = false;
1115 /* Make a declarator for the function given by TARGET, with the
1116 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1117 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1118 indicates what exceptions can be thrown. */
1121 make_call_declarator (cp_declarator *target,
1123 cp_cv_quals cv_qualifiers,
1124 cp_virt_specifiers virt_specifiers,
1125 tree exception_specification,
1126 tree late_return_type)
1128 cp_declarator *declarator;
1130 declarator = make_declarator (cdk_function);
1131 declarator->declarator = target;
1132 declarator->u.function.parameters = parms;
1133 declarator->u.function.qualifiers = cv_qualifiers;
1134 declarator->u.function.virt_specifiers = virt_specifiers;
1135 declarator->u.function.exception_specification = exception_specification;
1136 declarator->u.function.late_return_type = late_return_type;
1139 declarator->id_loc = target->id_loc;
1140 declarator->parameter_pack_p = target->parameter_pack_p;
1141 target->parameter_pack_p = false;
1144 declarator->parameter_pack_p = false;
1149 /* Make a declarator for an array of BOUNDS elements, each of which is
1150 defined by ELEMENT. */
1153 make_array_declarator (cp_declarator *element, tree bounds)
1155 cp_declarator *declarator;
1157 declarator = make_declarator (cdk_array);
1158 declarator->declarator = element;
1159 declarator->u.array.bounds = bounds;
1162 declarator->id_loc = element->id_loc;
1163 declarator->parameter_pack_p = element->parameter_pack_p;
1164 element->parameter_pack_p = false;
1167 declarator->parameter_pack_p = false;
1172 /* Determine whether the declarator we've seen so far can be a
1173 parameter pack, when followed by an ellipsis. */
1175 declarator_can_be_parameter_pack (cp_declarator *declarator)
1177 /* Search for a declarator name, or any other declarator that goes
1178 after the point where the ellipsis could appear in a parameter
1179 pack. If we find any of these, then this declarator can not be
1180 made into a parameter pack. */
1182 while (declarator && !found)
1184 switch ((int)declarator->kind)
1195 declarator = declarator->declarator;
1203 cp_parameter_declarator *no_parameters;
1205 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1206 DECLARATOR and DEFAULT_ARGUMENT. */
1208 cp_parameter_declarator *
1209 make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1210 cp_declarator *declarator,
1211 tree default_argument)
1213 cp_parameter_declarator *parameter;
1215 parameter = ((cp_parameter_declarator *)
1216 alloc_declarator (sizeof (cp_parameter_declarator)));
1217 parameter->next = NULL;
1218 if (decl_specifiers)
1219 parameter->decl_specifiers = *decl_specifiers;
1221 clear_decl_specs (¶meter->decl_specifiers);
1222 parameter->declarator = declarator;
1223 parameter->default_argument = default_argument;
1224 parameter->ellipsis_p = false;
1229 /* Returns true iff DECLARATOR is a declaration for a function. */
1232 function_declarator_p (const cp_declarator *declarator)
1236 if (declarator->kind == cdk_function
1237 && declarator->declarator->kind == cdk_id)
1239 if (declarator->kind == cdk_id
1240 || declarator->kind == cdk_error)
1242 declarator = declarator->declarator;
1252 A cp_parser parses the token stream as specified by the C++
1253 grammar. Its job is purely parsing, not semantic analysis. For
1254 example, the parser breaks the token stream into declarators,
1255 expressions, statements, and other similar syntactic constructs.
1256 It does not check that the types of the expressions on either side
1257 of an assignment-statement are compatible, or that a function is
1258 not declared with a parameter of type `void'.
1260 The parser invokes routines elsewhere in the compiler to perform
1261 semantic analysis and to build up the abstract syntax tree for the
1264 The parser (and the template instantiation code, which is, in a
1265 way, a close relative of parsing) are the only parts of the
1266 compiler that should be calling push_scope and pop_scope, or
1267 related functions. The parser (and template instantiation code)
1268 keeps track of what scope is presently active; everything else
1269 should simply honor that. (The code that generates static
1270 initializers may also need to set the scope, in order to check
1271 access control correctly when emitting the initializers.)
1276 The parser is of the standard recursive-descent variety. Upcoming
1277 tokens in the token stream are examined in order to determine which
1278 production to use when parsing a non-terminal. Some C++ constructs
1279 require arbitrary look ahead to disambiguate. For example, it is
1280 impossible, in the general case, to tell whether a statement is an
1281 expression or declaration without scanning the entire statement.
1282 Therefore, the parser is capable of "parsing tentatively." When the
1283 parser is not sure what construct comes next, it enters this mode.
1284 Then, while we attempt to parse the construct, the parser queues up
1285 error messages, rather than issuing them immediately, and saves the
1286 tokens it consumes. If the construct is parsed successfully, the
1287 parser "commits", i.e., it issues any queued error messages and
1288 the tokens that were being preserved are permanently discarded.
1289 If, however, the construct is not parsed successfully, the parser
1290 rolls back its state completely so that it can resume parsing using
1291 a different alternative.
1296 The performance of the parser could probably be improved substantially.
1297 We could often eliminate the need to parse tentatively by looking ahead
1298 a little bit. In some places, this approach might not entirely eliminate
1299 the need to parse tentatively, but it might still speed up the average
1302 /* Flags that are passed to some parsing functions. These values can
1303 be bitwise-ored together. */
1308 CP_PARSER_FLAGS_NONE = 0x0,
1309 /* The construct is optional. If it is not present, then no error
1310 should be issued. */
1311 CP_PARSER_FLAGS_OPTIONAL = 0x1,
1312 /* When parsing a type-specifier, treat user-defined type-names
1313 as non-type identifiers. */
1314 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
1315 /* When parsing a type-specifier, do not try to parse a class-specifier
1316 or enum-specifier. */
1317 CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
1318 /* When parsing a decl-specifier-seq, only allow type-specifier or
1320 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8
1323 /* This type is used for parameters and variables which hold
1324 combinations of the above flags. */
1325 typedef int cp_parser_flags;
1327 /* The different kinds of declarators we want to parse. */
1329 typedef enum cp_parser_declarator_kind
1331 /* We want an abstract declarator. */
1332 CP_PARSER_DECLARATOR_ABSTRACT,
1333 /* We want a named declarator. */
1334 CP_PARSER_DECLARATOR_NAMED,
1335 /* We don't mind, but the name must be an unqualified-id. */
1336 CP_PARSER_DECLARATOR_EITHER
1337 } cp_parser_declarator_kind;
1339 /* The precedence values used to parse binary expressions. The minimum value
1340 of PREC must be 1, because zero is reserved to quickly discriminate
1341 binary operators from other tokens. */
1346 PREC_LOGICAL_OR_EXPRESSION,
1347 PREC_LOGICAL_AND_EXPRESSION,
1348 PREC_INCLUSIVE_OR_EXPRESSION,
1349 PREC_EXCLUSIVE_OR_EXPRESSION,
1350 PREC_AND_EXPRESSION,
1351 PREC_EQUALITY_EXPRESSION,
1352 PREC_RELATIONAL_EXPRESSION,
1353 PREC_SHIFT_EXPRESSION,
1354 PREC_ADDITIVE_EXPRESSION,
1355 PREC_MULTIPLICATIVE_EXPRESSION,
1357 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1360 /* A mapping from a token type to a corresponding tree node type, with a
1361 precedence value. */
1363 typedef struct cp_parser_binary_operations_map_node
1365 /* The token type. */
1366 enum cpp_ttype token_type;
1367 /* The corresponding tree code. */
1368 enum tree_code tree_type;
1369 /* The precedence of this operator. */
1370 enum cp_parser_prec prec;
1371 } cp_parser_binary_operations_map_node;
1373 typedef struct cp_parser_expression_stack_entry
1375 /* Left hand side of the binary operation we are currently
1378 /* Original tree code for left hand side, if it was a binary
1379 expression itself (used for -Wparentheses). */
1380 enum tree_code lhs_type;
1381 /* Tree code for the binary operation we are parsing. */
1382 enum tree_code tree_type;
1383 /* Precedence of the binary operation we are parsing. */
1384 enum cp_parser_prec prec;
1385 } cp_parser_expression_stack_entry;
1387 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1388 entries because precedence levels on the stack are monotonically
1390 typedef struct cp_parser_expression_stack_entry
1391 cp_parser_expression_stack[NUM_PREC_VALUES];
1395 /* Constructors and destructors. */
1397 static cp_parser_context *cp_parser_context_new
1398 (cp_parser_context *);
1400 /* Class variables. */
1402 static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
1404 /* The operator-precedence table used by cp_parser_binary_expression.
1405 Transformed into an associative array (binops_by_token) by
1408 static const cp_parser_binary_operations_map_node binops[] = {
1409 { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
1410 { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
1412 { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1413 { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1414 { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1416 { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1417 { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1419 { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1420 { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1422 { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
1423 { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
1424 { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
1425 { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
1427 { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
1428 { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
1430 { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
1432 { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
1434 { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
1436 { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
1438 { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1441 /* The same as binops, but initialized by cp_parser_new so that
1442 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1444 static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
1446 /* Constructors and destructors. */
1448 /* Construct a new context. The context below this one on the stack
1449 is given by NEXT. */
1451 static cp_parser_context *
1452 cp_parser_context_new (cp_parser_context* next)
1454 cp_parser_context *context;
1456 /* Allocate the storage. */
1457 if (cp_parser_context_free_list != NULL)
1459 /* Pull the first entry from the free list. */
1460 context = cp_parser_context_free_list;
1461 cp_parser_context_free_list = context->next;
1462 memset (context, 0, sizeof (*context));
1465 context = ggc_alloc_cleared_cp_parser_context ();
1467 /* No errors have occurred yet in this context. */
1468 context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
1469 /* If this is not the bottommost context, copy information that we
1470 need from the previous context. */
1473 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1474 expression, then we are parsing one in this context, too. */
1475 context->object_type = next->object_type;
1476 /* Thread the stack. */
1477 context->next = next;
1483 /* Managing the unparsed function queues. */
1485 #define unparsed_funs_with_default_args \
1486 VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_default_args
1487 #define unparsed_funs_with_definitions \
1488 VEC_last (cp_unparsed_functions_entry, parser->unparsed_queues)->funs_with_definitions
1491 push_unparsed_function_queues (cp_parser *parser)
1493 VEC_safe_push (cp_unparsed_functions_entry, gc,
1494 parser->unparsed_queues, NULL);
1495 unparsed_funs_with_default_args = NULL;
1496 unparsed_funs_with_definitions = make_tree_vector ();
1500 pop_unparsed_function_queues (cp_parser *parser)
1502 release_tree_vector (unparsed_funs_with_definitions);
1503 VEC_pop (cp_unparsed_functions_entry, parser->unparsed_queues);
1508 /* Constructors and destructors. */
1510 static cp_parser *cp_parser_new
1513 /* Routines to parse various constructs.
1515 Those that return `tree' will return the error_mark_node (rather
1516 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1517 Sometimes, they will return an ordinary node if error-recovery was
1518 attempted, even though a parse error occurred. So, to check
1519 whether or not a parse error occurred, you should always use
1520 cp_parser_error_occurred. If the construct is optional (indicated
1521 either by an `_opt' in the name of the function that does the
1522 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1523 the construct is not present. */
1525 /* Lexical conventions [gram.lex] */
1527 static tree cp_parser_identifier
1529 static tree cp_parser_string_literal
1530 (cp_parser *, bool, bool);
1532 /* Basic concepts [gram.basic] */
1534 static bool cp_parser_translation_unit
1537 /* Expressions [gram.expr] */
1539 static tree cp_parser_primary_expression
1540 (cp_parser *, bool, bool, bool, cp_id_kind *);
1541 static tree cp_parser_id_expression
1542 (cp_parser *, bool, bool, bool *, bool, bool);
1543 static tree cp_parser_unqualified_id
1544 (cp_parser *, bool, bool, bool, bool);
1545 static tree cp_parser_nested_name_specifier_opt
1546 (cp_parser *, bool, bool, bool, bool);
1547 static tree cp_parser_nested_name_specifier
1548 (cp_parser *, bool, bool, bool, bool);
1549 static tree cp_parser_qualifying_entity
1550 (cp_parser *, bool, bool, bool, bool, bool);
1551 static tree cp_parser_postfix_expression
1552 (cp_parser *, bool, bool, bool, cp_id_kind *);
1553 static tree cp_parser_postfix_open_square_expression
1554 (cp_parser *, tree, bool);
1555 static tree cp_parser_postfix_dot_deref_expression
1556 (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *, location_t);
1557 static VEC(tree,gc) *cp_parser_parenthesized_expression_list
1558 (cp_parser *, int, bool, bool, bool *);
1559 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1560 enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
1561 static void cp_parser_pseudo_destructor_name
1562 (cp_parser *, tree *, tree *);
1563 static tree cp_parser_unary_expression
1564 (cp_parser *, bool, bool, cp_id_kind *);
1565 static enum tree_code cp_parser_unary_operator
1567 static tree cp_parser_new_expression
1569 static VEC(tree,gc) *cp_parser_new_placement
1571 static tree cp_parser_new_type_id
1572 (cp_parser *, tree *);
1573 static cp_declarator *cp_parser_new_declarator_opt
1575 static cp_declarator *cp_parser_direct_new_declarator
1577 static VEC(tree,gc) *cp_parser_new_initializer
1579 static tree cp_parser_delete_expression
1581 static tree cp_parser_cast_expression
1582 (cp_parser *, bool, bool, cp_id_kind *);
1583 static tree cp_parser_binary_expression
1584 (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
1585 static tree cp_parser_question_colon_clause
1586 (cp_parser *, tree);
1587 static tree cp_parser_assignment_expression
1588 (cp_parser *, bool, cp_id_kind *);
1589 static enum tree_code cp_parser_assignment_operator_opt
1591 static tree cp_parser_expression
1592 (cp_parser *, bool, cp_id_kind *);
1593 static tree cp_parser_constant_expression
1594 (cp_parser *, bool, bool *);
1595 static tree cp_parser_builtin_offsetof
1597 static tree cp_parser_lambda_expression
1599 static void cp_parser_lambda_introducer
1600 (cp_parser *, tree);
1601 static bool cp_parser_lambda_declarator_opt
1602 (cp_parser *, tree);
1603 static void cp_parser_lambda_body
1604 (cp_parser *, tree);
1606 /* Statements [gram.stmt.stmt] */
1608 static void cp_parser_statement
1609 (cp_parser *, tree, bool, bool *);
1610 static void cp_parser_label_for_labeled_statement
1612 static tree cp_parser_expression_statement
1613 (cp_parser *, tree);
1614 static tree cp_parser_compound_statement
1615 (cp_parser *, tree, bool, bool);
1616 static void cp_parser_statement_seq_opt
1617 (cp_parser *, tree);
1618 static tree cp_parser_selection_statement
1619 (cp_parser *, bool *);
1620 static tree cp_parser_condition
1622 static tree cp_parser_iteration_statement
1624 static bool cp_parser_for_init_statement
1625 (cp_parser *, tree *decl);
1626 static tree cp_parser_for
1628 static tree cp_parser_c_for
1629 (cp_parser *, tree, tree);
1630 static tree cp_parser_range_for
1631 (cp_parser *, tree, tree, tree);
1632 static tree cp_parser_perform_range_for_lookup
1633 (tree, tree *, tree *);
1634 static tree cp_parser_range_for_member_function
1636 static tree cp_parser_jump_statement
1638 static void cp_parser_declaration_statement
1641 static tree cp_parser_implicitly_scoped_statement
1642 (cp_parser *, bool *);
1643 static void cp_parser_already_scoped_statement
1646 /* Declarations [gram.dcl.dcl] */
1648 static void cp_parser_declaration_seq_opt
1650 static void cp_parser_declaration
1652 static void cp_parser_block_declaration
1653 (cp_parser *, bool);
1654 static void cp_parser_simple_declaration
1655 (cp_parser *, bool, tree *);
1656 static void cp_parser_decl_specifier_seq
1657 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
1658 static tree cp_parser_storage_class_specifier_opt
1660 static tree cp_parser_function_specifier_opt
1661 (cp_parser *, cp_decl_specifier_seq *);
1662 static tree cp_parser_type_specifier
1663 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
1665 static tree cp_parser_simple_type_specifier
1666 (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
1667 static tree cp_parser_type_name
1669 static tree cp_parser_nonclass_name
1670 (cp_parser* parser);
1671 static tree cp_parser_elaborated_type_specifier
1672 (cp_parser *, bool, bool);
1673 static tree cp_parser_enum_specifier
1675 static void cp_parser_enumerator_list
1676 (cp_parser *, tree);
1677 static void cp_parser_enumerator_definition
1678 (cp_parser *, tree);
1679 static tree cp_parser_namespace_name
1681 static void cp_parser_namespace_definition
1683 static void cp_parser_namespace_body
1685 static tree cp_parser_qualified_namespace_specifier
1687 static void cp_parser_namespace_alias_definition
1689 static bool cp_parser_using_declaration
1690 (cp_parser *, bool);
1691 static void cp_parser_using_directive
1693 static void cp_parser_asm_definition
1695 static void cp_parser_linkage_specification
1697 static void cp_parser_static_assert
1698 (cp_parser *, bool);
1699 static tree cp_parser_decltype
1702 /* Declarators [gram.dcl.decl] */
1704 static tree cp_parser_init_declarator
1705 (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *, tree *);
1706 static cp_declarator *cp_parser_declarator
1707 (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool);
1708 static cp_declarator *cp_parser_direct_declarator
1709 (cp_parser *, cp_parser_declarator_kind, int *, bool);
1710 static enum tree_code cp_parser_ptr_operator
1711 (cp_parser *, tree *, cp_cv_quals *);
1712 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
1714 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
1716 static tree cp_parser_late_return_type_opt
1717 (cp_parser *, cp_cv_quals);
1718 static tree cp_parser_declarator_id
1719 (cp_parser *, bool);
1720 static tree cp_parser_type_id
1722 static tree cp_parser_template_type_arg
1724 static tree cp_parser_trailing_type_id (cp_parser *);
1725 static tree cp_parser_type_id_1
1726 (cp_parser *, bool, bool);
1727 static void cp_parser_type_specifier_seq
1728 (cp_parser *, bool, bool, cp_decl_specifier_seq *);
1729 static tree cp_parser_parameter_declaration_clause
1731 static tree cp_parser_parameter_declaration_list
1732 (cp_parser *, bool *);
1733 static cp_parameter_declarator *cp_parser_parameter_declaration
1734 (cp_parser *, bool, bool *);
1735 static tree cp_parser_default_argument
1736 (cp_parser *, bool);
1737 static void cp_parser_function_body
1739 static tree cp_parser_initializer
1740 (cp_parser *, bool *, bool *);
1741 static tree cp_parser_initializer_clause
1742 (cp_parser *, bool *);
1743 static tree cp_parser_braced_list
1744 (cp_parser*, bool*);
1745 static VEC(constructor_elt,gc) *cp_parser_initializer_list
1746 (cp_parser *, bool *);
1748 static bool cp_parser_ctor_initializer_opt_and_function_body
1751 /* Classes [gram.class] */
1753 static tree cp_parser_class_name
1754 (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
1755 static tree cp_parser_class_specifier
1757 static tree cp_parser_class_head
1758 (cp_parser *, bool *, tree *, tree *);
1759 static enum tag_types cp_parser_class_key
1761 static void cp_parser_member_specification_opt
1763 static void cp_parser_member_declaration
1765 static tree cp_parser_pure_specifier
1767 static tree cp_parser_constant_initializer
1770 /* Derived classes [gram.class.derived] */
1772 static tree cp_parser_base_clause
1774 static tree cp_parser_base_specifier
1777 /* Special member functions [gram.special] */
1779 static tree cp_parser_conversion_function_id
1781 static tree cp_parser_conversion_type_id
1783 static cp_declarator *cp_parser_conversion_declarator_opt
1785 static bool cp_parser_ctor_initializer_opt
1787 static void cp_parser_mem_initializer_list
1789 static tree cp_parser_mem_initializer
1791 static tree cp_parser_mem_initializer_id
1794 /* Overloading [gram.over] */
1796 static tree cp_parser_operator_function_id
1798 static tree cp_parser_operator
1801 /* Templates [gram.temp] */
1803 static void cp_parser_template_declaration
1804 (cp_parser *, bool);
1805 static tree cp_parser_template_parameter_list
1807 static tree cp_parser_template_parameter
1808 (cp_parser *, bool *, bool *);
1809 static tree cp_parser_type_parameter
1810 (cp_parser *, bool *);
1811 static tree cp_parser_template_id
1812 (cp_parser *, bool, bool, bool);
1813 static tree cp_parser_template_name
1814 (cp_parser *, bool, bool, bool, bool *);
1815 static tree cp_parser_template_argument_list
1817 static tree cp_parser_template_argument
1819 static void cp_parser_explicit_instantiation
1821 static void cp_parser_explicit_specialization
1824 /* Exception handling [gram.exception] */
1826 static tree cp_parser_try_block
1828 static bool cp_parser_function_try_block
1830 static void cp_parser_handler_seq
1832 static void cp_parser_handler
1834 static tree cp_parser_exception_declaration
1836 static tree cp_parser_throw_expression
1838 static tree cp_parser_exception_specification_opt
1840 static tree cp_parser_type_id_list
1843 /* GNU Extensions */
1845 static tree cp_parser_asm_specification_opt
1847 static tree cp_parser_asm_operand_list
1849 static tree cp_parser_asm_clobber_list
1851 static tree cp_parser_asm_label_list
1853 static tree cp_parser_attributes_opt
1855 static tree cp_parser_attribute_list
1857 static bool cp_parser_extension_opt
1858 (cp_parser *, int *);
1859 static void cp_parser_label_declaration
1862 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1863 static bool cp_parser_pragma
1864 (cp_parser *, enum pragma_context);
1866 /* Objective-C++ Productions */
1868 static tree cp_parser_objc_message_receiver
1870 static tree cp_parser_objc_message_args
1872 static tree cp_parser_objc_message_expression
1874 static tree cp_parser_objc_encode_expression
1876 static tree cp_parser_objc_defs_expression
1878 static tree cp_parser_objc_protocol_expression
1880 static tree cp_parser_objc_selector_expression
1882 static tree cp_parser_objc_expression
1884 static bool cp_parser_objc_selector_p
1886 static tree cp_parser_objc_selector
1888 static tree cp_parser_objc_protocol_refs_opt
1890 static void cp_parser_objc_declaration
1891 (cp_parser *, tree);
1892 static tree cp_parser_objc_statement
1894 static bool cp_parser_objc_valid_prefix_attributes
1895 (cp_parser *, tree *);
1896 static void cp_parser_objc_at_property_declaration
1898 static void cp_parser_objc_at_synthesize_declaration
1900 static void cp_parser_objc_at_dynamic_declaration
1902 static tree cp_parser_objc_struct_declaration
1905 /* Utility Routines */
1907 static tree cp_parser_lookup_name
1908 (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *, location_t);
1909 static tree cp_parser_lookup_name_simple
1910 (cp_parser *, tree, location_t);
1911 static tree cp_parser_maybe_treat_template_as_class
1913 static bool cp_parser_check_declarator_template_parameters
1914 (cp_parser *, cp_declarator *, location_t);
1915 static bool cp_parser_check_template_parameters
1916 (cp_parser *, unsigned, location_t, cp_declarator *);
1917 static tree cp_parser_simple_cast_expression
1919 static tree cp_parser_global_scope_opt
1920 (cp_parser *, bool);
1921 static bool cp_parser_constructor_declarator_p
1922 (cp_parser *, bool);
1923 static tree cp_parser_function_definition_from_specifiers_and_declarator
1924 (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
1925 static tree cp_parser_function_definition_after_declarator
1926 (cp_parser *, bool);
1927 static void cp_parser_template_declaration_after_export
1928 (cp_parser *, bool);
1929 static void cp_parser_perform_template_parameter_access_checks
1930 (VEC (deferred_access_check,gc)*);
1931 static tree cp_parser_single_declaration
1932 (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool, bool *);
1933 static tree cp_parser_functional_cast
1934 (cp_parser *, tree);
1935 static tree cp_parser_save_member_function_body
1936 (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
1937 static tree cp_parser_enclosed_template_argument_list
1939 static void cp_parser_save_default_args
1940 (cp_parser *, tree);
1941 static void cp_parser_late_parsing_for_member
1942 (cp_parser *, tree);
1943 static void cp_parser_late_parsing_default_args
1944 (cp_parser *, tree);
1945 static tree cp_parser_sizeof_operand
1946 (cp_parser *, enum rid);
1947 static tree cp_parser_trait_expr
1948 (cp_parser *, enum rid);
1949 static bool cp_parser_declares_only_class_p
1951 static void cp_parser_set_storage_class
1952 (cp_parser *, cp_decl_specifier_seq *, enum rid, location_t);
1953 static void cp_parser_set_decl_spec_type
1954 (cp_decl_specifier_seq *, tree, location_t, bool);
1955 static bool cp_parser_friend_p
1956 (const cp_decl_specifier_seq *);
1957 static void cp_parser_required_error
1958 (cp_parser *, required_token, bool);
1959 static cp_token *cp_parser_require
1960 (cp_parser *, enum cpp_ttype, required_token);
1961 static cp_token *cp_parser_require_keyword
1962 (cp_parser *, enum rid, required_token);
1963 static bool cp_parser_token_starts_function_definition_p
1965 static bool cp_parser_next_token_starts_class_definition_p
1967 static bool cp_parser_next_token_ends_template_argument_p
1969 static bool cp_parser_nth_token_starts_template_argument_list_p
1970 (cp_parser *, size_t);
1971 static enum tag_types cp_parser_token_is_class_key
1973 static void cp_parser_check_class_key
1974 (enum tag_types, tree type);
1975 static void cp_parser_check_access_in_redeclaration
1976 (tree type, location_t location);
1977 static bool cp_parser_optional_template_keyword
1979 static void cp_parser_pre_parsed_nested_name_specifier
1981 static bool cp_parser_cache_group
1982 (cp_parser *, enum cpp_ttype, unsigned);
1983 static void cp_parser_parse_tentatively
1985 static void cp_parser_commit_to_tentative_parse
1987 static void cp_parser_abort_tentative_parse
1989 static bool cp_parser_parse_definitely
1991 static inline bool cp_parser_parsing_tentatively
1993 static bool cp_parser_uncommitted_to_tentative_parse_p
1995 static void cp_parser_error
1996 (cp_parser *, const char *);
1997 static void cp_parser_name_lookup_error
1998 (cp_parser *, tree, tree, name_lookup_error, location_t);
1999 static bool cp_parser_simulate_error
2001 static bool cp_parser_check_type_definition
2003 static void cp_parser_check_for_definition_in_return_type
2004 (cp_declarator *, tree, location_t type_location);
2005 static void cp_parser_check_for_invalid_template_id
2006 (cp_parser *, tree, location_t location);
2007 static bool cp_parser_non_integral_constant_expression
2008 (cp_parser *, non_integral_constant);
2009 static void cp_parser_diagnose_invalid_type_name
2010 (cp_parser *, tree, tree, location_t);
2011 static bool cp_parser_parse_and_diagnose_invalid_type_name
2013 static int cp_parser_skip_to_closing_parenthesis
2014 (cp_parser *, bool, bool, bool);
2015 static void cp_parser_skip_to_end_of_statement
2017 static void cp_parser_consume_semicolon_at_end_of_statement
2019 static void cp_parser_skip_to_end_of_block_or_statement
2021 static bool cp_parser_skip_to_closing_brace
2023 static void cp_parser_skip_to_end_of_template_parameter_list
2025 static void cp_parser_skip_to_pragma_eol
2026 (cp_parser*, cp_token *);
2027 static bool cp_parser_error_occurred
2029 static bool cp_parser_allow_gnu_extensions_p
2031 static bool cp_parser_is_string_literal
2033 static bool cp_parser_is_keyword
2034 (cp_token *, enum rid);
2035 static tree cp_parser_make_typename_type
2036 (cp_parser *, tree, tree, location_t location);
2037 static cp_declarator * cp_parser_make_indirect_declarator
2038 (enum tree_code, tree, cp_cv_quals, cp_declarator *);
2040 /* Returns nonzero if we are parsing tentatively. */
2043 cp_parser_parsing_tentatively (cp_parser* parser)
2045 return parser->context->next != NULL;
2048 /* Returns nonzero if TOKEN is a string literal. */
2051 cp_parser_is_string_literal (cp_token* token)
2053 return (token->type == CPP_STRING ||
2054 token->type == CPP_STRING16 ||
2055 token->type == CPP_STRING32 ||
2056 token->type == CPP_WSTRING ||
2057 token->type == CPP_UTF8STRING);
2060 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2063 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2065 return token->keyword == keyword;
2068 /* If not parsing tentatively, issue a diagnostic of the form
2069 FILE:LINE: MESSAGE before TOKEN
2070 where TOKEN is the next token in the input stream. MESSAGE
2071 (specified by the caller) is usually of the form "expected
2075 cp_parser_error (cp_parser* parser, const char* gmsgid)
2077 if (!cp_parser_simulate_error (parser))
2079 cp_token *token = cp_lexer_peek_token (parser->lexer);
2080 /* This diagnostic makes more sense if it is tagged to the line
2081 of the token we just peeked at. */
2082 cp_lexer_set_source_position_from_token (token);
2084 if (token->type == CPP_PRAGMA)
2086 error_at (token->location,
2087 "%<#pragma%> is not allowed here");
2088 cp_parser_skip_to_pragma_eol (parser, token);
2092 c_parse_error (gmsgid,
2093 /* Because c_parser_error does not understand
2094 CPP_KEYWORD, keywords are treated like
2096 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2097 token->u.value, token->flags);
2101 /* Issue an error about name-lookup failing. NAME is the
2102 IDENTIFIER_NODE DECL is the result of
2103 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2104 the thing that we hoped to find. */
2107 cp_parser_name_lookup_error (cp_parser* parser,
2110 name_lookup_error desired,
2111 location_t location)
2113 /* If name lookup completely failed, tell the user that NAME was not
2115 if (decl == error_mark_node)
2117 if (parser->scope && parser->scope != global_namespace)
2118 error_at (location, "%<%E::%E%> has not been declared",
2119 parser->scope, name);
2120 else if (parser->scope == global_namespace)
2121 error_at (location, "%<::%E%> has not been declared", name);
2122 else if (parser->object_scope
2123 && !CLASS_TYPE_P (parser->object_scope))
2124 error_at (location, "request for member %qE in non-class type %qT",
2125 name, parser->object_scope);
2126 else if (parser->object_scope)
2127 error_at (location, "%<%T::%E%> has not been declared",
2128 parser->object_scope, name);
2130 error_at (location, "%qE has not been declared", name);
2132 else if (parser->scope && parser->scope != global_namespace)
2137 error_at (location, "%<%E::%E%> is not a type",
2138 parser->scope, name);
2141 error_at (location, "%<%E::%E%> is not a class or namespace",
2142 parser->scope, name);
2146 "%<%E::%E%> is not a class, namespace, or enumeration",
2147 parser->scope, name);
2154 else if (parser->scope == global_namespace)
2159 error_at (location, "%<::%E%> is not a type", name);
2162 error_at (location, "%<::%E%> is not a class or namespace", name);
2166 "%<::%E%> is not a class, namespace, or enumeration",
2178 error_at (location, "%qE is not a type", name);
2181 error_at (location, "%qE is not a class or namespace", name);
2185 "%qE is not a class, namespace, or enumeration", name);
2193 /* If we are parsing tentatively, remember that an error has occurred
2194 during this tentative parse. Returns true if the error was
2195 simulated; false if a message should be issued by the caller. */
2198 cp_parser_simulate_error (cp_parser* parser)
2200 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2202 parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2208 /* Check for repeated decl-specifiers. */
2211 cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs,
2212 location_t location)
2216 for (ds = ds_first; ds != ds_last; ++ds)
2218 unsigned count = decl_specs->specs[ds];
2221 /* The "long" specifier is a special case because of "long long". */
2225 error_at (location, "%<long long long%> is too long for GCC");
2227 pedwarn_cxx98 (location, OPT_Wlong_long,
2228 "ISO C++ 1998 does not support %<long long%>");
2232 static const char *const decl_spec_names[] = {
2249 error_at (location, "duplicate %qs", decl_spec_names[ds]);
2254 /* This function is called when a type is defined. If type
2255 definitions are forbidden at this point, an error message is
2259 cp_parser_check_type_definition (cp_parser* parser)
2261 /* If types are forbidden here, issue a message. */
2262 if (parser->type_definition_forbidden_message)
2264 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2265 in the message need to be interpreted. */
2266 error (parser->type_definition_forbidden_message);
2272 /* This function is called when the DECLARATOR is processed. The TYPE
2273 was a type defined in the decl-specifiers. If it is invalid to
2274 define a type in the decl-specifiers for DECLARATOR, an error is
2275 issued. TYPE_LOCATION is the location of TYPE and is used
2276 for error reporting. */
2279 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2280 tree type, location_t type_location)
2282 /* [dcl.fct] forbids type definitions in return types.
2283 Unfortunately, it's not easy to know whether or not we are
2284 processing a return type until after the fact. */
2286 && (declarator->kind == cdk_pointer
2287 || declarator->kind == cdk_reference
2288 || declarator->kind == cdk_ptrmem))
2289 declarator = declarator->declarator;
2291 && declarator->kind == cdk_function)
2293 error_at (type_location,
2294 "new types may not be defined in a return type");
2295 inform (type_location,
2296 "(perhaps a semicolon is missing after the definition of %qT)",
2301 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2302 "<" in any valid C++ program. If the next token is indeed "<",
2303 issue a message warning the user about what appears to be an
2304 invalid attempt to form a template-id. LOCATION is the location
2305 of the type-specifier (TYPE) */
2308 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2309 tree type, location_t location)
2311 cp_token_position start = 0;
2313 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2316 error_at (location, "%qT is not a template", type);
2317 else if (TREE_CODE (type) == IDENTIFIER_NODE)
2318 error_at (location, "%qE is not a template", type);
2320 error_at (location, "invalid template-id");
2321 /* Remember the location of the invalid "<". */
2322 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2323 start = cp_lexer_token_position (parser->lexer, true);
2324 /* Consume the "<". */
2325 cp_lexer_consume_token (parser->lexer);
2326 /* Parse the template arguments. */
2327 cp_parser_enclosed_template_argument_list (parser);
2328 /* Permanently remove the invalid template arguments so that
2329 this error message is not issued again. */
2331 cp_lexer_purge_tokens_after (parser->lexer, start);
2335 /* If parsing an integral constant-expression, issue an error message
2336 about the fact that THING appeared and return true. Otherwise,
2337 return false. In either case, set
2338 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2341 cp_parser_non_integral_constant_expression (cp_parser *parser,
2342 non_integral_constant thing)
2344 parser->non_integral_constant_expression_p = true;
2345 if (parser->integral_constant_expression_p)
2347 if (!parser->allow_non_integral_constant_expression_p)
2349 const char *msg = NULL;
2353 error ("floating-point literal "
2354 "cannot appear in a constant-expression");
2357 error ("a cast to a type other than an integral or "
2358 "enumeration type cannot appear in a "
2359 "constant-expression");
2362 error ("%<typeid%> operator "
2363 "cannot appear in a constant-expression");
2366 error ("non-constant compound literals "
2367 "cannot appear in a constant-expression");
2370 error ("a function call "
2371 "cannot appear in a constant-expression");
2374 error ("an increment "
2375 "cannot appear in a constant-expression");
2378 error ("an decrement "
2379 "cannot appear in a constant-expression");
2382 error ("an array reference "
2383 "cannot appear in a constant-expression");
2385 case NIC_ADDR_LABEL:
2386 error ("the address of a label "
2387 "cannot appear in a constant-expression");
2389 case NIC_OVERLOADED:
2390 error ("calls to overloaded operators "
2391 "cannot appear in a constant-expression");
2393 case NIC_ASSIGNMENT:
2394 error ("an assignment cannot appear in a constant-expression");
2397 error ("a comma operator "
2398 "cannot appear in a constant-expression");
2400 case NIC_CONSTRUCTOR:
2401 error ("a call to a constructor "
2402 "cannot appear in a constant-expression");
2408 msg = "__FUNCTION__";
2410 case NIC_PRETTY_FUNC:
2411 msg = "__PRETTY_FUNCTION__";
2431 case NIC_PREINCREMENT:
2434 case NIC_PREDECREMENT:
2447 error ("%qs cannot appear in a constant-expression", msg);
2454 /* Emit a diagnostic for an invalid type name. SCOPE is the
2455 qualifying scope (or NULL, if none) for ID. This function commits
2456 to the current active tentative parse, if any. (Otherwise, the
2457 problematic construct might be encountered again later, resulting
2458 in duplicate error messages.) LOCATION is the location of ID. */
2461 cp_parser_diagnose_invalid_type_name (cp_parser *parser,
2462 tree scope, tree id,
2463 location_t location)
2465 tree decl, old_scope;
2466 cp_parser_commit_to_tentative_parse (parser);
2467 /* Try to lookup the identifier. */
2468 old_scope = parser->scope;
2469 parser->scope = scope;
2470 decl = cp_parser_lookup_name_simple (parser, id, location);
2471 parser->scope = old_scope;
2472 /* If the lookup found a template-name, it means that the user forgot
2473 to specify an argument list. Emit a useful error message. */
2474 if (TREE_CODE (decl) == TEMPLATE_DECL)
2476 "invalid use of template-name %qE without an argument list",
2478 else if (TREE_CODE (id) == BIT_NOT_EXPR)
2479 error_at (location, "invalid use of destructor %qD as a type", id);
2480 else if (TREE_CODE (decl) == TYPE_DECL)
2481 /* Something like 'unsigned A a;' */
2482 error_at (location, "invalid combination of multiple type-specifiers");
2483 else if (!parser->scope)
2485 /* Issue an error message. */
2486 error_at (location, "%qE does not name a type", id);
2487 /* If we're in a template class, it's possible that the user was
2488 referring to a type from a base class. For example:
2490 template <typename T> struct A { typedef T X; };
2491 template <typename T> struct B : public A<T> { X x; };
2493 The user should have said "typename A<T>::X". */
2494 if (cxx_dialect < cxx0x && id == ridpointers[(int)RID_CONSTEXPR])
2495 inform (location, "C++0x %<constexpr%> only available with "
2496 "-std=c++0x or -std=gnu++0x");
2497 else if (processing_template_decl && current_class_type
2498 && TYPE_BINFO (current_class_type))
2502 for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
2506 tree base_type = BINFO_TYPE (b);
2507 if (CLASS_TYPE_P (base_type)
2508 && dependent_type_p (base_type))
2511 /* Go from a particular instantiation of the
2512 template (which will have an empty TYPE_FIELDs),
2513 to the main version. */
2514 base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
2515 for (field = TYPE_FIELDS (base_type);
2517 field = DECL_CHAIN (field))
2518 if (TREE_CODE (field) == TYPE_DECL
2519 && DECL_NAME (field) == id)
2522 "(perhaps %<typename %T::%E%> was intended)",
2523 BINFO_TYPE (b), id);
2532 /* Here we diagnose qualified-ids where the scope is actually correct,
2533 but the identifier does not resolve to a valid type name. */
2534 else if (parser->scope != error_mark_node)
2536 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
2537 error_at (location, "%qE in namespace %qE does not name a type",
2539 else if (CLASS_TYPE_P (parser->scope)
2540 && constructor_name_p (id, parser->scope))
2543 error_at (location, "%<%T::%E%> names the constructor, not"
2544 " the type", parser->scope, id);
2545 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2546 error_at (location, "and %qT has no template constructors",
2549 else if (TYPE_P (parser->scope)
2550 && dependent_scope_p (parser->scope))
2551 error_at (location, "need %<typename%> before %<%T::%E%> because "
2552 "%qT is a dependent scope",
2553 parser->scope, id, parser->scope);
2554 else if (TYPE_P (parser->scope))
2555 error_at (location, "%qE in %q#T does not name a type",
2562 /* Check for a common situation where a type-name should be present,
2563 but is not, and issue a sensible error message. Returns true if an
2564 invalid type-name was detected.
2566 The situation handled by this function are variable declarations of the
2567 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
2568 Usually, `ID' should name a type, but if we got here it means that it
2569 does not. We try to emit the best possible error message depending on
2570 how exactly the id-expression looks like. */
2573 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
2576 cp_token *token = cp_lexer_peek_token (parser->lexer);
2578 /* Avoid duplicate error about ambiguous lookup. */
2579 if (token->type == CPP_NESTED_NAME_SPECIFIER)
2581 cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
2582 if (next->type == CPP_NAME && next->ambiguous_p)
2586 cp_parser_parse_tentatively (parser);
2587 id = cp_parser_id_expression (parser,
2588 /*template_keyword_p=*/false,
2589 /*check_dependency_p=*/true,
2590 /*template_p=*/NULL,
2591 /*declarator_p=*/true,
2592 /*optional_p=*/false);
2593 /* If the next token is a (, this is a function with no explicit return
2594 type, i.e. constructor, destructor or conversion op. */
2595 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
2596 || TREE_CODE (id) == TYPE_DECL)
2598 cp_parser_abort_tentative_parse (parser);
2601 if (!cp_parser_parse_definitely (parser))
2604 /* Emit a diagnostic for the invalid type. */
2605 cp_parser_diagnose_invalid_type_name (parser, parser->scope,
2606 id, token->location);
2608 /* If we aren't in the middle of a declarator (i.e. in a
2609 parameter-declaration-clause), skip to the end of the declaration;
2610 there's no point in trying to process it. */
2611 if (!parser->in_declarator_p)
2612 cp_parser_skip_to_end_of_block_or_statement (parser);
2616 /* Consume tokens up to, and including, the next non-nested closing `)'.
2617 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
2618 are doing error recovery. Returns -1 if OR_COMMA is true and we
2619 found an unnested comma. */
2622 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
2627 unsigned paren_depth = 0;
2628 unsigned brace_depth = 0;
2629 unsigned square_depth = 0;
2631 if (recovering && !or_comma
2632 && cp_parser_uncommitted_to_tentative_parse_p (parser))
2637 cp_token * token = cp_lexer_peek_token (parser->lexer);
2639 switch (token->type)
2642 case CPP_PRAGMA_EOL:
2643 /* If we've run out of tokens, then there is no closing `)'. */
2646 /* This is good for lambda expression capture-lists. */
2647 case CPP_OPEN_SQUARE:
2650 case CPP_CLOSE_SQUARE:
2651 if (!square_depth--)
2656 /* This matches the processing in skip_to_end_of_statement. */
2661 case CPP_OPEN_BRACE:
2664 case CPP_CLOSE_BRACE:
2670 if (recovering && or_comma && !brace_depth && !paren_depth
2675 case CPP_OPEN_PAREN:
2680 case CPP_CLOSE_PAREN:
2681 if (!brace_depth && !paren_depth--)
2684 cp_lexer_consume_token (parser->lexer);
2693 /* Consume the token. */
2694 cp_lexer_consume_token (parser->lexer);
2698 /* Consume tokens until we reach the end of the current statement.
2699 Normally, that will be just before consuming a `;'. However, if a
2700 non-nested `}' comes first, then we stop before consuming that. */
2703 cp_parser_skip_to_end_of_statement (cp_parser* parser)
2705 unsigned nesting_depth = 0;
2709 cp_token *token = cp_lexer_peek_token (parser->lexer);
2711 switch (token->type)
2714 case CPP_PRAGMA_EOL:
2715 /* If we've run out of tokens, stop. */
2719 /* If the next token is a `;', we have reached the end of the
2725 case CPP_CLOSE_BRACE:
2726 /* If this is a non-nested '}', stop before consuming it.
2727 That way, when confronted with something like:
2731 we stop before consuming the closing '}', even though we
2732 have not yet reached a `;'. */
2733 if (nesting_depth == 0)
2736 /* If it is the closing '}' for a block that we have
2737 scanned, stop -- but only after consuming the token.
2743 we will stop after the body of the erroneously declared
2744 function, but before consuming the following `typedef'
2746 if (--nesting_depth == 0)
2748 cp_lexer_consume_token (parser->lexer);
2752 case CPP_OPEN_BRACE:
2760 /* Consume the token. */
2761 cp_lexer_consume_token (parser->lexer);
2765 /* This function is called at the end of a statement or declaration.
2766 If the next token is a semicolon, it is consumed; otherwise, error
2767 recovery is attempted. */
2770 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
2772 /* Look for the trailing `;'. */
2773 if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
2775 /* If there is additional (erroneous) input, skip to the end of
2777 cp_parser_skip_to_end_of_statement (parser);
2778 /* If the next token is now a `;', consume it. */
2779 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
2780 cp_lexer_consume_token (parser->lexer);
2784 /* Skip tokens until we have consumed an entire block, or until we
2785 have consumed a non-nested `;'. */
2788 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
2790 int nesting_depth = 0;
2792 while (nesting_depth >= 0)
2794 cp_token *token = cp_lexer_peek_token (parser->lexer);
2796 switch (token->type)
2799 case CPP_PRAGMA_EOL:
2800 /* If we've run out of tokens, stop. */
2804 /* Stop if this is an unnested ';'. */
2809 case CPP_CLOSE_BRACE:
2810 /* Stop if this is an unnested '}', or closes the outermost
2813 if (nesting_depth < 0)
2819 case CPP_OPEN_BRACE:
2828 /* Consume the token. */
2829 cp_lexer_consume_token (parser->lexer);
2833 /* Skip tokens until a non-nested closing curly brace is the next
2834 token, or there are no more tokens. Return true in the first case,
2838 cp_parser_skip_to_closing_brace (cp_parser *parser)
2840 unsigned nesting_depth = 0;
2844 cp_token *token = cp_lexer_peek_token (parser->lexer);
2846 switch (token->type)
2849 case CPP_PRAGMA_EOL:
2850 /* If we've run out of tokens, stop. */
2853 case CPP_CLOSE_BRACE:
2854 /* If the next token is a non-nested `}', then we have reached
2855 the end of the current block. */
2856 if (nesting_depth-- == 0)
2860 case CPP_OPEN_BRACE:
2861 /* If it the next token is a `{', then we are entering a new
2862 block. Consume the entire block. */
2870 /* Consume the token. */
2871 cp_lexer_consume_token (parser->lexer);
2875 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
2876 parameter is the PRAGMA token, allowing us to purge the entire pragma
2880 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
2884 parser->lexer->in_pragma = false;
2887 token = cp_lexer_consume_token (parser->lexer);
2888 while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
2890 /* Ensure that the pragma is not parsed again. */
2891 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
2894 /* Require pragma end of line, resyncing with it as necessary. The
2895 arguments are as for cp_parser_skip_to_pragma_eol. */
2898 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
2900 parser->lexer->in_pragma = false;
2901 if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
2902 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
2905 /* This is a simple wrapper around make_typename_type. When the id is
2906 an unresolved identifier node, we can provide a superior diagnostic
2907 using cp_parser_diagnose_invalid_type_name. */
2910 cp_parser_make_typename_type (cp_parser *parser, tree scope,
2911 tree id, location_t id_location)
2914 if (TREE_CODE (id) == IDENTIFIER_NODE)
2916 result = make_typename_type (scope, id, typename_type,
2917 /*complain=*/tf_none);
2918 if (result == error_mark_node)
2919 cp_parser_diagnose_invalid_type_name (parser, scope, id, id_location);
2922 return make_typename_type (scope, id, typename_type, tf_error);
2925 /* This is a wrapper around the
2926 make_{pointer,ptrmem,reference}_declarator functions that decides
2927 which one to call based on the CODE and CLASS_TYPE arguments. The
2928 CODE argument should be one of the values returned by
2929 cp_parser_ptr_operator. */
2930 static cp_declarator *
2931 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
2932 cp_cv_quals cv_qualifiers,
2933 cp_declarator *target)
2935 if (code == ERROR_MARK)
2936 return cp_error_declarator;
2938 if (code == INDIRECT_REF)
2939 if (class_type == NULL_TREE)
2940 return make_pointer_declarator (cv_qualifiers, target);
2942 return make_ptrmem_declarator (cv_qualifiers, class_type, target);
2943 else if (code == ADDR_EXPR && class_type == NULL_TREE)
2944 return make_reference_declarator (cv_qualifiers, target, false);
2945 else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
2946 return make_reference_declarator (cv_qualifiers, target, true);
2950 /* Create a new C++ parser. */
2953 cp_parser_new (void)
2959 /* cp_lexer_new_main is called before doing GC allocation because
2960 cp_lexer_new_main might load a PCH file. */
2961 lexer = cp_lexer_new_main ();
2963 /* Initialize the binops_by_token so that we can get the tree
2964 directly from the token. */
2965 for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
2966 binops_by_token[binops[i].token_type] = binops[i];
2968 parser = ggc_alloc_cleared_cp_parser ();
2969 parser->lexer = lexer;
2970 parser->context = cp_parser_context_new (NULL);
2972 /* For now, we always accept GNU extensions. */
2973 parser->allow_gnu_extensions_p = 1;
2975 /* The `>' token is a greater-than operator, not the end of a
2977 parser->greater_than_is_operator_p = true;
2979 parser->default_arg_ok_p = true;
2981 /* We are not parsing a constant-expression. */
2982 parser->integral_constant_expression_p = false;
2983 parser->allow_non_integral_constant_expression_p = false;
2984 parser->non_integral_constant_expression_p = false;
2986 /* Local variable names are not forbidden. */
2987 parser->local_variables_forbidden_p = false;
2989 /* We are not processing an `extern "C"' declaration. */
2990 parser->in_unbraced_linkage_specification_p = false;
2992 /* We are not processing a declarator. */
2993 parser->in_declarator_p = false;
2995 /* We are not processing a template-argument-list. */
2996 parser->in_template_argument_list_p = false;
2998 /* We are not in an iteration statement. */
2999 parser->in_statement = 0;
3001 /* We are not in a switch statement. */
3002 parser->in_switch_statement_p = false;
3004 /* We are not parsing a type-id inside an expression. */
3005 parser->in_type_id_in_expr_p = false;
3007 /* Declarations aren't implicitly extern "C". */
3008 parser->implicit_extern_c = false;
3010 /* String literals should be translated to the execution character set. */
3011 parser->translate_strings_p = true;
3013 /* We are not parsing a function body. */
3014 parser->in_function_body = false;
3016 /* We can correct until told otherwise. */
3017 parser->colon_corrects_to_scope_p = true;
3019 /* The unparsed function queue is empty. */
3020 push_unparsed_function_queues (parser);
3022 /* There are no classes being defined. */
3023 parser->num_classes_being_defined = 0;
3025 /* No template parameters apply. */
3026 parser->num_template_parameter_lists = 0;
3031 /* Create a cp_lexer structure which will emit the tokens in CACHE
3032 and push it onto the parser's lexer stack. This is used for delayed
3033 parsing of in-class method bodies and default arguments, and should
3034 not be confused with tentative parsing. */
3036 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
3038 cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
3039 lexer->next = parser->lexer;
3040 parser->lexer = lexer;
3042 /* Move the current source position to that of the first token in the
3044 cp_lexer_set_source_position_from_token (lexer->next_token);
3047 /* Pop the top lexer off the parser stack. This is never used for the
3048 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3050 cp_parser_pop_lexer (cp_parser *parser)
3052 cp_lexer *lexer = parser->lexer;
3053 parser->lexer = lexer->next;
3054 cp_lexer_destroy (lexer);
3056 /* Put the current source position back where it was before this
3057 lexer was pushed. */
3058 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
3061 /* Lexical conventions [gram.lex] */
3063 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3067 cp_parser_identifier (cp_parser* parser)
3071 /* Look for the identifier. */
3072 token = cp_parser_require (parser, CPP_NAME, RT_NAME);
3073 /* Return the value. */
3074 return token ? token->u.value : error_mark_node;
3077 /* Parse a sequence of adjacent string constants. Returns a
3078 TREE_STRING representing the combined, nul-terminated string
3079 constant. If TRANSLATE is true, translate the string to the
3080 execution character set. If WIDE_OK is true, a wide string is
3083 C++98 [lex.string] says that if a narrow string literal token is
3084 adjacent to a wide string literal token, the behavior is undefined.
3085 However, C99 6.4.5p4 says that this results in a wide string literal.
3086 We follow C99 here, for consistency with the C front end.
3088 This code is largely lifted from lex_string() in c-lex.c.
3090 FUTURE: ObjC++ will need to handle @-strings here. */
3092 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok)
3096 struct obstack str_ob;
3097 cpp_string str, istr, *strs;
3099 enum cpp_ttype type;
3101 tok = cp_lexer_peek_token (parser->lexer);
3102 if (!cp_parser_is_string_literal (tok))
3104 cp_parser_error (parser, "expected string-literal");
3105 return error_mark_node;
3110 /* Try to avoid the overhead of creating and destroying an obstack
3111 for the common case of just one string. */
3112 if (!cp_parser_is_string_literal
3113 (cp_lexer_peek_nth_token (parser->lexer, 2)))
3115 cp_lexer_consume_token (parser->lexer);
3117 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
3118 str.len = TREE_STRING_LENGTH (tok->u.value);
3125 gcc_obstack_init (&str_ob);
3130 cp_lexer_consume_token (parser->lexer);
3132 str.text = (const unsigned char *)TREE_STRING_POINTER (tok->u.value);
3133 str.len = TREE_STRING_LENGTH (tok->u.value);
3135 if (type != tok->type)
3137 if (type == CPP_STRING)
3139 else if (tok->type != CPP_STRING)
3140 error_at (tok->location,
3141 "unsupported non-standard concatenation "
3142 "of string literals");
3145 obstack_grow (&str_ob, &str, sizeof (cpp_string));
3147 tok = cp_lexer_peek_token (parser->lexer);
3149 while (cp_parser_is_string_literal (tok));
3151 strs = (cpp_string *) obstack_finish (&str_ob);
3154 if (type != CPP_STRING && !wide_ok)
3156 cp_parser_error (parser, "a wide string is invalid in this context");
3160 if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
3161 (parse_in, strs, count, &istr, type))
3163 value = build_string (istr.len, (const char *)istr.text);
3164 free (CONST_CAST (unsigned char *, istr.text));
3170 case CPP_UTF8STRING:
3171 TREE_TYPE (value) = char_array_type_node;
3174 TREE_TYPE (value) = char16_array_type_node;
3177 TREE_TYPE (value) = char32_array_type_node;
3180 TREE_TYPE (value) = wchar_array_type_node;
3184 value = fix_string_type (value);
3187 /* cpp_interpret_string has issued an error. */
3188 value = error_mark_node;
3191 obstack_free (&str_ob, 0);
3197 /* Basic concepts [gram.basic] */
3199 /* Parse a translation-unit.
3202 declaration-seq [opt]
3204 Returns TRUE if all went well. */
3207 cp_parser_translation_unit (cp_parser* parser)
3209 /* The address of the first non-permanent object on the declarator
3211 static void *declarator_obstack_base;
3215 /* Create the declarator obstack, if necessary. */
3216 if (!cp_error_declarator)
3218 gcc_obstack_init (&declarator_obstack);
3219 /* Create the error declarator. */
3220 cp_error_declarator = make_declarator (cdk_error);
3221 /* Create the empty parameter list. */
3222 no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
3223 /* Remember where the base of the declarator obstack lies. */
3224 declarator_obstack_base = obstack_next_free (&declarator_obstack);
3227 cp_parser_declaration_seq_opt (parser);
3229 /* If there are no tokens left then all went well. */
3230 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
3232 /* Get rid of the token array; we don't need it any more. */
3233 cp_lexer_destroy (parser->lexer);
3234 parser->lexer = NULL;
3236 /* This file might have been a context that's implicitly extern
3237 "C". If so, pop the lang context. (Only relevant for PCH.) */
3238 if (parser->implicit_extern_c)
3240 pop_lang_context ();
3241 parser->implicit_extern_c = false;
3245 finish_translation_unit ();
3251 cp_parser_error (parser, "expected declaration");
3255 /* Make sure the declarator obstack was fully cleaned up. */
3256 gcc_assert (obstack_next_free (&declarator_obstack)
3257 == declarator_obstack_base);
3259 /* All went well. */
3263 /* Expressions [gram.expr] */
3265 /* Parse a primary-expression.
3276 ( compound-statement )
3277 __builtin_va_arg ( assignment-expression , type-id )
3278 __builtin_offsetof ( type-id , offsetof-expression )
3281 __has_nothrow_assign ( type-id )
3282 __has_nothrow_constructor ( type-id )
3283 __has_nothrow_copy ( type-id )
3284 __has_trivial_assign ( type-id )
3285 __has_trivial_constructor ( type-id )
3286 __has_trivial_copy ( type-id )
3287 __has_trivial_destructor ( type-id )
3288 __has_virtual_destructor ( type-id )
3289 __is_abstract ( type-id )
3290 __is_base_of ( type-id , type-id )
3291 __is_class ( type-id )
3292 __is_convertible_to ( type-id , type-id )
3293 __is_empty ( type-id )
3294 __is_enum ( type-id )
3295 __is_literal_type ( type-id )
3296 __is_pod ( type-id )
3297 __is_polymorphic ( type-id )
3298 __is_std_layout ( type-id )
3299 __is_trivial ( type-id )
3300 __is_union ( type-id )
3302 Objective-C++ Extension:
3310 ADDRESS_P is true iff this expression was immediately preceded by
3311 "&" and therefore might denote a pointer-to-member. CAST_P is true
3312 iff this expression is the target of a cast. TEMPLATE_ARG_P is
3313 true iff this expression is a template argument.
3315 Returns a representation of the expression. Upon return, *IDK
3316 indicates what kind of id-expression (if any) was present. */
3319 cp_parser_primary_expression (cp_parser *parser,
3322 bool template_arg_p,
3325 cp_token *token = NULL;
3327 /* Assume the primary expression is not an id-expression. */
3328 *idk = CP_ID_KIND_NONE;
3330 /* Peek at the next token. */
3331 token = cp_lexer_peek_token (parser->lexer);
3332 switch (token->type)
3345 token = cp_lexer_consume_token (parser->lexer);
3346 if (TREE_CODE (token->u.value) == FIXED_CST)
3348 error_at (token->location,
3349 "fixed-point types not supported in C++");
3350 return error_mark_node;
3352 /* Floating-point literals are only allowed in an integral
3353 constant expression if they are cast to an integral or
3354 enumeration type. */
3355 if (TREE_CODE (token->u.value) == REAL_CST
3356 && parser->integral_constant_expression_p
3359 /* CAST_P will be set even in invalid code like "int(2.7 +
3360 ...)". Therefore, we have to check that the next token
3361 is sure to end the cast. */
3364 cp_token *next_token;
3366 next_token = cp_lexer_peek_token (parser->lexer);
3367 if (/* The comma at the end of an
3368 enumerator-definition. */
3369 next_token->type != CPP_COMMA
3370 /* The curly brace at the end of an enum-specifier. */
3371 && next_token->type != CPP_CLOSE_BRACE
3372 /* The end of a statement. */
3373 && next_token->type != CPP_SEMICOLON
3374 /* The end of the cast-expression. */
3375 && next_token->type != CPP_CLOSE_PAREN
3376 /* The end of an array bound. */
3377 && next_token->type != CPP_CLOSE_SQUARE
3378 /* The closing ">" in a template-argument-list. */
3379 && (next_token->type != CPP_GREATER
3380 || parser->greater_than_is_operator_p)
3381 /* C++0x only: A ">>" treated like two ">" tokens,
3382 in a template-argument-list. */
3383 && (next_token->type != CPP_RSHIFT
3384 || (cxx_dialect == cxx98)
3385 || parser->greater_than_is_operator_p))
3389 /* If we are within a cast, then the constraint that the
3390 cast is to an integral or enumeration type will be
3391 checked at that point. If we are not within a cast, then
3392 this code is invalid. */
3394 cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
3396 return token->u.value;
3402 case CPP_UTF8STRING:
3403 /* ??? Should wide strings be allowed when parser->translate_strings_p
3404 is false (i.e. in attributes)? If not, we can kill the third
3405 argument to cp_parser_string_literal. */
3406 return cp_parser_string_literal (parser,
3407 parser->translate_strings_p,
3410 case CPP_OPEN_PAREN:
3413 bool saved_greater_than_is_operator_p;
3415 /* Consume the `('. */
3416 cp_lexer_consume_token (parser->lexer);
3417 /* Within a parenthesized expression, a `>' token is always
3418 the greater-than operator. */
3419 saved_greater_than_is_operator_p
3420 = parser->greater_than_is_operator_p;
3421 parser->greater_than_is_operator_p = true;
3422 /* If we see `( { ' then we are looking at the beginning of
3423 a GNU statement-expression. */
3424 if (cp_parser_allow_gnu_extensions_p (parser)
3425 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
3427 /* Statement-expressions are not allowed by the standard. */
3428 pedwarn (token->location, OPT_pedantic,
3429 "ISO C++ forbids braced-groups within expressions");
3431 /* And they're not allowed outside of a function-body; you
3432 cannot, for example, write:
3434 int i = ({ int j = 3; j + 1; });
3436 at class or namespace scope. */
3437 if (!parser->in_function_body
3438 || parser->in_template_argument_list_p)
3440 error_at (token->location,
3441 "statement-expressions are not allowed outside "
3442 "functions nor in template-argument lists");
3443 cp_parser_skip_to_end_of_block_or_statement (parser);
3444 expr = error_mark_node;
3448 /* Start the statement-expression. */
3449 expr = begin_stmt_expr ();
3450 /* Parse the compound-statement. */
3451 cp_parser_compound_statement (parser, expr, false, false);
3453 expr = finish_stmt_expr (expr, false);
3458 /* Parse the parenthesized expression. */
3459 expr = cp_parser_expression (parser, cast_p, idk);
3460 /* Let the front end know that this expression was
3461 enclosed in parentheses. This matters in case, for
3462 example, the expression is of the form `A::B', since
3463 `&A::B' might be a pointer-to-member, but `&(A::B)' is
3465 finish_parenthesized_expr (expr);
3466 /* DR 705: Wrapping an unqualified name in parentheses
3467 suppresses arg-dependent lookup. We want to pass back
3468 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
3469 (c++/37862), but none of the others. */
3470 if (*idk != CP_ID_KIND_QUALIFIED)
3471 *idk = CP_ID_KIND_NONE;
3473 /* The `>' token might be the end of a template-id or
3474 template-parameter-list now. */
3475 parser->greater_than_is_operator_p
3476 = saved_greater_than_is_operator_p;
3477 /* Consume the `)'. */
3478 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
3479 cp_parser_skip_to_end_of_statement (parser);
3484 case CPP_OPEN_SQUARE:
3485 if (c_dialect_objc ())
3486 /* We have an Objective-C++ message. */
3487 return cp_parser_objc_expression (parser);
3489 tree lam = cp_parser_lambda_expression (parser);
3490 /* Don't warn about a failed tentative parse. */
3491 if (cp_parser_error_occurred (parser))
3492 return error_mark_node;
3493 maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
3497 case CPP_OBJC_STRING:
3498 if (c_dialect_objc ())
3499 /* We have an Objective-C++ string literal. */
3500 return cp_parser_objc_expression (parser);
3501 cp_parser_error (parser, "expected primary-expression");
3502 return error_mark_node;
3505 switch (token->keyword)
3507 /* These two are the boolean literals. */
3509 cp_lexer_consume_token (parser->lexer);
3510 return boolean_true_node;
3512 cp_lexer_consume_token (parser->lexer);
3513 return boolean_false_node;
3515 /* The `__null' literal. */
3517 cp_lexer_consume_token (parser->lexer);
3520 /* The `nullptr' literal. */
3522 cp_lexer_consume_token (parser->lexer);
3523 return nullptr_node;
3525 /* Recognize the `this' keyword. */
3527 cp_lexer_consume_token (parser->lexer);
3528 if (parser->local_variables_forbidden_p)
3530 error_at (token->location,
3531 "%<this%> may not be used in this context");
3532 return error_mark_node;
3534 /* Pointers cannot appear in constant-expressions. */
3535 if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
3536 return error_mark_node;
3537 return finish_this_expr ();
3539 /* The `operator' keyword can be the beginning of an
3544 case RID_FUNCTION_NAME:
3545 case RID_PRETTY_FUNCTION_NAME:
3546 case RID_C99_FUNCTION_NAME:
3548 non_integral_constant name;
3550 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
3551 __func__ are the names of variables -- but they are
3552 treated specially. Therefore, they are handled here,
3553 rather than relying on the generic id-expression logic
3554 below. Grammatically, these names are id-expressions.
3556 Consume the token. */
3557 token = cp_lexer_consume_token (parser->lexer);
3559 switch (token->keyword)
3561 case RID_FUNCTION_NAME:
3562 name = NIC_FUNC_NAME;
3564 case RID_PRETTY_FUNCTION_NAME:
3565 name = NIC_PRETTY_FUNC;
3567 case RID_C99_FUNCTION_NAME:
3568 name = NIC_C99_FUNC;
3574 if (cp_parser_non_integral_constant_expression (parser, name))
3575 return error_mark_node;
3577 /* Look up the name. */
3578 return finish_fname (token->u.value);
3586 /* The `__builtin_va_arg' construct is used to handle
3587 `va_arg'. Consume the `__builtin_va_arg' token. */
3588 cp_lexer_consume_token (parser->lexer);
3589 /* Look for the opening `('. */
3590 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
3591 /* Now, parse the assignment-expression. */
3592 expression = cp_parser_assignment_expression (parser,
3593 /*cast_p=*/false, NULL);
3594 /* Look for the `,'. */
3595 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
3596 /* Parse the type-id. */
3597 type = cp_parser_type_id (parser);
3598 /* Look for the closing `)'. */
3599 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
3600 /* Using `va_arg' in a constant-expression is not
3602 if (cp_parser_non_integral_constant_expression (parser,
3604 return error_mark_node;
3605 return build_x_va_arg (expression, type);
3609 return cp_parser_builtin_offsetof (parser);
3611 case RID_HAS_NOTHROW_ASSIGN:
3612 case RID_HAS_NOTHROW_CONSTRUCTOR:
3613 case RID_HAS_NOTHROW_COPY:
3614 case RID_HAS_TRIVIAL_ASSIGN:
3615 case RID_HAS_TRIVIAL_CONSTRUCTOR:
3616 case RID_HAS_TRIVIAL_COPY:
3617 case RID_HAS_TRIVIAL_DESTRUCTOR:
3618 case RID_HAS_VIRTUAL_DESTRUCTOR:
3619 case RID_IS_ABSTRACT:
3620 case RID_IS_BASE_OF:
3622 case RID_IS_CONVERTIBLE_TO:
3625 case RID_IS_LITERAL_TYPE:
3627 case RID_IS_POLYMORPHIC:
3628 case RID_IS_STD_LAYOUT:
3629 case RID_IS_TRIVIAL:
3631 return cp_parser_trait_expr (parser, token->keyword);
3633 /* Objective-C++ expressions. */
3635 case RID_AT_PROTOCOL:
3636 case RID_AT_SELECTOR:
3637 return cp_parser_objc_expression (parser);
3640 if (parser->in_function_body
3641 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
3644 error_at (token->location,
3645 "a template declaration cannot appear at block scope");
3646 cp_parser_skip_to_end_of_block_or_statement (parser);
3647 return error_mark_node;
3650 cp_parser_error (parser, "expected primary-expression");
3651 return error_mark_node;
3654 /* An id-expression can start with either an identifier, a
3655 `::' as the beginning of a qualified-id, or the "operator"
3659 case CPP_TEMPLATE_ID:
3660 case CPP_NESTED_NAME_SPECIFIER:
3664 const char *error_msg;
3667 cp_token *id_expr_token;
3670 /* Parse the id-expression. */
3672 = cp_parser_id_expression (parser,
3673 /*template_keyword_p=*/false,
3674 /*check_dependency_p=*/true,
3676 /*declarator_p=*/false,
3677 /*optional_p=*/false);
3678 if (id_expression == error_mark_node)
3679 return error_mark_node;
3680 id_expr_token = token;
3681 token = cp_lexer_peek_token (parser->lexer);
3682 done = (token->type != CPP_OPEN_SQUARE
3683 && token->type != CPP_OPEN_PAREN
3684 && token->type != CPP_DOT
3685 && token->type != CPP_DEREF
3686 && token->type != CPP_PLUS_PLUS
3687 && token->type != CPP_MINUS_MINUS);
3688 /* If we have a template-id, then no further lookup is
3689 required. If the template-id was for a template-class, we
3690 will sometimes have a TYPE_DECL at this point. */
3691 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
3692 || TREE_CODE (id_expression) == TYPE_DECL)
3693 decl = id_expression;
3694 /* Look up the name. */
3697 tree ambiguous_decls;
3699 /* If we already know that this lookup is ambiguous, then
3700 we've already issued an error message; there's no reason
3702 if (id_expr_token->type == CPP_NAME
3703 && id_expr_token->ambiguous_p)
3705 cp_parser_simulate_error (parser);
3706 return error_mark_node;
3709 decl = cp_parser_lookup_name (parser, id_expression,
3712 /*is_namespace=*/false,
3713 /*check_dependency=*/true,
3715 id_expr_token->location);
3716 /* If the lookup was ambiguous, an error will already have
3718 if (ambiguous_decls)
3719 return error_mark_node;
3721 /* In Objective-C++, we may have an Objective-C 2.0
3722 dot-syntax for classes here. */
3723 if (c_dialect_objc ()
3724 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
3725 && TREE_CODE (decl) == TYPE_DECL
3726 && objc_is_class_name (decl))
3729 cp_lexer_consume_token (parser->lexer);
3730 component = cp_parser_identifier (parser);
3731 if (component == error_mark_node)
3732 return error_mark_node;
3734 return objc_build_class_component_ref (id_expression, component);
3737 /* In Objective-C++, an instance variable (ivar) may be preferred
3738 to whatever cp_parser_lookup_name() found. */
3739 decl = objc_lookup_ivar (decl, id_expression);
3741 /* If name lookup gives us a SCOPE_REF, then the
3742 qualifying scope was dependent. */
3743 if (TREE_CODE (decl) == SCOPE_REF)
3745 /* At this point, we do not know if DECL is a valid
3746 integral constant expression. We assume that it is
3747 in fact such an expression, so that code like:
3749 template <int N> struct A {
3753 is accepted. At template-instantiation time, we
3754 will check that B<N>::i is actually a constant. */
3757 /* Check to see if DECL is a local variable in a context
3758 where that is forbidden. */
3759 if (parser->local_variables_forbidden_p
3760 && local_variable_p (decl))
3762 /* It might be that we only found DECL because we are
3763 trying to be generous with pre-ISO scoping rules.
3764 For example, consider:
3768 for (int i = 0; i < 10; ++i) {}
3769 extern void f(int j = i);
3772 Here, name look up will originally find the out
3773 of scope `i'. We need to issue a warning message,
3774 but then use the global `i'. */
3775 decl = check_for_out_of_scope_variable (decl);
3776 if (local_variable_p (decl))
3778 error_at (id_expr_token->location,
3779 "local variable %qD may not appear in this context",
3781 return error_mark_node;
3786 decl = (finish_id_expression
3787 (id_expression, decl, parser->scope,
3789 parser->integral_constant_expression_p,
3790 parser->allow_non_integral_constant_expression_p,
3791 &parser->non_integral_constant_expression_p,
3792 template_p, done, address_p,
3795 id_expr_token->location));
3797 cp_parser_error (parser, error_msg);
3801 /* Anything else is an error. */
3803 cp_parser_error (parser, "expected primary-expression");
3804 return error_mark_node;
3808 /* Parse an id-expression.
3815 :: [opt] nested-name-specifier template [opt] unqualified-id
3817 :: operator-function-id
3820 Return a representation of the unqualified portion of the
3821 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
3822 a `::' or nested-name-specifier.
3824 Often, if the id-expression was a qualified-id, the caller will
3825 want to make a SCOPE_REF to represent the qualified-id. This
3826 function does not do this in order to avoid wastefully creating
3827 SCOPE_REFs when they are not required.
3829 If TEMPLATE_KEYWORD_P is true, then we have just seen the
3832 If CHECK_DEPENDENCY_P is false, then names are looked up inside
3833 uninstantiated templates.
3835 If *TEMPLATE_P is non-NULL, it is set to true iff the
3836 `template' keyword is used to explicitly indicate that the entity
3837 named is a template.
3839 If DECLARATOR_P is true, the id-expression is appearing as part of
3840 a declarator, rather than as part of an expression. */
3843 cp_parser_id_expression (cp_parser *parser,
3844 bool template_keyword_p,
3845 bool check_dependency_p,
3850 bool global_scope_p;
3851 bool nested_name_specifier_p;
3853 /* Assume the `template' keyword was not used. */
3855 *template_p = template_keyword_p;
3857 /* Look for the optional `::' operator. */
3859 = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
3861 /* Look for the optional nested-name-specifier. */
3862 nested_name_specifier_p
3863 = (cp_parser_nested_name_specifier_opt (parser,
3864 /*typename_keyword_p=*/false,
3869 /* If there is a nested-name-specifier, then we are looking at
3870 the first qualified-id production. */
3871 if (nested_name_specifier_p)
3874 tree saved_object_scope;
3875 tree saved_qualifying_scope;
3876 tree unqualified_id;
3879 /* See if the next token is the `template' keyword. */
3881 template_p = &is_template;
3882 *template_p = cp_parser_optional_template_keyword (parser);
3883 /* Name lookup we do during the processing of the
3884 unqualified-id might obliterate SCOPE. */
3885 saved_scope = parser->scope;
3886 saved_object_scope = parser->object_scope;
3887 saved_qualifying_scope = parser->qualifying_scope;
3888 /* Process the final unqualified-id. */
3889 unqualified_id = cp_parser_unqualified_id (parser, *template_p,
3892 /*optional_p=*/false);
3893 /* Restore the SAVED_SCOPE for our caller. */
3894 parser->scope = saved_scope;
3895 parser->object_scope = saved_object_scope;
3896 parser->qualifying_scope = saved_qualifying_scope;
3898 return unqualified_id;
3900 /* Otherwise, if we are in global scope, then we are looking at one
3901 of the other qualified-id productions. */
3902 else if (global_scope_p)
3907 /* Peek at the next token. */
3908 token = cp_lexer_peek_token (parser->lexer);
3910 /* If it's an identifier, and the next token is not a "<", then
3911 we can avoid the template-id case. This is an optimization
3912 for this common case. */
3913 if (token->type == CPP_NAME
3914 && !cp_parser_nth_token_starts_template_argument_list_p
3916 return cp_parser_identifier (parser);
3918 cp_parser_parse_tentatively (parser);
3919 /* Try a template-id. */
3920 id = cp_parser_template_id (parser,
3921 /*template_keyword_p=*/false,
3922 /*check_dependency_p=*/true,
3924 /* If that worked, we're done. */
3925 if (cp_parser_parse_definitely (parser))
3928 /* Peek at the next token. (Changes in the token buffer may
3929 have invalidated the pointer obtained above.) */
3930 token = cp_lexer_peek_token (parser->lexer);
3932 switch (token->type)
3935 return cp_parser_identifier (parser);
3938 if (token->keyword == RID_OPERATOR)
3939 return cp_parser_operator_function_id (parser);
3943 cp_parser_error (parser, "expected id-expression");
3944 return error_mark_node;
3948 return cp_parser_unqualified_id (parser, template_keyword_p,
3949 /*check_dependency_p=*/true,
3954 /* Parse an unqualified-id.
3958 operator-function-id
3959 conversion-function-id
3963 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
3964 keyword, in a construct like `A::template ...'.
3966 Returns a representation of unqualified-id. For the `identifier'
3967 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
3968 production a BIT_NOT_EXPR is returned; the operand of the
3969 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
3970 other productions, see the documentation accompanying the
3971 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
3972 names are looked up in uninstantiated templates. If DECLARATOR_P
3973 is true, the unqualified-id is appearing as part of a declarator,
3974 rather than as part of an expression. */
3977 cp_parser_unqualified_id (cp_parser* parser,
3978 bool template_keyword_p,
3979 bool check_dependency_p,
3985 /* Peek at the next token. */
3986 token = cp_lexer_peek_token (parser->lexer);
3988 switch (token->type)
3994 /* We don't know yet whether or not this will be a
3996 cp_parser_parse_tentatively (parser);
3997 /* Try a template-id. */
3998 id = cp_parser_template_id (parser, template_keyword_p,
4001 /* If it worked, we're done. */
4002 if (cp_parser_parse_definitely (parser))
4004 /* Otherwise, it's an ordinary identifier. */
4005 return cp_parser_identifier (parser);
4008 case CPP_TEMPLATE_ID:
4009 return cp_parser_template_id (parser, template_keyword_p,
4016 tree qualifying_scope;
4021 /* Consume the `~' token. */
4022 cp_lexer_consume_token (parser->lexer);
4023 /* Parse the class-name. The standard, as written, seems to
4026 template <typename T> struct S { ~S (); };
4027 template <typename T> S<T>::~S() {}
4029 is invalid, since `~' must be followed by a class-name, but
4030 `S<T>' is dependent, and so not known to be a class.
4031 That's not right; we need to look in uninstantiated
4032 templates. A further complication arises from:
4034 template <typename T> void f(T t) {
4038 Here, it is not possible to look up `T' in the scope of `T'
4039 itself. We must look in both the current scope, and the
4040 scope of the containing complete expression.
4042 Yet another issue is:
4051 The standard does not seem to say that the `S' in `~S'
4052 should refer to the type `S' and not the data member
4055 /* DR 244 says that we look up the name after the "~" in the
4056 same scope as we looked up the qualifying name. That idea
4057 isn't fully worked out; it's more complicated than that. */
4058 scope = parser->scope;
4059 object_scope = parser->object_scope;
4060 qualifying_scope = parser->qualifying_scope;
4062 /* Check for invalid scopes. */
4063 if (scope == error_mark_node)
4065 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
4066 cp_lexer_consume_token (parser->lexer);
4067 return error_mark_node;
4069 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
4071 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
4072 error_at (token->location,
4073 "scope %qT before %<~%> is not a class-name",
4075 cp_parser_simulate_error (parser);
4076 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
4077 cp_lexer_consume_token (parser->lexer);
4078 return error_mark_node;
4080 gcc_assert (!scope || TYPE_P (scope));
4082 /* If the name is of the form "X::~X" it's OK even if X is a
4084 token = cp_lexer_peek_token (parser->lexer);
4086 && token->type == CPP_NAME
4087 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4089 && (token->u.value == TYPE_IDENTIFIER (scope)
4090 || (CLASS_TYPE_P (scope)
4091 && constructor_name_p (token->u.value, scope))))
4093 cp_lexer_consume_token (parser->lexer);
4094 return build_nt (BIT_NOT_EXPR, scope);
4097 /* If there was an explicit qualification (S::~T), first look
4098 in the scope given by the qualification (i.e., S).
4100 Note: in the calls to cp_parser_class_name below we pass
4101 typename_type so that lookup finds the injected-class-name
4102 rather than the constructor. */
4104 type_decl = NULL_TREE;
4107 cp_parser_parse_tentatively (parser);
4108 type_decl = cp_parser_class_name (parser,
4109 /*typename_keyword_p=*/false,
4110 /*template_keyword_p=*/false,
4112 /*check_dependency=*/false,
4113 /*class_head_p=*/false,
4115 if (cp_parser_parse_definitely (parser))
4118 /* In "N::S::~S", look in "N" as well. */
4119 if (!done && scope && qualifying_scope)
4121 cp_parser_parse_tentatively (parser);
4122 parser->scope = qualifying_scope;
4123 parser->object_scope = NULL_TREE;
4124 parser->qualifying_scope = NULL_TREE;
4126 = cp_parser_class_name (parser,
4127 /*typename_keyword_p=*/false,
4128 /*template_keyword_p=*/false,
4130 /*check_dependency=*/false,
4131 /*class_head_p=*/false,
4133 if (cp_parser_parse_definitely (parser))
4136 /* In "p->S::~T", look in the scope given by "*p" as well. */
4137 else if (!done && object_scope)
4139 cp_parser_parse_tentatively (parser);
4140 parser->scope = object_scope;
4141 parser->object_scope = NULL_TREE;
4142 parser->qualifying_scope = NULL_TREE;
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 (cp_parser_parse_definitely (parser))
4154 /* Look in the surrounding context. */
4157 parser->scope = NULL_TREE;
4158 parser->object_scope = NULL_TREE;
4159 parser->qualifying_scope = NULL_TREE;
4160 if (processing_template_decl)
4161 cp_parser_parse_tentatively (parser);
4163 = cp_parser_class_name (parser,
4164 /*typename_keyword_p=*/false,
4165 /*template_keyword_p=*/false,
4167 /*check_dependency=*/false,
4168 /*class_head_p=*/false,
4170 if (processing_template_decl
4171 && ! cp_parser_parse_definitely (parser))
4173 /* We couldn't find a type with this name, so just accept
4174 it and check for a match at instantiation time. */
4175 type_decl = cp_parser_identifier (parser);
4176 if (type_decl != error_mark_node)
4177 type_decl = build_nt (BIT_NOT_EXPR, type_decl);
4181 /* If an error occurred, assume that the name of the
4182 destructor is the same as the name of the qualifying
4183 class. That allows us to keep parsing after running
4184 into ill-formed destructor names. */
4185 if (type_decl == error_mark_node && scope)
4186 return build_nt (BIT_NOT_EXPR, scope);
4187 else if (type_decl == error_mark_node)
4188 return error_mark_node;
4190 /* Check that destructor name and scope match. */
4191 if (declarator_p && scope && !check_dtor_name (scope, type_decl))
4193 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
4194 error_at (token->location,
4195 "declaration of %<~%T%> as member of %qT",
4197 cp_parser_simulate_error (parser);
4198 return error_mark_node;
4203 A typedef-name that names a class shall not be used as the
4204 identifier in the declarator for a destructor declaration. */
4206 && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
4207 && !DECL_SELF_REFERENCE_P (type_decl)
4208 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
4209 error_at (token->location,
4210 "typedef-name %qD used as destructor declarator",
4213 return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
4217 if (token->keyword == RID_OPERATOR)
4221 /* This could be a template-id, so we try that first. */
4222 cp_parser_parse_tentatively (parser);
4223 /* Try a template-id. */
4224 id = cp_parser_template_id (parser, template_keyword_p,
4225 /*check_dependency_p=*/true,
4227 /* If that worked, we're done. */
4228 if (cp_parser_parse_definitely (parser))
4230 /* We still don't know whether we're looking at an
4231 operator-function-id or a conversion-function-id. */
4232 cp_parser_parse_tentatively (parser);
4233 /* Try an operator-function-id. */
4234 id = cp_parser_operator_function_id (parser);
4235 /* If that didn't work, try a conversion-function-id. */
4236 if (!cp_parser_parse_definitely (parser))
4237 id = cp_parser_conversion_function_id (parser);
4246 cp_parser_error (parser, "expected unqualified-id");
4247 return error_mark_node;
4251 /* Parse an (optional) nested-name-specifier.
4253 nested-name-specifier: [C++98]
4254 class-or-namespace-name :: nested-name-specifier [opt]
4255 class-or-namespace-name :: template nested-name-specifier [opt]
4257 nested-name-specifier: [C++0x]
4260 nested-name-specifier identifier ::
4261 nested-name-specifier template [opt] simple-template-id ::
4263 PARSER->SCOPE should be set appropriately before this function is
4264 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
4265 effect. TYPE_P is TRUE if we non-type bindings should be ignored
4268 Sets PARSER->SCOPE to the class (TYPE) or namespace
4269 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
4270 it unchanged if there is no nested-name-specifier. Returns the new
4271 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
4273 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
4274 part of a declaration and/or decl-specifier. */
4277 cp_parser_nested_name_specifier_opt (cp_parser *parser,
4278 bool typename_keyword_p,
4279 bool check_dependency_p,
4281 bool is_declaration)
4283 bool success = false;
4284 cp_token_position start = 0;
4287 /* Remember where the nested-name-specifier starts. */
4288 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
4290 start = cp_lexer_token_position (parser->lexer, false);
4291 push_deferring_access_checks (dk_deferred);
4298 tree saved_qualifying_scope;
4299 bool template_keyword_p;
4301 /* Spot cases that cannot be the beginning of a
4302 nested-name-specifier. */
4303 token = cp_lexer_peek_token (parser->lexer);
4305 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
4306 the already parsed nested-name-specifier. */
4307 if (token->type == CPP_NESTED_NAME_SPECIFIER)
4309 /* Grab the nested-name-specifier and continue the loop. */
4310 cp_parser_pre_parsed_nested_name_specifier (parser);
4311 /* If we originally encountered this nested-name-specifier
4312 with IS_DECLARATION set to false, we will not have
4313 resolved TYPENAME_TYPEs, so we must do so here. */
4315 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
4317 new_scope = resolve_typename_type (parser->scope,
4318 /*only_current_p=*/false);
4319 if (TREE_CODE (new_scope) != TYPENAME_TYPE)
4320 parser->scope = new_scope;
4326 /* Spot cases that cannot be the beginning of a
4327 nested-name-specifier. On the second and subsequent times
4328 through the loop, we look for the `template' keyword. */
4329 if (success && token->keyword == RID_TEMPLATE)
4331 /* A template-id can start a nested-name-specifier. */
4332 else if (token->type == CPP_TEMPLATE_ID)
4334 /* DR 743: decltype can be used in a nested-name-specifier. */
4335 else if (token_is_decltype (token))
4339 /* If the next token is not an identifier, then it is
4340 definitely not a type-name or namespace-name. */
4341 if (token->type != CPP_NAME)
4343 /* If the following token is neither a `<' (to begin a
4344 template-id), nor a `::', then we are not looking at a
4345 nested-name-specifier. */
4346 token = cp_lexer_peek_nth_token (parser->lexer, 2);
4348 if (token->type == CPP_COLON
4349 && parser->colon_corrects_to_scope_p
4350 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME)
4352 error_at (token->location,
4353 "found %<:%> in nested-name-specifier, expected %<::%>");
4354 token->type = CPP_SCOPE;
4357 if (token->type != CPP_SCOPE
4358 && !cp_parser_nth_token_starts_template_argument_list_p
4363 /* The nested-name-specifier is optional, so we parse
4365 cp_parser_parse_tentatively (parser);
4367 /* Look for the optional `template' keyword, if this isn't the
4368 first time through the loop. */
4370 template_keyword_p = cp_parser_optional_template_keyword (parser);
4372 template_keyword_p = false;
4374 /* Save the old scope since the name lookup we are about to do
4375 might destroy it. */
4376 old_scope = parser->scope;
4377 saved_qualifying_scope = parser->qualifying_scope;
4378 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
4379 look up names in "X<T>::I" in order to determine that "Y" is
4380 a template. So, if we have a typename at this point, we make
4381 an effort to look through it. */
4383 && !typename_keyword_p
4385 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
4386 parser->scope = resolve_typename_type (parser->scope,
4387 /*only_current_p=*/false);
4388 /* Parse the qualifying entity. */
4390 = cp_parser_qualifying_entity (parser,
4396 /* Look for the `::' token. */
4397 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
4399 /* If we found what we wanted, we keep going; otherwise, we're
4401 if (!cp_parser_parse_definitely (parser))
4403 bool error_p = false;
4405 /* Restore the OLD_SCOPE since it was valid before the
4406 failed attempt at finding the last
4407 class-or-namespace-name. */
4408 parser->scope = old_scope;
4409 parser->qualifying_scope = saved_qualifying_scope;
4411 /* If the next token is a decltype, and the one after that is a
4412 `::', then the decltype has failed to resolve to a class or
4413 enumeration type. Give this error even when parsing
4414 tentatively since it can't possibly be valid--and we're going
4415 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
4416 won't get another chance.*/
4417 if (cp_lexer_next_token_is (parser->lexer, CPP_DECLTYPE)
4418 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4421 token = cp_lexer_consume_token (parser->lexer);
4422 error_at (token->location, "decltype evaluates to %qT, "
4423 "which is not a class or enumeration type",
4425 parser->scope = error_mark_node;
4429 cp_lexer_consume_token (parser->lexer);
4432 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
4434 /* If the next token is an identifier, and the one after
4435 that is a `::', then any valid interpretation would have
4436 found a class-or-namespace-name. */
4437 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
4438 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4440 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
4443 token = cp_lexer_consume_token (parser->lexer);
4446 if (!token->ambiguous_p)
4449 tree ambiguous_decls;
4451 decl = cp_parser_lookup_name (parser, token->u.value,
4453 /*is_template=*/false,
4454 /*is_namespace=*/false,
4455 /*check_dependency=*/true,
4458 if (TREE_CODE (decl) == TEMPLATE_DECL)
4459 error_at (token->location,
4460 "%qD used without template parameters",
4462 else if (ambiguous_decls)
4464 error_at (token->location,
4465 "reference to %qD is ambiguous",
4467 print_candidates (ambiguous_decls);
4468 decl = error_mark_node;
4472 if (cxx_dialect != cxx98)
4473 cp_parser_name_lookup_error
4474 (parser, token->u.value, decl, NLE_NOT_CXX98,
4477 cp_parser_name_lookup_error
4478 (parser, token->u.value, decl, NLE_CXX98,
4482 parser->scope = error_mark_node;
4484 /* Treat this as a successful nested-name-specifier
4489 If the name found is not a class-name (clause
4490 _class_) or namespace-name (_namespace.def_), the
4491 program is ill-formed. */
4494 cp_lexer_consume_token (parser->lexer);
4498 /* We've found one valid nested-name-specifier. */
4500 /* Name lookup always gives us a DECL. */
4501 if (TREE_CODE (new_scope) == TYPE_DECL)
4502 new_scope = TREE_TYPE (new_scope);
4503 /* Uses of "template" must be followed by actual templates. */
4504 if (template_keyword_p
4505 && !(CLASS_TYPE_P (new_scope)
4506 && ((CLASSTYPE_USE_TEMPLATE (new_scope)
4507 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
4508 || CLASSTYPE_IS_TEMPLATE (new_scope)))
4509 && !(TREE_CODE (new_scope) == TYPENAME_TYPE
4510 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
4511 == TEMPLATE_ID_EXPR)))
4512 permerror (input_location, TYPE_P (new_scope)
4513 ? "%qT is not a template"
4514 : "%qD is not a template",
4516 /* If it is a class scope, try to complete it; we are about to
4517 be looking up names inside the class. */
4518 if (TYPE_P (new_scope)
4519 /* Since checking types for dependency can be expensive,
4520 avoid doing it if the type is already complete. */
4521 && !COMPLETE_TYPE_P (new_scope)
4522 /* Do not try to complete dependent types. */
4523 && !dependent_type_p (new_scope))
4525 new_scope = complete_type (new_scope);
4526 /* If it is a typedef to current class, use the current
4527 class instead, as the typedef won't have any names inside
4529 if (!COMPLETE_TYPE_P (new_scope)
4530 && currently_open_class (new_scope))
4531 new_scope = TYPE_MAIN_VARIANT (new_scope);
4533 /* Make sure we look in the right scope the next time through
4535 parser->scope = new_scope;
4538 /* If parsing tentatively, replace the sequence of tokens that makes
4539 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
4540 token. That way, should we re-parse the token stream, we will
4541 not have to repeat the effort required to do the parse, nor will
4542 we issue duplicate error messages. */
4543 if (success && start)
4547 token = cp_lexer_token_at (parser->lexer, start);
4548 /* Reset the contents of the START token. */
4549 token->type = CPP_NESTED_NAME_SPECIFIER;
4550 /* Retrieve any deferred checks. Do not pop this access checks yet
4551 so the memory will not be reclaimed during token replacing below. */
4552 token->u.tree_check_value = ggc_alloc_cleared_tree_check ();
4553 token->u.tree_check_value->value = parser->scope;
4554 token->u.tree_check_value->checks = get_deferred_access_checks ();
4555 token->u.tree_check_value->qualifying_scope =
4556 parser->qualifying_scope;
4557 token->keyword = RID_MAX;
4559 /* Purge all subsequent tokens. */
4560 cp_lexer_purge_tokens_after (parser->lexer, start);
4564 pop_to_parent_deferring_access_checks ();
4566 return success ? parser->scope : NULL_TREE;
4569 /* Parse a nested-name-specifier. See
4570 cp_parser_nested_name_specifier_opt for details. This function
4571 behaves identically, except that it will an issue an error if no
4572 nested-name-specifier is present. */
4575 cp_parser_nested_name_specifier (cp_parser *parser,
4576 bool typename_keyword_p,
4577 bool check_dependency_p,
4579 bool is_declaration)
4583 /* Look for the nested-name-specifier. */
4584 scope = cp_parser_nested_name_specifier_opt (parser,
4589 /* If it was not present, issue an error message. */
4592 cp_parser_error (parser, "expected nested-name-specifier");
4593 parser->scope = NULL_TREE;
4599 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
4600 this is either a class-name or a namespace-name (which corresponds
4601 to the class-or-namespace-name production in the grammar). For
4602 C++0x, it can also be a type-name that refers to an enumeration
4605 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
4606 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
4607 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
4608 TYPE_P is TRUE iff the next name should be taken as a class-name,
4609 even the same name is declared to be another entity in the same
4612 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
4613 specified by the class-or-namespace-name. If neither is found the
4614 ERROR_MARK_NODE is returned. */
4617 cp_parser_qualifying_entity (cp_parser *parser,
4618 bool typename_keyword_p,
4619 bool template_keyword_p,
4620 bool check_dependency_p,
4622 bool is_declaration)
4625 tree saved_qualifying_scope;
4626 tree saved_object_scope;
4629 bool successful_parse_p;
4631 /* DR 743: decltype can appear in a nested-name-specifier. */
4632 if (cp_lexer_next_token_is_decltype (parser->lexer))
4634 scope = cp_parser_decltype (parser);
4635 if (TREE_CODE (scope) != ENUMERAL_TYPE
4636 && !MAYBE_CLASS_TYPE_P (scope))
4638 cp_parser_simulate_error (parser);
4639 return error_mark_node;
4641 if (TYPE_NAME (scope))
4642 scope = TYPE_NAME (scope);
4646 /* Before we try to parse the class-name, we must save away the
4647 current PARSER->SCOPE since cp_parser_class_name will destroy
4649 saved_scope = parser->scope;
4650 saved_qualifying_scope = parser->qualifying_scope;
4651 saved_object_scope = parser->object_scope;
4652 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
4653 there is no need to look for a namespace-name. */
4654 only_class_p = template_keyword_p
4655 || (saved_scope && TYPE_P (saved_scope) && cxx_dialect == cxx98);
4657 cp_parser_parse_tentatively (parser);
4658 scope = cp_parser_class_name (parser,
4661 type_p ? class_type : none_type,
4663 /*class_head_p=*/false,
4665 successful_parse_p = only_class_p || cp_parser_parse_definitely (parser);
4666 /* If that didn't work and we're in C++0x mode, try for a type-name. */
4668 && cxx_dialect != cxx98
4669 && !successful_parse_p)
4671 /* Restore the saved scope. */
4672 parser->scope = saved_scope;
4673 parser->qualifying_scope = saved_qualifying_scope;
4674 parser->object_scope = saved_object_scope;
4676 /* Parse tentatively. */
4677 cp_parser_parse_tentatively (parser);
4679 /* Parse a typedef-name or enum-name. */
4680 scope = cp_parser_nonclass_name (parser);
4682 /* "If the name found does not designate a namespace or a class,
4683 enumeration, or dependent type, the program is ill-formed."
4685 We cover classes and dependent types above and namespaces below,
4686 so this code is only looking for enums. */
4687 if (!scope || TREE_CODE (scope) != TYPE_DECL
4688 || TREE_CODE (TREE_TYPE (scope)) != ENUMERAL_TYPE)
4689 cp_parser_simulate_error (parser);
4691 successful_parse_p = cp_parser_parse_definitely (parser);
4693 /* If that didn't work, try for a namespace-name. */
4694 if (!only_class_p && !successful_parse_p)
4696 /* Restore the saved scope. */
4697 parser->scope = saved_scope;
4698 parser->qualifying_scope = saved_qualifying_scope;
4699 parser->object_scope = saved_object_scope;
4700 /* If we are not looking at an identifier followed by the scope
4701 resolution operator, then this is not part of a
4702 nested-name-specifier. (Note that this function is only used
4703 to parse the components of a nested-name-specifier.) */
4704 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
4705 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
4706 return error_mark_node;
4707 scope = cp_parser_namespace_name (parser);
4713 /* Parse a postfix-expression.
4717 postfix-expression [ expression ]
4718 postfix-expression ( expression-list [opt] )
4719 simple-type-specifier ( expression-list [opt] )
4720 typename :: [opt] nested-name-specifier identifier
4721 ( expression-list [opt] )
4722 typename :: [opt] nested-name-specifier template [opt] template-id
4723 ( expression-list [opt] )
4724 postfix-expression . template [opt] id-expression
4725 postfix-expression -> template [opt] id-expression
4726 postfix-expression . pseudo-destructor-name
4727 postfix-expression -> pseudo-destructor-name
4728 postfix-expression ++
4729 postfix-expression --
4730 dynamic_cast < type-id > ( expression )
4731 static_cast < type-id > ( expression )
4732 reinterpret_cast < type-id > ( expression )
4733 const_cast < type-id > ( expression )
4734 typeid ( expression )
4740 ( type-id ) { initializer-list , [opt] }
4742 This extension is a GNU version of the C99 compound-literal
4743 construct. (The C99 grammar uses `type-name' instead of `type-id',
4744 but they are essentially the same concept.)
4746 If ADDRESS_P is true, the postfix expression is the operand of the
4747 `&' operator. CAST_P is true if this expression is the target of a
4750 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
4751 class member access expressions [expr.ref].
4753 Returns a representation of the expression. */
4756 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
4757 bool member_access_only_p,
4758 cp_id_kind * pidk_return)
4762 cp_id_kind idk = CP_ID_KIND_NONE;
4763 tree postfix_expression = NULL_TREE;
4764 bool is_member_access = false;
4766 /* Peek at the next token. */
4767 token = cp_lexer_peek_token (parser->lexer);
4768 /* Some of the productions are determined by keywords. */
4769 keyword = token->keyword;
4779 const char *saved_message;
4781 /* All of these can be handled in the same way from the point
4782 of view of parsing. Begin by consuming the token
4783 identifying the cast. */
4784 cp_lexer_consume_token (parser->lexer);
4786 /* New types cannot be defined in the cast. */
4787 saved_message = parser->type_definition_forbidden_message;
4788 parser->type_definition_forbidden_message
4789 = G_("types may not be defined in casts");
4791 /* Look for the opening `<'. */
4792 cp_parser_require (parser, CPP_LESS, RT_LESS);
4793 /* Parse the type to which we are casting. */
4794 type = cp_parser_type_id (parser);
4795 /* Look for the closing `>'. */
4796 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
4797 /* Restore the old message. */
4798 parser->type_definition_forbidden_message = saved_message;
4800 /* And the expression which is being cast. */
4801 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4802 expression = cp_parser_expression (parser, /*cast_p=*/true, & idk);
4803 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4805 /* Only type conversions to integral or enumeration types
4806 can be used in constant-expressions. */
4807 if (!cast_valid_in_integral_constant_expression_p (type)
4808 && cp_parser_non_integral_constant_expression (parser, NIC_CAST))
4809 return error_mark_node;
4815 = build_dynamic_cast (type, expression, tf_warning_or_error);
4819 = build_static_cast (type, expression, tf_warning_or_error);
4823 = build_reinterpret_cast (type, expression,
4824 tf_warning_or_error);
4828 = build_const_cast (type, expression, tf_warning_or_error);
4839 const char *saved_message;
4840 bool saved_in_type_id_in_expr_p;
4842 /* Consume the `typeid' token. */
4843 cp_lexer_consume_token (parser->lexer);
4844 /* Look for the `(' token. */
4845 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4846 /* Types cannot be defined in a `typeid' expression. */
4847 saved_message = parser->type_definition_forbidden_message;
4848 parser->type_definition_forbidden_message
4849 = G_("types may not be defined in a %<typeid%> expression");
4850 /* We can't be sure yet whether we're looking at a type-id or an
4852 cp_parser_parse_tentatively (parser);
4853 /* Try a type-id first. */
4854 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4855 parser->in_type_id_in_expr_p = true;
4856 type = cp_parser_type_id (parser);
4857 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4858 /* Look for the `)' token. Otherwise, we can't be sure that
4859 we're not looking at an expression: consider `typeid (int
4860 (3))', for example. */
4861 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4862 /* If all went well, simply lookup the type-id. */
4863 if (cp_parser_parse_definitely (parser))
4864 postfix_expression = get_typeid (type);
4865 /* Otherwise, fall back to the expression variant. */
4870 /* Look for an expression. */
4871 expression = cp_parser_expression (parser, /*cast_p=*/false, & idk);
4872 /* Compute its typeid. */
4873 postfix_expression = build_typeid (expression);
4874 /* Look for the `)' token. */
4875 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4877 /* Restore the saved message. */
4878 parser->type_definition_forbidden_message = saved_message;
4879 /* `typeid' may not appear in an integral constant expression. */
4880 if (cp_parser_non_integral_constant_expression(parser, NIC_TYPEID))
4881 return error_mark_node;
4888 /* The syntax permitted here is the same permitted for an
4889 elaborated-type-specifier. */
4890 type = cp_parser_elaborated_type_specifier (parser,
4891 /*is_friend=*/false,
4892 /*is_declaration=*/false);
4893 postfix_expression = cp_parser_functional_cast (parser, type);
4901 /* If the next thing is a simple-type-specifier, we may be
4902 looking at a functional cast. We could also be looking at
4903 an id-expression. So, we try the functional cast, and if
4904 that doesn't work we fall back to the primary-expression. */
4905 cp_parser_parse_tentatively (parser);
4906 /* Look for the simple-type-specifier. */
4907 type = cp_parser_simple_type_specifier (parser,
4908 /*decl_specs=*/NULL,
4909 CP_PARSER_FLAGS_NONE);
4910 /* Parse the cast itself. */
4911 if (!cp_parser_error_occurred (parser))
4913 = cp_parser_functional_cast (parser, type);
4914 /* If that worked, we're done. */
4915 if (cp_parser_parse_definitely (parser))
4918 /* If the functional-cast didn't work out, try a
4919 compound-literal. */
4920 if (cp_parser_allow_gnu_extensions_p (parser)
4921 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
4923 VEC(constructor_elt,gc) *initializer_list = NULL;
4924 bool saved_in_type_id_in_expr_p;
4926 cp_parser_parse_tentatively (parser);
4927 /* Consume the `('. */
4928 cp_lexer_consume_token (parser->lexer);
4929 /* Parse the type. */
4930 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
4931 parser->in_type_id_in_expr_p = true;
4932 type = cp_parser_type_id (parser);
4933 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
4934 /* Look for the `)'. */
4935 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4936 /* Look for the `{'. */
4937 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
4938 /* If things aren't going well, there's no need to
4940 if (!cp_parser_error_occurred (parser))
4942 bool non_constant_p;
4943 /* Parse the initializer-list. */
4945 = cp_parser_initializer_list (parser, &non_constant_p);
4946 /* Allow a trailing `,'. */
4947 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
4948 cp_lexer_consume_token (parser->lexer);
4949 /* Look for the final `}'. */
4950 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
4952 /* If that worked, we're definitely looking at a
4953 compound-literal expression. */
4954 if (cp_parser_parse_definitely (parser))
4956 /* Warn the user that a compound literal is not
4957 allowed in standard C++. */
4958 pedwarn (input_location, OPT_pedantic, "ISO C++ forbids compound-literals");
4959 /* For simplicity, we disallow compound literals in
4960 constant-expressions. We could
4961 allow compound literals of integer type, whose
4962 initializer was a constant, in constant
4963 expressions. Permitting that usage, as a further
4964 extension, would not change the meaning of any
4965 currently accepted programs. (Of course, as
4966 compound literals are not part of ISO C++, the
4967 standard has nothing to say.) */
4968 if (cp_parser_non_integral_constant_expression (parser,
4971 postfix_expression = error_mark_node;
4974 /* Form the representation of the compound-literal. */
4976 = (finish_compound_literal
4977 (type, build_constructor (init_list_type_node,
4979 tf_warning_or_error));
4984 /* It must be a primary-expression. */
4986 = cp_parser_primary_expression (parser, address_p, cast_p,
4987 /*template_arg_p=*/false,
4993 /* Keep looping until the postfix-expression is complete. */
4996 if (idk == CP_ID_KIND_UNQUALIFIED
4997 && TREE_CODE (postfix_expression) == IDENTIFIER_NODE
4998 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
4999 /* It is not a Koenig lookup function call. */
5001 = unqualified_name_lookup_error (postfix_expression);
5003 /* Peek at the next token. */
5004 token = cp_lexer_peek_token (parser->lexer);
5006 switch (token->type)
5008 case CPP_OPEN_SQUARE:
5010 = cp_parser_postfix_open_square_expression (parser,
5013 idk = CP_ID_KIND_NONE;
5014 is_member_access = false;
5017 case CPP_OPEN_PAREN:
5018 /* postfix-expression ( expression-list [opt] ) */
5021 bool is_builtin_constant_p;
5022 bool saved_integral_constant_expression_p = false;
5023 bool saved_non_integral_constant_expression_p = false;
5026 is_member_access = false;
5028 is_builtin_constant_p
5029 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
5030 if (is_builtin_constant_p)
5032 /* The whole point of __builtin_constant_p is to allow
5033 non-constant expressions to appear as arguments. */
5034 saved_integral_constant_expression_p
5035 = parser->integral_constant_expression_p;
5036 saved_non_integral_constant_expression_p
5037 = parser->non_integral_constant_expression_p;
5038 parser->integral_constant_expression_p = false;
5040 args = (cp_parser_parenthesized_expression_list
5042 /*cast_p=*/false, /*allow_expansion_p=*/true,
5043 /*non_constant_p=*/NULL));
5044 if (is_builtin_constant_p)
5046 parser->integral_constant_expression_p
5047 = saved_integral_constant_expression_p;
5048 parser->non_integral_constant_expression_p
5049 = saved_non_integral_constant_expression_p;
5054 postfix_expression = error_mark_node;
5058 /* Function calls are not permitted in
5059 constant-expressions. */
5060 if (! builtin_valid_in_constant_expr_p (postfix_expression)
5061 && cp_parser_non_integral_constant_expression (parser,
5064 postfix_expression = error_mark_node;
5065 release_tree_vector (args);
5070 if (idk == CP_ID_KIND_UNQUALIFIED
5071 || idk == CP_ID_KIND_TEMPLATE_ID)
5073 if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE)
5075 if (!VEC_empty (tree, args))
5078 if (!any_type_dependent_arguments_p (args))
5080 = perform_koenig_lookup (postfix_expression, args,
5081 /*include_std=*/false,
5082 tf_warning_or_error);
5086 = unqualified_fn_lookup_error (postfix_expression);
5088 /* We do not perform argument-dependent lookup if
5089 normal lookup finds a non-function, in accordance
5090 with the expected resolution of DR 218. */
5091 else if (!VEC_empty (tree, args)
5092 && is_overloaded_fn (postfix_expression))
5094 tree fn = get_first_fn (postfix_expression);
5095 fn = STRIP_TEMPLATE (fn);
5097 /* Do not do argument dependent lookup if regular
5098 lookup finds a member function or a block-scope
5099 function declaration. [basic.lookup.argdep]/3 */
5100 if (!DECL_FUNCTION_MEMBER_P (fn)
5101 && !DECL_LOCAL_FUNCTION_P (fn))
5104 if (!any_type_dependent_arguments_p (args))
5106 = perform_koenig_lookup (postfix_expression, args,
5107 /*include_std=*/false,
5108 tf_warning_or_error);
5113 if (TREE_CODE (postfix_expression) == COMPONENT_REF)
5115 tree instance = TREE_OPERAND (postfix_expression, 0);
5116 tree fn = TREE_OPERAND (postfix_expression, 1);
5118 if (processing_template_decl
5119 && (type_dependent_expression_p (instance)
5120 || (!BASELINK_P (fn)
5121 && TREE_CODE (fn) != FIELD_DECL)
5122 || type_dependent_expression_p (fn)
5123 || any_type_dependent_arguments_p (args)))
5126 = build_nt_call_vec (postfix_expression, args);
5127 release_tree_vector (args);
5131 if (BASELINK_P (fn))
5134 = (build_new_method_call
5135 (instance, fn, &args, NULL_TREE,
5136 (idk == CP_ID_KIND_QUALIFIED
5137 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
5140 tf_warning_or_error));
5144 = finish_call_expr (postfix_expression, &args,
5145 /*disallow_virtual=*/false,
5147 tf_warning_or_error);
5149 else if (TREE_CODE (postfix_expression) == OFFSET_REF
5150 || TREE_CODE (postfix_expression) == MEMBER_REF
5151 || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
5152 postfix_expression = (build_offset_ref_call_from_tree
5153 (postfix_expression, &args));
5154 else if (idk == CP_ID_KIND_QUALIFIED)
5155 /* A call to a static class member, or a namespace-scope
5158 = finish_call_expr (postfix_expression, &args,
5159 /*disallow_virtual=*/true,
5161 tf_warning_or_error);
5163 /* All other function calls. */
5165 = finish_call_expr (postfix_expression, &args,
5166 /*disallow_virtual=*/false,
5168 tf_warning_or_error);
5170 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
5171 idk = CP_ID_KIND_NONE;
5173 release_tree_vector (args);
5179 /* postfix-expression . template [opt] id-expression
5180 postfix-expression . pseudo-destructor-name
5181 postfix-expression -> template [opt] id-expression
5182 postfix-expression -> pseudo-destructor-name */
5184 /* Consume the `.' or `->' operator. */
5185 cp_lexer_consume_token (parser->lexer);
5188 = cp_parser_postfix_dot_deref_expression (parser, token->type,
5193 is_member_access = true;
5197 /* postfix-expression ++ */
5198 /* Consume the `++' token. */
5199 cp_lexer_consume_token (parser->lexer);
5200 /* Generate a representation for the complete expression. */
5202 = finish_increment_expr (postfix_expression,
5203 POSTINCREMENT_EXPR);
5204 /* Increments may not appear in constant-expressions. */
5205 if (cp_parser_non_integral_constant_expression (parser, NIC_INC))
5206 postfix_expression = error_mark_node;
5207 idk = CP_ID_KIND_NONE;
5208 is_member_access = false;
5211 case CPP_MINUS_MINUS:
5212 /* postfix-expression -- */
5213 /* Consume the `--' token. */
5214 cp_lexer_consume_token (parser->lexer);
5215 /* Generate a representation for the complete expression. */
5217 = finish_increment_expr (postfix_expression,
5218 POSTDECREMENT_EXPR);
5219 /* Decrements may not appear in constant-expressions. */
5220 if (cp_parser_non_integral_constant_expression (parser, NIC_DEC))
5221 postfix_expression = error_mark_node;
5222 idk = CP_ID_KIND_NONE;
5223 is_member_access = false;
5227 if (pidk_return != NULL)
5228 * pidk_return = idk;
5229 if (member_access_only_p)
5230 return is_member_access? postfix_expression : error_mark_node;
5232 return postfix_expression;
5236 /* We should never get here. */
5238 return error_mark_node;
5241 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
5242 by cp_parser_builtin_offsetof. We're looking for
5244 postfix-expression [ expression ]
5246 FOR_OFFSETOF is set if we're being called in that context, which
5247 changes how we deal with integer constant expressions. */
5250 cp_parser_postfix_open_square_expression (cp_parser *parser,
5251 tree postfix_expression,
5256 /* Consume the `[' token. */
5257 cp_lexer_consume_token (parser->lexer);
5259 /* Parse the index expression. */
5260 /* ??? For offsetof, there is a question of what to allow here. If
5261 offsetof is not being used in an integral constant expression context,
5262 then we *could* get the right answer by computing the value at runtime.
5263 If we are in an integral constant expression context, then we might
5264 could accept any constant expression; hard to say without analysis.
5265 Rather than open the barn door too wide right away, allow only integer
5266 constant expressions here. */
5268 index = cp_parser_constant_expression (parser, false, NULL);
5270 index = cp_parser_expression (parser, /*cast_p=*/false, NULL);
5272 /* Look for the closing `]'. */
5273 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
5275 /* Build the ARRAY_REF. */
5276 postfix_expression = grok_array_decl (postfix_expression, index);
5278 /* When not doing offsetof, array references are not permitted in
5279 constant-expressions. */
5281 && (cp_parser_non_integral_constant_expression (parser, NIC_ARRAY_REF)))
5282 postfix_expression = error_mark_node;
5284 return postfix_expression;
5287 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
5288 by cp_parser_builtin_offsetof. We're looking for
5290 postfix-expression . template [opt] id-expression
5291 postfix-expression . pseudo-destructor-name
5292 postfix-expression -> template [opt] id-expression
5293 postfix-expression -> pseudo-destructor-name
5295 FOR_OFFSETOF is set if we're being called in that context. That sorta
5296 limits what of the above we'll actually accept, but nevermind.
5297 TOKEN_TYPE is the "." or "->" token, which will already have been
5298 removed from the stream. */
5301 cp_parser_postfix_dot_deref_expression (cp_parser *parser,
5302 enum cpp_ttype token_type,
5303 tree postfix_expression,
5304 bool for_offsetof, cp_id_kind *idk,
5305 location_t location)
5309 bool pseudo_destructor_p;
5310 tree scope = NULL_TREE;
5312 /* If this is a `->' operator, dereference the pointer. */
5313 if (token_type == CPP_DEREF)
5314 postfix_expression = build_x_arrow (postfix_expression);
5315 /* Check to see whether or not the expression is type-dependent. */
5316 dependent_p = type_dependent_expression_p (postfix_expression);
5317 /* The identifier following the `->' or `.' is not qualified. */
5318 parser->scope = NULL_TREE;
5319 parser->qualifying_scope = NULL_TREE;
5320 parser->object_scope = NULL_TREE;
5321 *idk = CP_ID_KIND_NONE;
5323 /* Enter the scope corresponding to the type of the object
5324 given by the POSTFIX_EXPRESSION. */
5325 if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
5327 scope = TREE_TYPE (postfix_expression);
5328 /* According to the standard, no expression should ever have
5329 reference type. Unfortunately, we do not currently match
5330 the standard in this respect in that our internal representation
5331 of an expression may have reference type even when the standard
5332 says it does not. Therefore, we have to manually obtain the
5333 underlying type here. */
5334 scope = non_reference (scope);
5335 /* The type of the POSTFIX_EXPRESSION must be complete. */
5336 if (scope == unknown_type_node)
5338 error_at (location, "%qE does not have class type",
5339 postfix_expression);
5342 /* Unlike the object expression in other contexts, *this is not
5343 required to be of complete type for purposes of class member
5344 access (5.2.5) outside the member function body. */
5345 else if (scope != current_class_ref
5346 && !(processing_template_decl && scope == current_class_type))
5347 scope = complete_type_or_else (scope, NULL_TREE);
5348 /* Let the name lookup machinery know that we are processing a
5349 class member access expression. */
5350 parser->context->object_type = scope;
5351 /* If something went wrong, we want to be able to discern that case,
5352 as opposed to the case where there was no SCOPE due to the type
5353 of expression being dependent. */
5355 scope = error_mark_node;
5356 /* If the SCOPE was erroneous, make the various semantic analysis
5357 functions exit quickly -- and without issuing additional error
5359 if (scope == error_mark_node)
5360 postfix_expression = error_mark_node;
5363 /* Assume this expression is not a pseudo-destructor access. */
5364 pseudo_destructor_p = false;
5366 /* If the SCOPE is a scalar type, then, if this is a valid program,
5367 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
5368 is type dependent, it can be pseudo-destructor-name or something else.
5369 Try to parse it as pseudo-destructor-name first. */
5370 if ((scope && SCALAR_TYPE_P (scope)) || dependent_p)
5375 cp_parser_parse_tentatively (parser);
5376 /* Parse the pseudo-destructor-name. */
5378 cp_parser_pseudo_destructor_name (parser, &s, &type);
5380 && (cp_parser_error_occurred (parser)
5381 || TREE_CODE (type) != TYPE_DECL
5382 || !SCALAR_TYPE_P (TREE_TYPE (type))))
5383 cp_parser_abort_tentative_parse (parser);
5384 else if (cp_parser_parse_definitely (parser))
5386 pseudo_destructor_p = true;
5388 = finish_pseudo_destructor_expr (postfix_expression,
5389 s, TREE_TYPE (type));
5393 if (!pseudo_destructor_p)
5395 /* If the SCOPE is not a scalar type, we are looking at an
5396 ordinary class member access expression, rather than a
5397 pseudo-destructor-name. */
5399 cp_token *token = cp_lexer_peek_token (parser->lexer);
5400 /* Parse the id-expression. */
5401 name = (cp_parser_id_expression
5403 cp_parser_optional_template_keyword (parser),
5404 /*check_dependency_p=*/true,
5406 /*declarator_p=*/false,
5407 /*optional_p=*/false));
5408 /* In general, build a SCOPE_REF if the member name is qualified.
5409 However, if the name was not dependent and has already been
5410 resolved; there is no need to build the SCOPE_REF. For example;
5412 struct X { void f(); };
5413 template <typename T> void f(T* t) { t->X::f(); }
5415 Even though "t" is dependent, "X::f" is not and has been resolved
5416 to a BASELINK; there is no need to include scope information. */
5418 /* But we do need to remember that there was an explicit scope for
5419 virtual function calls. */
5421 *idk = CP_ID_KIND_QUALIFIED;
5423 /* If the name is a template-id that names a type, we will get a
5424 TYPE_DECL here. That is invalid code. */
5425 if (TREE_CODE (name) == TYPE_DECL)
5427 error_at (token->location, "invalid use of %qD", name);
5428 postfix_expression = error_mark_node;
5432 if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
5434 name = build_qualified_name (/*type=*/NULL_TREE,
5438 parser->scope = NULL_TREE;
5439 parser->qualifying_scope = NULL_TREE;
5440 parser->object_scope = NULL_TREE;
5442 if (scope && name && BASELINK_P (name))
5443 adjust_result_of_qualified_name_lookup
5444 (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope);
5446 = finish_class_member_access_expr (postfix_expression, name,
5448 tf_warning_or_error);
5452 /* We no longer need to look up names in the scope of the object on
5453 the left-hand side of the `.' or `->' operator. */
5454 parser->context->object_type = NULL_TREE;
5456 /* Outside of offsetof, these operators may not appear in
5457 constant-expressions. */
5459 && (cp_parser_non_integral_constant_expression
5460 (parser, token_type == CPP_DEREF ? NIC_ARROW : NIC_POINT)))
5461 postfix_expression = error_mark_node;
5463 return postfix_expression;
5466 /* Parse a parenthesized expression-list.
5469 assignment-expression
5470 expression-list, assignment-expression
5475 identifier, expression-list
5477 CAST_P is true if this expression is the target of a cast.
5479 ALLOW_EXPANSION_P is true if this expression allows expansion of an
5482 Returns a vector of trees. Each element is a representation of an
5483 assignment-expression. NULL is returned if the ( and or ) are
5484 missing. An empty, but allocated, vector is returned on no
5485 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
5486 if we are parsing an attribute list for an attribute that wants a
5487 plain identifier argument, normal_attr for an attribute that wants
5488 an expression, or non_attr if we aren't parsing an attribute list. If
5489 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
5490 not all of the expressions in the list were constant. */
5492 static VEC(tree,gc) *
5493 cp_parser_parenthesized_expression_list (cp_parser* parser,
5494 int is_attribute_list,
5496 bool allow_expansion_p,
5497 bool *non_constant_p)
5499 VEC(tree,gc) *expression_list;
5500 bool fold_expr_p = is_attribute_list != non_attr;
5501 tree identifier = NULL_TREE;
5502 bool saved_greater_than_is_operator_p;
5504 /* Assume all the expressions will be constant. */
5506 *non_constant_p = false;
5508 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
5511 expression_list = make_tree_vector ();
5513 /* Within a parenthesized expression, a `>' token is always
5514 the greater-than operator. */
5515 saved_greater_than_is_operator_p
5516 = parser->greater_than_is_operator_p;
5517 parser->greater_than_is_operator_p = true;
5519 /* Consume expressions until there are no more. */
5520 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
5525 /* At the beginning of attribute lists, check to see if the
5526 next token is an identifier. */
5527 if (is_attribute_list == id_attr
5528 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
5532 /* Consume the identifier. */
5533 token = cp_lexer_consume_token (parser->lexer);
5534 /* Save the identifier. */
5535 identifier = token->u.value;
5539 bool expr_non_constant_p;
5541 /* Parse the next assignment-expression. */
5542 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
5544 /* A braced-init-list. */
5545 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
5546 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
5547 if (non_constant_p && expr_non_constant_p)
5548 *non_constant_p = true;
5550 else if (non_constant_p)
5552 expr = (cp_parser_constant_expression
5553 (parser, /*allow_non_constant_p=*/true,
5554 &expr_non_constant_p));
5555 if (expr_non_constant_p)
5556 *non_constant_p = true;
5559 expr = cp_parser_assignment_expression (parser, cast_p, NULL);
5562 expr = fold_non_dependent_expr (expr);
5564 /* If we have an ellipsis, then this is an expression
5566 if (allow_expansion_p
5567 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5569 /* Consume the `...'. */
5570 cp_lexer_consume_token (parser->lexer);
5572 /* Build the argument pack. */
5573 expr = make_pack_expansion (expr);
5576 /* Add it to the list. We add error_mark_node
5577 expressions to the list, so that we can still tell if
5578 the correct form for a parenthesized expression-list
5579 is found. That gives better errors. */
5580 VEC_safe_push (tree, gc, expression_list, expr);
5582 if (expr == error_mark_node)
5586 /* After the first item, attribute lists look the same as
5587 expression lists. */
5588 is_attribute_list = non_attr;
5591 /* If the next token isn't a `,', then we are done. */
5592 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
5595 /* Otherwise, consume the `,' and keep going. */
5596 cp_lexer_consume_token (parser->lexer);
5599 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
5604 /* We try and resync to an unnested comma, as that will give the
5605 user better diagnostics. */
5606 ending = cp_parser_skip_to_closing_parenthesis (parser,
5607 /*recovering=*/true,
5609 /*consume_paren=*/true);
5614 parser->greater_than_is_operator_p
5615 = saved_greater_than_is_operator_p;
5620 parser->greater_than_is_operator_p
5621 = saved_greater_than_is_operator_p;
5624 VEC_safe_insert (tree, gc, expression_list, 0, identifier);
5626 return expression_list;
5629 /* Parse a pseudo-destructor-name.
5631 pseudo-destructor-name:
5632 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
5633 :: [opt] nested-name-specifier template template-id :: ~ type-name
5634 :: [opt] nested-name-specifier [opt] ~ type-name
5636 If either of the first two productions is used, sets *SCOPE to the
5637 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
5638 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
5639 or ERROR_MARK_NODE if the parse fails. */
5642 cp_parser_pseudo_destructor_name (cp_parser* parser,
5646 bool nested_name_specifier_p;
5648 /* Assume that things will not work out. */
5649 *type = error_mark_node;
5651 /* Look for the optional `::' operator. */
5652 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
5653 /* Look for the optional nested-name-specifier. */
5654 nested_name_specifier_p
5655 = (cp_parser_nested_name_specifier_opt (parser,
5656 /*typename_keyword_p=*/false,
5657 /*check_dependency_p=*/true,
5659 /*is_declaration=*/false)
5661 /* Now, if we saw a nested-name-specifier, we might be doing the
5662 second production. */
5663 if (nested_name_specifier_p
5664 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
5666 /* Consume the `template' keyword. */
5667 cp_lexer_consume_token (parser->lexer);
5668 /* Parse the template-id. */
5669 cp_parser_template_id (parser,
5670 /*template_keyword_p=*/true,
5671 /*check_dependency_p=*/false,
5672 /*is_declaration=*/true);
5673 /* Look for the `::' token. */
5674 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
5676 /* If the next token is not a `~', then there might be some
5677 additional qualification. */
5678 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
5680 /* At this point, we're looking for "type-name :: ~". The type-name
5681 must not be a class-name, since this is a pseudo-destructor. So,
5682 it must be either an enum-name, or a typedef-name -- both of which
5683 are just identifiers. So, we peek ahead to check that the "::"
5684 and "~" tokens are present; if they are not, then we can avoid
5685 calling type_name. */
5686 if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
5687 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
5688 || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
5690 cp_parser_error (parser, "non-scalar type");
5694 /* Look for the type-name. */
5695 *scope = TREE_TYPE (cp_parser_nonclass_name (parser));
5696 if (*scope == error_mark_node)
5699 /* Look for the `::' token. */
5700 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
5705 /* Look for the `~'. */
5706 cp_parser_require (parser, CPP_COMPL, RT_COMPL);
5708 /* Once we see the ~, this has to be a pseudo-destructor. */
5709 if (!processing_template_decl && !cp_parser_error_occurred (parser))
5710 cp_parser_commit_to_tentative_parse (parser);
5712 /* Look for the type-name again. We are not responsible for
5713 checking that it matches the first type-name. */
5714 *type = cp_parser_nonclass_name (parser);
5717 /* Parse a unary-expression.
5723 unary-operator cast-expression
5724 sizeof unary-expression
5726 alignof ( type-id ) [C++0x]
5733 __extension__ cast-expression
5734 __alignof__ unary-expression
5735 __alignof__ ( type-id )
5736 alignof unary-expression [C++0x]
5737 __real__ cast-expression
5738 __imag__ cast-expression
5741 ADDRESS_P is true iff the unary-expression is appearing as the
5742 operand of the `&' operator. CAST_P is true if this expression is
5743 the target of a cast.
5745 Returns a representation of the expression. */
5748 cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p,
5752 enum tree_code unary_operator;
5754 /* Peek at the next token. */
5755 token = cp_lexer_peek_token (parser->lexer);
5756 /* Some keywords give away the kind of expression. */
5757 if (token->type == CPP_KEYWORD)
5759 enum rid keyword = token->keyword;
5769 op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
5770 /* Consume the token. */
5771 cp_lexer_consume_token (parser->lexer);
5772 /* Parse the operand. */
5773 operand = cp_parser_sizeof_operand (parser, keyword);
5775 if (TYPE_P (operand))
5776 return cxx_sizeof_or_alignof_type (operand, op, true);
5779 /* ISO C++ defines alignof only with types, not with
5780 expressions. So pedwarn if alignof is used with a non-
5781 type expression. However, __alignof__ is ok. */
5782 if (!strcmp (IDENTIFIER_POINTER (token->u.value), "alignof"))
5783 pedwarn (token->location, OPT_pedantic,
5784 "ISO C++ does not allow %<alignof%> "
5787 return cxx_sizeof_or_alignof_expr (operand, op, true);
5792 return cp_parser_new_expression (parser);
5795 return cp_parser_delete_expression (parser);
5799 /* The saved value of the PEDANTIC flag. */
5803 /* Save away the PEDANTIC flag. */
5804 cp_parser_extension_opt (parser, &saved_pedantic);
5805 /* Parse the cast-expression. */
5806 expr = cp_parser_simple_cast_expression (parser);
5807 /* Restore the PEDANTIC flag. */
5808 pedantic = saved_pedantic;
5818 /* Consume the `__real__' or `__imag__' token. */
5819 cp_lexer_consume_token (parser->lexer);
5820 /* Parse the cast-expression. */
5821 expression = cp_parser_simple_cast_expression (parser);
5822 /* Create the complete representation. */
5823 return build_x_unary_op ((keyword == RID_REALPART
5824 ? REALPART_EXPR : IMAGPART_EXPR),
5826 tf_warning_or_error);
5833 const char *saved_message;
5834 bool saved_integral_constant_expression_p;
5835 bool saved_non_integral_constant_expression_p;
5836 bool saved_greater_than_is_operator_p;
5838 cp_lexer_consume_token (parser->lexer);
5839 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
5841 saved_message = parser->type_definition_forbidden_message;
5842 parser->type_definition_forbidden_message
5843 = G_("types may not be defined in %<noexcept%> expressions");
5845 saved_integral_constant_expression_p
5846 = parser->integral_constant_expression_p;
5847 saved_non_integral_constant_expression_p
5848 = parser->non_integral_constant_expression_p;
5849 parser->integral_constant_expression_p = false;
5851 saved_greater_than_is_operator_p
5852 = parser->greater_than_is_operator_p;
5853 parser->greater_than_is_operator_p = true;
5855 ++cp_unevaluated_operand;
5856 ++c_inhibit_evaluation_warnings;
5857 expr = cp_parser_expression (parser, false, NULL);
5858 --c_inhibit_evaluation_warnings;
5859 --cp_unevaluated_operand;
5861 parser->greater_than_is_operator_p
5862 = saved_greater_than_is_operator_p;
5864 parser->integral_constant_expression_p
5865 = saved_integral_constant_expression_p;
5866 parser->non_integral_constant_expression_p
5867 = saved_non_integral_constant_expression_p;
5869 parser->type_definition_forbidden_message = saved_message;
5871 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
5872 return finish_noexcept_expr (expr, tf_warning_or_error);
5880 /* Look for the `:: new' and `:: delete', which also signal the
5881 beginning of a new-expression, or delete-expression,
5882 respectively. If the next token is `::', then it might be one of
5884 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
5888 /* See if the token after the `::' is one of the keywords in
5889 which we're interested. */
5890 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
5891 /* If it's `new', we have a new-expression. */
5892 if (keyword == RID_NEW)
5893 return cp_parser_new_expression (parser);
5894 /* Similarly, for `delete'. */
5895 else if (keyword == RID_DELETE)
5896 return cp_parser_delete_expression (parser);
5899 /* Look for a unary operator. */
5900 unary_operator = cp_parser_unary_operator (token);
5901 /* The `++' and `--' operators can be handled similarly, even though
5902 they are not technically unary-operators in the grammar. */
5903 if (unary_operator == ERROR_MARK)
5905 if (token->type == CPP_PLUS_PLUS)
5906 unary_operator = PREINCREMENT_EXPR;
5907 else if (token->type == CPP_MINUS_MINUS)
5908 unary_operator = PREDECREMENT_EXPR;
5909 /* Handle the GNU address-of-label extension. */
5910 else if (cp_parser_allow_gnu_extensions_p (parser)
5911 && token->type == CPP_AND_AND)
5915 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
5917 /* Consume the '&&' token. */
5918 cp_lexer_consume_token (parser->lexer);
5919 /* Look for the identifier. */
5920 identifier = cp_parser_identifier (parser);
5921 /* Create an expression representing the address. */
5922 expression = finish_label_address_expr (identifier, loc);
5923 if (cp_parser_non_integral_constant_expression (parser,
5925 expression = error_mark_node;
5929 if (unary_operator != ERROR_MARK)
5931 tree cast_expression;
5932 tree expression = error_mark_node;
5933 non_integral_constant non_constant_p = NIC_NONE;
5935 /* Consume the operator token. */
5936 token = cp_lexer_consume_token (parser->lexer);
5937 /* Parse the cast-expression. */
5939 = cp_parser_cast_expression (parser,
5940 unary_operator == ADDR_EXPR,
5941 /*cast_p=*/false, pidk);
5942 /* Now, build an appropriate representation. */
5943 switch (unary_operator)
5946 non_constant_p = NIC_STAR;
5947 expression = build_x_indirect_ref (cast_expression, RO_UNARY_STAR,
5948 tf_warning_or_error);
5952 non_constant_p = NIC_ADDR;
5955 expression = build_x_unary_op (unary_operator, cast_expression,
5956 tf_warning_or_error);
5959 case PREINCREMENT_EXPR:
5960 case PREDECREMENT_EXPR:
5961 non_constant_p = unary_operator == PREINCREMENT_EXPR
5962 ? NIC_PREINCREMENT : NIC_PREDECREMENT;
5964 case UNARY_PLUS_EXPR:
5966 case TRUTH_NOT_EXPR:
5967 expression = finish_unary_op_expr (unary_operator, cast_expression);
5974 if (non_constant_p != NIC_NONE
5975 && cp_parser_non_integral_constant_expression (parser,
5977 expression = error_mark_node;
5982 return cp_parser_postfix_expression (parser, address_p, cast_p,
5983 /*member_access_only_p=*/false,
5987 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
5988 unary-operator, the corresponding tree code is returned. */
5990 static enum tree_code
5991 cp_parser_unary_operator (cp_token* token)
5993 switch (token->type)
5996 return INDIRECT_REF;
6002 return UNARY_PLUS_EXPR;
6008 return TRUTH_NOT_EXPR;
6011 return BIT_NOT_EXPR;
6018 /* Parse a new-expression.
6021 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
6022 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
6024 Returns a representation of the expression. */
6027 cp_parser_new_expression (cp_parser* parser)
6029 bool global_scope_p;
6030 VEC(tree,gc) *placement;
6032 VEC(tree,gc) *initializer;
6036 /* Look for the optional `::' operator. */
6038 = (cp_parser_global_scope_opt (parser,
6039 /*current_scope_valid_p=*/false)
6041 /* Look for the `new' operator. */
6042 cp_parser_require_keyword (parser, RID_NEW, RT_NEW);
6043 /* There's no easy way to tell a new-placement from the
6044 `( type-id )' construct. */
6045 cp_parser_parse_tentatively (parser);
6046 /* Look for a new-placement. */
6047 placement = cp_parser_new_placement (parser);
6048 /* If that didn't work out, there's no new-placement. */
6049 if (!cp_parser_parse_definitely (parser))
6051 if (placement != NULL)
6052 release_tree_vector (placement);
6056 /* If the next token is a `(', then we have a parenthesized
6058 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
6061 /* Consume the `('. */
6062 cp_lexer_consume_token (parser->lexer);
6063 /* Parse the type-id. */
6064 type = cp_parser_type_id (parser);
6065 /* Look for the closing `)'. */
6066 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
6067 token = cp_lexer_peek_token (parser->lexer);
6068 /* There should not be a direct-new-declarator in this production,
6069 but GCC used to allowed this, so we check and emit a sensible error
6070 message for this case. */
6071 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
6073 error_at (token->location,
6074 "array bound forbidden after parenthesized type-id");
6075 inform (token->location,
6076 "try removing the parentheses around the type-id");
6077 cp_parser_direct_new_declarator (parser);
6081 /* Otherwise, there must be a new-type-id. */
6083 type = cp_parser_new_type_id (parser, &nelts);
6085 /* If the next token is a `(' or '{', then we have a new-initializer. */
6086 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
6087 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
6088 initializer = cp_parser_new_initializer (parser);
6092 /* A new-expression may not appear in an integral constant
6094 if (cp_parser_non_integral_constant_expression (parser, NIC_NEW))
6095 ret = error_mark_node;
6098 /* Create a representation of the new-expression. */
6099 ret = build_new (&placement, type, nelts, &initializer, global_scope_p,
6100 tf_warning_or_error);
6103 if (placement != NULL)
6104 release_tree_vector (placement);
6105 if (initializer != NULL)
6106 release_tree_vector (initializer);
6111 /* Parse a new-placement.
6116 Returns the same representation as for an expression-list. */
6118 static VEC(tree,gc) *
6119 cp_parser_new_placement (cp_parser* parser)
6121 VEC(tree,gc) *expression_list;
6123 /* Parse the expression-list. */
6124 expression_list = (cp_parser_parenthesized_expression_list
6125 (parser, non_attr, /*cast_p=*/false,
6126 /*allow_expansion_p=*/true,
6127 /*non_constant_p=*/NULL));
6129 return expression_list;
6132 /* Parse a new-type-id.
6135 type-specifier-seq new-declarator [opt]
6137 Returns the TYPE allocated. If the new-type-id indicates an array
6138 type, *NELTS is set to the number of elements in the last array
6139 bound; the TYPE will not include the last array bound. */
6142 cp_parser_new_type_id (cp_parser* parser, tree *nelts)
6144 cp_decl_specifier_seq type_specifier_seq;
6145 cp_declarator *new_declarator;
6146 cp_declarator *declarator;
6147 cp_declarator *outer_declarator;
6148 const char *saved_message;
6151 /* The type-specifier sequence must not contain type definitions.
6152 (It cannot contain declarations of new types either, but if they
6153 are not definitions we will catch that because they are not
6155 saved_message = parser->type_definition_forbidden_message;
6156 parser->type_definition_forbidden_message
6157 = G_("types may not be defined in a new-type-id");
6158 /* Parse the type-specifier-seq. */
6159 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
6160 /*is_trailing_return=*/false,
6161 &type_specifier_seq);
6162 /* Restore the old message. */
6163 parser->type_definition_forbidden_message = saved_message;
6164 /* Parse the new-declarator. */
6165 new_declarator = cp_parser_new_declarator_opt (parser);
6167 /* Determine the number of elements in the last array dimension, if
6170 /* Skip down to the last array dimension. */
6171 declarator = new_declarator;
6172 outer_declarator = NULL;
6173 while (declarator && (declarator->kind == cdk_pointer
6174 || declarator->kind == cdk_ptrmem))
6176 outer_declarator = declarator;
6177 declarator = declarator->declarator;
6180 && declarator->kind == cdk_array
6181 && declarator->declarator
6182 && declarator->declarator->kind == cdk_array)
6184 outer_declarator = declarator;
6185 declarator = declarator->declarator;
6188 if (declarator && declarator->kind == cdk_array)
6190 *nelts = declarator->u.array.bounds;
6191 if (*nelts == error_mark_node)
6192 *nelts = integer_one_node;
6194 if (outer_declarator)
6195 outer_declarator->declarator = declarator->declarator;
6197 new_declarator = NULL;
6200 type = groktypename (&type_specifier_seq, new_declarator, false);
6204 /* Parse an (optional) new-declarator.
6207 ptr-operator new-declarator [opt]
6208 direct-new-declarator
6210 Returns the declarator. */
6212 static cp_declarator *
6213 cp_parser_new_declarator_opt (cp_parser* parser)
6215 enum tree_code code;
6217 cp_cv_quals cv_quals;
6219 /* We don't know if there's a ptr-operator next, or not. */
6220 cp_parser_parse_tentatively (parser);
6221 /* Look for a ptr-operator. */
6222 code = cp_parser_ptr_operator (parser, &type, &cv_quals);
6223 /* If that worked, look for more new-declarators. */
6224 if (cp_parser_parse_definitely (parser))
6226 cp_declarator *declarator;
6228 /* Parse another optional declarator. */
6229 declarator = cp_parser_new_declarator_opt (parser);
6231 return cp_parser_make_indirect_declarator
6232 (code, type, cv_quals, declarator);
6235 /* If the next token is a `[', there is a direct-new-declarator. */
6236 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
6237 return cp_parser_direct_new_declarator (parser);
6242 /* Parse a direct-new-declarator.
6244 direct-new-declarator:
6246 direct-new-declarator [constant-expression]
6250 static cp_declarator *
6251 cp_parser_direct_new_declarator (cp_parser* parser)
6253 cp_declarator *declarator = NULL;
6259 /* Look for the opening `['. */
6260 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
6261 /* The first expression is not required to be constant. */
6264 cp_token *token = cp_lexer_peek_token (parser->lexer);
6265 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
6266 /* The standard requires that the expression have integral
6267 type. DR 74 adds enumeration types. We believe that the
6268 real intent is that these expressions be handled like the
6269 expression in a `switch' condition, which also allows
6270 classes with a single conversion to integral or
6271 enumeration type. */
6272 if (!processing_template_decl)
6275 = build_expr_type_conversion (WANT_INT | WANT_ENUM,
6280 error_at (token->location,
6281 "expression in new-declarator must have integral "
6282 "or enumeration type");
6283 expression = error_mark_node;
6287 /* But all the other expressions must be. */
6290 = cp_parser_constant_expression (parser,
6291 /*allow_non_constant=*/false,
6293 /* Look for the closing `]'. */
6294 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
6296 /* Add this bound to the declarator. */
6297 declarator = make_array_declarator (declarator, expression);
6299 /* If the next token is not a `[', then there are no more
6301 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
6308 /* Parse a new-initializer.
6311 ( expression-list [opt] )
6314 Returns a representation of the expression-list. */
6316 static VEC(tree,gc) *
6317 cp_parser_new_initializer (cp_parser* parser)
6319 VEC(tree,gc) *expression_list;
6321 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
6324 bool expr_non_constant_p;
6325 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6326 t = cp_parser_braced_list (parser, &expr_non_constant_p);
6327 CONSTRUCTOR_IS_DIRECT_INIT (t) = 1;
6328 expression_list = make_tree_vector_single (t);
6331 expression_list = (cp_parser_parenthesized_expression_list
6332 (parser, non_attr, /*cast_p=*/false,
6333 /*allow_expansion_p=*/true,
6334 /*non_constant_p=*/NULL));
6336 return expression_list;
6339 /* Parse a delete-expression.
6342 :: [opt] delete cast-expression
6343 :: [opt] delete [ ] cast-expression
6345 Returns a representation of the expression. */
6348 cp_parser_delete_expression (cp_parser* parser)
6350 bool global_scope_p;
6354 /* Look for the optional `::' operator. */
6356 = (cp_parser_global_scope_opt (parser,
6357 /*current_scope_valid_p=*/false)
6359 /* Look for the `delete' keyword. */
6360 cp_parser_require_keyword (parser, RID_DELETE, RT_DELETE);
6361 /* See if the array syntax is in use. */
6362 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
6364 /* Consume the `[' token. */
6365 cp_lexer_consume_token (parser->lexer);
6366 /* Look for the `]' token. */
6367 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
6368 /* Remember that this is the `[]' construct. */
6374 /* Parse the cast-expression. */
6375 expression = cp_parser_simple_cast_expression (parser);
6377 /* A delete-expression may not appear in an integral constant
6379 if (cp_parser_non_integral_constant_expression (parser, NIC_DEL))
6380 return error_mark_node;
6382 return delete_sanity (expression, NULL_TREE, array_p, global_scope_p,
6383 tf_warning_or_error);
6386 /* Returns true if TOKEN may start a cast-expression and false
6390 cp_parser_token_starts_cast_expression (cp_token *token)
6392 switch (token->type)
6398 case CPP_CLOSE_SQUARE:
6399 case CPP_CLOSE_PAREN:
6400 case CPP_CLOSE_BRACE:
6404 case CPP_DEREF_STAR:
6412 case CPP_GREATER_EQ:
6432 /* '[' may start a primary-expression in obj-c++. */
6433 case CPP_OPEN_SQUARE:
6434 return c_dialect_objc ();
6441 /* Parse a cast-expression.
6445 ( type-id ) cast-expression
6447 ADDRESS_P is true iff the unary-expression is appearing as the
6448 operand of the `&' operator. CAST_P is true if this expression is
6449 the target of a cast.
6451 Returns a representation of the expression. */
6454 cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
6457 /* If it's a `(', then we might be looking at a cast. */
6458 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
6460 tree type = NULL_TREE;
6461 tree expr = NULL_TREE;
6462 bool compound_literal_p;
6463 const char *saved_message;
6465 /* There's no way to know yet whether or not this is a cast.
6466 For example, `(int (3))' is a unary-expression, while `(int)
6467 3' is a cast. So, we resort to parsing tentatively. */
6468 cp_parser_parse_tentatively (parser);
6469 /* Types may not be defined in a cast. */
6470 saved_message = parser->type_definition_forbidden_message;
6471 parser->type_definition_forbidden_message
6472 = G_("types may not be defined in casts");
6473 /* Consume the `('. */
6474 cp_lexer_consume_token (parser->lexer);
6475 /* A very tricky bit is that `(struct S) { 3 }' is a
6476 compound-literal (which we permit in C++ as an extension).
6477 But, that construct is not a cast-expression -- it is a
6478 postfix-expression. (The reason is that `(struct S) { 3 }.i'
6479 is legal; if the compound-literal were a cast-expression,
6480 you'd need an extra set of parentheses.) But, if we parse
6481 the type-id, and it happens to be a class-specifier, then we
6482 will commit to the parse at that point, because we cannot
6483 undo the action that is done when creating a new class. So,
6484 then we cannot back up and do a postfix-expression.
6486 Therefore, we scan ahead to the closing `)', and check to see
6487 if the token after the `)' is a `{'. If so, we are not
6488 looking at a cast-expression.
6490 Save tokens so that we can put them back. */
6491 cp_lexer_save_tokens (parser->lexer);
6492 /* Skip tokens until the next token is a closing parenthesis.
6493 If we find the closing `)', and the next token is a `{', then
6494 we are looking at a compound-literal. */
6496 = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
6497 /*consume_paren=*/true)
6498 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
6499 /* Roll back the tokens we skipped. */
6500 cp_lexer_rollback_tokens (parser->lexer);
6501 /* If we were looking at a compound-literal, simulate an error
6502 so that the call to cp_parser_parse_definitely below will
6504 if (compound_literal_p)
6505 cp_parser_simulate_error (parser);
6508 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
6509 parser->in_type_id_in_expr_p = true;
6510 /* Look for the type-id. */
6511 type = cp_parser_type_id (parser);
6512 /* Look for the closing `)'. */
6513 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
6514 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
6517 /* Restore the saved message. */
6518 parser->type_definition_forbidden_message = saved_message;
6520 /* At this point this can only be either a cast or a
6521 parenthesized ctor such as `(T ())' that looks like a cast to
6522 function returning T. */
6523 if (!cp_parser_error_occurred (parser)
6524 && cp_parser_token_starts_cast_expression (cp_lexer_peek_token
6527 cp_parser_parse_definitely (parser);
6528 expr = cp_parser_cast_expression (parser,
6529 /*address_p=*/false,
6530 /*cast_p=*/true, pidk);
6532 /* Warn about old-style casts, if so requested. */
6533 if (warn_old_style_cast
6534 && !in_system_header
6535 && !VOID_TYPE_P (type)
6536 && current_lang_name != lang_name_c)
6537 warning (OPT_Wold_style_cast, "use of old-style cast");
6539 /* Only type conversions to integral or enumeration types
6540 can be used in constant-expressions. */
6541 if (!cast_valid_in_integral_constant_expression_p (type)
6542 && cp_parser_non_integral_constant_expression (parser,
6544 return error_mark_node;
6546 /* Perform the cast. */
6547 expr = build_c_cast (input_location, type, expr);
6551 cp_parser_abort_tentative_parse (parser);
6554 /* If we get here, then it's not a cast, so it must be a
6555 unary-expression. */
6556 return cp_parser_unary_expression (parser, address_p, cast_p, pidk);
6559 /* Parse a binary expression of the general form:
6563 pm-expression .* cast-expression
6564 pm-expression ->* cast-expression
6566 multiplicative-expression:
6568 multiplicative-expression * pm-expression
6569 multiplicative-expression / pm-expression
6570 multiplicative-expression % pm-expression
6572 additive-expression:
6573 multiplicative-expression
6574 additive-expression + multiplicative-expression
6575 additive-expression - multiplicative-expression
6579 shift-expression << additive-expression
6580 shift-expression >> additive-expression
6582 relational-expression:
6584 relational-expression < shift-expression
6585 relational-expression > shift-expression
6586 relational-expression <= shift-expression
6587 relational-expression >= shift-expression
6591 relational-expression:
6592 relational-expression <? shift-expression
6593 relational-expression >? shift-expression
6595 equality-expression:
6596 relational-expression
6597 equality-expression == relational-expression
6598 equality-expression != relational-expression
6602 and-expression & equality-expression
6604 exclusive-or-expression:
6606 exclusive-or-expression ^ and-expression
6608 inclusive-or-expression:
6609 exclusive-or-expression
6610 inclusive-or-expression | exclusive-or-expression
6612 logical-and-expression:
6613 inclusive-or-expression
6614 logical-and-expression && inclusive-or-expression
6616 logical-or-expression:
6617 logical-and-expression
6618 logical-or-expression || logical-and-expression
6620 All these are implemented with a single function like:
6623 simple-cast-expression
6624 binary-expression <token> binary-expression
6626 CAST_P is true if this expression is the target of a cast.
6628 The binops_by_token map is used to get the tree codes for each <token> type.
6629 binary-expressions are associated according to a precedence table. */
6631 #define TOKEN_PRECEDENCE(token) \
6632 (((token->type == CPP_GREATER \
6633 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
6634 && !parser->greater_than_is_operator_p) \
6635 ? PREC_NOT_OPERATOR \
6636 : binops_by_token[token->type].prec)
6639 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
6640 bool no_toplevel_fold_p,
6641 enum cp_parser_prec prec,
6644 cp_parser_expression_stack stack;
6645 cp_parser_expression_stack_entry *sp = &stack[0];
6648 enum tree_code tree_type, lhs_type, rhs_type;
6649 enum cp_parser_prec new_prec, lookahead_prec;
6652 /* Parse the first expression. */
6653 lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p, pidk);
6654 lhs_type = ERROR_MARK;
6658 /* Get an operator token. */
6659 token = cp_lexer_peek_token (parser->lexer);
6661 if (warn_cxx0x_compat
6662 && token->type == CPP_RSHIFT
6663 && !parser->greater_than_is_operator_p)
6665 if (warning_at (token->location, OPT_Wc__0x_compat,
6666 "%<>>%> operator will be treated as"
6667 " two right angle brackets in C++0x"))
6668 inform (token->location,
6669 "suggest parentheses around %<>>%> expression");
6672 new_prec = TOKEN_PRECEDENCE (token);
6674 /* Popping an entry off the stack means we completed a subexpression:
6675 - either we found a token which is not an operator (`>' where it is not
6676 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
6677 will happen repeatedly;
6678 - or, we found an operator which has lower priority. This is the case
6679 where the recursive descent *ascends*, as in `3 * 4 + 5' after
6681 if (new_prec <= prec)
6690 tree_type = binops_by_token[token->type].tree_type;
6692 /* We used the operator token. */
6693 cp_lexer_consume_token (parser->lexer);
6695 /* For "false && x" or "true || x", x will never be executed;
6696 disable warnings while evaluating it. */
6697 if (tree_type == TRUTH_ANDIF_EXPR)
6698 c_inhibit_evaluation_warnings += lhs == truthvalue_false_node;
6699 else if (tree_type == TRUTH_ORIF_EXPR)
6700 c_inhibit_evaluation_warnings += lhs == truthvalue_true_node;
6702 /* Extract another operand. It may be the RHS of this expression
6703 or the LHS of a new, higher priority expression. */
6704 rhs = cp_parser_simple_cast_expression (parser);
6705 rhs_type = ERROR_MARK;
6707 /* Get another operator token. Look up its precedence to avoid
6708 building a useless (immediately popped) stack entry for common
6709 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
6710 token = cp_lexer_peek_token (parser->lexer);
6711 lookahead_prec = TOKEN_PRECEDENCE (token);
6712 if (lookahead_prec > new_prec)
6714 /* ... and prepare to parse the RHS of the new, higher priority
6715 expression. Since precedence levels on the stack are
6716 monotonically increasing, we do not have to care about
6719 sp->tree_type = tree_type;
6721 sp->lhs_type = lhs_type;
6724 lhs_type = rhs_type;
6726 new_prec = lookahead_prec;
6730 lookahead_prec = new_prec;
6731 /* If the stack is not empty, we have parsed into LHS the right side
6732 (`4' in the example above) of an expression we had suspended.
6733 We can use the information on the stack to recover the LHS (`3')
6734 from the stack together with the tree code (`MULT_EXPR'), and
6735 the precedence of the higher level subexpression
6736 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
6737 which will be used to actually build the additive expression. */
6740 tree_type = sp->tree_type;
6742 rhs_type = lhs_type;
6744 lhs_type = sp->lhs_type;
6747 /* Undo the disabling of warnings done above. */
6748 if (tree_type == TRUTH_ANDIF_EXPR)
6749 c_inhibit_evaluation_warnings -= lhs == truthvalue_false_node;
6750 else if (tree_type == TRUTH_ORIF_EXPR)
6751 c_inhibit_evaluation_warnings -= lhs == truthvalue_true_node;
6754 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
6755 ERROR_MARK for everything that is not a binary expression.
6756 This makes warn_about_parentheses miss some warnings that
6757 involve unary operators. For unary expressions we should
6758 pass the correct tree_code unless the unary expression was
6759 surrounded by parentheses.
6761 if (no_toplevel_fold_p
6762 && lookahead_prec <= prec
6764 && TREE_CODE_CLASS (tree_type) == tcc_comparison)
6765 lhs = build2 (tree_type, boolean_type_node, lhs, rhs);
6767 lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type,
6768 &overload, tf_warning_or_error);
6769 lhs_type = tree_type;
6771 /* If the binary operator required the use of an overloaded operator,
6772 then this expression cannot be an integral constant-expression.
6773 An overloaded operator can be used even if both operands are
6774 otherwise permissible in an integral constant-expression if at
6775 least one of the operands is of enumeration type. */
6778 && cp_parser_non_integral_constant_expression (parser,
6780 return error_mark_node;
6787 /* Parse the `? expression : assignment-expression' part of a
6788 conditional-expression. The LOGICAL_OR_EXPR is the
6789 logical-or-expression that started the conditional-expression.
6790 Returns a representation of the entire conditional-expression.
6792 This routine is used by cp_parser_assignment_expression.
6794 ? expression : assignment-expression
6798 ? : assignment-expression */
6801 cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
6804 tree assignment_expr;
6805 struct cp_token *token;
6807 /* Consume the `?' token. */
6808 cp_lexer_consume_token (parser->lexer);
6809 token = cp_lexer_peek_token (parser->lexer);
6810 if (cp_parser_allow_gnu_extensions_p (parser)
6811 && token->type == CPP_COLON)
6813 pedwarn (token->location, OPT_pedantic,
6814 "ISO C++ does not allow ?: with omitted middle operand");
6815 /* Implicit true clause. */
6817 c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_true_node;
6818 warn_for_omitted_condop (token->location, logical_or_expr);
6822 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
6823 parser->colon_corrects_to_scope_p = false;
6824 /* Parse the expression. */
6825 c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_false_node;
6826 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
6827 c_inhibit_evaluation_warnings +=
6828 ((logical_or_expr == truthvalue_true_node)
6829 - (logical_or_expr == truthvalue_false_node));
6830 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
6833 /* The next token should be a `:'. */
6834 cp_parser_require (parser, CPP_COLON, RT_COLON);
6835 /* Parse the assignment-expression. */
6836 assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
6837 c_inhibit_evaluation_warnings -= logical_or_expr == truthvalue_true_node;
6839 /* Build the conditional-expression. */
6840 return build_x_conditional_expr (logical_or_expr,
6843 tf_warning_or_error);
6846 /* Parse an assignment-expression.
6848 assignment-expression:
6849 conditional-expression
6850 logical-or-expression assignment-operator assignment_expression
6853 CAST_P is true if this expression is the target of a cast.
6855 Returns a representation for the expression. */
6858 cp_parser_assignment_expression (cp_parser* parser, bool cast_p,
6863 /* If the next token is the `throw' keyword, then we're looking at
6864 a throw-expression. */
6865 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
6866 expr = cp_parser_throw_expression (parser);
6867 /* Otherwise, it must be that we are looking at a
6868 logical-or-expression. */
6871 /* Parse the binary expressions (logical-or-expression). */
6872 expr = cp_parser_binary_expression (parser, cast_p, false,
6873 PREC_NOT_OPERATOR, pidk);
6874 /* If the next token is a `?' then we're actually looking at a
6875 conditional-expression. */
6876 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
6877 return cp_parser_question_colon_clause (parser, expr);
6880 enum tree_code assignment_operator;
6882 /* If it's an assignment-operator, we're using the second
6885 = cp_parser_assignment_operator_opt (parser);
6886 if (assignment_operator != ERROR_MARK)
6888 bool non_constant_p;
6890 /* Parse the right-hand side of the assignment. */
6891 tree rhs = cp_parser_initializer_clause (parser, &non_constant_p);
6893 if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
6894 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6896 /* An assignment may not appear in a
6897 constant-expression. */
6898 if (cp_parser_non_integral_constant_expression (parser,
6900 return error_mark_node;
6901 /* Build the assignment expression. */
6902 expr = build_x_modify_expr (expr,
6903 assignment_operator,
6905 tf_warning_or_error);
6913 /* Parse an (optional) assignment-operator.
6915 assignment-operator: one of
6916 = *= /= %= += -= >>= <<= &= ^= |=
6920 assignment-operator: one of
6923 If the next token is an assignment operator, the corresponding tree
6924 code is returned, and the token is consumed. For example, for
6925 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
6926 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
6927 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
6928 operator, ERROR_MARK is returned. */
6930 static enum tree_code
6931 cp_parser_assignment_operator_opt (cp_parser* parser)
6936 /* Peek at the next token. */
6937 token = cp_lexer_peek_token (parser->lexer);
6939 switch (token->type)
6950 op = TRUNC_DIV_EXPR;
6954 op = TRUNC_MOD_EXPR;
6986 /* Nothing else is an assignment operator. */
6990 /* If it was an assignment operator, consume it. */
6991 if (op != ERROR_MARK)
6992 cp_lexer_consume_token (parser->lexer);
6997 /* Parse an expression.
7000 assignment-expression
7001 expression , assignment-expression
7003 CAST_P is true if this expression is the target of a cast.
7005 Returns a representation of the expression. */
7008 cp_parser_expression (cp_parser* parser, bool cast_p, cp_id_kind * pidk)
7010 tree expression = NULL_TREE;
7014 tree assignment_expression;
7016 /* Parse the next assignment-expression. */
7017 assignment_expression
7018 = cp_parser_assignment_expression (parser, cast_p, pidk);
7019 /* If this is the first assignment-expression, we can just
7022 expression = assignment_expression;
7024 expression = build_x_compound_expr (expression,
7025 assignment_expression,
7026 tf_warning_or_error);
7027 /* If the next token is not a comma, then we are done with the
7029 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
7031 /* Consume the `,'. */
7032 cp_lexer_consume_token (parser->lexer);
7033 /* A comma operator cannot appear in a constant-expression. */
7034 if (cp_parser_non_integral_constant_expression (parser, NIC_COMMA))
7035 expression = error_mark_node;
7041 /* Parse a constant-expression.
7043 constant-expression:
7044 conditional-expression
7046 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
7047 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
7048 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
7049 is false, NON_CONSTANT_P should be NULL. */
7052 cp_parser_constant_expression (cp_parser* parser,
7053 bool allow_non_constant_p,
7054 bool *non_constant_p)
7056 bool saved_integral_constant_expression_p;
7057 bool saved_allow_non_integral_constant_expression_p;
7058 bool saved_non_integral_constant_expression_p;
7061 /* It might seem that we could simply parse the
7062 conditional-expression, and then check to see if it were
7063 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
7064 one that the compiler can figure out is constant, possibly after
7065 doing some simplifications or optimizations. The standard has a
7066 precise definition of constant-expression, and we must honor
7067 that, even though it is somewhat more restrictive.
7073 is not a legal declaration, because `(2, 3)' is not a
7074 constant-expression. The `,' operator is forbidden in a
7075 constant-expression. However, GCC's constant-folding machinery
7076 will fold this operation to an INTEGER_CST for `3'. */
7078 /* Save the old settings. */
7079 saved_integral_constant_expression_p = parser->integral_constant_expression_p;
7080 saved_allow_non_integral_constant_expression_p
7081 = parser->allow_non_integral_constant_expression_p;
7082 saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
7083 /* We are now parsing a constant-expression. */
7084 parser->integral_constant_expression_p = true;
7085 parser->allow_non_integral_constant_expression_p
7086 = (allow_non_constant_p || cxx_dialect >= cxx0x);
7087 parser->non_integral_constant_expression_p = false;
7088 /* Although the grammar says "conditional-expression", we parse an
7089 "assignment-expression", which also permits "throw-expression"
7090 and the use of assignment operators. In the case that
7091 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
7092 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
7093 actually essential that we look for an assignment-expression.
7094 For example, cp_parser_initializer_clauses uses this function to
7095 determine whether a particular assignment-expression is in fact
7097 expression = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
7098 /* Restore the old settings. */
7099 parser->integral_constant_expression_p
7100 = saved_integral_constant_expression_p;
7101 parser->allow_non_integral_constant_expression_p
7102 = saved_allow_non_integral_constant_expression_p;
7103 if (cxx_dialect >= cxx0x)
7105 /* Require an rvalue constant expression here; that's what our
7106 callers expect. Reference constant expressions are handled
7107 separately in e.g. cp_parser_template_argument. */
7108 bool is_const = potential_rvalue_constant_expression (expression);
7109 parser->non_integral_constant_expression_p = !is_const;
7110 if (!is_const && !allow_non_constant_p)
7111 require_potential_rvalue_constant_expression (expression);
7113 if (allow_non_constant_p)
7114 *non_constant_p = parser->non_integral_constant_expression_p;
7115 parser->non_integral_constant_expression_p
7116 = saved_non_integral_constant_expression_p;
7121 /* Parse __builtin_offsetof.
7123 offsetof-expression:
7124 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
7126 offsetof-member-designator:
7128 | offsetof-member-designator "." id-expression
7129 | offsetof-member-designator "[" expression "]"
7130 | offsetof-member-designator "->" id-expression */
7133 cp_parser_builtin_offsetof (cp_parser *parser)
7135 int save_ice_p, save_non_ice_p;
7140 /* We're about to accept non-integral-constant things, but will
7141 definitely yield an integral constant expression. Save and
7142 restore these values around our local parsing. */
7143 save_ice_p = parser->integral_constant_expression_p;
7144 save_non_ice_p = parser->non_integral_constant_expression_p;
7146 /* Consume the "__builtin_offsetof" token. */
7147 cp_lexer_consume_token (parser->lexer);
7148 /* Consume the opening `('. */
7149 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
7150 /* Parse the type-id. */
7151 type = cp_parser_type_id (parser);
7152 /* Look for the `,'. */
7153 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7154 token = cp_lexer_peek_token (parser->lexer);
7156 /* Build the (type *)null that begins the traditional offsetof macro. */
7157 expr = build_static_cast (build_pointer_type (type), null_pointer_node,
7158 tf_warning_or_error);
7160 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
7161 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
7162 true, &dummy, token->location);
7165 token = cp_lexer_peek_token (parser->lexer);
7166 switch (token->type)
7168 case CPP_OPEN_SQUARE:
7169 /* offsetof-member-designator "[" expression "]" */
7170 expr = cp_parser_postfix_open_square_expression (parser, expr, true);
7174 /* offsetof-member-designator "->" identifier */
7175 expr = grok_array_decl (expr, integer_zero_node);
7179 /* offsetof-member-designator "." identifier */
7180 cp_lexer_consume_token (parser->lexer);
7181 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT,
7186 case CPP_CLOSE_PAREN:
7187 /* Consume the ")" token. */
7188 cp_lexer_consume_token (parser->lexer);
7192 /* Error. We know the following require will fail, but
7193 that gives the proper error message. */
7194 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7195 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
7196 expr = error_mark_node;
7202 /* If we're processing a template, we can't finish the semantics yet.
7203 Otherwise we can fold the entire expression now. */
7204 if (processing_template_decl)
7205 expr = build1 (OFFSETOF_EXPR, size_type_node, expr);
7207 expr = finish_offsetof (expr);
7210 parser->integral_constant_expression_p = save_ice_p;
7211 parser->non_integral_constant_expression_p = save_non_ice_p;
7216 /* Parse a trait expression.
7218 Returns a representation of the expression, the underlying type
7219 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
7222 cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
7225 tree type1, type2 = NULL_TREE;
7226 bool binary = false;
7227 cp_decl_specifier_seq decl_specs;
7231 case RID_HAS_NOTHROW_ASSIGN:
7232 kind = CPTK_HAS_NOTHROW_ASSIGN;
7234 case RID_HAS_NOTHROW_CONSTRUCTOR:
7235 kind = CPTK_HAS_NOTHROW_CONSTRUCTOR;
7237 case RID_HAS_NOTHROW_COPY:
7238 kind = CPTK_HAS_NOTHROW_COPY;
7240 case RID_HAS_TRIVIAL_ASSIGN:
7241 kind = CPTK_HAS_TRIVIAL_ASSIGN;
7243 case RID_HAS_TRIVIAL_CONSTRUCTOR:
7244 kind = CPTK_HAS_TRIVIAL_CONSTRUCTOR;
7246 case RID_HAS_TRIVIAL_COPY:
7247 kind = CPTK_HAS_TRIVIAL_COPY;
7249 case RID_HAS_TRIVIAL_DESTRUCTOR:
7250 kind = CPTK_HAS_TRIVIAL_DESTRUCTOR;
7252 case RID_HAS_VIRTUAL_DESTRUCTOR:
7253 kind = CPTK_HAS_VIRTUAL_DESTRUCTOR;
7255 case RID_IS_ABSTRACT:
7256 kind = CPTK_IS_ABSTRACT;
7258 case RID_IS_BASE_OF:
7259 kind = CPTK_IS_BASE_OF;
7263 kind = CPTK_IS_CLASS;
7265 case RID_IS_CONVERTIBLE_TO:
7266 kind = CPTK_IS_CONVERTIBLE_TO;
7270 kind = CPTK_IS_EMPTY;
7273 kind = CPTK_IS_ENUM;
7275 case RID_IS_LITERAL_TYPE:
7276 kind = CPTK_IS_LITERAL_TYPE;
7281 case RID_IS_POLYMORPHIC:
7282 kind = CPTK_IS_POLYMORPHIC;
7284 case RID_IS_STD_LAYOUT:
7285 kind = CPTK_IS_STD_LAYOUT;
7287 case RID_IS_TRIVIAL:
7288 kind = CPTK_IS_TRIVIAL;
7291 kind = CPTK_IS_UNION;
7293 case RID_UNDERLYING_TYPE:
7294 kind = CPTK_UNDERLYING_TYPE;
7300 /* Consume the token. */
7301 cp_lexer_consume_token (parser->lexer);
7303 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
7305 type1 = cp_parser_type_id (parser);
7307 if (type1 == error_mark_node)
7308 return error_mark_node;
7310 /* Build a trivial decl-specifier-seq. */
7311 clear_decl_specs (&decl_specs);
7312 decl_specs.type = type1;
7314 /* Call grokdeclarator to figure out what type this is. */
7315 type1 = grokdeclarator (NULL, &decl_specs, TYPENAME,
7316 /*initialized=*/0, /*attrlist=*/NULL);
7320 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7322 type2 = cp_parser_type_id (parser);
7324 if (type2 == error_mark_node)
7325 return error_mark_node;
7327 /* Build a trivial decl-specifier-seq. */
7328 clear_decl_specs (&decl_specs);
7329 decl_specs.type = type2;
7331 /* Call grokdeclarator to figure out what type this is. */
7332 type2 = grokdeclarator (NULL, &decl_specs, TYPENAME,
7333 /*initialized=*/0, /*attrlist=*/NULL);
7336 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7338 /* Complete the trait expression, which may mean either processing
7339 the trait expr now or saving it for template instantiation. */
7340 return kind != CPTK_UNDERLYING_TYPE
7341 ? finish_trait_expr (kind, type1, type2)
7342 : finish_underlying_type (type1);
7345 /* Lambdas that appear in variable initializer or default argument scope
7346 get that in their mangling, so we need to record it. We might as well
7347 use the count for function and namespace scopes as well. */
7348 static GTY(()) tree lambda_scope;
7349 static GTY(()) int lambda_count;
7350 typedef struct GTY(()) tree_int
7355 DEF_VEC_O(tree_int);
7356 DEF_VEC_ALLOC_O(tree_int,gc);
7357 static GTY(()) VEC(tree_int,gc) *lambda_scope_stack;
7360 start_lambda_scope (tree decl)
7364 /* Once we're inside a function, we ignore other scopes and just push
7365 the function again so that popping works properly. */
7366 if (current_function_decl && TREE_CODE (decl) != FUNCTION_DECL)
7367 decl = current_function_decl;
7368 ti.t = lambda_scope;
7369 ti.i = lambda_count;
7370 VEC_safe_push (tree_int, gc, lambda_scope_stack, &ti);
7371 if (lambda_scope != decl)
7373 /* Don't reset the count if we're still in the same function. */
7374 lambda_scope = decl;
7380 record_lambda_scope (tree lambda)
7382 LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope;
7383 LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++;
7387 finish_lambda_scope (void)
7389 tree_int *p = VEC_last (tree_int, lambda_scope_stack);
7390 if (lambda_scope != p->t)
7392 lambda_scope = p->t;
7393 lambda_count = p->i;
7395 VEC_pop (tree_int, lambda_scope_stack);
7398 /* Parse a lambda expression.
7401 lambda-introducer lambda-declarator [opt] compound-statement
7403 Returns a representation of the expression. */
7406 cp_parser_lambda_expression (cp_parser* parser)
7408 tree lambda_expr = build_lambda_expr ();
7412 LAMBDA_EXPR_LOCATION (lambda_expr)
7413 = cp_lexer_peek_token (parser->lexer)->location;
7415 if (cp_unevaluated_operand)
7416 error_at (LAMBDA_EXPR_LOCATION (lambda_expr),
7417 "lambda-expression in unevaluated context");
7419 /* We may be in the middle of deferred access check. Disable
7421 push_deferring_access_checks (dk_no_deferred);
7423 cp_parser_lambda_introducer (parser, lambda_expr);
7425 type = begin_lambda_type (lambda_expr);
7427 record_lambda_scope (lambda_expr);
7429 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
7430 determine_visibility (TYPE_NAME (type));
7432 /* Now that we've started the type, add the capture fields for any
7433 explicit captures. */
7434 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr));
7437 /* Inside the class, surrounding template-parameter-lists do not apply. */
7438 unsigned int saved_num_template_parameter_lists
7439 = parser->num_template_parameter_lists;
7440 unsigned char in_statement = parser->in_statement;
7441 bool in_switch_statement_p = parser->in_switch_statement_p;
7443 parser->num_template_parameter_lists = 0;
7444 parser->in_statement = 0;
7445 parser->in_switch_statement_p = false;
7447 /* By virtue of defining a local class, a lambda expression has access to
7448 the private variables of enclosing classes. */
7450 ok = cp_parser_lambda_declarator_opt (parser, lambda_expr);
7453 cp_parser_lambda_body (parser, lambda_expr);
7454 else if (cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
7455 cp_parser_skip_to_end_of_block_or_statement (parser);
7457 /* The capture list was built up in reverse order; fix that now. */
7459 tree newlist = NULL_TREE;
7462 for (elt = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr);
7465 next = TREE_CHAIN (elt);
7466 TREE_CHAIN (elt) = newlist;
7469 LAMBDA_EXPR_CAPTURE_LIST (lambda_expr) = newlist;
7473 maybe_add_lambda_conv_op (type);
7475 type = finish_struct (type, /*attributes=*/NULL_TREE);
7477 parser->num_template_parameter_lists = saved_num_template_parameter_lists;
7478 parser->in_statement = in_statement;
7479 parser->in_switch_statement_p = in_switch_statement_p;
7482 pop_deferring_access_checks ();
7484 /* This field is only used during parsing of the lambda. */
7485 LAMBDA_EXPR_THIS_CAPTURE (lambda_expr) = NULL_TREE;
7487 /* This lambda shouldn't have any proxies left at this point. */
7488 gcc_assert (LAMBDA_EXPR_PENDING_PROXIES (lambda_expr) == NULL);
7489 /* And now that we're done, push proxies for an enclosing lambda. */
7490 insert_pending_capture_proxies ();
7493 return build_lambda_object (lambda_expr);
7495 return error_mark_node;
7498 /* Parse the beginning of a lambda expression.
7501 [ lambda-capture [opt] ]
7503 LAMBDA_EXPR is the current representation of the lambda expression. */
7506 cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
7508 /* Need commas after the first capture. */
7511 /* Eat the leading `['. */
7512 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
7514 /* Record default capture mode. "[&" "[=" "[&," "[=," */
7515 if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
7516 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_NAME)
7517 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_REFERENCE;
7518 else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
7519 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_COPY;
7521 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE)
7523 cp_lexer_consume_token (parser->lexer);
7527 while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
7529 cp_token* capture_token;
7531 tree capture_init_expr;
7532 cp_id_kind idk = CP_ID_KIND_NONE;
7533 bool explicit_init_p = false;
7535 enum capture_kind_type
7540 enum capture_kind_type capture_kind = BY_COPY;
7542 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
7544 error ("expected end of capture-list");
7551 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7553 /* Possibly capture `this'. */
7554 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THIS))
7556 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
7557 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_COPY)
7558 pedwarn (loc, 0, "explicit by-copy capture of %<this%> redundant "
7559 "with by-copy capture default");
7560 cp_lexer_consume_token (parser->lexer);
7561 add_capture (lambda_expr,
7562 /*id=*/this_identifier,
7563 /*initializer=*/finish_this_expr(),
7564 /*by_reference_p=*/false,
7569 /* Remember whether we want to capture as a reference or not. */
7570 if (cp_lexer_next_token_is (parser->lexer, CPP_AND))
7572 capture_kind = BY_REFERENCE;
7573 cp_lexer_consume_token (parser->lexer);
7576 /* Get the identifier. */
7577 capture_token = cp_lexer_peek_token (parser->lexer);
7578 capture_id = cp_parser_identifier (parser);
7580 if (capture_id == error_mark_node)
7581 /* Would be nice to have a cp_parser_skip_to_closing_x for general
7582 delimiters, but I modified this to stop on unnested ']' as well. It
7583 was already changed to stop on unnested '}', so the
7584 "closing_parenthesis" name is no more misleading with my change. */
7586 cp_parser_skip_to_closing_parenthesis (parser,
7587 /*recovering=*/true,
7589 /*consume_paren=*/true);
7593 /* Find the initializer for this capture. */
7594 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
7596 /* An explicit expression exists. */
7597 cp_lexer_consume_token (parser->lexer);
7598 pedwarn (input_location, OPT_pedantic,
7599 "ISO C++ does not allow initializers "
7600 "in lambda expression capture lists");
7601 capture_init_expr = cp_parser_assignment_expression (parser,
7604 explicit_init_p = true;
7608 const char* error_msg;
7610 /* Turn the identifier into an id-expression. */
7612 = cp_parser_lookup_name
7616 /*is_template=*/false,
7617 /*is_namespace=*/false,
7618 /*check_dependency=*/true,
7619 /*ambiguous_decls=*/NULL,
7620 capture_token->location);
7623 = finish_id_expression
7628 /*integral_constant_expression_p=*/false,
7629 /*allow_non_integral_constant_expression_p=*/false,
7630 /*non_integral_constant_expression_p=*/NULL,
7631 /*template_p=*/false,
7633 /*address_p=*/false,
7634 /*template_arg_p=*/false,
7636 capture_token->location);
7639 if (TREE_CODE (capture_init_expr) == IDENTIFIER_NODE)
7641 = unqualified_name_lookup_error (capture_init_expr);
7643 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE
7644 && !explicit_init_p)
7646 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_COPY
7647 && capture_kind == BY_COPY)
7648 pedwarn (capture_token->location, 0, "explicit by-copy capture "
7649 "of %qD redundant with by-copy capture default",
7651 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_REFERENCE
7652 && capture_kind == BY_REFERENCE)
7653 pedwarn (capture_token->location, 0, "explicit by-reference "
7654 "capture of %qD redundant with by-reference capture "
7655 "default", capture_id);
7658 add_capture (lambda_expr,
7661 /*by_reference_p=*/capture_kind == BY_REFERENCE,
7665 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
7668 /* Parse the (optional) middle of a lambda expression.
7671 ( parameter-declaration-clause [opt] )
7672 attribute-specifier [opt]
7674 exception-specification [opt]
7675 lambda-return-type-clause [opt]
7677 LAMBDA_EXPR is the current representation of the lambda expression. */
7680 cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr)
7682 /* 5.1.1.4 of the standard says:
7683 If a lambda-expression does not include a lambda-declarator, it is as if
7684 the lambda-declarator were ().
7685 This means an empty parameter list, no attributes, and no exception
7687 tree param_list = void_list_node;
7688 tree attributes = NULL_TREE;
7689 tree exception_spec = NULL_TREE;
7692 /* The lambda-declarator is optional, but must begin with an opening
7693 parenthesis if present. */
7694 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
7696 cp_lexer_consume_token (parser->lexer);
7698 begin_scope (sk_function_parms, /*entity=*/NULL_TREE);
7700 /* Parse parameters. */
7701 param_list = cp_parser_parameter_declaration_clause (parser);
7703 /* Default arguments shall not be specified in the
7704 parameter-declaration-clause of a lambda-declarator. */
7705 for (t = param_list; t; t = TREE_CHAIN (t))
7706 if (TREE_PURPOSE (t))
7707 pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t)), OPT_pedantic,
7708 "default argument specified for lambda parameter");
7710 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7712 attributes = cp_parser_attributes_opt (parser);
7714 /* Parse optional `mutable' keyword. */
7715 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_MUTABLE))
7717 cp_lexer_consume_token (parser->lexer);
7718 LAMBDA_EXPR_MUTABLE_P (lambda_expr) = 1;
7721 /* Parse optional exception specification. */
7722 exception_spec = cp_parser_exception_specification_opt (parser);
7724 /* Parse optional trailing return type. */
7725 if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
7727 cp_lexer_consume_token (parser->lexer);
7728 LAMBDA_EXPR_RETURN_TYPE (lambda_expr) = cp_parser_type_id (parser);
7731 /* The function parameters must be in scope all the way until after the
7732 trailing-return-type in case of decltype. */
7733 for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
7734 pop_binding (DECL_NAME (t), t);
7739 /* Create the function call operator.
7741 Messing with declarators like this is no uglier than building up the
7742 FUNCTION_DECL by hand, and this is less likely to get out of sync with
7745 cp_decl_specifier_seq return_type_specs;
7746 cp_declarator* declarator;
7751 clear_decl_specs (&return_type_specs);
7752 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
7753 return_type_specs.type = LAMBDA_EXPR_RETURN_TYPE (lambda_expr);
7755 /* Maybe we will deduce the return type later, but we can use void
7756 as a placeholder return type anyways. */
7757 return_type_specs.type = void_type_node;
7759 p = obstack_alloc (&declarator_obstack, 0);
7761 declarator = make_id_declarator (NULL_TREE, ansi_opname (CALL_EXPR),
7764 quals = (LAMBDA_EXPR_MUTABLE_P (lambda_expr)
7765 ? TYPE_UNQUALIFIED : TYPE_QUAL_CONST);
7766 declarator = make_call_declarator (declarator, param_list, quals,
7767 VIRT_SPEC_UNSPECIFIED,
7769 /*late_return_type=*/NULL_TREE);
7770 declarator->id_loc = LAMBDA_EXPR_LOCATION (lambda_expr);
7772 fco = grokmethod (&return_type_specs,
7775 if (fco != error_mark_node)
7777 DECL_INITIALIZED_IN_CLASS_P (fco) = 1;
7778 DECL_ARTIFICIAL (fco) = 1;
7779 /* Give the object parameter a different name. */
7780 DECL_NAME (DECL_ARGUMENTS (fco)) = get_identifier ("__closure");
7783 finish_member_declaration (fco);
7785 obstack_free (&declarator_obstack, p);
7787 return (fco != error_mark_node);
7791 /* Parse the body of a lambda expression, which is simply
7795 but which requires special handling.
7796 LAMBDA_EXPR is the current representation of the lambda expression. */
7799 cp_parser_lambda_body (cp_parser* parser, tree lambda_expr)
7801 bool nested = (current_function_decl != NULL_TREE);
7803 push_function_context ();
7805 /* Still increment function_depth so that we don't GC in the
7806 middle of an expression. */
7809 /* Finish the function call operator
7811 + late_parsing_for_member
7812 + function_definition_after_declarator
7813 + ctor_initializer_opt_and_function_body */
7815 tree fco = lambda_function (lambda_expr);
7821 /* Let the front end know that we are going to be defining this
7823 start_preparsed_function (fco,
7825 SF_PRE_PARSED | SF_INCLASS_INLINE);
7827 start_lambda_scope (fco);
7828 body = begin_function_body ();
7830 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
7833 /* Push the proxies for any explicit captures. */
7834 for (cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
7835 cap = TREE_CHAIN (cap))
7836 build_capture_proxy (TREE_PURPOSE (cap));
7838 compound_stmt = begin_compound_stmt (0);
7840 /* 5.1.1.4 of the standard says:
7841 If a lambda-expression does not include a trailing-return-type, it
7842 is as if the trailing-return-type denotes the following type:
7843 * if the compound-statement is of the form
7844 { return attribute-specifier [opt] expression ; }
7845 the type of the returned expression after lvalue-to-rvalue
7846 conversion (_conv.lval_ 4.1), array-to-pointer conversion
7847 (_conv.array_ 4.2), and function-to-pointer conversion
7849 * otherwise, void. */
7851 /* In a lambda that has neither a lambda-return-type-clause
7852 nor a deducible form, errors should be reported for return statements
7853 in the body. Since we used void as the placeholder return type, parsing
7854 the body as usual will give such desired behavior. */
7855 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr)
7856 && cp_lexer_peek_nth_token (parser->lexer, 1)->keyword == RID_RETURN
7857 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SEMICOLON)
7859 tree expr = NULL_TREE;
7860 cp_id_kind idk = CP_ID_KIND_NONE;
7862 /* Parse tentatively in case there's more after the initial return
7864 cp_parser_parse_tentatively (parser);
7866 cp_parser_require_keyword (parser, RID_RETURN, RT_RETURN);
7868 expr = cp_parser_expression (parser, /*cast_p=*/false, &idk);
7870 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
7871 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
7873 if (cp_parser_parse_definitely (parser))
7875 apply_lambda_return_type (lambda_expr, lambda_return_type (expr));
7877 /* Will get error here if type not deduced yet. */
7878 finish_return_stmt (expr);
7886 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
7887 LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda_expr) = true;
7888 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
7889 cp_parser_label_declaration (parser);
7890 cp_parser_statement_seq_opt (parser, NULL_TREE);
7891 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
7892 LAMBDA_EXPR_DEDUCE_RETURN_TYPE_P (lambda_expr) = false;
7895 finish_compound_stmt (compound_stmt);
7898 finish_function_body (body);
7899 finish_lambda_scope ();
7901 /* Finish the function and generate code for it if necessary. */
7902 expand_or_defer_fn (finish_function (/*inline*/2));
7906 pop_function_context();
7911 /* Statements [gram.stmt.stmt] */
7913 /* Parse a statement.
7917 expression-statement
7922 declaration-statement
7925 IN_COMPOUND is true when the statement is nested inside a
7926 cp_parser_compound_statement; this matters for certain pragmas.
7928 If IF_P is not NULL, *IF_P is set to indicate whether the statement
7929 is a (possibly labeled) if statement which is not enclosed in braces
7930 and has an else clause. This is used to implement -Wparentheses. */
7933 cp_parser_statement (cp_parser* parser, tree in_statement_expr,
7934 bool in_compound, bool *if_p)
7938 location_t statement_location;
7943 /* There is no statement yet. */
7944 statement = NULL_TREE;
7945 /* Peek at the next token. */
7946 token = cp_lexer_peek_token (parser->lexer);
7947 /* Remember the location of the first token in the statement. */
7948 statement_location = token->location;
7949 /* If this is a keyword, then that will often determine what kind of
7950 statement we have. */
7951 if (token->type == CPP_KEYWORD)
7953 enum rid keyword = token->keyword;
7959 /* Looks like a labeled-statement with a case label.
7960 Parse the label, and then use tail recursion to parse
7962 cp_parser_label_for_labeled_statement (parser);
7967 statement = cp_parser_selection_statement (parser, if_p);
7973 statement = cp_parser_iteration_statement (parser);
7980 statement = cp_parser_jump_statement (parser);
7983 /* Objective-C++ exception-handling constructs. */
7986 case RID_AT_FINALLY:
7987 case RID_AT_SYNCHRONIZED:
7989 statement = cp_parser_objc_statement (parser);
7993 statement = cp_parser_try_block (parser);
7997 /* This must be a namespace alias definition. */
7998 cp_parser_declaration_statement (parser);
8002 /* It might be a keyword like `int' that can start a
8003 declaration-statement. */
8007 else if (token->type == CPP_NAME)
8009 /* If the next token is a `:', then we are looking at a
8010 labeled-statement. */
8011 token = cp_lexer_peek_nth_token (parser->lexer, 2);
8012 if (token->type == CPP_COLON)
8014 /* Looks like a labeled-statement with an ordinary label.
8015 Parse the label, and then use tail recursion to parse
8017 cp_parser_label_for_labeled_statement (parser);
8021 /* Anything that starts with a `{' must be a compound-statement. */
8022 else if (token->type == CPP_OPEN_BRACE)
8023 statement = cp_parser_compound_statement (parser, NULL, false, false);
8024 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
8025 a statement all its own. */
8026 else if (token->type == CPP_PRAGMA)
8028 /* Only certain OpenMP pragmas are attached to statements, and thus
8029 are considered statements themselves. All others are not. In
8030 the context of a compound, accept the pragma as a "statement" and
8031 return so that we can check for a close brace. Otherwise we
8032 require a real statement and must go back and read one. */
8034 cp_parser_pragma (parser, pragma_compound);
8035 else if (!cp_parser_pragma (parser, pragma_stmt))
8039 else if (token->type == CPP_EOF)
8041 cp_parser_error (parser, "expected statement");
8045 /* Everything else must be a declaration-statement or an
8046 expression-statement. Try for the declaration-statement
8047 first, unless we are looking at a `;', in which case we know that
8048 we have an expression-statement. */
8051 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8053 cp_parser_parse_tentatively (parser);
8054 /* Try to parse the declaration-statement. */
8055 cp_parser_declaration_statement (parser);
8056 /* If that worked, we're done. */
8057 if (cp_parser_parse_definitely (parser))
8060 /* Look for an expression-statement instead. */
8061 statement = cp_parser_expression_statement (parser, in_statement_expr);
8064 /* Set the line number for the statement. */
8065 if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
8066 SET_EXPR_LOCATION (statement, statement_location);
8069 /* Parse the label for a labeled-statement, i.e.
8072 case constant-expression :
8076 case constant-expression ... constant-expression : statement
8078 When a label is parsed without errors, the label is added to the
8079 parse tree by the finish_* functions, so this function doesn't
8080 have to return the label. */
8083 cp_parser_label_for_labeled_statement (cp_parser* parser)
8086 tree label = NULL_TREE;
8087 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
8089 /* The next token should be an identifier. */
8090 token = cp_lexer_peek_token (parser->lexer);
8091 if (token->type != CPP_NAME
8092 && token->type != CPP_KEYWORD)
8094 cp_parser_error (parser, "expected labeled-statement");
8098 parser->colon_corrects_to_scope_p = false;
8099 switch (token->keyword)
8106 /* Consume the `case' token. */
8107 cp_lexer_consume_token (parser->lexer);
8108 /* Parse the constant-expression. */
8109 expr = cp_parser_constant_expression (parser,
8110 /*allow_non_constant_p=*/false,
8113 ellipsis = cp_lexer_peek_token (parser->lexer);
8114 if (ellipsis->type == CPP_ELLIPSIS)
8116 /* Consume the `...' token. */
8117 cp_lexer_consume_token (parser->lexer);
8119 cp_parser_constant_expression (parser,
8120 /*allow_non_constant_p=*/false,
8122 /* We don't need to emit warnings here, as the common code
8123 will do this for us. */
8126 expr_hi = NULL_TREE;
8128 if (parser->in_switch_statement_p)
8129 finish_case_label (token->location, expr, expr_hi);
8131 error_at (token->location,
8132 "case label %qE not within a switch statement",
8138 /* Consume the `default' token. */
8139 cp_lexer_consume_token (parser->lexer);
8141 if (parser->in_switch_statement_p)
8142 finish_case_label (token->location, NULL_TREE, NULL_TREE);
8144 error_at (token->location, "case label not within a switch statement");
8148 /* Anything else must be an ordinary label. */
8149 label = finish_label_stmt (cp_parser_identifier (parser));
8153 /* Require the `:' token. */
8154 cp_parser_require (parser, CPP_COLON, RT_COLON);
8156 /* An ordinary label may optionally be followed by attributes.
8157 However, this is only permitted if the attributes are then
8158 followed by a semicolon. This is because, for backward
8159 compatibility, when parsing
8160 lab: __attribute__ ((unused)) int i;
8161 we want the attribute to attach to "i", not "lab". */
8162 if (label != NULL_TREE
8163 && cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
8167 cp_parser_parse_tentatively (parser);
8168 attrs = cp_parser_attributes_opt (parser);
8169 if (attrs == NULL_TREE
8170 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8171 cp_parser_abort_tentative_parse (parser);
8172 else if (!cp_parser_parse_definitely (parser))
8175 cplus_decl_attributes (&label, attrs, 0);
8178 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
8181 /* Parse an expression-statement.
8183 expression-statement:
8186 Returns the new EXPR_STMT -- or NULL_TREE if the expression
8187 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
8188 indicates whether this expression-statement is part of an
8189 expression statement. */
8192 cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
8194 tree statement = NULL_TREE;
8195 cp_token *token = cp_lexer_peek_token (parser->lexer);
8197 /* If the next token is a ';', then there is no expression
8199 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8200 statement = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8202 /* Give a helpful message for "A<T>::type t;" and the like. */
8203 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
8204 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
8206 if (TREE_CODE (statement) == SCOPE_REF)
8207 error_at (token->location, "need %<typename%> before %qE because "
8208 "%qT is a dependent scope",
8209 statement, TREE_OPERAND (statement, 0));
8210 else if (is_overloaded_fn (statement)
8211 && DECL_CONSTRUCTOR_P (get_first_fn (statement)))
8214 tree fn = get_first_fn (statement);
8215 error_at (token->location,
8216 "%<%T::%D%> names the constructor, not the type",
8217 DECL_CONTEXT (fn), DECL_NAME (fn));
8221 /* Consume the final `;'. */
8222 cp_parser_consume_semicolon_at_end_of_statement (parser);
8224 if (in_statement_expr
8225 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
8226 /* This is the final expression statement of a statement
8228 statement = finish_stmt_expr_expr (statement, in_statement_expr);
8230 statement = finish_expr_stmt (statement);
8237 /* Parse a compound-statement.
8240 { statement-seq [opt] }
8245 { label-declaration-seq [opt] statement-seq [opt] }
8247 label-declaration-seq:
8249 label-declaration-seq label-declaration
8251 Returns a tree representing the statement. */
8254 cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
8255 bool in_try, bool function_body)
8259 /* Consume the `{'. */
8260 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
8261 return error_mark_node;
8262 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
8264 pedwarn (input_location, OPT_pedantic,
8265 "compound-statement in constexpr function");
8266 /* Begin the compound-statement. */
8267 compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
8268 /* If the next keyword is `__label__' we have a label declaration. */
8269 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
8270 cp_parser_label_declaration (parser);
8271 /* Parse an (optional) statement-seq. */
8272 cp_parser_statement_seq_opt (parser, in_statement_expr);
8273 /* Finish the compound-statement. */
8274 finish_compound_stmt (compound_stmt);
8275 /* Consume the `}'. */
8276 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
8278 return compound_stmt;
8281 /* Parse an (optional) statement-seq.
8285 statement-seq [opt] statement */
8288 cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
8290 /* Scan statements until there aren't any more. */
8293 cp_token *token = cp_lexer_peek_token (parser->lexer);
8295 /* If we are looking at a `}', then we have run out of
8296 statements; the same is true if we have reached the end
8297 of file, or have stumbled upon a stray '@end'. */
8298 if (token->type == CPP_CLOSE_BRACE
8299 || token->type == CPP_EOF
8300 || token->type == CPP_PRAGMA_EOL
8301 || (token->type == CPP_KEYWORD && token->keyword == RID_AT_END))
8304 /* If we are in a compound statement and find 'else' then
8305 something went wrong. */
8306 else if (token->type == CPP_KEYWORD && token->keyword == RID_ELSE)
8308 if (parser->in_statement & IN_IF_STMT)
8312 token = cp_lexer_consume_token (parser->lexer);
8313 error_at (token->location, "%<else%> without a previous %<if%>");
8317 /* Parse the statement. */
8318 cp_parser_statement (parser, in_statement_expr, true, NULL);
8322 /* Parse a selection-statement.
8324 selection-statement:
8325 if ( condition ) statement
8326 if ( condition ) statement else statement
8327 switch ( condition ) statement
8329 Returns the new IF_STMT or SWITCH_STMT.
8331 If IF_P is not NULL, *IF_P is set to indicate whether the statement
8332 is a (possibly labeled) if statement which is not enclosed in
8333 braces and has an else clause. This is used to implement
8337 cp_parser_selection_statement (cp_parser* parser, bool *if_p)
8345 /* Peek at the next token. */
8346 token = cp_parser_require (parser, CPP_KEYWORD, RT_SELECT);
8348 /* See what kind of keyword it is. */
8349 keyword = token->keyword;
8358 /* Look for the `('. */
8359 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
8361 cp_parser_skip_to_end_of_statement (parser);
8362 return error_mark_node;
8365 /* Begin the selection-statement. */
8366 if (keyword == RID_IF)
8367 statement = begin_if_stmt ();
8369 statement = begin_switch_stmt ();
8371 /* Parse the condition. */
8372 condition = cp_parser_condition (parser);
8373 /* Look for the `)'. */
8374 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
8375 cp_parser_skip_to_closing_parenthesis (parser, true, false,
8376 /*consume_paren=*/true);
8378 if (keyword == RID_IF)
8381 unsigned char in_statement;
8383 /* Add the condition. */
8384 finish_if_stmt_cond (condition, statement);
8386 /* Parse the then-clause. */
8387 in_statement = parser->in_statement;
8388 parser->in_statement |= IN_IF_STMT;
8389 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
8391 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8392 add_stmt (build_empty_stmt (loc));
8393 cp_lexer_consume_token (parser->lexer);
8394 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
8395 warning_at (loc, OPT_Wempty_body, "suggest braces around "
8396 "empty body in an %<if%> statement");
8400 cp_parser_implicitly_scoped_statement (parser, &nested_if);
8401 parser->in_statement = in_statement;
8403 finish_then_clause (statement);
8405 /* If the next token is `else', parse the else-clause. */
8406 if (cp_lexer_next_token_is_keyword (parser->lexer,
8409 /* Consume the `else' keyword. */
8410 cp_lexer_consume_token (parser->lexer);
8411 begin_else_clause (statement);
8412 /* Parse the else-clause. */
8413 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
8416 loc = cp_lexer_peek_token (parser->lexer)->location;
8418 OPT_Wempty_body, "suggest braces around "
8419 "empty body in an %<else%> statement");
8420 add_stmt (build_empty_stmt (loc));
8421 cp_lexer_consume_token (parser->lexer);
8424 cp_parser_implicitly_scoped_statement (parser, NULL);
8426 finish_else_clause (statement);
8428 /* If we are currently parsing a then-clause, then
8429 IF_P will not be NULL. We set it to true to
8430 indicate that this if statement has an else clause.
8431 This may trigger the Wparentheses warning below
8432 when we get back up to the parent if statement. */
8438 /* This if statement does not have an else clause. If
8439 NESTED_IF is true, then the then-clause is an if
8440 statement which does have an else clause. We warn
8441 about the potential ambiguity. */
8443 warning_at (EXPR_LOCATION (statement), OPT_Wparentheses,
8444 "suggest explicit braces to avoid ambiguous"
8448 /* Now we're all done with the if-statement. */
8449 finish_if_stmt (statement);
8453 bool in_switch_statement_p;
8454 unsigned char in_statement;
8456 /* Add the condition. */
8457 finish_switch_cond (condition, statement);
8459 /* Parse the body of the switch-statement. */
8460 in_switch_statement_p = parser->in_switch_statement_p;
8461 in_statement = parser->in_statement;
8462 parser->in_switch_statement_p = true;
8463 parser->in_statement |= IN_SWITCH_STMT;
8464 cp_parser_implicitly_scoped_statement (parser, NULL);
8465 parser->in_switch_statement_p = in_switch_statement_p;
8466 parser->in_statement = in_statement;
8468 /* Now we're all done with the switch-statement. */
8469 finish_switch_stmt (statement);
8477 cp_parser_error (parser, "expected selection-statement");
8478 return error_mark_node;
8482 /* Parse a condition.
8486 type-specifier-seq declarator = initializer-clause
8487 type-specifier-seq declarator braced-init-list
8492 type-specifier-seq declarator asm-specification [opt]
8493 attributes [opt] = assignment-expression
8495 Returns the expression that should be tested. */
8498 cp_parser_condition (cp_parser* parser)
8500 cp_decl_specifier_seq type_specifiers;
8501 const char *saved_message;
8502 int declares_class_or_enum;
8504 /* Try the declaration first. */
8505 cp_parser_parse_tentatively (parser);
8506 /* New types are not allowed in the type-specifier-seq for a
8508 saved_message = parser->type_definition_forbidden_message;
8509 parser->type_definition_forbidden_message
8510 = G_("types may not be defined in conditions");
8511 /* Parse the type-specifier-seq. */
8512 cp_parser_decl_specifier_seq (parser,
8513 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
8515 &declares_class_or_enum);
8516 /* Restore the saved message. */
8517 parser->type_definition_forbidden_message = saved_message;
8518 /* If all is well, we might be looking at a declaration. */
8519 if (!cp_parser_error_occurred (parser))
8522 tree asm_specification;
8524 cp_declarator *declarator;
8525 tree initializer = NULL_TREE;
8527 /* Parse the declarator. */
8528 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
8529 /*ctor_dtor_or_conv_p=*/NULL,
8530 /*parenthesized_p=*/NULL,
8531 /*member_p=*/false);
8532 /* Parse the attributes. */
8533 attributes = cp_parser_attributes_opt (parser);
8534 /* Parse the asm-specification. */
8535 asm_specification = cp_parser_asm_specification_opt (parser);
8536 /* If the next token is not an `=' or '{', then we might still be
8537 looking at an expression. For example:
8541 looks like a decl-specifier-seq and a declarator -- but then
8542 there is no `=', so this is an expression. */
8543 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
8544 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
8545 cp_parser_simulate_error (parser);
8547 /* If we did see an `=' or '{', then we are looking at a declaration
8549 if (cp_parser_parse_definitely (parser))
8552 bool non_constant_p;
8553 bool flags = LOOKUP_ONLYCONVERTING;
8555 /* Create the declaration. */
8556 decl = start_decl (declarator, &type_specifiers,
8557 /*initialized_p=*/true,
8558 attributes, /*prefix_attributes=*/NULL_TREE,
8561 /* Parse the initializer. */
8562 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8564 initializer = cp_parser_braced_list (parser, &non_constant_p);
8565 CONSTRUCTOR_IS_DIRECT_INIT (initializer) = 1;
8570 /* Consume the `='. */
8571 cp_parser_require (parser, CPP_EQ, RT_EQ);
8572 initializer = cp_parser_initializer_clause (parser, &non_constant_p);
8574 if (BRACE_ENCLOSED_INITIALIZER_P (initializer))
8575 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
8577 /* Process the initializer. */
8578 cp_finish_decl (decl,
8579 initializer, !non_constant_p,
8584 pop_scope (pushed_scope);
8586 return convert_from_reference (decl);
8589 /* If we didn't even get past the declarator successfully, we are
8590 definitely not looking at a declaration. */
8592 cp_parser_abort_tentative_parse (parser);
8594 /* Otherwise, we are looking at an expression. */
8595 return cp_parser_expression (parser, /*cast_p=*/false, NULL);
8598 /* Parses a for-statement or range-for-statement until the closing ')',
8602 cp_parser_for (cp_parser *parser)
8604 tree init, scope, decl;
8607 /* Begin the for-statement. */
8608 scope = begin_for_scope (&init);
8610 /* Parse the initialization. */
8611 is_range_for = cp_parser_for_init_statement (parser, &decl);
8614 return cp_parser_range_for (parser, scope, init, decl);
8616 return cp_parser_c_for (parser, scope, init);
8620 cp_parser_c_for (cp_parser *parser, tree scope, tree init)
8622 /* Normal for loop */
8623 tree condition = NULL_TREE;
8624 tree expression = NULL_TREE;
8627 stmt = begin_for_stmt (scope, init);
8628 /* The for-init-statement has already been parsed in
8629 cp_parser_for_init_statement, so no work is needed here. */
8630 finish_for_init_stmt (stmt);
8632 /* If there's a condition, process it. */
8633 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
8634 condition = cp_parser_condition (parser);
8635 finish_for_cond (condition, stmt);
8636 /* Look for the `;'. */
8637 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
8639 /* If there's an expression, process it. */
8640 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
8641 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8642 finish_for_expr (expression, stmt);
8647 /* Tries to parse a range-based for-statement:
8650 decl-specifier-seq declarator : expression
8652 The decl-specifier-seq declarator and the `:' are already parsed by
8653 cp_parser_for_init_statement. If processing_template_decl it returns a
8654 newly created RANGE_FOR_STMT; if not, it is converted to a
8655 regular FOR_STMT. */
8658 cp_parser_range_for (cp_parser *parser, tree scope, tree init, tree range_decl)
8660 tree stmt, range_expr;
8662 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
8664 bool expr_non_constant_p;
8665 range_expr = cp_parser_braced_list (parser, &expr_non_constant_p);
8668 range_expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8670 /* If in template, STMT is converted to a normal for-statement
8671 at instantiation. If not, it is done just ahead. */
8672 if (processing_template_decl)
8674 stmt = begin_range_for_stmt (scope, init);
8675 finish_range_for_decl (stmt, range_decl, range_expr);
8679 stmt = begin_for_stmt (scope, init);
8680 stmt = cp_convert_range_for (stmt, range_decl, range_expr);
8685 /* Converts a range-based for-statement into a normal
8686 for-statement, as per the definition.
8688 for (RANGE_DECL : RANGE_EXPR)
8691 should be equivalent to:
8694 auto &&__range = RANGE_EXPR;
8695 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
8699 RANGE_DECL = *__begin;
8704 If RANGE_EXPR is an array:
8705 BEGIN_EXPR = __range
8706 END_EXPR = __range + ARRAY_SIZE(__range)
8707 Else if RANGE_EXPR has a member 'begin' or 'end':
8708 BEGIN_EXPR = __range.begin()
8709 END_EXPR = __range.end()
8711 BEGIN_EXPR = begin(__range)
8712 END_EXPR = end(__range);
8714 If __range has a member 'begin' but not 'end', or vice versa, we must
8715 still use the second alternative (it will surely fail, however).
8716 When calling begin()/end() in the third alternative we must use
8717 argument dependent lookup, but always considering 'std' as an associated
8721 cp_convert_range_for (tree statement, tree range_decl, tree range_expr)
8723 tree range_type, range_temp;
8725 tree iter_type, begin_expr, end_expr;
8726 tree condition, expression;
8728 if (range_decl == error_mark_node || range_expr == error_mark_node)
8729 /* If an error happened previously do nothing or else a lot of
8730 unhelpful errors would be issued. */
8731 begin_expr = end_expr = iter_type = error_mark_node;
8734 /* Find out the type deduced by the declaration
8735 `auto &&__range = range_expr'. */
8736 range_type = cp_build_reference_type (make_auto (), true);
8737 range_type = do_auto_deduction (range_type, range_expr,
8738 type_uses_auto (range_type));
8740 /* Create the __range variable. */
8741 range_temp = build_decl (input_location, VAR_DECL,
8742 get_identifier ("__for_range"), range_type);
8743 TREE_USED (range_temp) = 1;
8744 DECL_ARTIFICIAL (range_temp) = 1;
8745 pushdecl (range_temp);
8746 cp_finish_decl (range_temp, range_expr,
8747 /*is_constant_init*/false, NULL_TREE,
8748 LOOKUP_ONLYCONVERTING);
8750 range_temp = convert_from_reference (range_temp);
8751 iter_type = cp_parser_perform_range_for_lookup (range_temp,
8752 &begin_expr, &end_expr);
8755 /* The new for initialization statement. */
8756 begin = build_decl (input_location, VAR_DECL,
8757 get_identifier ("__for_begin"), iter_type);
8758 TREE_USED (begin) = 1;
8759 DECL_ARTIFICIAL (begin) = 1;
8761 cp_finish_decl (begin, begin_expr,
8762 /*is_constant_init*/false, NULL_TREE,
8763 LOOKUP_ONLYCONVERTING);
8765 end = build_decl (input_location, VAR_DECL,
8766 get_identifier ("__for_end"), iter_type);
8767 TREE_USED (end) = 1;
8768 DECL_ARTIFICIAL (end) = 1;
8770 cp_finish_decl (end, end_expr,
8771 /*is_constant_init*/false, NULL_TREE,
8772 LOOKUP_ONLYCONVERTING);
8774 finish_for_init_stmt (statement);
8776 /* The new for condition. */
8777 condition = build_x_binary_op (NE_EXPR,
8780 NULL, tf_warning_or_error);
8781 finish_for_cond (condition, statement);
8783 /* The new increment expression. */
8784 expression = finish_unary_op_expr (PREINCREMENT_EXPR, begin);
8785 finish_for_expr (expression, statement);
8787 /* The declaration is initialized with *__begin inside the loop body. */
8788 cp_finish_decl (range_decl,
8789 build_x_indirect_ref (begin, RO_NULL, tf_warning_or_error),
8790 /*is_constant_init*/false, NULL_TREE,
8791 LOOKUP_ONLYCONVERTING);
8796 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
8797 We need to solve both at the same time because the method used
8798 depends on the existence of members begin or end.
8799 Returns the type deduced for the iterator expression. */
8802 cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end)
8804 if (error_operand_p (range))
8806 *begin = *end = error_mark_node;
8807 return error_mark_node;
8810 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (range))))
8812 error ("range-based %<for%> expression of type %qT "
8813 "has incomplete type", TREE_TYPE (range));
8814 *begin = *end = error_mark_node;
8815 return error_mark_node;
8817 if (TREE_CODE (TREE_TYPE (range)) == ARRAY_TYPE)
8819 /* If RANGE is an array, we will use pointer arithmetic. */
8821 *end = build_binary_op (input_location, PLUS_EXPR,
8823 array_type_nelts_top (TREE_TYPE (range)),
8825 return build_pointer_type (TREE_TYPE (TREE_TYPE (range)));
8829 /* If it is not an array, we must do a bit of magic. */
8830 tree id_begin, id_end;
8831 tree member_begin, member_end;
8833 *begin = *end = error_mark_node;
8835 id_begin = get_identifier ("begin");
8836 id_end = get_identifier ("end");
8837 member_begin = lookup_member (TREE_TYPE (range), id_begin,
8838 /*protect=*/2, /*want_type=*/false);
8839 member_end = lookup_member (TREE_TYPE (range), id_end,
8840 /*protect=*/2, /*want_type=*/false);
8842 if (member_begin != NULL_TREE || member_end != NULL_TREE)
8844 /* Use the member functions. */
8845 if (member_begin != NULL_TREE)
8846 *begin = cp_parser_range_for_member_function (range, id_begin);
8848 error ("range-based %<for%> expression of type %qT has an "
8849 "%<end%> member but not a %<begin%>", TREE_TYPE (range));
8851 if (member_end != NULL_TREE)
8852 *end = cp_parser_range_for_member_function (range, id_end);
8854 error ("range-based %<for%> expression of type %qT has a "
8855 "%<begin%> member but not an %<end%>", TREE_TYPE (range));
8859 /* Use global functions with ADL. */
8861 vec = make_tree_vector ();
8863 VEC_safe_push (tree, gc, vec, range);
8865 member_begin = perform_koenig_lookup (id_begin, vec,
8866 /*include_std=*/true,
8867 tf_warning_or_error);
8868 *begin = finish_call_expr (member_begin, &vec, false, true,
8869 tf_warning_or_error);
8870 member_end = perform_koenig_lookup (id_end, vec,
8871 /*include_std=*/true,
8872 tf_warning_or_error);
8873 *end = finish_call_expr (member_end, &vec, false, true,
8874 tf_warning_or_error);
8876 release_tree_vector (vec);
8879 /* Last common checks. */
8880 if (*begin == error_mark_node || *end == error_mark_node)
8882 /* If one of the expressions is an error do no more checks. */
8883 *begin = *end = error_mark_node;
8884 return error_mark_node;
8888 tree iter_type = cv_unqualified (TREE_TYPE (*begin));
8889 /* The unqualified type of the __begin and __end temporaries should
8890 be the same, as required by the multiple auto declaration. */
8891 if (!same_type_p (iter_type, cv_unqualified (TREE_TYPE (*end))))
8892 error ("inconsistent begin/end types in range-based %<for%> "
8893 "statement: %qT and %qT",
8894 TREE_TYPE (*begin), TREE_TYPE (*end));
8900 /* Helper function for cp_parser_perform_range_for_lookup.
8901 Builds a tree for RANGE.IDENTIFIER(). */
8904 cp_parser_range_for_member_function (tree range, tree identifier)
8909 member = finish_class_member_access_expr (range, identifier,
8910 false, tf_warning_or_error);
8911 if (member == error_mark_node)
8912 return error_mark_node;
8914 vec = make_tree_vector ();
8915 res = finish_call_expr (member, &vec,
8916 /*disallow_virtual=*/false,
8918 tf_warning_or_error);
8919 release_tree_vector (vec);
8923 /* Parse an iteration-statement.
8925 iteration-statement:
8926 while ( condition ) statement
8927 do statement while ( expression ) ;
8928 for ( for-init-statement condition [opt] ; expression [opt] )
8931 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
8934 cp_parser_iteration_statement (cp_parser* parser)
8939 unsigned char in_statement;
8941 /* Peek at the next token. */
8942 token = cp_parser_require (parser, CPP_KEYWORD, RT_INTERATION);
8944 return error_mark_node;
8946 /* Remember whether or not we are already within an iteration
8948 in_statement = parser->in_statement;
8950 /* See what kind of keyword it is. */
8951 keyword = token->keyword;
8958 /* Begin the while-statement. */
8959 statement = begin_while_stmt ();
8960 /* Look for the `('. */
8961 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8962 /* Parse the condition. */
8963 condition = cp_parser_condition (parser);
8964 finish_while_stmt_cond (condition, statement);
8965 /* Look for the `)'. */
8966 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8967 /* Parse the dependent statement. */
8968 parser->in_statement = IN_ITERATION_STMT;
8969 cp_parser_already_scoped_statement (parser);
8970 parser->in_statement = in_statement;
8971 /* We're done with the while-statement. */
8972 finish_while_stmt (statement);
8980 /* Begin the do-statement. */
8981 statement = begin_do_stmt ();
8982 /* Parse the body of the do-statement. */
8983 parser->in_statement = IN_ITERATION_STMT;
8984 cp_parser_implicitly_scoped_statement (parser, NULL);
8985 parser->in_statement = in_statement;
8986 finish_do_body (statement);
8987 /* Look for the `while' keyword. */
8988 cp_parser_require_keyword (parser, RID_WHILE, RT_WHILE);
8989 /* Look for the `('. */
8990 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8991 /* Parse the expression. */
8992 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
8993 /* We're done with the do-statement. */
8994 finish_do_stmt (expression, statement);
8995 /* Look for the `)'. */
8996 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8997 /* Look for the `;'. */
8998 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9004 /* Look for the `('. */
9005 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
9007 statement = cp_parser_for (parser);
9009 /* Look for the `)'. */
9010 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
9012 /* Parse the body of the for-statement. */
9013 parser->in_statement = IN_ITERATION_STMT;
9014 cp_parser_already_scoped_statement (parser);
9015 parser->in_statement = in_statement;
9017 /* We're done with the for-statement. */
9018 finish_for_stmt (statement);
9023 cp_parser_error (parser, "expected iteration-statement");
9024 statement = error_mark_node;
9031 /* Parse a for-init-statement or the declarator of a range-based-for.
9032 Returns true if a range-based-for declaration is seen.
9035 expression-statement
9036 simple-declaration */
9039 cp_parser_for_init_statement (cp_parser* parser, tree *decl)
9041 /* If the next token is a `;', then we have an empty
9042 expression-statement. Grammatically, this is also a
9043 simple-declaration, but an invalid one, because it does not
9044 declare anything. Therefore, if we did not handle this case
9045 specially, we would issue an error message about an invalid
9047 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
9049 bool is_range_for = false;
9050 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
9052 parser->colon_corrects_to_scope_p = false;
9054 /* We're going to speculatively look for a declaration, falling back
9055 to an expression, if necessary. */
9056 cp_parser_parse_tentatively (parser);
9057 /* Parse the declaration. */
9058 cp_parser_simple_declaration (parser,
9059 /*function_definition_allowed_p=*/false,
9061 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
9062 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
9064 /* It is a range-for, consume the ':' */
9065 cp_lexer_consume_token (parser->lexer);
9066 is_range_for = true;
9067 if (cxx_dialect < cxx0x)
9069 error_at (cp_lexer_peek_token (parser->lexer)->location,
9070 "range-based %<for%> loops are not allowed "
9072 *decl = error_mark_node;
9076 /* The ';' is not consumed yet because we told
9077 cp_parser_simple_declaration not to. */
9078 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9080 if (cp_parser_parse_definitely (parser))
9081 return is_range_for;
9082 /* If the tentative parse failed, then we shall need to look for an
9083 expression-statement. */
9085 /* If we are here, it is an expression-statement. */
9086 cp_parser_expression_statement (parser, NULL_TREE);
9090 /* Parse a jump-statement.
9095 return expression [opt] ;
9096 return braced-init-list ;
9104 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
9107 cp_parser_jump_statement (cp_parser* parser)
9109 tree statement = error_mark_node;
9112 unsigned char in_statement;
9114 /* Peek at the next token. */
9115 token = cp_parser_require (parser, CPP_KEYWORD, RT_JUMP);
9117 return error_mark_node;
9119 /* See what kind of keyword it is. */
9120 keyword = token->keyword;
9124 in_statement = parser->in_statement & ~IN_IF_STMT;
9125 switch (in_statement)
9128 error_at (token->location, "break statement not within loop or switch");
9131 gcc_assert ((in_statement & IN_SWITCH_STMT)
9132 || in_statement == IN_ITERATION_STMT);
9133 statement = finish_break_stmt ();
9136 error_at (token->location, "invalid exit from OpenMP structured block");
9139 error_at (token->location, "break statement used with OpenMP for loop");
9142 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9146 switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
9149 error_at (token->location, "continue statement not within a loop");
9151 case IN_ITERATION_STMT:
9153 statement = finish_continue_stmt ();
9156 error_at (token->location, "invalid exit from OpenMP structured block");
9161 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9167 bool expr_non_constant_p;
9169 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9171 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
9172 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
9174 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
9175 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
9177 /* If the next token is a `;', then there is no
9180 /* Build the return-statement. */
9181 statement = finish_return_stmt (expr);
9182 /* Look for the final `;'. */
9183 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9188 /* Create the goto-statement. */
9189 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
9191 /* Issue a warning about this use of a GNU extension. */
9192 pedwarn (token->location, OPT_pedantic, "ISO C++ forbids computed gotos");
9193 /* Consume the '*' token. */
9194 cp_lexer_consume_token (parser->lexer);
9195 /* Parse the dependent expression. */
9196 finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false, NULL));
9199 finish_goto_stmt (cp_parser_identifier (parser));
9200 /* Look for the final `;'. */
9201 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9205 cp_parser_error (parser, "expected jump-statement");
9212 /* Parse a declaration-statement.
9214 declaration-statement:
9215 block-declaration */
9218 cp_parser_declaration_statement (cp_parser* parser)
9222 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
9223 p = obstack_alloc (&declarator_obstack, 0);
9225 /* Parse the block-declaration. */
9226 cp_parser_block_declaration (parser, /*statement_p=*/true);
9228 /* Free any declarators allocated. */
9229 obstack_free (&declarator_obstack, p);
9231 /* Finish off the statement. */
9235 /* Some dependent statements (like `if (cond) statement'), are
9236 implicitly in their own scope. In other words, if the statement is
9237 a single statement (as opposed to a compound-statement), it is
9238 none-the-less treated as if it were enclosed in braces. Any
9239 declarations appearing in the dependent statement are out of scope
9240 after control passes that point. This function parses a statement,
9241 but ensures that is in its own scope, even if it is not a
9244 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9245 is a (possibly labeled) if statement which is not enclosed in
9246 braces and has an else clause. This is used to implement
9249 Returns the new statement. */
9252 cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
9259 /* Mark if () ; with a special NOP_EXPR. */
9260 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
9262 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
9263 cp_lexer_consume_token (parser->lexer);
9264 statement = add_stmt (build_empty_stmt (loc));
9266 /* if a compound is opened, we simply parse the statement directly. */
9267 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9268 statement = cp_parser_compound_statement (parser, NULL, false, false);
9269 /* If the token is not a `{', then we must take special action. */
9272 /* Create a compound-statement. */
9273 statement = begin_compound_stmt (0);
9274 /* Parse the dependent-statement. */
9275 cp_parser_statement (parser, NULL_TREE, false, if_p);
9276 /* Finish the dummy compound-statement. */
9277 finish_compound_stmt (statement);
9280 /* Return the statement. */
9284 /* For some dependent statements (like `while (cond) statement'), we
9285 have already created a scope. Therefore, even if the dependent
9286 statement is a compound-statement, we do not want to create another
9290 cp_parser_already_scoped_statement (cp_parser* parser)
9292 /* If the token is a `{', then we must take special action. */
9293 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
9294 cp_parser_statement (parser, NULL_TREE, false, NULL);
9297 /* Avoid calling cp_parser_compound_statement, so that we
9298 don't create a new scope. Do everything else by hand. */
9299 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
9300 /* If the next keyword is `__label__' we have a label declaration. */
9301 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
9302 cp_parser_label_declaration (parser);
9303 /* Parse an (optional) statement-seq. */
9304 cp_parser_statement_seq_opt (parser, NULL_TREE);
9305 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
9309 /* Declarations [gram.dcl.dcl] */
9311 /* Parse an optional declaration-sequence.
9315 declaration-seq declaration */
9318 cp_parser_declaration_seq_opt (cp_parser* parser)
9324 token = cp_lexer_peek_token (parser->lexer);
9326 if (token->type == CPP_CLOSE_BRACE
9327 || token->type == CPP_EOF
9328 || token->type == CPP_PRAGMA_EOL)
9331 if (token->type == CPP_SEMICOLON)
9333 /* A declaration consisting of a single semicolon is
9334 invalid. Allow it unless we're being pedantic. */
9335 cp_lexer_consume_token (parser->lexer);
9336 if (!in_system_header)
9337 pedwarn (input_location, OPT_pedantic, "extra %<;%>");
9341 /* If we're entering or exiting a region that's implicitly
9342 extern "C", modify the lang context appropriately. */
9343 if (!parser->implicit_extern_c && token->implicit_extern_c)
9345 push_lang_context (lang_name_c);
9346 parser->implicit_extern_c = true;
9348 else if (parser->implicit_extern_c && !token->implicit_extern_c)
9350 pop_lang_context ();
9351 parser->implicit_extern_c = false;
9354 if (token->type == CPP_PRAGMA)
9356 /* A top-level declaration can consist solely of a #pragma.
9357 A nested declaration cannot, so this is done here and not
9358 in cp_parser_declaration. (A #pragma at block scope is
9359 handled in cp_parser_statement.) */
9360 cp_parser_pragma (parser, pragma_external);
9364 /* Parse the declaration itself. */
9365 cp_parser_declaration (parser);
9369 /* Parse a declaration.
9374 template-declaration
9375 explicit-instantiation
9376 explicit-specialization
9377 linkage-specification
9378 namespace-definition
9383 __extension__ declaration */
9386 cp_parser_declaration (cp_parser* parser)
9392 tree attributes = NULL_TREE;
9394 /* Check for the `__extension__' keyword. */
9395 if (cp_parser_extension_opt (parser, &saved_pedantic))
9397 /* Parse the qualified declaration. */
9398 cp_parser_declaration (parser);
9399 /* Restore the PEDANTIC flag. */
9400 pedantic = saved_pedantic;
9405 /* Try to figure out what kind of declaration is present. */
9406 token1 = *cp_lexer_peek_token (parser->lexer);
9408 if (token1.type != CPP_EOF)
9409 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
9412 token2.type = CPP_EOF;
9413 token2.keyword = RID_MAX;
9416 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
9417 p = obstack_alloc (&declarator_obstack, 0);
9419 /* If the next token is `extern' and the following token is a string
9420 literal, then we have a linkage specification. */
9421 if (token1.keyword == RID_EXTERN
9422 && cp_parser_is_string_literal (&token2))
9423 cp_parser_linkage_specification (parser);
9424 /* If the next token is `template', then we have either a template
9425 declaration, an explicit instantiation, or an explicit
9427 else if (token1.keyword == RID_TEMPLATE)
9429 /* `template <>' indicates a template specialization. */
9430 if (token2.type == CPP_LESS
9431 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
9432 cp_parser_explicit_specialization (parser);
9433 /* `template <' indicates a template declaration. */
9434 else if (token2.type == CPP_LESS)
9435 cp_parser_template_declaration (parser, /*member_p=*/false);
9436 /* Anything else must be an explicit instantiation. */
9438 cp_parser_explicit_instantiation (parser);
9440 /* If the next token is `export', then we have a template
9442 else if (token1.keyword == RID_EXPORT)
9443 cp_parser_template_declaration (parser, /*member_p=*/false);
9444 /* If the next token is `extern', 'static' or 'inline' and the one
9445 after that is `template', we have a GNU extended explicit
9446 instantiation directive. */
9447 else if (cp_parser_allow_gnu_extensions_p (parser)
9448 && (token1.keyword == RID_EXTERN
9449 || token1.keyword == RID_STATIC
9450 || token1.keyword == RID_INLINE)
9451 && token2.keyword == RID_TEMPLATE)
9452 cp_parser_explicit_instantiation (parser);
9453 /* If the next token is `namespace', check for a named or unnamed
9454 namespace definition. */
9455 else if (token1.keyword == RID_NAMESPACE
9456 && (/* A named namespace definition. */
9457 (token2.type == CPP_NAME
9458 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
9460 /* An unnamed namespace definition. */
9461 || token2.type == CPP_OPEN_BRACE
9462 || token2.keyword == RID_ATTRIBUTE))
9463 cp_parser_namespace_definition (parser);
9464 /* An inline (associated) namespace definition. */
9465 else if (token1.keyword == RID_INLINE
9466 && token2.keyword == RID_NAMESPACE)
9467 cp_parser_namespace_definition (parser);
9468 /* Objective-C++ declaration/definition. */
9469 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
9470 cp_parser_objc_declaration (parser, NULL_TREE);
9471 else if (c_dialect_objc ()
9472 && token1.keyword == RID_ATTRIBUTE
9473 && cp_parser_objc_valid_prefix_attributes (parser, &attributes))
9474 cp_parser_objc_declaration (parser, attributes);
9475 /* We must have either a block declaration or a function
9478 /* Try to parse a block-declaration, or a function-definition. */
9479 cp_parser_block_declaration (parser, /*statement_p=*/false);
9481 /* Free any declarators allocated. */
9482 obstack_free (&declarator_obstack, p);
9485 /* Parse a block-declaration.
9490 namespace-alias-definition
9497 __extension__ block-declaration
9502 static_assert-declaration
9504 If STATEMENT_P is TRUE, then this block-declaration is occurring as
9505 part of a declaration-statement. */
9508 cp_parser_block_declaration (cp_parser *parser,
9514 /* Check for the `__extension__' keyword. */
9515 if (cp_parser_extension_opt (parser, &saved_pedantic))
9517 /* Parse the qualified declaration. */
9518 cp_parser_block_declaration (parser, statement_p);
9519 /* Restore the PEDANTIC flag. */
9520 pedantic = saved_pedantic;
9525 /* Peek at the next token to figure out which kind of declaration is
9527 token1 = cp_lexer_peek_token (parser->lexer);
9529 /* If the next keyword is `asm', we have an asm-definition. */
9530 if (token1->keyword == RID_ASM)
9533 cp_parser_commit_to_tentative_parse (parser);
9534 cp_parser_asm_definition (parser);
9536 /* If the next keyword is `namespace', we have a
9537 namespace-alias-definition. */
9538 else if (token1->keyword == RID_NAMESPACE)
9539 cp_parser_namespace_alias_definition (parser);
9540 /* If the next keyword is `using', we have either a
9541 using-declaration or a using-directive. */
9542 else if (token1->keyword == RID_USING)
9547 cp_parser_commit_to_tentative_parse (parser);
9548 /* If the token after `using' is `namespace', then we have a
9550 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
9551 if (token2->keyword == RID_NAMESPACE)
9552 cp_parser_using_directive (parser);
9553 /* Otherwise, it's a using-declaration. */
9555 cp_parser_using_declaration (parser,
9556 /*access_declaration_p=*/false);
9558 /* If the next keyword is `__label__' we have a misplaced label
9560 else if (token1->keyword == RID_LABEL)
9562 cp_lexer_consume_token (parser->lexer);
9563 error_at (token1->location, "%<__label__%> not at the beginning of a block");
9564 cp_parser_skip_to_end_of_statement (parser);
9565 /* If the next token is now a `;', consume it. */
9566 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
9567 cp_lexer_consume_token (parser->lexer);
9569 /* If the next token is `static_assert' we have a static assertion. */
9570 else if (token1->keyword == RID_STATIC_ASSERT)
9571 cp_parser_static_assert (parser, /*member_p=*/false);
9572 /* Anything else must be a simple-declaration. */
9574 cp_parser_simple_declaration (parser, !statement_p,
9575 /*maybe_range_for_decl*/NULL);
9578 /* Parse a simple-declaration.
9581 decl-specifier-seq [opt] init-declarator-list [opt] ;
9583 init-declarator-list:
9585 init-declarator-list , init-declarator
9587 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
9588 function-definition as a simple-declaration.
9590 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
9591 parsed declaration if it is an uninitialized single declarator not followed
9592 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
9593 if present, will not be consumed. */
9596 cp_parser_simple_declaration (cp_parser* parser,
9597 bool function_definition_allowed_p,
9598 tree *maybe_range_for_decl)
9600 cp_decl_specifier_seq decl_specifiers;
9601 int declares_class_or_enum;
9602 bool saw_declarator;
9604 if (maybe_range_for_decl)
9605 *maybe_range_for_decl = NULL_TREE;
9607 /* Defer access checks until we know what is being declared; the
9608 checks for names appearing in the decl-specifier-seq should be
9609 done as if we were in the scope of the thing being declared. */
9610 push_deferring_access_checks (dk_deferred);
9612 /* Parse the decl-specifier-seq. We have to keep track of whether
9613 or not the decl-specifier-seq declares a named class or
9614 enumeration type, since that is the only case in which the
9615 init-declarator-list is allowed to be empty.
9619 In a simple-declaration, the optional init-declarator-list can be
9620 omitted only when declaring a class or enumeration, that is when
9621 the decl-specifier-seq contains either a class-specifier, an
9622 elaborated-type-specifier, or an enum-specifier. */
9623 cp_parser_decl_specifier_seq (parser,
9624 CP_PARSER_FLAGS_OPTIONAL,
9626 &declares_class_or_enum);
9627 /* We no longer need to defer access checks. */
9628 stop_deferring_access_checks ();
9630 /* In a block scope, a valid declaration must always have a
9631 decl-specifier-seq. By not trying to parse declarators, we can
9632 resolve the declaration/expression ambiguity more quickly. */
9633 if (!function_definition_allowed_p
9634 && !decl_specifiers.any_specifiers_p)
9636 cp_parser_error (parser, "expected declaration");
9640 /* If the next two tokens are both identifiers, the code is
9641 erroneous. The usual cause of this situation is code like:
9645 where "T" should name a type -- but does not. */
9646 if (!decl_specifiers.any_type_specifiers_p
9647 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
9649 /* If parsing tentatively, we should commit; we really are
9650 looking at a declaration. */
9651 cp_parser_commit_to_tentative_parse (parser);
9656 /* If we have seen at least one decl-specifier, and the next token
9657 is not a parenthesis, then we must be looking at a declaration.
9658 (After "int (" we might be looking at a functional cast.) */
9659 if (decl_specifiers.any_specifiers_p
9660 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)
9661 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
9662 && !cp_parser_error_occurred (parser))
9663 cp_parser_commit_to_tentative_parse (parser);
9665 /* Keep going until we hit the `;' at the end of the simple
9667 saw_declarator = false;
9668 while (cp_lexer_next_token_is_not (parser->lexer,
9672 bool function_definition_p;
9677 /* If we are processing next declarator, coma is expected */
9678 token = cp_lexer_peek_token (parser->lexer);
9679 gcc_assert (token->type == CPP_COMMA);
9680 cp_lexer_consume_token (parser->lexer);
9681 if (maybe_range_for_decl)
9682 *maybe_range_for_decl = error_mark_node;
9685 saw_declarator = true;
9687 /* Parse the init-declarator. */
9688 decl = cp_parser_init_declarator (parser, &decl_specifiers,
9690 function_definition_allowed_p,
9692 declares_class_or_enum,
9693 &function_definition_p,
9694 maybe_range_for_decl);
9695 /* If an error occurred while parsing tentatively, exit quickly.
9696 (That usually happens when in the body of a function; each
9697 statement is treated as a declaration-statement until proven
9699 if (cp_parser_error_occurred (parser))
9701 /* Handle function definitions specially. */
9702 if (function_definition_p)
9704 /* If the next token is a `,', then we are probably
9705 processing something like:
9709 which is erroneous. */
9710 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
9712 cp_token *token = cp_lexer_peek_token (parser->lexer);
9713 error_at (token->location,
9715 " declarations and function-definitions is forbidden");
9717 /* Otherwise, we're done with the list of declarators. */
9720 pop_deferring_access_checks ();
9724 if (maybe_range_for_decl && *maybe_range_for_decl == NULL_TREE)
9725 *maybe_range_for_decl = decl;
9726 /* The next token should be either a `,' or a `;'. */
9727 token = cp_lexer_peek_token (parser->lexer);
9728 /* If it's a `,', there are more declarators to come. */
9729 if (token->type == CPP_COMMA)
9730 /* will be consumed next time around */;
9731 /* If it's a `;', we are done. */
9732 else if (token->type == CPP_SEMICOLON || maybe_range_for_decl)
9734 /* Anything else is an error. */
9737 /* If we have already issued an error message we don't need
9738 to issue another one. */
9739 if (decl != error_mark_node
9740 || cp_parser_uncommitted_to_tentative_parse_p (parser))
9741 cp_parser_error (parser, "expected %<,%> or %<;%>");
9742 /* Skip tokens until we reach the end of the statement. */
9743 cp_parser_skip_to_end_of_statement (parser);
9744 /* If the next token is now a `;', consume it. */
9745 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
9746 cp_lexer_consume_token (parser->lexer);
9749 /* After the first time around, a function-definition is not
9750 allowed -- even if it was OK at first. For example:
9755 function_definition_allowed_p = false;
9758 /* Issue an error message if no declarators are present, and the
9759 decl-specifier-seq does not itself declare a class or
9761 if (!saw_declarator)
9763 if (cp_parser_declares_only_class_p (parser))
9764 shadow_tag (&decl_specifiers);
9765 /* Perform any deferred access checks. */
9766 perform_deferred_access_checks ();
9769 /* Consume the `;'. */
9770 if (!maybe_range_for_decl)
9771 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9774 pop_deferring_access_checks ();
9777 /* Parse a decl-specifier-seq.
9780 decl-specifier-seq [opt] decl-specifier
9783 storage-class-specifier
9794 Set *DECL_SPECS to a representation of the decl-specifier-seq.
9796 The parser flags FLAGS is used to control type-specifier parsing.
9798 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
9801 1: one of the decl-specifiers is an elaborated-type-specifier
9802 (i.e., a type declaration)
9803 2: one of the decl-specifiers is an enum-specifier or a
9804 class-specifier (i.e., a type definition)
9809 cp_parser_decl_specifier_seq (cp_parser* parser,
9810 cp_parser_flags flags,
9811 cp_decl_specifier_seq *decl_specs,
9812 int* declares_class_or_enum)
9814 bool constructor_possible_p = !parser->in_declarator_p;
9815 cp_token *start_token = NULL;
9817 /* Clear DECL_SPECS. */
9818 clear_decl_specs (decl_specs);
9820 /* Assume no class or enumeration type is declared. */
9821 *declares_class_or_enum = 0;
9823 /* Keep reading specifiers until there are no more to read. */
9827 bool found_decl_spec;
9830 /* Peek at the next token. */
9831 token = cp_lexer_peek_token (parser->lexer);
9833 /* Save the first token of the decl spec list for error
9836 start_token = token;
9837 /* Handle attributes. */
9838 if (token->keyword == RID_ATTRIBUTE)
9840 /* Parse the attributes. */
9841 decl_specs->attributes
9842 = chainon (decl_specs->attributes,
9843 cp_parser_attributes_opt (parser));
9846 /* Assume we will find a decl-specifier keyword. */
9847 found_decl_spec = true;
9848 /* If the next token is an appropriate keyword, we can simply
9849 add it to the list. */
9850 switch (token->keyword)
9856 if (!at_class_scope_p ())
9858 error_at (token->location, "%<friend%> used outside of class");
9859 cp_lexer_purge_token (parser->lexer);
9863 ++decl_specs->specs[(int) ds_friend];
9864 /* Consume the token. */
9865 cp_lexer_consume_token (parser->lexer);
9870 ++decl_specs->specs[(int) ds_constexpr];
9871 cp_lexer_consume_token (parser->lexer);
9874 /* function-specifier:
9881 cp_parser_function_specifier_opt (parser, decl_specs);
9887 ++decl_specs->specs[(int) ds_typedef];
9888 /* Consume the token. */
9889 cp_lexer_consume_token (parser->lexer);
9890 /* A constructor declarator cannot appear in a typedef. */
9891 constructor_possible_p = false;
9892 /* The "typedef" keyword can only occur in a declaration; we
9893 may as well commit at this point. */
9894 cp_parser_commit_to_tentative_parse (parser);
9896 if (decl_specs->storage_class != sc_none)
9897 decl_specs->conflicting_specifiers_p = true;
9900 /* storage-class-specifier:
9910 if (cxx_dialect == cxx98)
9912 /* Consume the token. */
9913 cp_lexer_consume_token (parser->lexer);
9915 /* Complain about `auto' as a storage specifier, if
9916 we're complaining about C++0x compatibility. */
9917 warning_at (token->location, OPT_Wc__0x_compat, "%<auto%>"
9918 " will change meaning in C++0x; please remove it");
9920 /* Set the storage class anyway. */
9921 cp_parser_set_storage_class (parser, decl_specs, RID_AUTO,
9925 /* C++0x auto type-specifier. */
9926 found_decl_spec = false;
9933 /* Consume the token. */
9934 cp_lexer_consume_token (parser->lexer);
9935 cp_parser_set_storage_class (parser, decl_specs, token->keyword,
9939 /* Consume the token. */
9940 cp_lexer_consume_token (parser->lexer);
9941 ++decl_specs->specs[(int) ds_thread];
9945 /* We did not yet find a decl-specifier yet. */
9946 found_decl_spec = false;
9951 && (flags & CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR)
9952 && token->keyword != RID_CONSTEXPR)
9953 error ("decl-specifier invalid in condition");
9955 /* Constructors are a special case. The `S' in `S()' is not a
9956 decl-specifier; it is the beginning of the declarator. */
9959 && constructor_possible_p
9960 && (cp_parser_constructor_declarator_p
9961 (parser, decl_specs->specs[(int) ds_friend] != 0)));
9963 /* If we don't have a DECL_SPEC yet, then we must be looking at
9964 a type-specifier. */
9965 if (!found_decl_spec && !constructor_p)
9967 int decl_spec_declares_class_or_enum;
9968 bool is_cv_qualifier;
9972 = cp_parser_type_specifier (parser, flags,
9974 /*is_declaration=*/true,
9975 &decl_spec_declares_class_or_enum,
9977 *declares_class_or_enum |= decl_spec_declares_class_or_enum;
9979 /* If this type-specifier referenced a user-defined type
9980 (a typedef, class-name, etc.), then we can't allow any
9981 more such type-specifiers henceforth.
9985 The longest sequence of decl-specifiers that could
9986 possibly be a type name is taken as the
9987 decl-specifier-seq of a declaration. The sequence shall
9988 be self-consistent as described below.
9992 As a general rule, at most one type-specifier is allowed
9993 in the complete decl-specifier-seq of a declaration. The
9994 only exceptions are the following:
9996 -- const or volatile can be combined with any other
9999 -- signed or unsigned can be combined with char, long,
10007 void g (const int Pc);
10009 Here, Pc is *not* part of the decl-specifier seq; it's
10010 the declarator. Therefore, once we see a type-specifier
10011 (other than a cv-qualifier), we forbid any additional
10012 user-defined types. We *do* still allow things like `int
10013 int' to be considered a decl-specifier-seq, and issue the
10014 error message later. */
10015 if (type_spec && !is_cv_qualifier)
10016 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
10017 /* A constructor declarator cannot follow a type-specifier. */
10020 constructor_possible_p = false;
10021 found_decl_spec = true;
10022 if (!is_cv_qualifier)
10023 decl_specs->any_type_specifiers_p = true;
10027 /* If we still do not have a DECL_SPEC, then there are no more
10028 decl-specifiers. */
10029 if (!found_decl_spec)
10032 decl_specs->any_specifiers_p = true;
10033 /* After we see one decl-specifier, further decl-specifiers are
10034 always optional. */
10035 flags |= CP_PARSER_FLAGS_OPTIONAL;
10038 cp_parser_check_decl_spec (decl_specs, start_token->location);
10040 /* Don't allow a friend specifier with a class definition. */
10041 if (decl_specs->specs[(int) ds_friend] != 0
10042 && (*declares_class_or_enum & 2))
10043 error_at (start_token->location,
10044 "class definition may not be declared a friend");
10047 /* Parse an (optional) storage-class-specifier.
10049 storage-class-specifier:
10058 storage-class-specifier:
10061 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
10064 cp_parser_storage_class_specifier_opt (cp_parser* parser)
10066 switch (cp_lexer_peek_token (parser->lexer)->keyword)
10069 if (cxx_dialect != cxx98)
10071 /* Fall through for C++98. */
10078 /* Consume the token. */
10079 return cp_lexer_consume_token (parser->lexer)->u.value;
10086 /* Parse an (optional) function-specifier.
10088 function-specifier:
10093 Returns an IDENTIFIER_NODE corresponding to the keyword used.
10094 Updates DECL_SPECS, if it is non-NULL. */
10097 cp_parser_function_specifier_opt (cp_parser* parser,
10098 cp_decl_specifier_seq *decl_specs)
10100 cp_token *token = cp_lexer_peek_token (parser->lexer);
10101 switch (token->keyword)
10105 ++decl_specs->specs[(int) ds_inline];
10109 /* 14.5.2.3 [temp.mem]
10111 A member function template shall not be virtual. */
10112 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
10113 error_at (token->location, "templates may not be %<virtual%>");
10114 else if (decl_specs)
10115 ++decl_specs->specs[(int) ds_virtual];
10120 ++decl_specs->specs[(int) ds_explicit];
10127 /* Consume the token. */
10128 return cp_lexer_consume_token (parser->lexer)->u.value;
10131 /* Parse a linkage-specification.
10133 linkage-specification:
10134 extern string-literal { declaration-seq [opt] }
10135 extern string-literal declaration */
10138 cp_parser_linkage_specification (cp_parser* parser)
10142 /* Look for the `extern' keyword. */
10143 cp_parser_require_keyword (parser, RID_EXTERN, RT_EXTERN);
10145 /* Look for the string-literal. */
10146 linkage = cp_parser_string_literal (parser, false, false);
10148 /* Transform the literal into an identifier. If the literal is a
10149 wide-character string, or contains embedded NULs, then we can't
10150 handle it as the user wants. */
10151 if (strlen (TREE_STRING_POINTER (linkage))
10152 != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
10154 cp_parser_error (parser, "invalid linkage-specification");
10155 /* Assume C++ linkage. */
10156 linkage = lang_name_cplusplus;
10159 linkage = get_identifier (TREE_STRING_POINTER (linkage));
10161 /* We're now using the new linkage. */
10162 push_lang_context (linkage);
10164 /* If the next token is a `{', then we're using the first
10166 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10168 /* Consume the `{' token. */
10169 cp_lexer_consume_token (parser->lexer);
10170 /* Parse the declarations. */
10171 cp_parser_declaration_seq_opt (parser);
10172 /* Look for the closing `}'. */
10173 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
10175 /* Otherwise, there's just one declaration. */
10178 bool saved_in_unbraced_linkage_specification_p;
10180 saved_in_unbraced_linkage_specification_p
10181 = parser->in_unbraced_linkage_specification_p;
10182 parser->in_unbraced_linkage_specification_p = true;
10183 cp_parser_declaration (parser);
10184 parser->in_unbraced_linkage_specification_p
10185 = saved_in_unbraced_linkage_specification_p;
10188 /* We're done with the linkage-specification. */
10189 pop_lang_context ();
10192 /* Parse a static_assert-declaration.
10194 static_assert-declaration:
10195 static_assert ( constant-expression , string-literal ) ;
10197 If MEMBER_P, this static_assert is a class member. */
10200 cp_parser_static_assert(cp_parser *parser, bool member_p)
10205 location_t saved_loc;
10208 /* Peek at the `static_assert' token so we can keep track of exactly
10209 where the static assertion started. */
10210 token = cp_lexer_peek_token (parser->lexer);
10211 saved_loc = token->location;
10213 /* Look for the `static_assert' keyword. */
10214 if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
10218 /* We know we are in a static assertion; commit to any tentative
10220 if (cp_parser_parsing_tentatively (parser))
10221 cp_parser_commit_to_tentative_parse (parser);
10223 /* Parse the `(' starting the static assertion condition. */
10224 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
10226 /* Parse the constant-expression. Allow a non-constant expression
10227 here in order to give better diagnostics in finish_static_assert. */
10229 cp_parser_constant_expression (parser,
10230 /*allow_non_constant_p=*/true,
10231 /*non_constant_p=*/&dummy);
10233 /* Parse the separating `,'. */
10234 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
10236 /* Parse the string-literal message. */
10237 message = cp_parser_string_literal (parser,
10238 /*translate=*/false,
10241 /* A `)' completes the static assertion. */
10242 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
10243 cp_parser_skip_to_closing_parenthesis (parser,
10244 /*recovering=*/true,
10245 /*or_comma=*/false,
10246 /*consume_paren=*/true);
10248 /* A semicolon terminates the declaration. */
10249 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
10251 /* Complete the static assertion, which may mean either processing
10252 the static assert now or saving it for template instantiation. */
10253 finish_static_assert (condition, message, saved_loc, member_p);
10256 /* Parse a `decltype' type. Returns the type.
10258 simple-type-specifier:
10259 decltype ( expression ) */
10262 cp_parser_decltype (cp_parser *parser)
10265 bool id_expression_or_member_access_p = false;
10266 const char *saved_message;
10267 bool saved_integral_constant_expression_p;
10268 bool saved_non_integral_constant_expression_p;
10269 cp_token *id_expr_start_token;
10270 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
10272 if (start_token->type == CPP_DECLTYPE)
10274 /* Already parsed. */
10275 cp_lexer_consume_token (parser->lexer);
10276 return start_token->u.value;
10279 /* Look for the `decltype' token. */
10280 if (!cp_parser_require_keyword (parser, RID_DECLTYPE, RT_DECLTYPE))
10281 return error_mark_node;
10283 /* Types cannot be defined in a `decltype' expression. Save away the
10285 saved_message = parser->type_definition_forbidden_message;
10287 /* And create the new one. */
10288 parser->type_definition_forbidden_message
10289 = G_("types may not be defined in %<decltype%> expressions");
10291 /* The restrictions on constant-expressions do not apply inside
10292 decltype expressions. */
10293 saved_integral_constant_expression_p
10294 = parser->integral_constant_expression_p;
10295 saved_non_integral_constant_expression_p
10296 = parser->non_integral_constant_expression_p;
10297 parser->integral_constant_expression_p = false;
10299 /* Do not actually evaluate the expression. */
10300 ++cp_unevaluated_operand;
10302 /* Do not warn about problems with the expression. */
10303 ++c_inhibit_evaluation_warnings;
10305 /* Parse the opening `('. */
10306 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
10307 return error_mark_node;
10309 /* First, try parsing an id-expression. */
10310 id_expr_start_token = cp_lexer_peek_token (parser->lexer);
10311 cp_parser_parse_tentatively (parser);
10312 expr = cp_parser_id_expression (parser,
10313 /*template_keyword_p=*/false,
10314 /*check_dependency_p=*/true,
10315 /*template_p=*/NULL,
10316 /*declarator_p=*/false,
10317 /*optional_p=*/false);
10319 if (!cp_parser_error_occurred (parser) && expr != error_mark_node)
10321 bool non_integral_constant_expression_p = false;
10322 tree id_expression = expr;
10324 const char *error_msg;
10326 if (TREE_CODE (expr) == IDENTIFIER_NODE)
10327 /* Lookup the name we got back from the id-expression. */
10328 expr = cp_parser_lookup_name (parser, expr,
10330 /*is_template=*/false,
10331 /*is_namespace=*/false,
10332 /*check_dependency=*/true,
10333 /*ambiguous_decls=*/NULL,
10334 id_expr_start_token->location);
10337 && expr != error_mark_node
10338 && TREE_CODE (expr) != TEMPLATE_ID_EXPR
10339 && TREE_CODE (expr) != TYPE_DECL
10340 && (TREE_CODE (expr) != BIT_NOT_EXPR
10341 || !TYPE_P (TREE_OPERAND (expr, 0)))
10342 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
10344 /* Complete lookup of the id-expression. */
10345 expr = (finish_id_expression
10346 (id_expression, expr, parser->scope, &idk,
10347 /*integral_constant_expression_p=*/false,
10348 /*allow_non_integral_constant_expression_p=*/true,
10349 &non_integral_constant_expression_p,
10350 /*template_p=*/false,
10352 /*address_p=*/false,
10353 /*template_arg_p=*/false,
10355 id_expr_start_token->location));
10357 if (expr == error_mark_node)
10358 /* We found an id-expression, but it was something that we
10359 should not have found. This is an error, not something
10360 we can recover from, so note that we found an
10361 id-expression and we'll recover as gracefully as
10363 id_expression_or_member_access_p = true;
10367 && expr != error_mark_node
10368 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
10369 /* We have an id-expression. */
10370 id_expression_or_member_access_p = true;
10373 if (!id_expression_or_member_access_p)
10375 /* Abort the id-expression parse. */
10376 cp_parser_abort_tentative_parse (parser);
10378 /* Parsing tentatively, again. */
10379 cp_parser_parse_tentatively (parser);
10381 /* Parse a class member access. */
10382 expr = cp_parser_postfix_expression (parser, /*address_p=*/false,
10384 /*member_access_only_p=*/true, NULL);
10387 && expr != error_mark_node
10388 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
10389 /* We have an id-expression. */
10390 id_expression_or_member_access_p = true;
10393 if (id_expression_or_member_access_p)
10394 /* We have parsed the complete id-expression or member access. */
10395 cp_parser_parse_definitely (parser);
10398 bool saved_greater_than_is_operator_p;
10400 /* Abort our attempt to parse an id-expression or member access
10402 cp_parser_abort_tentative_parse (parser);
10404 /* Within a parenthesized expression, a `>' token is always
10405 the greater-than operator. */
10406 saved_greater_than_is_operator_p
10407 = parser->greater_than_is_operator_p;
10408 parser->greater_than_is_operator_p = true;
10410 /* Parse a full expression. */
10411 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
10413 /* The `>' token might be the end of a template-id or
10414 template-parameter-list now. */
10415 parser->greater_than_is_operator_p
10416 = saved_greater_than_is_operator_p;
10419 /* Go back to evaluating expressions. */
10420 --cp_unevaluated_operand;
10421 --c_inhibit_evaluation_warnings;
10423 /* Restore the old message and the integral constant expression
10425 parser->type_definition_forbidden_message = saved_message;
10426 parser->integral_constant_expression_p
10427 = saved_integral_constant_expression_p;
10428 parser->non_integral_constant_expression_p
10429 = saved_non_integral_constant_expression_p;
10431 /* Parse to the closing `)'. */
10432 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
10434 cp_parser_skip_to_closing_parenthesis (parser, true, false,
10435 /*consume_paren=*/true);
10436 return error_mark_node;
10439 expr = finish_decltype_type (expr, id_expression_or_member_access_p,
10440 tf_warning_or_error);
10442 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
10444 start_token->type = CPP_DECLTYPE;
10445 start_token->u.value = expr;
10446 start_token->keyword = RID_MAX;
10447 cp_lexer_purge_tokens_after (parser->lexer, start_token);
10452 /* Special member functions [gram.special] */
10454 /* Parse a conversion-function-id.
10456 conversion-function-id:
10457 operator conversion-type-id
10459 Returns an IDENTIFIER_NODE representing the operator. */
10462 cp_parser_conversion_function_id (cp_parser* parser)
10466 tree saved_qualifying_scope;
10467 tree saved_object_scope;
10468 tree pushed_scope = NULL_TREE;
10470 /* Look for the `operator' token. */
10471 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
10472 return error_mark_node;
10473 /* When we parse the conversion-type-id, the current scope will be
10474 reset. However, we need that information in able to look up the
10475 conversion function later, so we save it here. */
10476 saved_scope = parser->scope;
10477 saved_qualifying_scope = parser->qualifying_scope;
10478 saved_object_scope = parser->object_scope;
10479 /* We must enter the scope of the class so that the names of
10480 entities declared within the class are available in the
10481 conversion-type-id. For example, consider:
10488 S::operator I() { ... }
10490 In order to see that `I' is a type-name in the definition, we
10491 must be in the scope of `S'. */
10493 pushed_scope = push_scope (saved_scope);
10494 /* Parse the conversion-type-id. */
10495 type = cp_parser_conversion_type_id (parser);
10496 /* Leave the scope of the class, if any. */
10498 pop_scope (pushed_scope);
10499 /* Restore the saved scope. */
10500 parser->scope = saved_scope;
10501 parser->qualifying_scope = saved_qualifying_scope;
10502 parser->object_scope = saved_object_scope;
10503 /* If the TYPE is invalid, indicate failure. */
10504 if (type == error_mark_node)
10505 return error_mark_node;
10506 return mangle_conv_op_name_for_type (type);
10509 /* Parse a conversion-type-id:
10511 conversion-type-id:
10512 type-specifier-seq conversion-declarator [opt]
10514 Returns the TYPE specified. */
10517 cp_parser_conversion_type_id (cp_parser* parser)
10520 cp_decl_specifier_seq type_specifiers;
10521 cp_declarator *declarator;
10522 tree type_specified;
10524 /* Parse the attributes. */
10525 attributes = cp_parser_attributes_opt (parser);
10526 /* Parse the type-specifiers. */
10527 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
10528 /*is_trailing_return=*/false,
10530 /* If that didn't work, stop. */
10531 if (type_specifiers.type == error_mark_node)
10532 return error_mark_node;
10533 /* Parse the conversion-declarator. */
10534 declarator = cp_parser_conversion_declarator_opt (parser);
10536 type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
10537 /*initialized=*/0, &attributes);
10539 cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
10541 /* Don't give this error when parsing tentatively. This happens to
10542 work because we always parse this definitively once. */
10543 if (! cp_parser_uncommitted_to_tentative_parse_p (parser)
10544 && type_uses_auto (type_specified))
10546 error ("invalid use of %<auto%> in conversion operator");
10547 return error_mark_node;
10550 return type_specified;
10553 /* Parse an (optional) conversion-declarator.
10555 conversion-declarator:
10556 ptr-operator conversion-declarator [opt]
10560 static cp_declarator *
10561 cp_parser_conversion_declarator_opt (cp_parser* parser)
10563 enum tree_code code;
10565 cp_cv_quals cv_quals;
10567 /* We don't know if there's a ptr-operator next, or not. */
10568 cp_parser_parse_tentatively (parser);
10569 /* Try the ptr-operator. */
10570 code = cp_parser_ptr_operator (parser, &class_type, &cv_quals);
10571 /* If it worked, look for more conversion-declarators. */
10572 if (cp_parser_parse_definitely (parser))
10574 cp_declarator *declarator;
10576 /* Parse another optional declarator. */
10577 declarator = cp_parser_conversion_declarator_opt (parser);
10579 return cp_parser_make_indirect_declarator
10580 (code, class_type, cv_quals, declarator);
10586 /* Parse an (optional) ctor-initializer.
10589 : mem-initializer-list
10591 Returns TRUE iff the ctor-initializer was actually present. */
10594 cp_parser_ctor_initializer_opt (cp_parser* parser)
10596 /* If the next token is not a `:', then there is no
10597 ctor-initializer. */
10598 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
10600 /* Do default initialization of any bases and members. */
10601 if (DECL_CONSTRUCTOR_P (current_function_decl))
10602 finish_mem_initializers (NULL_TREE);
10607 /* Consume the `:' token. */
10608 cp_lexer_consume_token (parser->lexer);
10609 /* And the mem-initializer-list. */
10610 cp_parser_mem_initializer_list (parser);
10615 /* Parse a mem-initializer-list.
10617 mem-initializer-list:
10618 mem-initializer ... [opt]
10619 mem-initializer ... [opt] , mem-initializer-list */
10622 cp_parser_mem_initializer_list (cp_parser* parser)
10624 tree mem_initializer_list = NULL_TREE;
10625 cp_token *token = cp_lexer_peek_token (parser->lexer);
10627 /* Let the semantic analysis code know that we are starting the
10628 mem-initializer-list. */
10629 if (!DECL_CONSTRUCTOR_P (current_function_decl))
10630 error_at (token->location,
10631 "only constructors take member initializers");
10633 /* Loop through the list. */
10636 tree mem_initializer;
10638 token = cp_lexer_peek_token (parser->lexer);
10639 /* Parse the mem-initializer. */
10640 mem_initializer = cp_parser_mem_initializer (parser);
10641 /* If the next token is a `...', we're expanding member initializers. */
10642 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10644 /* Consume the `...'. */
10645 cp_lexer_consume_token (parser->lexer);
10647 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
10648 can be expanded but members cannot. */
10649 if (mem_initializer != error_mark_node
10650 && !TYPE_P (TREE_PURPOSE (mem_initializer)))
10652 error_at (token->location,
10653 "cannot expand initializer for member %<%D%>",
10654 TREE_PURPOSE (mem_initializer));
10655 mem_initializer = error_mark_node;
10658 /* Construct the pack expansion type. */
10659 if (mem_initializer != error_mark_node)
10660 mem_initializer = make_pack_expansion (mem_initializer);
10662 /* Add it to the list, unless it was erroneous. */
10663 if (mem_initializer != error_mark_node)
10665 TREE_CHAIN (mem_initializer) = mem_initializer_list;
10666 mem_initializer_list = mem_initializer;
10668 /* If the next token is not a `,', we're done. */
10669 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
10671 /* Consume the `,' token. */
10672 cp_lexer_consume_token (parser->lexer);
10675 /* Perform semantic analysis. */
10676 if (DECL_CONSTRUCTOR_P (current_function_decl))
10677 finish_mem_initializers (mem_initializer_list);
10680 /* Parse a mem-initializer.
10683 mem-initializer-id ( expression-list [opt] )
10684 mem-initializer-id braced-init-list
10689 ( expression-list [opt] )
10691 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
10692 class) or FIELD_DECL (for a non-static data member) to initialize;
10693 the TREE_VALUE is the expression-list. An empty initialization
10694 list is represented by void_list_node. */
10697 cp_parser_mem_initializer (cp_parser* parser)
10699 tree mem_initializer_id;
10700 tree expression_list;
10702 cp_token *token = cp_lexer_peek_token (parser->lexer);
10704 /* Find out what is being initialized. */
10705 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
10707 permerror (token->location,
10708 "anachronistic old-style base class initializer");
10709 mem_initializer_id = NULL_TREE;
10713 mem_initializer_id = cp_parser_mem_initializer_id (parser);
10714 if (mem_initializer_id == error_mark_node)
10715 return mem_initializer_id;
10717 member = expand_member_init (mem_initializer_id);
10718 if (member && !DECL_P (member))
10719 in_base_initializer = 1;
10721 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10723 bool expr_non_constant_p;
10724 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
10725 expression_list = cp_parser_braced_list (parser, &expr_non_constant_p);
10726 CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
10727 expression_list = build_tree_list (NULL_TREE, expression_list);
10732 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
10734 /*allow_expansion_p=*/true,
10735 /*non_constant_p=*/NULL);
10737 return error_mark_node;
10738 expression_list = build_tree_list_vec (vec);
10739 release_tree_vector (vec);
10742 if (expression_list == error_mark_node)
10743 return error_mark_node;
10744 if (!expression_list)
10745 expression_list = void_type_node;
10747 in_base_initializer = 0;
10749 return member ? build_tree_list (member, expression_list) : error_mark_node;
10752 /* Parse a mem-initializer-id.
10754 mem-initializer-id:
10755 :: [opt] nested-name-specifier [opt] class-name
10758 Returns a TYPE indicating the class to be initializer for the first
10759 production. Returns an IDENTIFIER_NODE indicating the data member
10760 to be initialized for the second production. */
10763 cp_parser_mem_initializer_id (cp_parser* parser)
10765 bool global_scope_p;
10766 bool nested_name_specifier_p;
10767 bool template_p = false;
10770 cp_token *token = cp_lexer_peek_token (parser->lexer);
10772 /* `typename' is not allowed in this context ([temp.res]). */
10773 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
10775 error_at (token->location,
10776 "keyword %<typename%> not allowed in this context (a qualified "
10777 "member initializer is implicitly a type)");
10778 cp_lexer_consume_token (parser->lexer);
10780 /* Look for the optional `::' operator. */
10782 = (cp_parser_global_scope_opt (parser,
10783 /*current_scope_valid_p=*/false)
10785 /* Look for the optional nested-name-specifier. The simplest way to
10790 The keyword `typename' is not permitted in a base-specifier or
10791 mem-initializer; in these contexts a qualified name that
10792 depends on a template-parameter is implicitly assumed to be a
10795 is to assume that we have seen the `typename' keyword at this
10797 nested_name_specifier_p
10798 = (cp_parser_nested_name_specifier_opt (parser,
10799 /*typename_keyword_p=*/true,
10800 /*check_dependency_p=*/true,
10802 /*is_declaration=*/true)
10804 if (nested_name_specifier_p)
10805 template_p = cp_parser_optional_template_keyword (parser);
10806 /* If there is a `::' operator or a nested-name-specifier, then we
10807 are definitely looking for a class-name. */
10808 if (global_scope_p || nested_name_specifier_p)
10809 return cp_parser_class_name (parser,
10810 /*typename_keyword_p=*/true,
10811 /*template_keyword_p=*/template_p,
10813 /*check_dependency_p=*/true,
10814 /*class_head_p=*/false,
10815 /*is_declaration=*/true);
10816 /* Otherwise, we could also be looking for an ordinary identifier. */
10817 cp_parser_parse_tentatively (parser);
10818 /* Try a class-name. */
10819 id = cp_parser_class_name (parser,
10820 /*typename_keyword_p=*/true,
10821 /*template_keyword_p=*/false,
10823 /*check_dependency_p=*/true,
10824 /*class_head_p=*/false,
10825 /*is_declaration=*/true);
10826 /* If we found one, we're done. */
10827 if (cp_parser_parse_definitely (parser))
10829 /* Otherwise, look for an ordinary identifier. */
10830 return cp_parser_identifier (parser);
10833 /* Overloading [gram.over] */
10835 /* Parse an operator-function-id.
10837 operator-function-id:
10840 Returns an IDENTIFIER_NODE for the operator which is a
10841 human-readable spelling of the identifier, e.g., `operator +'. */
10844 cp_parser_operator_function_id (cp_parser* parser)
10846 /* Look for the `operator' keyword. */
10847 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
10848 return error_mark_node;
10849 /* And then the name of the operator itself. */
10850 return cp_parser_operator (parser);
10853 /* Parse an operator.
10856 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
10857 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
10858 || ++ -- , ->* -> () []
10865 Returns an IDENTIFIER_NODE for the operator which is a
10866 human-readable spelling of the identifier, e.g., `operator +'. */
10869 cp_parser_operator (cp_parser* parser)
10871 tree id = NULL_TREE;
10874 /* Peek at the next token. */
10875 token = cp_lexer_peek_token (parser->lexer);
10876 /* Figure out which operator we have. */
10877 switch (token->type)
10883 /* The keyword should be either `new' or `delete'. */
10884 if (token->keyword == RID_NEW)
10886 else if (token->keyword == RID_DELETE)
10891 /* Consume the `new' or `delete' token. */
10892 cp_lexer_consume_token (parser->lexer);
10894 /* Peek at the next token. */
10895 token = cp_lexer_peek_token (parser->lexer);
10896 /* If it's a `[' token then this is the array variant of the
10898 if (token->type == CPP_OPEN_SQUARE)
10900 /* Consume the `[' token. */
10901 cp_lexer_consume_token (parser->lexer);
10902 /* Look for the `]' token. */
10903 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
10904 id = ansi_opname (op == NEW_EXPR
10905 ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
10907 /* Otherwise, we have the non-array variant. */
10909 id = ansi_opname (op);
10915 id = ansi_opname (PLUS_EXPR);
10919 id = ansi_opname (MINUS_EXPR);
10923 id = ansi_opname (MULT_EXPR);
10927 id = ansi_opname (TRUNC_DIV_EXPR);
10931 id = ansi_opname (TRUNC_MOD_EXPR);
10935 id = ansi_opname (BIT_XOR_EXPR);
10939 id = ansi_opname (BIT_AND_EXPR);
10943 id = ansi_opname (BIT_IOR_EXPR);
10947 id = ansi_opname (BIT_NOT_EXPR);
10951 id = ansi_opname (TRUTH_NOT_EXPR);
10955 id = ansi_assopname (NOP_EXPR);
10959 id = ansi_opname (LT_EXPR);
10963 id = ansi_opname (GT_EXPR);
10967 id = ansi_assopname (PLUS_EXPR);
10971 id = ansi_assopname (MINUS_EXPR);
10975 id = ansi_assopname (MULT_EXPR);
10979 id = ansi_assopname (TRUNC_DIV_EXPR);
10983 id = ansi_assopname (TRUNC_MOD_EXPR);
10987 id = ansi_assopname (BIT_XOR_EXPR);
10991 id = ansi_assopname (BIT_AND_EXPR);
10995 id = ansi_assopname (BIT_IOR_EXPR);
10999 id = ansi_opname (LSHIFT_EXPR);
11003 id = ansi_opname (RSHIFT_EXPR);
11006 case CPP_LSHIFT_EQ:
11007 id = ansi_assopname (LSHIFT_EXPR);
11010 case CPP_RSHIFT_EQ:
11011 id = ansi_assopname (RSHIFT_EXPR);
11015 id = ansi_opname (EQ_EXPR);
11019 id = ansi_opname (NE_EXPR);
11023 id = ansi_opname (LE_EXPR);
11026 case CPP_GREATER_EQ:
11027 id = ansi_opname (GE_EXPR);
11031 id = ansi_opname (TRUTH_ANDIF_EXPR);
11035 id = ansi_opname (TRUTH_ORIF_EXPR);
11038 case CPP_PLUS_PLUS:
11039 id = ansi_opname (POSTINCREMENT_EXPR);
11042 case CPP_MINUS_MINUS:
11043 id = ansi_opname (PREDECREMENT_EXPR);
11047 id = ansi_opname (COMPOUND_EXPR);
11050 case CPP_DEREF_STAR:
11051 id = ansi_opname (MEMBER_REF);
11055 id = ansi_opname (COMPONENT_REF);
11058 case CPP_OPEN_PAREN:
11059 /* Consume the `('. */
11060 cp_lexer_consume_token (parser->lexer);
11061 /* Look for the matching `)'. */
11062 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
11063 return ansi_opname (CALL_EXPR);
11065 case CPP_OPEN_SQUARE:
11066 /* Consume the `['. */
11067 cp_lexer_consume_token (parser->lexer);
11068 /* Look for the matching `]'. */
11069 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
11070 return ansi_opname (ARRAY_REF);
11073 /* Anything else is an error. */
11077 /* If we have selected an identifier, we need to consume the
11080 cp_lexer_consume_token (parser->lexer);
11081 /* Otherwise, no valid operator name was present. */
11084 cp_parser_error (parser, "expected operator");
11085 id = error_mark_node;
11091 /* Parse a template-declaration.
11093 template-declaration:
11094 export [opt] template < template-parameter-list > declaration
11096 If MEMBER_P is TRUE, this template-declaration occurs within a
11099 The grammar rule given by the standard isn't correct. What
11100 is really meant is:
11102 template-declaration:
11103 export [opt] template-parameter-list-seq
11104 decl-specifier-seq [opt] init-declarator [opt] ;
11105 export [opt] template-parameter-list-seq
11106 function-definition
11108 template-parameter-list-seq:
11109 template-parameter-list-seq [opt]
11110 template < template-parameter-list > */
11113 cp_parser_template_declaration (cp_parser* parser, bool member_p)
11115 /* Check for `export'. */
11116 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
11118 /* Consume the `export' token. */
11119 cp_lexer_consume_token (parser->lexer);
11120 /* Warn that we do not support `export'. */
11121 warning (0, "keyword %<export%> not implemented, and will be ignored");
11124 cp_parser_template_declaration_after_export (parser, member_p);
11127 /* Parse a template-parameter-list.
11129 template-parameter-list:
11131 template-parameter-list , template-parameter
11133 Returns a TREE_LIST. Each node represents a template parameter.
11134 The nodes are connected via their TREE_CHAINs. */
11137 cp_parser_template_parameter_list (cp_parser* parser)
11139 tree parameter_list = NULL_TREE;
11141 begin_template_parm_list ();
11143 /* The loop below parses the template parms. We first need to know
11144 the total number of template parms to be able to compute proper
11145 canonical types of each dependent type. So after the loop, when
11146 we know the total number of template parms,
11147 end_template_parm_list computes the proper canonical types and
11148 fixes up the dependent types accordingly. */
11153 bool is_parameter_pack;
11154 location_t parm_loc;
11156 /* Parse the template-parameter. */
11157 parm_loc = cp_lexer_peek_token (parser->lexer)->location;
11158 parameter = cp_parser_template_parameter (parser,
11160 &is_parameter_pack);
11161 /* Add it to the list. */
11162 if (parameter != error_mark_node)
11163 parameter_list = process_template_parm (parameter_list,
11171 tree err_parm = build_tree_list (parameter, parameter);
11172 parameter_list = chainon (parameter_list, err_parm);
11175 /* If the next token is not a `,', we're done. */
11176 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
11178 /* Otherwise, consume the `,' token. */
11179 cp_lexer_consume_token (parser->lexer);
11182 return end_template_parm_list (parameter_list);
11185 /* Parse a template-parameter.
11187 template-parameter:
11189 parameter-declaration
11191 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
11192 the parameter. The TREE_PURPOSE is the default value, if any.
11193 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
11194 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
11195 set to true iff this parameter is a parameter pack. */
11198 cp_parser_template_parameter (cp_parser* parser, bool *is_non_type,
11199 bool *is_parameter_pack)
11202 cp_parameter_declarator *parameter_declarator;
11203 cp_declarator *id_declarator;
11206 /* Assume it is a type parameter or a template parameter. */
11207 *is_non_type = false;
11208 /* Assume it not a parameter pack. */
11209 *is_parameter_pack = false;
11210 /* Peek at the next token. */
11211 token = cp_lexer_peek_token (parser->lexer);
11212 /* If it is `class' or `template', we have a type-parameter. */
11213 if (token->keyword == RID_TEMPLATE)
11214 return cp_parser_type_parameter (parser, is_parameter_pack);
11215 /* If it is `class' or `typename' we do not know yet whether it is a
11216 type parameter or a non-type parameter. Consider:
11218 template <typename T, typename T::X X> ...
11222 template <class C, class D*> ...
11224 Here, the first parameter is a type parameter, and the second is
11225 a non-type parameter. We can tell by looking at the token after
11226 the identifier -- if it is a `,', `=', or `>' then we have a type
11228 if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
11230 /* Peek at the token after `class' or `typename'. */
11231 token = cp_lexer_peek_nth_token (parser->lexer, 2);
11232 /* If it's an ellipsis, we have a template type parameter
11234 if (token->type == CPP_ELLIPSIS)
11235 return cp_parser_type_parameter (parser, is_parameter_pack);
11236 /* If it's an identifier, skip it. */
11237 if (token->type == CPP_NAME)
11238 token = cp_lexer_peek_nth_token (parser->lexer, 3);
11239 /* Now, see if the token looks like the end of a template
11241 if (token->type == CPP_COMMA
11242 || token->type == CPP_EQ
11243 || token->type == CPP_GREATER)
11244 return cp_parser_type_parameter (parser, is_parameter_pack);
11247 /* Otherwise, it is a non-type parameter.
11251 When parsing a default template-argument for a non-type
11252 template-parameter, the first non-nested `>' is taken as the end
11253 of the template parameter-list rather than a greater-than
11255 *is_non_type = true;
11256 parameter_declarator
11257 = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
11258 /*parenthesized_p=*/NULL);
11260 /* If the parameter declaration is marked as a parameter pack, set
11261 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
11262 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
11264 if (parameter_declarator
11265 && parameter_declarator->declarator
11266 && parameter_declarator->declarator->parameter_pack_p)
11268 *is_parameter_pack = true;
11269 parameter_declarator->declarator->parameter_pack_p = false;
11272 /* If the next token is an ellipsis, and we don't already have it
11273 marked as a parameter pack, then we have a parameter pack (that
11274 has no declarator). */
11275 if (!*is_parameter_pack
11276 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
11277 && declarator_can_be_parameter_pack (parameter_declarator->declarator))
11279 /* Consume the `...'. */
11280 cp_lexer_consume_token (parser->lexer);
11281 maybe_warn_variadic_templates ();
11283 *is_parameter_pack = true;
11285 /* We might end up with a pack expansion as the type of the non-type
11286 template parameter, in which case this is a non-type template
11288 else if (parameter_declarator
11289 && parameter_declarator->decl_specifiers.type
11290 && PACK_EXPANSION_P (parameter_declarator->decl_specifiers.type))
11292 *is_parameter_pack = true;
11293 parameter_declarator->decl_specifiers.type =
11294 PACK_EXPANSION_PATTERN (parameter_declarator->decl_specifiers.type);
11297 if (*is_parameter_pack && cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11299 /* Parameter packs cannot have default arguments. However, a
11300 user may try to do so, so we'll parse them and give an
11301 appropriate diagnostic here. */
11303 /* Consume the `='. */
11304 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
11305 cp_lexer_consume_token (parser->lexer);
11307 /* Find the name of the parameter pack. */
11308 id_declarator = parameter_declarator->declarator;
11309 while (id_declarator && id_declarator->kind != cdk_id)
11310 id_declarator = id_declarator->declarator;
11312 if (id_declarator && id_declarator->kind == cdk_id)
11313 error_at (start_token->location,
11314 "template parameter pack %qD cannot have a default argument",
11315 id_declarator->u.id.unqualified_name);
11317 error_at (start_token->location,
11318 "template parameter pack cannot have a default argument");
11320 /* Parse the default argument, but throw away the result. */
11321 cp_parser_default_argument (parser, /*template_parm_p=*/true);
11324 parm = grokdeclarator (parameter_declarator->declarator,
11325 ¶meter_declarator->decl_specifiers,
11326 TPARM, /*initialized=*/0,
11327 /*attrlist=*/NULL);
11328 if (parm == error_mark_node)
11329 return error_mark_node;
11331 return build_tree_list (parameter_declarator->default_argument, parm);
11334 /* Parse a type-parameter.
11337 class identifier [opt]
11338 class identifier [opt] = type-id
11339 typename identifier [opt]
11340 typename identifier [opt] = type-id
11341 template < template-parameter-list > class identifier [opt]
11342 template < template-parameter-list > class identifier [opt]
11345 GNU Extension (variadic templates):
11348 class ... identifier [opt]
11349 typename ... identifier [opt]
11351 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
11352 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
11353 the declaration of the parameter.
11355 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
11358 cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack)
11363 /* Look for a keyword to tell us what kind of parameter this is. */
11364 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_TYPENAME_TEMPLATE);
11366 return error_mark_node;
11368 switch (token->keyword)
11374 tree default_argument;
11376 /* If the next token is an ellipsis, we have a template
11378 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11380 /* Consume the `...' token. */
11381 cp_lexer_consume_token (parser->lexer);
11382 maybe_warn_variadic_templates ();
11384 *is_parameter_pack = true;
11387 /* If the next token is an identifier, then it names the
11389 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
11390 identifier = cp_parser_identifier (parser);
11392 identifier = NULL_TREE;
11394 /* Create the parameter. */
11395 parameter = finish_template_type_parm (class_type_node, identifier);
11397 /* If the next token is an `=', we have a default argument. */
11398 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11400 /* Consume the `=' token. */
11401 cp_lexer_consume_token (parser->lexer);
11402 /* Parse the default-argument. */
11403 push_deferring_access_checks (dk_no_deferred);
11404 default_argument = cp_parser_type_id (parser);
11406 /* Template parameter packs cannot have default
11408 if (*is_parameter_pack)
11411 error_at (token->location,
11412 "template parameter pack %qD cannot have a "
11413 "default argument", identifier);
11415 error_at (token->location,
11416 "template parameter packs cannot have "
11417 "default arguments");
11418 default_argument = NULL_TREE;
11420 pop_deferring_access_checks ();
11423 default_argument = NULL_TREE;
11425 /* Create the combined representation of the parameter and the
11426 default argument. */
11427 parameter = build_tree_list (default_argument, parameter);
11434 tree default_argument;
11436 /* Look for the `<'. */
11437 cp_parser_require (parser, CPP_LESS, RT_LESS);
11438 /* Parse the template-parameter-list. */
11439 cp_parser_template_parameter_list (parser);
11440 /* Look for the `>'. */
11441 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
11442 /* Look for the `class' keyword. */
11443 cp_parser_require_keyword (parser, RID_CLASS, RT_CLASS);
11444 /* If the next token is an ellipsis, we have a template
11446 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11448 /* Consume the `...' token. */
11449 cp_lexer_consume_token (parser->lexer);
11450 maybe_warn_variadic_templates ();
11452 *is_parameter_pack = true;
11454 /* If the next token is an `=', then there is a
11455 default-argument. If the next token is a `>', we are at
11456 the end of the parameter-list. If the next token is a `,',
11457 then we are at the end of this parameter. */
11458 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
11459 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
11460 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
11462 identifier = cp_parser_identifier (parser);
11463 /* Treat invalid names as if the parameter were nameless. */
11464 if (identifier == error_mark_node)
11465 identifier = NULL_TREE;
11468 identifier = NULL_TREE;
11470 /* Create the template parameter. */
11471 parameter = finish_template_template_parm (class_type_node,
11474 /* If the next token is an `=', then there is a
11475 default-argument. */
11476 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
11480 /* Consume the `='. */
11481 cp_lexer_consume_token (parser->lexer);
11482 /* Parse the id-expression. */
11483 push_deferring_access_checks (dk_no_deferred);
11484 /* save token before parsing the id-expression, for error
11486 token = cp_lexer_peek_token (parser->lexer);
11488 = cp_parser_id_expression (parser,
11489 /*template_keyword_p=*/false,
11490 /*check_dependency_p=*/true,
11491 /*template_p=*/&is_template,
11492 /*declarator_p=*/false,
11493 /*optional_p=*/false);
11494 if (TREE_CODE (default_argument) == TYPE_DECL)
11495 /* If the id-expression was a template-id that refers to
11496 a template-class, we already have the declaration here,
11497 so no further lookup is needed. */
11500 /* Look up the name. */
11502 = cp_parser_lookup_name (parser, default_argument,
11504 /*is_template=*/is_template,
11505 /*is_namespace=*/false,
11506 /*check_dependency=*/true,
11507 /*ambiguous_decls=*/NULL,
11509 /* See if the default argument is valid. */
11511 = check_template_template_default_arg (default_argument);
11513 /* Template parameter packs cannot have default
11515 if (*is_parameter_pack)
11518 error_at (token->location,
11519 "template parameter pack %qD cannot "
11520 "have a default argument",
11523 error_at (token->location, "template parameter packs cannot "
11524 "have default arguments");
11525 default_argument = NULL_TREE;
11527 pop_deferring_access_checks ();
11530 default_argument = NULL_TREE;
11532 /* Create the combined representation of the parameter and the
11533 default argument. */
11534 parameter = build_tree_list (default_argument, parameter);
11539 gcc_unreachable ();
11546 /* Parse a template-id.
11549 template-name < template-argument-list [opt] >
11551 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
11552 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
11553 returned. Otherwise, if the template-name names a function, or set
11554 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
11555 names a class, returns a TYPE_DECL for the specialization.
11557 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
11558 uninstantiated templates. */
11561 cp_parser_template_id (cp_parser *parser,
11562 bool template_keyword_p,
11563 bool check_dependency_p,
11564 bool is_declaration)
11570 cp_token_position start_of_id = 0;
11571 deferred_access_check *chk;
11572 VEC (deferred_access_check,gc) *access_check;
11573 cp_token *next_token = NULL, *next_token_2 = NULL;
11574 bool is_identifier;
11576 /* If the next token corresponds to a template-id, there is no need
11578 next_token = cp_lexer_peek_token (parser->lexer);
11579 if (next_token->type == CPP_TEMPLATE_ID)
11581 struct tree_check *check_value;
11583 /* Get the stored value. */
11584 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
11585 /* Perform any access checks that were deferred. */
11586 access_check = check_value->checks;
11589 FOR_EACH_VEC_ELT (deferred_access_check, access_check, i, chk)
11590 perform_or_defer_access_check (chk->binfo,
11594 /* Return the stored value. */
11595 return check_value->value;
11598 /* Avoid performing name lookup if there is no possibility of
11599 finding a template-id. */
11600 if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
11601 || (next_token->type == CPP_NAME
11602 && !cp_parser_nth_token_starts_template_argument_list_p
11605 cp_parser_error (parser, "expected template-id");
11606 return error_mark_node;
11609 /* Remember where the template-id starts. */
11610 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
11611 start_of_id = cp_lexer_token_position (parser->lexer, false);
11613 push_deferring_access_checks (dk_deferred);
11615 /* Parse the template-name. */
11616 is_identifier = false;
11617 templ = cp_parser_template_name (parser, template_keyword_p,
11618 check_dependency_p,
11621 if (templ == error_mark_node || is_identifier)
11623 pop_deferring_access_checks ();
11627 /* If we find the sequence `[:' after a template-name, it's probably
11628 a digraph-typo for `< ::'. Substitute the tokens and check if we can
11629 parse correctly the argument list. */
11630 next_token = cp_lexer_peek_token (parser->lexer);
11631 next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
11632 if (next_token->type == CPP_OPEN_SQUARE
11633 && next_token->flags & DIGRAPH
11634 && next_token_2->type == CPP_COLON
11635 && !(next_token_2->flags & PREV_WHITE))
11637 cp_parser_parse_tentatively (parser);
11638 /* Change `:' into `::'. */
11639 next_token_2->type = CPP_SCOPE;
11640 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
11642 cp_lexer_consume_token (parser->lexer);
11644 /* Parse the arguments. */
11645 arguments = cp_parser_enclosed_template_argument_list (parser);
11646 if (!cp_parser_parse_definitely (parser))
11648 /* If we couldn't parse an argument list, then we revert our changes
11649 and return simply an error. Maybe this is not a template-id
11651 next_token_2->type = CPP_COLON;
11652 cp_parser_error (parser, "expected %<<%>");
11653 pop_deferring_access_checks ();
11654 return error_mark_node;
11656 /* Otherwise, emit an error about the invalid digraph, but continue
11657 parsing because we got our argument list. */
11658 if (permerror (next_token->location,
11659 "%<<::%> cannot begin a template-argument list"))
11661 static bool hint = false;
11662 inform (next_token->location,
11663 "%<<:%> is an alternate spelling for %<[%>."
11664 " Insert whitespace between %<<%> and %<::%>");
11665 if (!hint && !flag_permissive)
11667 inform (next_token->location, "(if you use %<-fpermissive%>"
11668 " G++ will accept your code)");
11675 /* Look for the `<' that starts the template-argument-list. */
11676 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
11678 pop_deferring_access_checks ();
11679 return error_mark_node;
11681 /* Parse the arguments. */
11682 arguments = cp_parser_enclosed_template_argument_list (parser);
11685 /* Build a representation of the specialization. */
11686 if (TREE_CODE (templ) == IDENTIFIER_NODE)
11687 template_id = build_min_nt (TEMPLATE_ID_EXPR, templ, arguments);
11688 else if (DECL_CLASS_TEMPLATE_P (templ)
11689 || DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
11691 bool entering_scope;
11692 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
11693 template (rather than some instantiation thereof) only if
11694 is not nested within some other construct. For example, in
11695 "template <typename T> void f(T) { A<T>::", A<T> is just an
11696 instantiation of A. */
11697 entering_scope = (template_parm_scope_p ()
11698 && cp_lexer_next_token_is (parser->lexer,
11701 = finish_template_type (templ, arguments, entering_scope);
11705 /* If it's not a class-template or a template-template, it should be
11706 a function-template. */
11707 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
11708 || TREE_CODE (templ) == OVERLOAD
11709 || BASELINK_P (templ)));
11711 template_id = lookup_template_function (templ, arguments);
11714 /* If parsing tentatively, replace the sequence of tokens that makes
11715 up the template-id with a CPP_TEMPLATE_ID token. That way,
11716 should we re-parse the token stream, we will not have to repeat
11717 the effort required to do the parse, nor will we issue duplicate
11718 error messages about problems during instantiation of the
11722 cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);
11724 /* Reset the contents of the START_OF_ID token. */
11725 token->type = CPP_TEMPLATE_ID;
11726 /* Retrieve any deferred checks. Do not pop this access checks yet
11727 so the memory will not be reclaimed during token replacing below. */
11728 token->u.tree_check_value = ggc_alloc_cleared_tree_check ();
11729 token->u.tree_check_value->value = template_id;
11730 token->u.tree_check_value->checks = get_deferred_access_checks ();
11731 token->keyword = RID_MAX;
11733 /* Purge all subsequent tokens. */
11734 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
11736 /* ??? Can we actually assume that, if template_id ==
11737 error_mark_node, we will have issued a diagnostic to the
11738 user, as opposed to simply marking the tentative parse as
11740 if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
11741 error_at (token->location, "parse error in template argument list");
11744 pop_deferring_access_checks ();
11745 return template_id;
11748 /* Parse a template-name.
11753 The standard should actually say:
11757 operator-function-id
11759 A defect report has been filed about this issue.
11761 A conversion-function-id cannot be a template name because they cannot
11762 be part of a template-id. In fact, looking at this code:
11764 a.operator K<int>()
11766 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
11767 It is impossible to call a templated conversion-function-id with an
11768 explicit argument list, since the only allowed template parameter is
11769 the type to which it is converting.
11771 If TEMPLATE_KEYWORD_P is true, then we have just seen the
11772 `template' keyword, in a construction like:
11776 In that case `f' is taken to be a template-name, even though there
11777 is no way of knowing for sure.
11779 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
11780 name refers to a set of overloaded functions, at least one of which
11781 is a template, or an IDENTIFIER_NODE with the name of the template,
11782 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
11783 names are looked up inside uninstantiated templates. */
11786 cp_parser_template_name (cp_parser* parser,
11787 bool template_keyword_p,
11788 bool check_dependency_p,
11789 bool is_declaration,
11790 bool *is_identifier)
11795 cp_token *token = cp_lexer_peek_token (parser->lexer);
11797 /* If the next token is `operator', then we have either an
11798 operator-function-id or a conversion-function-id. */
11799 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
11801 /* We don't know whether we're looking at an
11802 operator-function-id or a conversion-function-id. */
11803 cp_parser_parse_tentatively (parser);
11804 /* Try an operator-function-id. */
11805 identifier = cp_parser_operator_function_id (parser);
11806 /* If that didn't work, try a conversion-function-id. */
11807 if (!cp_parser_parse_definitely (parser))
11809 cp_parser_error (parser, "expected template-name");
11810 return error_mark_node;
11813 /* Look for the identifier. */
11815 identifier = cp_parser_identifier (parser);
11817 /* If we didn't find an identifier, we don't have a template-id. */
11818 if (identifier == error_mark_node)
11819 return error_mark_node;
11821 /* If the name immediately followed the `template' keyword, then it
11822 is a template-name. However, if the next token is not `<', then
11823 we do not treat it as a template-name, since it is not being used
11824 as part of a template-id. This enables us to handle constructs
11827 template <typename T> struct S { S(); };
11828 template <typename T> S<T>::S();
11830 correctly. We would treat `S' as a template -- if it were `S<T>'
11831 -- but we do not if there is no `<'. */
11833 if (processing_template_decl
11834 && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
11836 /* In a declaration, in a dependent context, we pretend that the
11837 "template" keyword was present in order to improve error
11838 recovery. For example, given:
11840 template <typename T> void f(T::X<int>);
11842 we want to treat "X<int>" as a template-id. */
11844 && !template_keyword_p
11845 && parser->scope && TYPE_P (parser->scope)
11846 && check_dependency_p
11847 && dependent_scope_p (parser->scope)
11848 /* Do not do this for dtors (or ctors), since they never
11849 need the template keyword before their name. */
11850 && !constructor_name_p (identifier, parser->scope))
11852 cp_token_position start = 0;
11854 /* Explain what went wrong. */
11855 error_at (token->location, "non-template %qD used as template",
11857 inform (token->location, "use %<%T::template %D%> to indicate that it is a template",
11858 parser->scope, identifier);
11859 /* If parsing tentatively, find the location of the "<" token. */
11860 if (cp_parser_simulate_error (parser))
11861 start = cp_lexer_token_position (parser->lexer, true);
11862 /* Parse the template arguments so that we can issue error
11863 messages about them. */
11864 cp_lexer_consume_token (parser->lexer);
11865 cp_parser_enclosed_template_argument_list (parser);
11866 /* Skip tokens until we find a good place from which to
11867 continue parsing. */
11868 cp_parser_skip_to_closing_parenthesis (parser,
11869 /*recovering=*/true,
11871 /*consume_paren=*/false);
11872 /* If parsing tentatively, permanently remove the
11873 template argument list. That will prevent duplicate
11874 error messages from being issued about the missing
11875 "template" keyword. */
11877 cp_lexer_purge_tokens_after (parser->lexer, start);
11879 *is_identifier = true;
11883 /* If the "template" keyword is present, then there is generally
11884 no point in doing name-lookup, so we just return IDENTIFIER.
11885 But, if the qualifying scope is non-dependent then we can
11886 (and must) do name-lookup normally. */
11887 if (template_keyword_p
11889 || (TYPE_P (parser->scope)
11890 && dependent_type_p (parser->scope))))
11894 /* Look up the name. */
11895 decl = cp_parser_lookup_name (parser, identifier,
11897 /*is_template=*/true,
11898 /*is_namespace=*/false,
11899 check_dependency_p,
11900 /*ambiguous_decls=*/NULL,
11903 /* If DECL is a template, then the name was a template-name. */
11904 if (TREE_CODE (decl) == TEMPLATE_DECL)
11908 tree fn = NULL_TREE;
11910 /* The standard does not explicitly indicate whether a name that
11911 names a set of overloaded declarations, some of which are
11912 templates, is a template-name. However, such a name should
11913 be a template-name; otherwise, there is no way to form a
11914 template-id for the overloaded templates. */
11915 fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
11916 if (TREE_CODE (fns) == OVERLOAD)
11917 for (fn = fns; fn; fn = OVL_NEXT (fn))
11918 if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
11923 /* The name does not name a template. */
11924 cp_parser_error (parser, "expected template-name");
11925 return error_mark_node;
11929 /* If DECL is dependent, and refers to a function, then just return
11930 its name; we will look it up again during template instantiation. */
11931 if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
11933 tree scope = CP_DECL_CONTEXT (get_first_fn (decl));
11934 if (TYPE_P (scope) && dependent_type_p (scope))
11941 /* Parse a template-argument-list.
11943 template-argument-list:
11944 template-argument ... [opt]
11945 template-argument-list , template-argument ... [opt]
11947 Returns a TREE_VEC containing the arguments. */
11950 cp_parser_template_argument_list (cp_parser* parser)
11952 tree fixed_args[10];
11953 unsigned n_args = 0;
11954 unsigned alloced = 10;
11955 tree *arg_ary = fixed_args;
11957 bool saved_in_template_argument_list_p;
11959 bool saved_non_ice_p;
11961 saved_in_template_argument_list_p = parser->in_template_argument_list_p;
11962 parser->in_template_argument_list_p = true;
11963 /* Even if the template-id appears in an integral
11964 constant-expression, the contents of the argument list do
11966 saved_ice_p = parser->integral_constant_expression_p;
11967 parser->integral_constant_expression_p = false;
11968 saved_non_ice_p = parser->non_integral_constant_expression_p;
11969 parser->non_integral_constant_expression_p = false;
11970 /* Parse the arguments. */
11976 /* Consume the comma. */
11977 cp_lexer_consume_token (parser->lexer);
11979 /* Parse the template-argument. */
11980 argument = cp_parser_template_argument (parser);
11982 /* If the next token is an ellipsis, we're expanding a template
11984 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
11986 if (argument == error_mark_node)
11988 cp_token *token = cp_lexer_peek_token (parser->lexer);
11989 error_at (token->location,
11990 "expected parameter pack before %<...%>");
11992 /* Consume the `...' token. */
11993 cp_lexer_consume_token (parser->lexer);
11995 /* Make the argument into a TYPE_PACK_EXPANSION or
11996 EXPR_PACK_EXPANSION. */
11997 argument = make_pack_expansion (argument);
12000 if (n_args == alloced)
12004 if (arg_ary == fixed_args)
12006 arg_ary = XNEWVEC (tree, alloced);
12007 memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
12010 arg_ary = XRESIZEVEC (tree, arg_ary, alloced);
12012 arg_ary[n_args++] = argument;
12014 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
12016 vec = make_tree_vec (n_args);
12019 TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];
12021 if (arg_ary != fixed_args)
12023 parser->non_integral_constant_expression_p = saved_non_ice_p;
12024 parser->integral_constant_expression_p = saved_ice_p;
12025 parser->in_template_argument_list_p = saved_in_template_argument_list_p;
12026 #ifdef ENABLE_CHECKING
12027 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
12032 /* Parse a template-argument.
12035 assignment-expression
12039 The representation is that of an assignment-expression, type-id, or
12040 id-expression -- except that the qualified id-expression is
12041 evaluated, so that the value returned is either a DECL or an
12044 Although the standard says "assignment-expression", it forbids
12045 throw-expressions or assignments in the template argument.
12046 Therefore, we use "conditional-expression" instead. */
12049 cp_parser_template_argument (cp_parser* parser)
12054 bool maybe_type_id = false;
12055 cp_token *token = NULL, *argument_start_token = NULL;
12058 /* There's really no way to know what we're looking at, so we just
12059 try each alternative in order.
12063 In a template-argument, an ambiguity between a type-id and an
12064 expression is resolved to a type-id, regardless of the form of
12065 the corresponding template-parameter.
12067 Therefore, we try a type-id first. */
12068 cp_parser_parse_tentatively (parser);
12069 argument = cp_parser_template_type_arg (parser);
12070 /* If there was no error parsing the type-id but the next token is a
12071 '>>', our behavior depends on which dialect of C++ we're
12072 parsing. In C++98, we probably found a typo for '> >'. But there
12073 are type-id which are also valid expressions. For instance:
12075 struct X { int operator >> (int); };
12076 template <int V> struct Foo {};
12079 Here 'X()' is a valid type-id of a function type, but the user just
12080 wanted to write the expression "X() >> 5". Thus, we remember that we
12081 found a valid type-id, but we still try to parse the argument as an
12082 expression to see what happens.
12084 In C++0x, the '>>' will be considered two separate '>'
12086 if (!cp_parser_error_occurred (parser)
12087 && cxx_dialect == cxx98
12088 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
12090 maybe_type_id = true;
12091 cp_parser_abort_tentative_parse (parser);
12095 /* If the next token isn't a `,' or a `>', then this argument wasn't
12096 really finished. This means that the argument is not a valid
12098 if (!cp_parser_next_token_ends_template_argument_p (parser))
12099 cp_parser_error (parser, "expected template-argument");
12100 /* If that worked, we're done. */
12101 if (cp_parser_parse_definitely (parser))
12104 /* We're still not sure what the argument will be. */
12105 cp_parser_parse_tentatively (parser);
12106 /* Try a template. */
12107 argument_start_token = cp_lexer_peek_token (parser->lexer);
12108 argument = cp_parser_id_expression (parser,
12109 /*template_keyword_p=*/false,
12110 /*check_dependency_p=*/true,
12112 /*declarator_p=*/false,
12113 /*optional_p=*/false);
12114 /* If the next token isn't a `,' or a `>', then this argument wasn't
12115 really finished. */
12116 if (!cp_parser_next_token_ends_template_argument_p (parser))
12117 cp_parser_error (parser, "expected template-argument");
12118 if (!cp_parser_error_occurred (parser))
12120 /* Figure out what is being referred to. If the id-expression
12121 was for a class template specialization, then we will have a
12122 TYPE_DECL at this point. There is no need to do name lookup
12123 at this point in that case. */
12124 if (TREE_CODE (argument) != TYPE_DECL)
12125 argument = cp_parser_lookup_name (parser, argument,
12127 /*is_template=*/template_p,
12128 /*is_namespace=*/false,
12129 /*check_dependency=*/true,
12130 /*ambiguous_decls=*/NULL,
12131 argument_start_token->location);
12132 if (TREE_CODE (argument) != TEMPLATE_DECL
12133 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
12134 cp_parser_error (parser, "expected template-name");
12136 if (cp_parser_parse_definitely (parser))
12138 /* It must be a non-type argument. There permitted cases are given
12139 in [temp.arg.nontype]:
12141 -- an integral constant-expression of integral or enumeration
12144 -- the name of a non-type template-parameter; or
12146 -- the name of an object or function with external linkage...
12148 -- the address of an object or function with external linkage...
12150 -- a pointer to member... */
12151 /* Look for a non-type template parameter. */
12152 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
12154 cp_parser_parse_tentatively (parser);
12155 argument = cp_parser_primary_expression (parser,
12156 /*address_p=*/false,
12158 /*template_arg_p=*/true,
12160 if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
12161 || !cp_parser_next_token_ends_template_argument_p (parser))
12162 cp_parser_simulate_error (parser);
12163 if (cp_parser_parse_definitely (parser))
12167 /* If the next token is "&", the argument must be the address of an
12168 object or function with external linkage. */
12169 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
12171 cp_lexer_consume_token (parser->lexer);
12172 /* See if we might have an id-expression. */
12173 token = cp_lexer_peek_token (parser->lexer);
12174 if (token->type == CPP_NAME
12175 || token->keyword == RID_OPERATOR
12176 || token->type == CPP_SCOPE
12177 || token->type == CPP_TEMPLATE_ID
12178 || token->type == CPP_NESTED_NAME_SPECIFIER)
12180 cp_parser_parse_tentatively (parser);
12181 argument = cp_parser_primary_expression (parser,
12184 /*template_arg_p=*/true,
12186 if (cp_parser_error_occurred (parser)
12187 || !cp_parser_next_token_ends_template_argument_p (parser))
12188 cp_parser_abort_tentative_parse (parser);
12193 if (TREE_CODE (argument) == INDIRECT_REF)
12195 gcc_assert (REFERENCE_REF_P (argument));
12196 argument = TREE_OPERAND (argument, 0);
12199 /* If we're in a template, we represent a qualified-id referring
12200 to a static data member as a SCOPE_REF even if the scope isn't
12201 dependent so that we can check access control later. */
12203 if (TREE_CODE (probe) == SCOPE_REF)
12204 probe = TREE_OPERAND (probe, 1);
12205 if (TREE_CODE (probe) == VAR_DECL)
12207 /* A variable without external linkage might still be a
12208 valid constant-expression, so no error is issued here
12209 if the external-linkage check fails. */
12210 if (!address_p && !DECL_EXTERNAL_LINKAGE_P (probe))
12211 cp_parser_simulate_error (parser);
12213 else if (is_overloaded_fn (argument))
12214 /* All overloaded functions are allowed; if the external
12215 linkage test does not pass, an error will be issued
12219 && (TREE_CODE (argument) == OFFSET_REF
12220 || TREE_CODE (argument) == SCOPE_REF))
12221 /* A pointer-to-member. */
12223 else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
12226 cp_parser_simulate_error (parser);
12228 if (cp_parser_parse_definitely (parser))
12231 argument = build_x_unary_op (ADDR_EXPR, argument,
12232 tf_warning_or_error);
12237 /* If the argument started with "&", there are no other valid
12238 alternatives at this point. */
12241 cp_parser_error (parser, "invalid non-type template argument");
12242 return error_mark_node;
12245 /* If the argument wasn't successfully parsed as a type-id followed
12246 by '>>', the argument can only be a constant expression now.
12247 Otherwise, we try parsing the constant-expression tentatively,
12248 because the argument could really be a type-id. */
12250 cp_parser_parse_tentatively (parser);
12251 argument = cp_parser_constant_expression (parser,
12252 /*allow_non_constant_p=*/false,
12253 /*non_constant_p=*/NULL);
12254 argument = fold_non_dependent_expr (argument);
12255 if (!maybe_type_id)
12257 if (!cp_parser_next_token_ends_template_argument_p (parser))
12258 cp_parser_error (parser, "expected template-argument");
12259 if (cp_parser_parse_definitely (parser))
12261 /* We did our best to parse the argument as a non type-id, but that
12262 was the only alternative that matched (albeit with a '>' after
12263 it). We can assume it's just a typo from the user, and a
12264 diagnostic will then be issued. */
12265 return cp_parser_template_type_arg (parser);
12268 /* Parse an explicit-instantiation.
12270 explicit-instantiation:
12271 template declaration
12273 Although the standard says `declaration', what it really means is:
12275 explicit-instantiation:
12276 template decl-specifier-seq [opt] declarator [opt] ;
12278 Things like `template int S<int>::i = 5, int S<double>::j;' are not
12279 supposed to be allowed. A defect report has been filed about this
12284 explicit-instantiation:
12285 storage-class-specifier template
12286 decl-specifier-seq [opt] declarator [opt] ;
12287 function-specifier template
12288 decl-specifier-seq [opt] declarator [opt] ; */
12291 cp_parser_explicit_instantiation (cp_parser* parser)
12293 int declares_class_or_enum;
12294 cp_decl_specifier_seq decl_specifiers;
12295 tree extension_specifier = NULL_TREE;
12297 timevar_push (TV_TEMPLATE_INST);
12299 /* Look for an (optional) storage-class-specifier or
12300 function-specifier. */
12301 if (cp_parser_allow_gnu_extensions_p (parser))
12303 extension_specifier
12304 = cp_parser_storage_class_specifier_opt (parser);
12305 if (!extension_specifier)
12306 extension_specifier
12307 = cp_parser_function_specifier_opt (parser,
12308 /*decl_specs=*/NULL);
12311 /* Look for the `template' keyword. */
12312 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
12313 /* Let the front end know that we are processing an explicit
12315 begin_explicit_instantiation ();
12316 /* [temp.explicit] says that we are supposed to ignore access
12317 control while processing explicit instantiation directives. */
12318 push_deferring_access_checks (dk_no_check);
12319 /* Parse a decl-specifier-seq. */
12320 cp_parser_decl_specifier_seq (parser,
12321 CP_PARSER_FLAGS_OPTIONAL,
12323 &declares_class_or_enum);
12324 /* If there was exactly one decl-specifier, and it declared a class,
12325 and there's no declarator, then we have an explicit type
12327 if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
12331 type = check_tag_decl (&decl_specifiers);
12332 /* Turn access control back on for names used during
12333 template instantiation. */
12334 pop_deferring_access_checks ();
12336 do_type_instantiation (type, extension_specifier,
12337 /*complain=*/tf_error);
12341 cp_declarator *declarator;
12344 /* Parse the declarator. */
12346 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
12347 /*ctor_dtor_or_conv_p=*/NULL,
12348 /*parenthesized_p=*/NULL,
12349 /*member_p=*/false);
12350 if (declares_class_or_enum & 2)
12351 cp_parser_check_for_definition_in_return_type (declarator,
12352 decl_specifiers.type,
12353 decl_specifiers.type_location);
12354 if (declarator != cp_error_declarator)
12356 if (decl_specifiers.specs[(int)ds_inline])
12357 permerror (input_location, "explicit instantiation shall not use"
12358 " %<inline%> specifier");
12359 if (decl_specifiers.specs[(int)ds_constexpr])
12360 permerror (input_location, "explicit instantiation shall not use"
12361 " %<constexpr%> specifier");
12363 decl = grokdeclarator (declarator, &decl_specifiers,
12364 NORMAL, 0, &decl_specifiers.attributes);
12365 /* Turn access control back on for names used during
12366 template instantiation. */
12367 pop_deferring_access_checks ();
12368 /* Do the explicit instantiation. */
12369 do_decl_instantiation (decl, extension_specifier);
12373 pop_deferring_access_checks ();
12374 /* Skip the body of the explicit instantiation. */
12375 cp_parser_skip_to_end_of_statement (parser);
12378 /* We're done with the instantiation. */
12379 end_explicit_instantiation ();
12381 cp_parser_consume_semicolon_at_end_of_statement (parser);
12383 timevar_pop (TV_TEMPLATE_INST);
12386 /* Parse an explicit-specialization.
12388 explicit-specialization:
12389 template < > declaration
12391 Although the standard says `declaration', what it really means is:
12393 explicit-specialization:
12394 template <> decl-specifier [opt] init-declarator [opt] ;
12395 template <> function-definition
12396 template <> explicit-specialization
12397 template <> template-declaration */
12400 cp_parser_explicit_specialization (cp_parser* parser)
12402 bool need_lang_pop;
12403 cp_token *token = cp_lexer_peek_token (parser->lexer);
12405 /* Look for the `template' keyword. */
12406 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
12407 /* Look for the `<'. */
12408 cp_parser_require (parser, CPP_LESS, RT_LESS);
12409 /* Look for the `>'. */
12410 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
12411 /* We have processed another parameter list. */
12412 ++parser->num_template_parameter_lists;
12415 A template ... explicit specialization ... shall not have C
12417 if (current_lang_name == lang_name_c)
12419 error_at (token->location, "template specialization with C linkage");
12420 /* Give it C++ linkage to avoid confusing other parts of the
12422 push_lang_context (lang_name_cplusplus);
12423 need_lang_pop = true;
12426 need_lang_pop = false;
12427 /* Let the front end know that we are beginning a specialization. */
12428 if (!begin_specialization ())
12430 end_specialization ();
12434 /* If the next keyword is `template', we need to figure out whether
12435 or not we're looking a template-declaration. */
12436 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
12438 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
12439 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
12440 cp_parser_template_declaration_after_export (parser,
12441 /*member_p=*/false);
12443 cp_parser_explicit_specialization (parser);
12446 /* Parse the dependent declaration. */
12447 cp_parser_single_declaration (parser,
12449 /*member_p=*/false,
12450 /*explicit_specialization_p=*/true,
12451 /*friend_p=*/NULL);
12452 /* We're done with the specialization. */
12453 end_specialization ();
12454 /* For the erroneous case of a template with C linkage, we pushed an
12455 implicit C++ linkage scope; exit that scope now. */
12457 pop_lang_context ();
12458 /* We're done with this parameter list. */
12459 --parser->num_template_parameter_lists;
12462 /* Parse a type-specifier.
12465 simple-type-specifier
12468 elaborated-type-specifier
12476 Returns a representation of the type-specifier. For a
12477 class-specifier, enum-specifier, or elaborated-type-specifier, a
12478 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
12480 The parser flags FLAGS is used to control type-specifier parsing.
12482 If IS_DECLARATION is TRUE, then this type-specifier is appearing
12483 in a decl-specifier-seq.
12485 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
12486 class-specifier, enum-specifier, or elaborated-type-specifier, then
12487 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
12488 if a type is declared; 2 if it is defined. Otherwise, it is set to
12491 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
12492 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
12493 is set to FALSE. */
12496 cp_parser_type_specifier (cp_parser* parser,
12497 cp_parser_flags flags,
12498 cp_decl_specifier_seq *decl_specs,
12499 bool is_declaration,
12500 int* declares_class_or_enum,
12501 bool* is_cv_qualifier)
12503 tree type_spec = NULL_TREE;
12506 cp_decl_spec ds = ds_last;
12508 /* Assume this type-specifier does not declare a new type. */
12509 if (declares_class_or_enum)
12510 *declares_class_or_enum = 0;
12511 /* And that it does not specify a cv-qualifier. */
12512 if (is_cv_qualifier)
12513 *is_cv_qualifier = false;
12514 /* Peek at the next token. */
12515 token = cp_lexer_peek_token (parser->lexer);
12517 /* If we're looking at a keyword, we can use that to guide the
12518 production we choose. */
12519 keyword = token->keyword;
12523 if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
12524 goto elaborated_type_specifier;
12526 /* Look for the enum-specifier. */
12527 type_spec = cp_parser_enum_specifier (parser);
12528 /* If that worked, we're done. */
12531 if (declares_class_or_enum)
12532 *declares_class_or_enum = 2;
12534 cp_parser_set_decl_spec_type (decl_specs,
12537 /*user_defined_p=*/true);
12541 goto elaborated_type_specifier;
12543 /* Any of these indicate either a class-specifier, or an
12544 elaborated-type-specifier. */
12548 if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
12549 goto elaborated_type_specifier;
12551 /* Parse tentatively so that we can back up if we don't find a
12552 class-specifier. */
12553 cp_parser_parse_tentatively (parser);
12554 /* Look for the class-specifier. */
12555 type_spec = cp_parser_class_specifier (parser);
12556 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, type_spec);
12557 /* If that worked, we're done. */
12558 if (cp_parser_parse_definitely (parser))
12560 if (declares_class_or_enum)
12561 *declares_class_or_enum = 2;
12563 cp_parser_set_decl_spec_type (decl_specs,
12566 /*user_defined_p=*/true);
12570 /* Fall through. */
12571 elaborated_type_specifier:
12572 /* We're declaring (not defining) a class or enum. */
12573 if (declares_class_or_enum)
12574 *declares_class_or_enum = 1;
12576 /* Fall through. */
12578 /* Look for an elaborated-type-specifier. */
12580 = (cp_parser_elaborated_type_specifier
12582 decl_specs && decl_specs->specs[(int) ds_friend],
12585 cp_parser_set_decl_spec_type (decl_specs,
12588 /*user_defined_p=*/true);
12593 if (is_cv_qualifier)
12594 *is_cv_qualifier = true;
12599 if (is_cv_qualifier)
12600 *is_cv_qualifier = true;
12605 if (is_cv_qualifier)
12606 *is_cv_qualifier = true;
12610 /* The `__complex__' keyword is a GNU extension. */
12618 /* Handle simple keywords. */
12623 ++decl_specs->specs[(int)ds];
12624 decl_specs->any_specifiers_p = true;
12626 return cp_lexer_consume_token (parser->lexer)->u.value;
12629 /* If we do not already have a type-specifier, assume we are looking
12630 at a simple-type-specifier. */
12631 type_spec = cp_parser_simple_type_specifier (parser,
12635 /* If we didn't find a type-specifier, and a type-specifier was not
12636 optional in this context, issue an error message. */
12637 if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
12639 cp_parser_error (parser, "expected type specifier");
12640 return error_mark_node;
12646 /* Parse a simple-type-specifier.
12648 simple-type-specifier:
12649 :: [opt] nested-name-specifier [opt] type-name
12650 :: [opt] nested-name-specifier template template-id
12665 simple-type-specifier:
12667 decltype ( expression )
12670 __underlying_type ( type-id )
12674 simple-type-specifier:
12676 __typeof__ unary-expression
12677 __typeof__ ( type-id )
12679 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
12680 appropriately updated. */
12683 cp_parser_simple_type_specifier (cp_parser* parser,
12684 cp_decl_specifier_seq *decl_specs,
12685 cp_parser_flags flags)
12687 tree type = NULL_TREE;
12690 /* Peek at the next token. */
12691 token = cp_lexer_peek_token (parser->lexer);
12693 /* If we're looking at a keyword, things are easy. */
12694 switch (token->keyword)
12698 decl_specs->explicit_char_p = true;
12699 type = char_type_node;
12702 type = char16_type_node;
12705 type = char32_type_node;
12708 type = wchar_type_node;
12711 type = boolean_type_node;
12715 ++decl_specs->specs[(int) ds_short];
12716 type = short_integer_type_node;
12720 decl_specs->explicit_int_p = true;
12721 type = integer_type_node;
12724 if (!int128_integer_type_node)
12727 decl_specs->explicit_int128_p = true;
12728 type = int128_integer_type_node;
12732 ++decl_specs->specs[(int) ds_long];
12733 type = long_integer_type_node;
12737 ++decl_specs->specs[(int) ds_signed];
12738 type = integer_type_node;
12742 ++decl_specs->specs[(int) ds_unsigned];
12743 type = unsigned_type_node;
12746 type = float_type_node;
12749 type = double_type_node;
12752 type = void_type_node;
12756 maybe_warn_cpp0x (CPP0X_AUTO);
12757 type = make_auto ();
12761 /* Since DR 743, decltype can either be a simple-type-specifier by
12762 itself or begin a nested-name-specifier. Parsing it will replace
12763 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
12764 handling below decide what to do. */
12765 cp_parser_decltype (parser);
12766 cp_lexer_set_token_position (parser->lexer, token);
12770 /* Consume the `typeof' token. */
12771 cp_lexer_consume_token (parser->lexer);
12772 /* Parse the operand to `typeof'. */
12773 type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
12774 /* If it is not already a TYPE, take its type. */
12775 if (!TYPE_P (type))
12776 type = finish_typeof (type);
12779 cp_parser_set_decl_spec_type (decl_specs, type,
12781 /*user_defined_p=*/true);
12785 case RID_UNDERLYING_TYPE:
12786 type = cp_parser_trait_expr (parser, RID_UNDERLYING_TYPE);
12789 cp_parser_set_decl_spec_type (decl_specs, type,
12791 /*user_defined_p=*/true);
12799 /* If token is an already-parsed decltype not followed by ::,
12800 it's a simple-type-specifier. */
12801 if (token->type == CPP_DECLTYPE
12802 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
12804 type = token->u.value;
12806 cp_parser_set_decl_spec_type (decl_specs, type,
12808 /*user_defined_p=*/true);
12809 cp_lexer_consume_token (parser->lexer);
12813 /* If the type-specifier was for a built-in type, we're done. */
12816 /* Record the type. */
12818 && (token->keyword != RID_SIGNED
12819 && token->keyword != RID_UNSIGNED
12820 && token->keyword != RID_SHORT
12821 && token->keyword != RID_LONG))
12822 cp_parser_set_decl_spec_type (decl_specs,
12825 /*user_defined=*/false);
12827 decl_specs->any_specifiers_p = true;
12829 /* Consume the token. */
12830 cp_lexer_consume_token (parser->lexer);
12832 /* There is no valid C++ program where a non-template type is
12833 followed by a "<". That usually indicates that the user thought
12834 that the type was a template. */
12835 cp_parser_check_for_invalid_template_id (parser, type, token->location);
12837 return TYPE_NAME (type);
12840 /* The type-specifier must be a user-defined type. */
12841 if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
12846 /* Don't gobble tokens or issue error messages if this is an
12847 optional type-specifier. */
12848 if (flags & CP_PARSER_FLAGS_OPTIONAL)
12849 cp_parser_parse_tentatively (parser);
12851 /* Look for the optional `::' operator. */
12853 = (cp_parser_global_scope_opt (parser,
12854 /*current_scope_valid_p=*/false)
12856 /* Look for the nested-name specifier. */
12858 = (cp_parser_nested_name_specifier_opt (parser,
12859 /*typename_keyword_p=*/false,
12860 /*check_dependency_p=*/true,
12862 /*is_declaration=*/false)
12864 token = cp_lexer_peek_token (parser->lexer);
12865 /* If we have seen a nested-name-specifier, and the next token
12866 is `template', then we are using the template-id production. */
12868 && cp_parser_optional_template_keyword (parser))
12870 /* Look for the template-id. */
12871 type = cp_parser_template_id (parser,
12872 /*template_keyword_p=*/true,
12873 /*check_dependency_p=*/true,
12874 /*is_declaration=*/false);
12875 /* If the template-id did not name a type, we are out of
12877 if (TREE_CODE (type) != TYPE_DECL)
12879 cp_parser_error (parser, "expected template-id for type");
12883 /* Otherwise, look for a type-name. */
12885 type = cp_parser_type_name (parser);
12886 /* Keep track of all name-lookups performed in class scopes. */
12890 && TREE_CODE (type) == TYPE_DECL
12891 && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE)
12892 maybe_note_name_used_in_class (DECL_NAME (type), type);
12893 /* If it didn't work out, we don't have a TYPE. */
12894 if ((flags & CP_PARSER_FLAGS_OPTIONAL)
12895 && !cp_parser_parse_definitely (parser))
12897 if (type && decl_specs)
12898 cp_parser_set_decl_spec_type (decl_specs, type,
12900 /*user_defined=*/true);
12903 /* If we didn't get a type-name, issue an error message. */
12904 if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
12906 cp_parser_error (parser, "expected type-name");
12907 return error_mark_node;
12910 if (type && type != error_mark_node)
12912 /* See if TYPE is an Objective-C type, and if so, parse and
12913 accept any protocol references following it. Do this before
12914 the cp_parser_check_for_invalid_template_id() call, because
12915 Objective-C types can be followed by '<...>' which would
12916 enclose protocol names rather than template arguments, and so
12917 everything is fine. */
12918 if (c_dialect_objc () && !parser->scope
12919 && (objc_is_id (type) || objc_is_class_name (type)))
12921 tree protos = cp_parser_objc_protocol_refs_opt (parser);
12922 tree qual_type = objc_get_protocol_qualified_type (type, protos);
12924 /* Clobber the "unqualified" type previously entered into
12925 DECL_SPECS with the new, improved protocol-qualified version. */
12927 decl_specs->type = qual_type;
12932 /* There is no valid C++ program where a non-template type is
12933 followed by a "<". That usually indicates that the user
12934 thought that the type was a template. */
12935 cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type),
12942 /* Parse a type-name.
12955 Returns a TYPE_DECL for the type. */
12958 cp_parser_type_name (cp_parser* parser)
12962 /* We can't know yet whether it is a class-name or not. */
12963 cp_parser_parse_tentatively (parser);
12964 /* Try a class-name. */
12965 type_decl = cp_parser_class_name (parser,
12966 /*typename_keyword_p=*/false,
12967 /*template_keyword_p=*/false,
12969 /*check_dependency_p=*/true,
12970 /*class_head_p=*/false,
12971 /*is_declaration=*/false);
12972 /* If it's not a class-name, keep looking. */
12973 if (!cp_parser_parse_definitely (parser))
12975 /* It must be a typedef-name or an enum-name. */
12976 return cp_parser_nonclass_name (parser);
12982 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
12990 Returns a TYPE_DECL for the type. */
12993 cp_parser_nonclass_name (cp_parser* parser)
12998 cp_token *token = cp_lexer_peek_token (parser->lexer);
12999 identifier = cp_parser_identifier (parser);
13000 if (identifier == error_mark_node)
13001 return error_mark_node;
13003 /* Look up the type-name. */
13004 type_decl = cp_parser_lookup_name_simple (parser, identifier, token->location);
13006 if (TREE_CODE (type_decl) != TYPE_DECL
13007 && (objc_is_id (identifier) || objc_is_class_name (identifier)))
13009 /* See if this is an Objective-C type. */
13010 tree protos = cp_parser_objc_protocol_refs_opt (parser);
13011 tree type = objc_get_protocol_qualified_type (identifier, protos);
13013 type_decl = TYPE_NAME (type);
13016 /* Issue an error if we did not find a type-name. */
13017 if (TREE_CODE (type_decl) != TYPE_DECL
13018 /* In Objective-C, we have the complication that class names are
13019 normally type names and start declarations (eg, the
13020 "NSObject" in "NSObject *object;"), but can be used in an
13021 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
13022 is an expression. So, a classname followed by a dot is not a
13023 valid type-name. */
13024 || (objc_is_class_name (TREE_TYPE (type_decl))
13025 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT))
13027 if (!cp_parser_simulate_error (parser))
13028 cp_parser_name_lookup_error (parser, identifier, type_decl,
13029 NLE_TYPE, token->location);
13030 return error_mark_node;
13032 /* Remember that the name was used in the definition of the
13033 current class so that we can check later to see if the
13034 meaning would have been different after the class was
13035 entirely defined. */
13036 else if (type_decl != error_mark_node
13038 maybe_note_name_used_in_class (identifier, type_decl);
13043 /* Parse an elaborated-type-specifier. Note that the grammar given
13044 here incorporates the resolution to DR68.
13046 elaborated-type-specifier:
13047 class-key :: [opt] nested-name-specifier [opt] identifier
13048 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
13049 enum-key :: [opt] nested-name-specifier [opt] identifier
13050 typename :: [opt] nested-name-specifier identifier
13051 typename :: [opt] nested-name-specifier template [opt]
13056 elaborated-type-specifier:
13057 class-key attributes :: [opt] nested-name-specifier [opt] identifier
13058 class-key attributes :: [opt] nested-name-specifier [opt]
13059 template [opt] template-id
13060 enum attributes :: [opt] nested-name-specifier [opt] identifier
13062 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
13063 declared `friend'. If IS_DECLARATION is TRUE, then this
13064 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
13065 something is being declared.
13067 Returns the TYPE specified. */
13070 cp_parser_elaborated_type_specifier (cp_parser* parser,
13072 bool is_declaration)
13074 enum tag_types tag_type;
13076 tree type = NULL_TREE;
13077 tree attributes = NULL_TREE;
13079 cp_token *token = NULL;
13081 /* See if we're looking at the `enum' keyword. */
13082 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
13084 /* Consume the `enum' token. */
13085 cp_lexer_consume_token (parser->lexer);
13086 /* Remember that it's an enumeration type. */
13087 tag_type = enum_type;
13088 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
13089 enums) is used here. */
13090 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
13091 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
13093 pedwarn (input_location, 0, "elaborated-type-specifier "
13094 "for a scoped enum must not use the %<%D%> keyword",
13095 cp_lexer_peek_token (parser->lexer)->u.value);
13096 /* Consume the `struct' or `class' and parse it anyway. */
13097 cp_lexer_consume_token (parser->lexer);
13099 /* Parse the attributes. */
13100 attributes = cp_parser_attributes_opt (parser);
13102 /* Or, it might be `typename'. */
13103 else if (cp_lexer_next_token_is_keyword (parser->lexer,
13106 /* Consume the `typename' token. */
13107 cp_lexer_consume_token (parser->lexer);
13108 /* Remember that it's a `typename' type. */
13109 tag_type = typename_type;
13111 /* Otherwise it must be a class-key. */
13114 tag_type = cp_parser_class_key (parser);
13115 if (tag_type == none_type)
13116 return error_mark_node;
13117 /* Parse the attributes. */
13118 attributes = cp_parser_attributes_opt (parser);
13121 /* Look for the `::' operator. */
13122 globalscope = cp_parser_global_scope_opt (parser,
13123 /*current_scope_valid_p=*/false);
13124 /* Look for the nested-name-specifier. */
13125 if (tag_type == typename_type && !globalscope)
13127 if (!cp_parser_nested_name_specifier (parser,
13128 /*typename_keyword_p=*/true,
13129 /*check_dependency_p=*/true,
13132 return error_mark_node;
13135 /* Even though `typename' is not present, the proposed resolution
13136 to Core Issue 180 says that in `class A<T>::B', `B' should be
13137 considered a type-name, even if `A<T>' is dependent. */
13138 cp_parser_nested_name_specifier_opt (parser,
13139 /*typename_keyword_p=*/true,
13140 /*check_dependency_p=*/true,
13143 /* For everything but enumeration types, consider a template-id.
13144 For an enumeration type, consider only a plain identifier. */
13145 if (tag_type != enum_type)
13147 bool template_p = false;
13150 /* Allow the `template' keyword. */
13151 template_p = cp_parser_optional_template_keyword (parser);
13152 /* If we didn't see `template', we don't know if there's a
13153 template-id or not. */
13155 cp_parser_parse_tentatively (parser);
13156 /* Parse the template-id. */
13157 token = cp_lexer_peek_token (parser->lexer);
13158 decl = cp_parser_template_id (parser, template_p,
13159 /*check_dependency_p=*/true,
13161 /* If we didn't find a template-id, look for an ordinary
13163 if (!template_p && !cp_parser_parse_definitely (parser))
13165 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
13166 in effect, then we must assume that, upon instantiation, the
13167 template will correspond to a class. */
13168 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
13169 && tag_type == typename_type)
13170 type = make_typename_type (parser->scope, decl,
13172 /*complain=*/tf_error);
13173 /* If the `typename' keyword is in effect and DECL is not a type
13174 decl. Then type is non existant. */
13175 else if (tag_type == typename_type && TREE_CODE (decl) != TYPE_DECL)
13178 type = TREE_TYPE (decl);
13183 token = cp_lexer_peek_token (parser->lexer);
13184 identifier = cp_parser_identifier (parser);
13186 if (identifier == error_mark_node)
13188 parser->scope = NULL_TREE;
13189 return error_mark_node;
13192 /* For a `typename', we needn't call xref_tag. */
13193 if (tag_type == typename_type
13194 && TREE_CODE (parser->scope) != NAMESPACE_DECL)
13195 return cp_parser_make_typename_type (parser, parser->scope,
13198 /* Look up a qualified name in the usual way. */
13202 tree ambiguous_decls;
13204 decl = cp_parser_lookup_name (parser, identifier,
13206 /*is_template=*/false,
13207 /*is_namespace=*/false,
13208 /*check_dependency=*/true,
13212 /* If the lookup was ambiguous, an error will already have been
13214 if (ambiguous_decls)
13215 return error_mark_node;
13217 /* If we are parsing friend declaration, DECL may be a
13218 TEMPLATE_DECL tree node here. However, we need to check
13219 whether this TEMPLATE_DECL results in valid code. Consider
13220 the following example:
13223 template <class T> class C {};
13226 template <class T> friend class N::C; // #1, valid code
13228 template <class T> class Y {
13229 friend class N::C; // #2, invalid code
13232 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
13233 name lookup of `N::C'. We see that friend declaration must
13234 be template for the code to be valid. Note that
13235 processing_template_decl does not work here since it is
13236 always 1 for the above two cases. */
13238 decl = (cp_parser_maybe_treat_template_as_class
13239 (decl, /*tag_name_p=*/is_friend
13240 && parser->num_template_parameter_lists));
13242 if (TREE_CODE (decl) != TYPE_DECL)
13244 cp_parser_diagnose_invalid_type_name (parser,
13248 return error_mark_node;
13251 if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
13253 bool allow_template = (parser->num_template_parameter_lists
13254 || DECL_SELF_REFERENCE_P (decl));
13255 type = check_elaborated_type_specifier (tag_type, decl,
13258 if (type == error_mark_node)
13259 return error_mark_node;
13262 /* Forward declarations of nested types, such as
13267 are invalid unless all components preceding the final '::'
13268 are complete. If all enclosing types are complete, these
13269 declarations become merely pointless.
13271 Invalid forward declarations of nested types are errors
13272 caught elsewhere in parsing. Those that are pointless arrive
13275 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
13276 && !is_friend && !processing_explicit_instantiation)
13277 warning (0, "declaration %qD does not declare anything", decl);
13279 type = TREE_TYPE (decl);
13283 /* An elaborated-type-specifier sometimes introduces a new type and
13284 sometimes names an existing type. Normally, the rule is that it
13285 introduces a new type only if there is not an existing type of
13286 the same name already in scope. For example, given:
13289 void f() { struct S s; }
13291 the `struct S' in the body of `f' is the same `struct S' as in
13292 the global scope; the existing definition is used. However, if
13293 there were no global declaration, this would introduce a new
13294 local class named `S'.
13296 An exception to this rule applies to the following code:
13298 namespace N { struct S; }
13300 Here, the elaborated-type-specifier names a new type
13301 unconditionally; even if there is already an `S' in the
13302 containing scope this declaration names a new type.
13303 This exception only applies if the elaborated-type-specifier
13304 forms the complete declaration:
13308 A declaration consisting solely of `class-key identifier ;' is
13309 either a redeclaration of the name in the current scope or a
13310 forward declaration of the identifier as a class name. It
13311 introduces the name into the current scope.
13313 We are in this situation precisely when the next token is a `;'.
13315 An exception to the exception is that a `friend' declaration does
13316 *not* name a new type; i.e., given:
13318 struct S { friend struct T; };
13320 `T' is not a new type in the scope of `S'.
13322 Also, `new struct S' or `sizeof (struct S)' never results in the
13323 definition of a new type; a new type can only be declared in a
13324 declaration context. */
13330 /* Friends have special name lookup rules. */
13331 ts = ts_within_enclosing_non_class;
13332 else if (is_declaration
13333 && cp_lexer_next_token_is (parser->lexer,
13335 /* This is a `class-key identifier ;' */
13341 (parser->num_template_parameter_lists
13342 && (cp_parser_next_token_starts_class_definition_p (parser)
13343 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
13344 /* An unqualified name was used to reference this type, so
13345 there were no qualifying templates. */
13346 if (!cp_parser_check_template_parameters (parser,
13347 /*num_templates=*/0,
13349 /*declarator=*/NULL))
13350 return error_mark_node;
13351 type = xref_tag (tag_type, identifier, ts, template_p);
13355 if (type == error_mark_node)
13356 return error_mark_node;
13358 /* Allow attributes on forward declarations of classes. */
13361 if (TREE_CODE (type) == TYPENAME_TYPE)
13362 warning (OPT_Wattributes,
13363 "attributes ignored on uninstantiated type");
13364 else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
13365 && ! processing_explicit_instantiation)
13366 warning (OPT_Wattributes,
13367 "attributes ignored on template instantiation");
13368 else if (is_declaration && cp_parser_declares_only_class_p (parser))
13369 cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
13371 warning (OPT_Wattributes,
13372 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
13375 if (tag_type != enum_type)
13376 cp_parser_check_class_key (tag_type, type);
13378 /* A "<" cannot follow an elaborated type specifier. If that
13379 happens, the user was probably trying to form a template-id. */
13380 cp_parser_check_for_invalid_template_id (parser, type, token->location);
13385 /* Parse an enum-specifier.
13388 enum-head { enumerator-list [opt] }
13391 enum-key identifier [opt] enum-base [opt]
13392 enum-key nested-name-specifier identifier enum-base [opt]
13397 enum struct [C++0x]
13400 : type-specifier-seq
13402 opaque-enum-specifier:
13403 enum-key identifier enum-base [opt] ;
13406 enum-key attributes[opt] identifier [opt] enum-base [opt]
13407 { enumerator-list [opt] }attributes[opt]
13409 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
13410 if the token stream isn't an enum-specifier after all. */
13413 cp_parser_enum_specifier (cp_parser* parser)
13416 tree type = NULL_TREE;
13418 tree nested_name_specifier = NULL_TREE;
13420 bool scoped_enum_p = false;
13421 bool has_underlying_type = false;
13422 bool nested_being_defined = false;
13423 bool new_value_list = false;
13424 bool is_new_type = false;
13425 bool is_anonymous = false;
13426 tree underlying_type = NULL_TREE;
13427 cp_token *type_start_token = NULL;
13428 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
13430 parser->colon_corrects_to_scope_p = false;
13432 /* Parse tentatively so that we can back up if we don't find a
13434 cp_parser_parse_tentatively (parser);
13436 /* Caller guarantees that the current token is 'enum', an identifier
13437 possibly follows, and the token after that is an opening brace.
13438 If we don't have an identifier, fabricate an anonymous name for
13439 the enumeration being defined. */
13440 cp_lexer_consume_token (parser->lexer);
13442 /* Parse the "class" or "struct", which indicates a scoped
13443 enumeration type in C++0x. */
13444 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
13445 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
13447 if (cxx_dialect < cxx0x)
13448 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
13450 /* Consume the `struct' or `class' token. */
13451 cp_lexer_consume_token (parser->lexer);
13453 scoped_enum_p = true;
13456 attributes = cp_parser_attributes_opt (parser);
13458 /* Clear the qualification. */
13459 parser->scope = NULL_TREE;
13460 parser->qualifying_scope = NULL_TREE;
13461 parser->object_scope = NULL_TREE;
13463 /* Figure out in what scope the declaration is being placed. */
13464 prev_scope = current_scope ();
13466 type_start_token = cp_lexer_peek_token (parser->lexer);
13468 push_deferring_access_checks (dk_no_check);
13469 nested_name_specifier
13470 = cp_parser_nested_name_specifier_opt (parser,
13471 /*typename_keyword_p=*/true,
13472 /*check_dependency_p=*/false,
13474 /*is_declaration=*/false);
13476 if (nested_name_specifier)
13480 identifier = cp_parser_identifier (parser);
13481 name = cp_parser_lookup_name (parser, identifier,
13483 /*is_template=*/false,
13484 /*is_namespace=*/false,
13485 /*check_dependency=*/true,
13486 /*ambiguous_decls=*/NULL,
13490 type = TREE_TYPE (name);
13491 if (TREE_CODE (type) == TYPENAME_TYPE)
13493 /* Are template enums allowed in ISO? */
13494 if (template_parm_scope_p ())
13495 pedwarn (type_start_token->location, OPT_pedantic,
13496 "%qD is an enumeration template", name);
13497 /* ignore a typename reference, for it will be solved by name
13503 error_at (type_start_token->location,
13504 "%qD is not an enumerator-name", identifier);
13508 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
13509 identifier = cp_parser_identifier (parser);
13512 identifier = make_anon_name ();
13513 is_anonymous = true;
13516 pop_deferring_access_checks ();
13518 /* Check for the `:' that denotes a specified underlying type in C++0x.
13519 Note that a ':' could also indicate a bitfield width, however. */
13520 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
13522 cp_decl_specifier_seq type_specifiers;
13524 /* Consume the `:'. */
13525 cp_lexer_consume_token (parser->lexer);
13527 /* Parse the type-specifier-seq. */
13528 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
13529 /*is_trailing_return=*/false,
13532 /* At this point this is surely not elaborated type specifier. */
13533 if (!cp_parser_parse_definitely (parser))
13536 if (cxx_dialect < cxx0x)
13537 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
13539 has_underlying_type = true;
13541 /* If that didn't work, stop. */
13542 if (type_specifiers.type != error_mark_node)
13544 underlying_type = grokdeclarator (NULL, &type_specifiers, TYPENAME,
13545 /*initialized=*/0, NULL);
13546 if (underlying_type == error_mark_node)
13547 underlying_type = NULL_TREE;
13551 /* Look for the `{' but don't consume it yet. */
13552 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13554 if (cxx_dialect < cxx0x || (!scoped_enum_p && !underlying_type))
13556 cp_parser_error (parser, "expected %<{%>");
13557 if (has_underlying_type)
13563 /* An opaque-enum-specifier must have a ';' here. */
13564 if ((scoped_enum_p || underlying_type)
13565 && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13567 cp_parser_error (parser, "expected %<;%> or %<{%>");
13568 if (has_underlying_type)
13576 if (!has_underlying_type && !cp_parser_parse_definitely (parser))
13579 if (nested_name_specifier)
13581 if (CLASS_TYPE_P (nested_name_specifier))
13583 nested_being_defined = TYPE_BEING_DEFINED (nested_name_specifier);
13584 TYPE_BEING_DEFINED (nested_name_specifier) = 1;
13585 push_scope (nested_name_specifier);
13587 else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
13589 push_nested_namespace (nested_name_specifier);
13593 /* Issue an error message if type-definitions are forbidden here. */
13594 if (!cp_parser_check_type_definition (parser))
13595 type = error_mark_node;
13597 /* Create the new type. We do this before consuming the opening
13598 brace so the enum will be recorded as being on the line of its
13599 tag (or the 'enum' keyword, if there is no tag). */
13600 type = start_enum (identifier, type, underlying_type,
13601 scoped_enum_p, &is_new_type);
13603 /* If the next token is not '{' it is an opaque-enum-specifier or an
13604 elaborated-type-specifier. */
13605 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13607 timevar_push (TV_PARSE_ENUM);
13608 if (nested_name_specifier)
13610 /* The following catches invalid code such as:
13611 enum class S<int>::E { A, B, C }; */
13612 if (!processing_specialization
13613 && CLASS_TYPE_P (nested_name_specifier)
13614 && CLASSTYPE_USE_TEMPLATE (nested_name_specifier))
13615 error_at (type_start_token->location, "cannot add an enumerator "
13616 "list to a template instantiation");
13618 /* If that scope does not contain the scope in which the
13619 class was originally declared, the program is invalid. */
13620 if (prev_scope && !is_ancestor (prev_scope, nested_name_specifier))
13622 if (at_namespace_scope_p ())
13623 error_at (type_start_token->location,
13624 "declaration of %qD in namespace %qD which does not "
13626 type, prev_scope, nested_name_specifier);
13628 error_at (type_start_token->location,
13629 "declaration of %qD in %qD which does not enclose %qD",
13630 type, prev_scope, nested_name_specifier);
13631 type = error_mark_node;
13636 begin_scope (sk_scoped_enum, type);
13638 /* Consume the opening brace. */
13639 cp_lexer_consume_token (parser->lexer);
13641 if (type == error_mark_node)
13642 ; /* Nothing to add */
13643 else if (OPAQUE_ENUM_P (type)
13644 || (cxx_dialect > cxx98 && processing_specialization))
13646 new_value_list = true;
13647 SET_OPAQUE_ENUM_P (type, false);
13648 DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
13652 error_at (type_start_token->location, "multiple definition of %q#T", type);
13653 error_at (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
13654 "previous definition here");
13655 type = error_mark_node;
13658 if (type == error_mark_node)
13659 cp_parser_skip_to_end_of_block_or_statement (parser);
13660 /* If the next token is not '}', then there are some enumerators. */
13661 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
13662 cp_parser_enumerator_list (parser, type);
13664 /* Consume the final '}'. */
13665 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
13669 timevar_pop (TV_PARSE_ENUM);
13673 /* If a ';' follows, then it is an opaque-enum-specifier
13674 and additional restrictions apply. */
13675 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13678 error_at (type_start_token->location,
13679 "opaque-enum-specifier without name");
13680 else if (nested_name_specifier)
13681 error_at (type_start_token->location,
13682 "opaque-enum-specifier must use a simple identifier");
13686 /* Look for trailing attributes to apply to this enumeration, and
13687 apply them if appropriate. */
13688 if (cp_parser_allow_gnu_extensions_p (parser))
13690 tree trailing_attr = cp_parser_attributes_opt (parser);
13691 trailing_attr = chainon (trailing_attr, attributes);
13692 cplus_decl_attributes (&type,
13694 (int) ATTR_FLAG_TYPE_IN_PLACE);
13697 /* Finish up the enumeration. */
13698 if (type != error_mark_node)
13700 if (new_value_list)
13701 finish_enum_value_list (type);
13703 finish_enum (type);
13706 if (nested_name_specifier)
13708 if (CLASS_TYPE_P (nested_name_specifier))
13710 TYPE_BEING_DEFINED (nested_name_specifier) = nested_being_defined;
13711 pop_scope (nested_name_specifier);
13713 else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
13715 pop_nested_namespace (nested_name_specifier);
13719 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
13723 /* Parse an enumerator-list. The enumerators all have the indicated
13727 enumerator-definition
13728 enumerator-list , enumerator-definition */
13731 cp_parser_enumerator_list (cp_parser* parser, tree type)
13735 /* Parse an enumerator-definition. */
13736 cp_parser_enumerator_definition (parser, type);
13738 /* If the next token is not a ',', we've reached the end of
13740 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
13742 /* Otherwise, consume the `,' and keep going. */
13743 cp_lexer_consume_token (parser->lexer);
13744 /* If the next token is a `}', there is a trailing comma. */
13745 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
13747 if (!in_system_header)
13748 pedwarn (input_location, OPT_pedantic, "comma at end of enumerator list");
13754 /* Parse an enumerator-definition. The enumerator has the indicated
13757 enumerator-definition:
13759 enumerator = constant-expression
13765 cp_parser_enumerator_definition (cp_parser* parser, tree type)
13771 /* Save the input location because we are interested in the location
13772 of the identifier and not the location of the explicit value. */
13773 loc = cp_lexer_peek_token (parser->lexer)->location;
13775 /* Look for the identifier. */
13776 identifier = cp_parser_identifier (parser);
13777 if (identifier == error_mark_node)
13780 /* If the next token is an '=', then there is an explicit value. */
13781 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13783 /* Consume the `=' token. */
13784 cp_lexer_consume_token (parser->lexer);
13785 /* Parse the value. */
13786 value = cp_parser_constant_expression (parser,
13787 /*allow_non_constant_p=*/false,
13793 /* If we are processing a template, make sure the initializer of the
13794 enumerator doesn't contain any bare template parameter pack. */
13795 if (check_for_bare_parameter_packs (value))
13796 value = error_mark_node;
13798 /* integral_constant_value will pull out this expression, so make sure
13799 it's folded as appropriate. */
13800 value = fold_non_dependent_expr (value);
13802 /* Create the enumerator. */
13803 build_enumerator (identifier, value, type, loc);
13806 /* Parse a namespace-name.
13809 original-namespace-name
13812 Returns the NAMESPACE_DECL for the namespace. */
13815 cp_parser_namespace_name (cp_parser* parser)
13818 tree namespace_decl;
13820 cp_token *token = cp_lexer_peek_token (parser->lexer);
13822 /* Get the name of the namespace. */
13823 identifier = cp_parser_identifier (parser);
13824 if (identifier == error_mark_node)
13825 return error_mark_node;
13827 /* Look up the identifier in the currently active scope. Look only
13828 for namespaces, due to:
13830 [basic.lookup.udir]
13832 When looking up a namespace-name in a using-directive or alias
13833 definition, only namespace names are considered.
13837 [basic.lookup.qual]
13839 During the lookup of a name preceding the :: scope resolution
13840 operator, object, function, and enumerator names are ignored.
13842 (Note that cp_parser_qualifying_entity only calls this
13843 function if the token after the name is the scope resolution
13845 namespace_decl = cp_parser_lookup_name (parser, identifier,
13847 /*is_template=*/false,
13848 /*is_namespace=*/true,
13849 /*check_dependency=*/true,
13850 /*ambiguous_decls=*/NULL,
13852 /* If it's not a namespace, issue an error. */
13853 if (namespace_decl == error_mark_node
13854 || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
13856 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
13857 error_at (token->location, "%qD is not a namespace-name", identifier);
13858 cp_parser_error (parser, "expected namespace-name");
13859 namespace_decl = error_mark_node;
13862 return namespace_decl;
13865 /* Parse a namespace-definition.
13867 namespace-definition:
13868 named-namespace-definition
13869 unnamed-namespace-definition
13871 named-namespace-definition:
13872 original-namespace-definition
13873 extension-namespace-definition
13875 original-namespace-definition:
13876 namespace identifier { namespace-body }
13878 extension-namespace-definition:
13879 namespace original-namespace-name { namespace-body }
13881 unnamed-namespace-definition:
13882 namespace { namespace-body } */
13885 cp_parser_namespace_definition (cp_parser* parser)
13887 tree identifier, attribs;
13888 bool has_visibility;
13891 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE))
13893 maybe_warn_cpp0x (CPP0X_INLINE_NAMESPACES);
13895 cp_lexer_consume_token (parser->lexer);
13900 /* Look for the `namespace' keyword. */
13901 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
13903 /* Get the name of the namespace. We do not attempt to distinguish
13904 between an original-namespace-definition and an
13905 extension-namespace-definition at this point. The semantic
13906 analysis routines are responsible for that. */
13907 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
13908 identifier = cp_parser_identifier (parser);
13910 identifier = NULL_TREE;
13912 /* Parse any specified attributes. */
13913 attribs = cp_parser_attributes_opt (parser);
13915 /* Look for the `{' to start the namespace. */
13916 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
13917 /* Start the namespace. */
13918 push_namespace (identifier);
13920 /* "inline namespace" is equivalent to a stub namespace definition
13921 followed by a strong using directive. */
13924 tree name_space = current_namespace;
13925 /* Set up namespace association. */
13926 DECL_NAMESPACE_ASSOCIATIONS (name_space)
13927 = tree_cons (CP_DECL_CONTEXT (name_space), NULL_TREE,
13928 DECL_NAMESPACE_ASSOCIATIONS (name_space));
13929 /* Import the contents of the inline namespace. */
13931 do_using_directive (name_space);
13932 push_namespace (identifier);
13935 has_visibility = handle_namespace_attrs (current_namespace, attribs);
13937 /* Parse the body of the namespace. */
13938 cp_parser_namespace_body (parser);
13940 if (has_visibility)
13941 pop_visibility (1);
13943 /* Finish the namespace. */
13945 /* Look for the final `}'. */
13946 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
13949 /* Parse a namespace-body.
13952 declaration-seq [opt] */
13955 cp_parser_namespace_body (cp_parser* parser)
13957 cp_parser_declaration_seq_opt (parser);
13960 /* Parse a namespace-alias-definition.
13962 namespace-alias-definition:
13963 namespace identifier = qualified-namespace-specifier ; */
13966 cp_parser_namespace_alias_definition (cp_parser* parser)
13969 tree namespace_specifier;
13971 cp_token *token = cp_lexer_peek_token (parser->lexer);
13973 /* Look for the `namespace' keyword. */
13974 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
13975 /* Look for the identifier. */
13976 identifier = cp_parser_identifier (parser);
13977 if (identifier == error_mark_node)
13979 /* Look for the `=' token. */
13980 if (!cp_parser_uncommitted_to_tentative_parse_p (parser)
13981 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13983 error_at (token->location, "%<namespace%> definition is not allowed here");
13984 /* Skip the definition. */
13985 cp_lexer_consume_token (parser->lexer);
13986 if (cp_parser_skip_to_closing_brace (parser))
13987 cp_lexer_consume_token (parser->lexer);
13990 cp_parser_require (parser, CPP_EQ, RT_EQ);
13991 /* Look for the qualified-namespace-specifier. */
13992 namespace_specifier
13993 = cp_parser_qualified_namespace_specifier (parser);
13994 /* Look for the `;' token. */
13995 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13997 /* Register the alias in the symbol table. */
13998 do_namespace_alias (identifier, namespace_specifier);
14001 /* Parse a qualified-namespace-specifier.
14003 qualified-namespace-specifier:
14004 :: [opt] nested-name-specifier [opt] namespace-name
14006 Returns a NAMESPACE_DECL corresponding to the specified
14010 cp_parser_qualified_namespace_specifier (cp_parser* parser)
14012 /* Look for the optional `::'. */
14013 cp_parser_global_scope_opt (parser,
14014 /*current_scope_valid_p=*/false);
14016 /* Look for the optional nested-name-specifier. */
14017 cp_parser_nested_name_specifier_opt (parser,
14018 /*typename_keyword_p=*/false,
14019 /*check_dependency_p=*/true,
14021 /*is_declaration=*/true);
14023 return cp_parser_namespace_name (parser);
14026 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
14027 access declaration.
14030 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
14031 using :: unqualified-id ;
14033 access-declaration:
14039 cp_parser_using_declaration (cp_parser* parser,
14040 bool access_declaration_p)
14043 bool typename_p = false;
14044 bool global_scope_p;
14049 if (access_declaration_p)
14050 cp_parser_parse_tentatively (parser);
14053 /* Look for the `using' keyword. */
14054 cp_parser_require_keyword (parser, RID_USING, RT_USING);
14056 /* Peek at the next token. */
14057 token = cp_lexer_peek_token (parser->lexer);
14058 /* See if it's `typename'. */
14059 if (token->keyword == RID_TYPENAME)
14061 /* Remember that we've seen it. */
14063 /* Consume the `typename' token. */
14064 cp_lexer_consume_token (parser->lexer);
14068 /* Look for the optional global scope qualification. */
14070 = (cp_parser_global_scope_opt (parser,
14071 /*current_scope_valid_p=*/false)
14074 /* If we saw `typename', or didn't see `::', then there must be a
14075 nested-name-specifier present. */
14076 if (typename_p || !global_scope_p)
14077 qscope = cp_parser_nested_name_specifier (parser, typename_p,
14078 /*check_dependency_p=*/true,
14080 /*is_declaration=*/true);
14081 /* Otherwise, we could be in either of the two productions. In that
14082 case, treat the nested-name-specifier as optional. */
14084 qscope = cp_parser_nested_name_specifier_opt (parser,
14085 /*typename_keyword_p=*/false,
14086 /*check_dependency_p=*/true,
14088 /*is_declaration=*/true);
14090 qscope = global_namespace;
14092 if (access_declaration_p && cp_parser_error_occurred (parser))
14093 /* Something has already gone wrong; there's no need to parse
14094 further. Since an error has occurred, the return value of
14095 cp_parser_parse_definitely will be false, as required. */
14096 return cp_parser_parse_definitely (parser);
14098 token = cp_lexer_peek_token (parser->lexer);
14099 /* Parse the unqualified-id. */
14100 identifier = cp_parser_unqualified_id (parser,
14101 /*template_keyword_p=*/false,
14102 /*check_dependency_p=*/true,
14103 /*declarator_p=*/true,
14104 /*optional_p=*/false);
14106 if (access_declaration_p)
14108 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
14109 cp_parser_simulate_error (parser);
14110 if (!cp_parser_parse_definitely (parser))
14114 /* The function we call to handle a using-declaration is different
14115 depending on what scope we are in. */
14116 if (qscope == error_mark_node || identifier == error_mark_node)
14118 else if (TREE_CODE (identifier) != IDENTIFIER_NODE
14119 && TREE_CODE (identifier) != BIT_NOT_EXPR)
14120 /* [namespace.udecl]
14122 A using declaration shall not name a template-id. */
14123 error_at (token->location,
14124 "a template-id may not appear in a using-declaration");
14127 if (at_class_scope_p ())
14129 /* Create the USING_DECL. */
14130 decl = do_class_using_decl (parser->scope, identifier);
14132 if (check_for_bare_parameter_packs (decl))
14135 /* Add it to the list of members in this class. */
14136 finish_member_declaration (decl);
14140 decl = cp_parser_lookup_name_simple (parser,
14143 if (decl == error_mark_node)
14144 cp_parser_name_lookup_error (parser, identifier,
14147 else if (check_for_bare_parameter_packs (decl))
14149 else if (!at_namespace_scope_p ())
14150 do_local_using_decl (decl, qscope, identifier);
14152 do_toplevel_using_decl (decl, qscope, identifier);
14156 /* Look for the final `;'. */
14157 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14162 /* Parse a using-directive.
14165 using namespace :: [opt] nested-name-specifier [opt]
14166 namespace-name ; */
14169 cp_parser_using_directive (cp_parser* parser)
14171 tree namespace_decl;
14174 /* Look for the `using' keyword. */
14175 cp_parser_require_keyword (parser, RID_USING, RT_USING);
14176 /* And the `namespace' keyword. */
14177 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
14178 /* Look for the optional `::' operator. */
14179 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
14180 /* And the optional nested-name-specifier. */
14181 cp_parser_nested_name_specifier_opt (parser,
14182 /*typename_keyword_p=*/false,
14183 /*check_dependency_p=*/true,
14185 /*is_declaration=*/true);
14186 /* Get the namespace being used. */
14187 namespace_decl = cp_parser_namespace_name (parser);
14188 /* And any specified attributes. */
14189 attribs = cp_parser_attributes_opt (parser);
14190 /* Update the symbol table. */
14191 parse_using_directive (namespace_decl, attribs);
14192 /* Look for the final `;'. */
14193 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14196 /* Parse an asm-definition.
14199 asm ( string-literal ) ;
14204 asm volatile [opt] ( string-literal ) ;
14205 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
14206 asm volatile [opt] ( string-literal : asm-operand-list [opt]
14207 : asm-operand-list [opt] ) ;
14208 asm volatile [opt] ( string-literal : asm-operand-list [opt]
14209 : asm-operand-list [opt]
14210 : asm-clobber-list [opt] ) ;
14211 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
14212 : asm-clobber-list [opt]
14213 : asm-goto-list ) ; */
14216 cp_parser_asm_definition (cp_parser* parser)
14219 tree outputs = NULL_TREE;
14220 tree inputs = NULL_TREE;
14221 tree clobbers = NULL_TREE;
14222 tree labels = NULL_TREE;
14224 bool volatile_p = false;
14225 bool extended_p = false;
14226 bool invalid_inputs_p = false;
14227 bool invalid_outputs_p = false;
14228 bool goto_p = false;
14229 required_token missing = RT_NONE;
14231 /* Look for the `asm' keyword. */
14232 cp_parser_require_keyword (parser, RID_ASM, RT_ASM);
14233 /* See if the next token is `volatile'. */
14234 if (cp_parser_allow_gnu_extensions_p (parser)
14235 && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
14237 /* Remember that we saw the `volatile' keyword. */
14239 /* Consume the token. */
14240 cp_lexer_consume_token (parser->lexer);
14242 if (cp_parser_allow_gnu_extensions_p (parser)
14243 && parser->in_function_body
14244 && cp_lexer_next_token_is_keyword (parser->lexer, RID_GOTO))
14246 /* Remember that we saw the `goto' keyword. */
14248 /* Consume the token. */
14249 cp_lexer_consume_token (parser->lexer);
14251 /* Look for the opening `('. */
14252 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
14254 /* Look for the string. */
14255 string = cp_parser_string_literal (parser, false, false);
14256 if (string == error_mark_node)
14258 cp_parser_skip_to_closing_parenthesis (parser, true, false,
14259 /*consume_paren=*/true);
14263 /* If we're allowing GNU extensions, check for the extended assembly
14264 syntax. Unfortunately, the `:' tokens need not be separated by
14265 a space in C, and so, for compatibility, we tolerate that here
14266 too. Doing that means that we have to treat the `::' operator as
14268 if (cp_parser_allow_gnu_extensions_p (parser)
14269 && parser->in_function_body
14270 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
14271 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
14273 bool inputs_p = false;
14274 bool clobbers_p = false;
14275 bool labels_p = false;
14277 /* The extended syntax was used. */
14280 /* Look for outputs. */
14281 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14283 /* Consume the `:'. */
14284 cp_lexer_consume_token (parser->lexer);
14285 /* Parse the output-operands. */
14286 if (cp_lexer_next_token_is_not (parser->lexer,
14288 && cp_lexer_next_token_is_not (parser->lexer,
14290 && cp_lexer_next_token_is_not (parser->lexer,
14293 outputs = cp_parser_asm_operand_list (parser);
14295 if (outputs == error_mark_node)
14296 invalid_outputs_p = true;
14298 /* If the next token is `::', there are no outputs, and the
14299 next token is the beginning of the inputs. */
14300 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14301 /* The inputs are coming next. */
14304 /* Look for inputs. */
14306 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14308 /* Consume the `:' or `::'. */
14309 cp_lexer_consume_token (parser->lexer);
14310 /* Parse the output-operands. */
14311 if (cp_lexer_next_token_is_not (parser->lexer,
14313 && cp_lexer_next_token_is_not (parser->lexer,
14315 && cp_lexer_next_token_is_not (parser->lexer,
14317 inputs = cp_parser_asm_operand_list (parser);
14319 if (inputs == error_mark_node)
14320 invalid_inputs_p = true;
14322 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14323 /* The clobbers are coming next. */
14326 /* Look for clobbers. */
14328 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
14331 /* Consume the `:' or `::'. */
14332 cp_lexer_consume_token (parser->lexer);
14333 /* Parse the clobbers. */
14334 if (cp_lexer_next_token_is_not (parser->lexer,
14336 && cp_lexer_next_token_is_not (parser->lexer,
14338 clobbers = cp_parser_asm_clobber_list (parser);
14341 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
14342 /* The labels are coming next. */
14345 /* Look for labels. */
14347 || (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
14350 /* Consume the `:' or `::'. */
14351 cp_lexer_consume_token (parser->lexer);
14352 /* Parse the labels. */
14353 labels = cp_parser_asm_label_list (parser);
14356 if (goto_p && !labels_p)
14357 missing = clobbers_p ? RT_COLON : RT_COLON_SCOPE;
14360 missing = RT_COLON_SCOPE;
14362 /* Look for the closing `)'. */
14363 if (!cp_parser_require (parser, missing ? CPP_COLON : CPP_CLOSE_PAREN,
14364 missing ? missing : RT_CLOSE_PAREN))
14365 cp_parser_skip_to_closing_parenthesis (parser, true, false,
14366 /*consume_paren=*/true);
14367 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14369 if (!invalid_inputs_p && !invalid_outputs_p)
14371 /* Create the ASM_EXPR. */
14372 if (parser->in_function_body)
14374 asm_stmt = finish_asm_stmt (volatile_p, string, outputs,
14375 inputs, clobbers, labels);
14376 /* If the extended syntax was not used, mark the ASM_EXPR. */
14379 tree temp = asm_stmt;
14380 if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
14381 temp = TREE_OPERAND (temp, 0);
14383 ASM_INPUT_P (temp) = 1;
14387 cgraph_add_asm_node (string);
14391 /* Declarators [gram.dcl.decl] */
14393 /* Parse an init-declarator.
14396 declarator initializer [opt]
14401 declarator asm-specification [opt] attributes [opt] initializer [opt]
14403 function-definition:
14404 decl-specifier-seq [opt] declarator ctor-initializer [opt]
14406 decl-specifier-seq [opt] declarator function-try-block
14410 function-definition:
14411 __extension__ function-definition
14413 The DECL_SPECIFIERS apply to this declarator. Returns a
14414 representation of the entity declared. If MEMBER_P is TRUE, then
14415 this declarator appears in a class scope. The new DECL created by
14416 this declarator is returned.
14418 The CHECKS are access checks that should be performed once we know
14419 what entity is being declared (and, therefore, what classes have
14422 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
14423 for a function-definition here as well. If the declarator is a
14424 declarator for a function-definition, *FUNCTION_DEFINITION_P will
14425 be TRUE upon return. By that point, the function-definition will
14426 have been completely parsed.
14428 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
14431 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
14432 parsed declaration if it is an uninitialized single declarator not followed
14433 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
14434 if present, will not be consumed. If returned, this declarator will be
14435 created with SD_INITIALIZED but will not call cp_finish_decl. */
14438 cp_parser_init_declarator (cp_parser* parser,
14439 cp_decl_specifier_seq *decl_specifiers,
14440 VEC (deferred_access_check,gc)* checks,
14441 bool function_definition_allowed_p,
14443 int declares_class_or_enum,
14444 bool* function_definition_p,
14445 tree* maybe_range_for_decl)
14447 cp_token *token = NULL, *asm_spec_start_token = NULL,
14448 *attributes_start_token = NULL;
14449 cp_declarator *declarator;
14450 tree prefix_attributes;
14452 tree asm_specification;
14454 tree decl = NULL_TREE;
14456 int is_initialized;
14457 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
14458 initialized with "= ..", CPP_OPEN_PAREN if initialized with
14460 enum cpp_ttype initialization_kind;
14461 bool is_direct_init = false;
14462 bool is_non_constant_init;
14463 int ctor_dtor_or_conv_p;
14465 tree pushed_scope = NULL_TREE;
14466 bool range_for_decl_p = false;
14468 /* Gather the attributes that were provided with the
14469 decl-specifiers. */
14470 prefix_attributes = decl_specifiers->attributes;
14472 /* Assume that this is not the declarator for a function
14474 if (function_definition_p)
14475 *function_definition_p = false;
14477 /* Defer access checks while parsing the declarator; we cannot know
14478 what names are accessible until we know what is being
14480 resume_deferring_access_checks ();
14482 /* Parse the declarator. */
14483 token = cp_lexer_peek_token (parser->lexer);
14485 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
14486 &ctor_dtor_or_conv_p,
14487 /*parenthesized_p=*/NULL,
14489 /* Gather up the deferred checks. */
14490 stop_deferring_access_checks ();
14492 /* If the DECLARATOR was erroneous, there's no need to go
14494 if (declarator == cp_error_declarator)
14495 return error_mark_node;
14497 /* Check that the number of template-parameter-lists is OK. */
14498 if (!cp_parser_check_declarator_template_parameters (parser, declarator,
14500 return error_mark_node;
14502 if (declares_class_or_enum & 2)
14503 cp_parser_check_for_definition_in_return_type (declarator,
14504 decl_specifiers->type,
14505 decl_specifiers->type_location);
14507 /* Figure out what scope the entity declared by the DECLARATOR is
14508 located in. `grokdeclarator' sometimes changes the scope, so
14509 we compute it now. */
14510 scope = get_scope_of_declarator (declarator);
14512 /* Perform any lookups in the declared type which were thought to be
14513 dependent, but are not in the scope of the declarator. */
14514 decl_specifiers->type
14515 = maybe_update_decl_type (decl_specifiers->type, scope);
14517 /* If we're allowing GNU extensions, look for an asm-specification
14519 if (cp_parser_allow_gnu_extensions_p (parser))
14521 /* Look for an asm-specification. */
14522 asm_spec_start_token = cp_lexer_peek_token (parser->lexer);
14523 asm_specification = cp_parser_asm_specification_opt (parser);
14524 /* And attributes. */
14525 attributes_start_token = cp_lexer_peek_token (parser->lexer);
14526 attributes = cp_parser_attributes_opt (parser);
14530 asm_specification = NULL_TREE;
14531 attributes = NULL_TREE;
14534 /* Peek at the next token. */
14535 token = cp_lexer_peek_token (parser->lexer);
14536 /* Check to see if the token indicates the start of a
14537 function-definition. */
14538 if (function_declarator_p (declarator)
14539 && cp_parser_token_starts_function_definition_p (token))
14541 if (!function_definition_allowed_p)
14543 /* If a function-definition should not appear here, issue an
14545 cp_parser_error (parser,
14546 "a function-definition is not allowed here");
14547 return error_mark_node;
14551 location_t func_brace_location
14552 = cp_lexer_peek_token (parser->lexer)->location;
14554 /* Neither attributes nor an asm-specification are allowed
14555 on a function-definition. */
14556 if (asm_specification)
14557 error_at (asm_spec_start_token->location,
14558 "an asm-specification is not allowed "
14559 "on a function-definition");
14561 error_at (attributes_start_token->location,
14562 "attributes are not allowed on a function-definition");
14563 /* This is a function-definition. */
14564 *function_definition_p = true;
14566 /* Parse the function definition. */
14568 decl = cp_parser_save_member_function_body (parser,
14571 prefix_attributes);
14574 = (cp_parser_function_definition_from_specifiers_and_declarator
14575 (parser, decl_specifiers, prefix_attributes, declarator));
14577 if (decl != error_mark_node && DECL_STRUCT_FUNCTION (decl))
14579 /* This is where the prologue starts... */
14580 DECL_STRUCT_FUNCTION (decl)->function_start_locus
14581 = func_brace_location;
14590 Only in function declarations for constructors, destructors, and
14591 type conversions can the decl-specifier-seq be omitted.
14593 We explicitly postpone this check past the point where we handle
14594 function-definitions because we tolerate function-definitions
14595 that are missing their return types in some modes. */
14596 if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
14598 cp_parser_error (parser,
14599 "expected constructor, destructor, or type conversion");
14600 return error_mark_node;
14603 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
14604 if (token->type == CPP_EQ
14605 || token->type == CPP_OPEN_PAREN
14606 || token->type == CPP_OPEN_BRACE)
14608 is_initialized = SD_INITIALIZED;
14609 initialization_kind = token->type;
14610 if (maybe_range_for_decl)
14611 *maybe_range_for_decl = error_mark_node;
14613 if (token->type == CPP_EQ
14614 && function_declarator_p (declarator))
14616 cp_token *t2 = cp_lexer_peek_nth_token (parser->lexer, 2);
14617 if (t2->keyword == RID_DEFAULT)
14618 is_initialized = SD_DEFAULTED;
14619 else if (t2->keyword == RID_DELETE)
14620 is_initialized = SD_DELETED;
14625 /* If the init-declarator isn't initialized and isn't followed by a
14626 `,' or `;', it's not a valid init-declarator. */
14627 if (token->type != CPP_COMMA
14628 && token->type != CPP_SEMICOLON)
14630 if (maybe_range_for_decl && *maybe_range_for_decl != error_mark_node)
14631 range_for_decl_p = true;
14634 cp_parser_error (parser, "expected initializer");
14635 return error_mark_node;
14638 is_initialized = SD_UNINITIALIZED;
14639 initialization_kind = CPP_EOF;
14642 /* Because start_decl has side-effects, we should only call it if we
14643 know we're going ahead. By this point, we know that we cannot
14644 possibly be looking at any other construct. */
14645 cp_parser_commit_to_tentative_parse (parser);
14647 /* If the decl specifiers were bad, issue an error now that we're
14648 sure this was intended to be a declarator. Then continue
14649 declaring the variable(s), as int, to try to cut down on further
14651 if (decl_specifiers->any_specifiers_p
14652 && decl_specifiers->type == error_mark_node)
14654 cp_parser_error (parser, "invalid type in declaration");
14655 decl_specifiers->type = integer_type_node;
14658 /* Check to see whether or not this declaration is a friend. */
14659 friend_p = cp_parser_friend_p (decl_specifiers);
14661 /* Enter the newly declared entry in the symbol table. If we're
14662 processing a declaration in a class-specifier, we wait until
14663 after processing the initializer. */
14666 if (parser->in_unbraced_linkage_specification_p)
14667 decl_specifiers->storage_class = sc_extern;
14668 decl = start_decl (declarator, decl_specifiers,
14669 range_for_decl_p? SD_INITIALIZED : is_initialized,
14670 attributes, prefix_attributes,
14672 /* Adjust location of decl if declarator->id_loc is more appropriate:
14673 set, and decl wasn't merged with another decl, in which case its
14674 location would be different from input_location, and more accurate. */
14676 && declarator->id_loc != UNKNOWN_LOCATION
14677 && DECL_SOURCE_LOCATION (decl) == input_location)
14678 DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
14681 /* Enter the SCOPE. That way unqualified names appearing in the
14682 initializer will be looked up in SCOPE. */
14683 pushed_scope = push_scope (scope);
14685 /* Perform deferred access control checks, now that we know in which
14686 SCOPE the declared entity resides. */
14687 if (!member_p && decl)
14689 tree saved_current_function_decl = NULL_TREE;
14691 /* If the entity being declared is a function, pretend that we
14692 are in its scope. If it is a `friend', it may have access to
14693 things that would not otherwise be accessible. */
14694 if (TREE_CODE (decl) == FUNCTION_DECL)
14696 saved_current_function_decl = current_function_decl;
14697 current_function_decl = decl;
14700 /* Perform access checks for template parameters. */
14701 cp_parser_perform_template_parameter_access_checks (checks);
14703 /* Perform the access control checks for the declarator and the
14704 decl-specifiers. */
14705 perform_deferred_access_checks ();
14707 /* Restore the saved value. */
14708 if (TREE_CODE (decl) == FUNCTION_DECL)
14709 current_function_decl = saved_current_function_decl;
14712 /* Parse the initializer. */
14713 initializer = NULL_TREE;
14714 is_direct_init = false;
14715 is_non_constant_init = true;
14716 if (is_initialized)
14718 if (function_declarator_p (declarator))
14720 cp_token *initializer_start_token = cp_lexer_peek_token (parser->lexer);
14721 if (initialization_kind == CPP_EQ)
14722 initializer = cp_parser_pure_specifier (parser);
14725 /* If the declaration was erroneous, we don't really
14726 know what the user intended, so just silently
14727 consume the initializer. */
14728 if (decl != error_mark_node)
14729 error_at (initializer_start_token->location,
14730 "initializer provided for function");
14731 cp_parser_skip_to_closing_parenthesis (parser,
14732 /*recovering=*/true,
14733 /*or_comma=*/false,
14734 /*consume_paren=*/true);
14739 /* We want to record the extra mangling scope for in-class
14740 initializers of class members and initializers of static data
14741 member templates. The former is a C++0x feature which isn't
14742 implemented yet, and I expect it will involve deferring
14743 parsing of the initializer until end of class as with default
14744 arguments. So right here we only handle the latter. */
14745 if (!member_p && processing_template_decl)
14746 start_lambda_scope (decl);
14747 initializer = cp_parser_initializer (parser,
14749 &is_non_constant_init);
14750 if (!member_p && processing_template_decl)
14751 finish_lambda_scope ();
14755 /* The old parser allows attributes to appear after a parenthesized
14756 initializer. Mark Mitchell proposed removing this functionality
14757 on the GCC mailing lists on 2002-08-13. This parser accepts the
14758 attributes -- but ignores them. */
14759 if (cp_parser_allow_gnu_extensions_p (parser)
14760 && initialization_kind == CPP_OPEN_PAREN)
14761 if (cp_parser_attributes_opt (parser))
14762 warning (OPT_Wattributes,
14763 "attributes after parenthesized initializer ignored");
14765 /* For an in-class declaration, use `grokfield' to create the
14771 pop_scope (pushed_scope);
14772 pushed_scope = NULL_TREE;
14774 decl = grokfield (declarator, decl_specifiers,
14775 initializer, !is_non_constant_init,
14776 /*asmspec=*/NULL_TREE,
14777 prefix_attributes);
14778 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
14779 cp_parser_save_default_args (parser, decl);
14782 /* Finish processing the declaration. But, skip member
14784 if (!member_p && decl && decl != error_mark_node && !range_for_decl_p)
14786 cp_finish_decl (decl,
14787 initializer, !is_non_constant_init,
14789 /* If the initializer is in parentheses, then this is
14790 a direct-initialization, which means that an
14791 `explicit' constructor is OK. Otherwise, an
14792 `explicit' constructor cannot be used. */
14793 ((is_direct_init || !is_initialized)
14794 ? LOOKUP_NORMAL : LOOKUP_IMPLICIT));
14796 else if ((cxx_dialect != cxx98) && friend_p
14797 && decl && TREE_CODE (decl) == FUNCTION_DECL)
14798 /* Core issue #226 (C++0x only): A default template-argument
14799 shall not be specified in a friend class template
14801 check_default_tmpl_args (decl, current_template_parms, /*is_primary=*/1,
14802 /*is_partial=*/0, /*is_friend_decl=*/1);
14804 if (!friend_p && pushed_scope)
14805 pop_scope (pushed_scope);
14810 /* Parse a declarator.
14814 ptr-operator declarator
14816 abstract-declarator:
14817 ptr-operator abstract-declarator [opt]
14818 direct-abstract-declarator
14823 attributes [opt] direct-declarator
14824 attributes [opt] ptr-operator declarator
14826 abstract-declarator:
14827 attributes [opt] ptr-operator abstract-declarator [opt]
14828 attributes [opt] direct-abstract-declarator
14830 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
14831 detect constructor, destructor or conversion operators. It is set
14832 to -1 if the declarator is a name, and +1 if it is a
14833 function. Otherwise it is set to zero. Usually you just want to
14834 test for >0, but internally the negative value is used.
14836 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
14837 a decl-specifier-seq unless it declares a constructor, destructor,
14838 or conversion. It might seem that we could check this condition in
14839 semantic analysis, rather than parsing, but that makes it difficult
14840 to handle something like `f()'. We want to notice that there are
14841 no decl-specifiers, and therefore realize that this is an
14842 expression, not a declaration.)
14844 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
14845 the declarator is a direct-declarator of the form "(...)".
14847 MEMBER_P is true iff this declarator is a member-declarator. */
14849 static cp_declarator *
14850 cp_parser_declarator (cp_parser* parser,
14851 cp_parser_declarator_kind dcl_kind,
14852 int* ctor_dtor_or_conv_p,
14853 bool* parenthesized_p,
14856 cp_declarator *declarator;
14857 enum tree_code code;
14858 cp_cv_quals cv_quals;
14860 tree attributes = NULL_TREE;
14862 /* Assume this is not a constructor, destructor, or type-conversion
14864 if (ctor_dtor_or_conv_p)
14865 *ctor_dtor_or_conv_p = 0;
14867 if (cp_parser_allow_gnu_extensions_p (parser))
14868 attributes = cp_parser_attributes_opt (parser);
14870 /* Check for the ptr-operator production. */
14871 cp_parser_parse_tentatively (parser);
14872 /* Parse the ptr-operator. */
14873 code = cp_parser_ptr_operator (parser,
14876 /* If that worked, then we have a ptr-operator. */
14877 if (cp_parser_parse_definitely (parser))
14879 /* If a ptr-operator was found, then this declarator was not
14881 if (parenthesized_p)
14882 *parenthesized_p = true;
14883 /* The dependent declarator is optional if we are parsing an
14884 abstract-declarator. */
14885 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
14886 cp_parser_parse_tentatively (parser);
14888 /* Parse the dependent declarator. */
14889 declarator = cp_parser_declarator (parser, dcl_kind,
14890 /*ctor_dtor_or_conv_p=*/NULL,
14891 /*parenthesized_p=*/NULL,
14892 /*member_p=*/false);
14894 /* If we are parsing an abstract-declarator, we must handle the
14895 case where the dependent declarator is absent. */
14896 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
14897 && !cp_parser_parse_definitely (parser))
14900 declarator = cp_parser_make_indirect_declarator
14901 (code, class_type, cv_quals, declarator);
14903 /* Everything else is a direct-declarator. */
14906 if (parenthesized_p)
14907 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
14909 declarator = cp_parser_direct_declarator (parser, dcl_kind,
14910 ctor_dtor_or_conv_p,
14914 if (attributes && declarator && declarator != cp_error_declarator)
14915 declarator->attributes = attributes;
14920 /* Parse a direct-declarator or direct-abstract-declarator.
14924 direct-declarator ( parameter-declaration-clause )
14925 cv-qualifier-seq [opt]
14926 exception-specification [opt]
14927 direct-declarator [ constant-expression [opt] ]
14930 direct-abstract-declarator:
14931 direct-abstract-declarator [opt]
14932 ( parameter-declaration-clause )
14933 cv-qualifier-seq [opt]
14934 exception-specification [opt]
14935 direct-abstract-declarator [opt] [ constant-expression [opt] ]
14936 ( abstract-declarator )
14938 Returns a representation of the declarator. DCL_KIND is
14939 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
14940 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
14941 we are parsing a direct-declarator. It is
14942 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
14943 of ambiguity we prefer an abstract declarator, as per
14944 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for
14945 cp_parser_declarator. */
14947 static cp_declarator *
14948 cp_parser_direct_declarator (cp_parser* parser,
14949 cp_parser_declarator_kind dcl_kind,
14950 int* ctor_dtor_or_conv_p,
14954 cp_declarator *declarator = NULL;
14955 tree scope = NULL_TREE;
14956 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
14957 bool saved_in_declarator_p = parser->in_declarator_p;
14959 tree pushed_scope = NULL_TREE;
14963 /* Peek at the next token. */
14964 token = cp_lexer_peek_token (parser->lexer);
14965 if (token->type == CPP_OPEN_PAREN)
14967 /* This is either a parameter-declaration-clause, or a
14968 parenthesized declarator. When we know we are parsing a
14969 named declarator, it must be a parenthesized declarator
14970 if FIRST is true. For instance, `(int)' is a
14971 parameter-declaration-clause, with an omitted
14972 direct-abstract-declarator. But `((*))', is a
14973 parenthesized abstract declarator. Finally, when T is a
14974 template parameter `(T)' is a
14975 parameter-declaration-clause, and not a parenthesized
14978 We first try and parse a parameter-declaration-clause,
14979 and then try a nested declarator (if FIRST is true).
14981 It is not an error for it not to be a
14982 parameter-declaration-clause, even when FIRST is
14988 The first is the declaration of a function while the
14989 second is the definition of a variable, including its
14992 Having seen only the parenthesis, we cannot know which of
14993 these two alternatives should be selected. Even more
14994 complex are examples like:
14999 The former is a function-declaration; the latter is a
15000 variable initialization.
15002 Thus again, we try a parameter-declaration-clause, and if
15003 that fails, we back out and return. */
15005 if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
15008 unsigned saved_num_template_parameter_lists;
15009 bool is_declarator = false;
15012 /* In a member-declarator, the only valid interpretation
15013 of a parenthesis is the start of a
15014 parameter-declaration-clause. (It is invalid to
15015 initialize a static data member with a parenthesized
15016 initializer; only the "=" form of initialization is
15019 cp_parser_parse_tentatively (parser);
15021 /* Consume the `('. */
15022 cp_lexer_consume_token (parser->lexer);
15025 /* If this is going to be an abstract declarator, we're
15026 in a declarator and we can't have default args. */
15027 parser->default_arg_ok_p = false;
15028 parser->in_declarator_p = true;
15031 /* Inside the function parameter list, surrounding
15032 template-parameter-lists do not apply. */
15033 saved_num_template_parameter_lists
15034 = parser->num_template_parameter_lists;
15035 parser->num_template_parameter_lists = 0;
15037 begin_scope (sk_function_parms, NULL_TREE);
15039 /* Parse the parameter-declaration-clause. */
15040 params = cp_parser_parameter_declaration_clause (parser);
15042 parser->num_template_parameter_lists
15043 = saved_num_template_parameter_lists;
15045 /* Consume the `)'. */
15046 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
15048 /* If all went well, parse the cv-qualifier-seq and the
15049 exception-specification. */
15050 if (member_p || cp_parser_parse_definitely (parser))
15052 cp_cv_quals cv_quals;
15053 cp_virt_specifiers virt_specifiers;
15054 tree exception_specification;
15057 is_declarator = true;
15059 if (ctor_dtor_or_conv_p)
15060 *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
15063 /* Parse the cv-qualifier-seq. */
15064 cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
15065 /* And the exception-specification. */
15066 exception_specification
15067 = cp_parser_exception_specification_opt (parser);
15068 /* Parse the virt-specifier-seq. */
15069 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
15071 late_return = (cp_parser_late_return_type_opt
15072 (parser, member_p ? cv_quals : -1));
15074 /* Create the function-declarator. */
15075 declarator = make_call_declarator (declarator,
15079 exception_specification,
15081 /* Any subsequent parameter lists are to do with
15082 return type, so are not those of the declared
15084 parser->default_arg_ok_p = false;
15087 /* Remove the function parms from scope. */
15088 for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
15089 pop_binding (DECL_NAME (t), t);
15093 /* Repeat the main loop. */
15097 /* If this is the first, we can try a parenthesized
15101 bool saved_in_type_id_in_expr_p;
15103 parser->default_arg_ok_p = saved_default_arg_ok_p;
15104 parser->in_declarator_p = saved_in_declarator_p;
15106 /* Consume the `('. */
15107 cp_lexer_consume_token (parser->lexer);
15108 /* Parse the nested declarator. */
15109 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
15110 parser->in_type_id_in_expr_p = true;
15112 = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
15113 /*parenthesized_p=*/NULL,
15115 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
15117 /* Expect a `)'. */
15118 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
15119 declarator = cp_error_declarator;
15120 if (declarator == cp_error_declarator)
15123 goto handle_declarator;
15125 /* Otherwise, we must be done. */
15129 else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
15130 && token->type == CPP_OPEN_SQUARE)
15132 /* Parse an array-declarator. */
15135 if (ctor_dtor_or_conv_p)
15136 *ctor_dtor_or_conv_p = 0;
15139 parser->default_arg_ok_p = false;
15140 parser->in_declarator_p = true;
15141 /* Consume the `['. */
15142 cp_lexer_consume_token (parser->lexer);
15143 /* Peek at the next token. */
15144 token = cp_lexer_peek_token (parser->lexer);
15145 /* If the next token is `]', then there is no
15146 constant-expression. */
15147 if (token->type != CPP_CLOSE_SQUARE)
15149 bool non_constant_p;
15152 = cp_parser_constant_expression (parser,
15153 /*allow_non_constant=*/true,
15155 if (!non_constant_p)
15157 /* Normally, the array bound must be an integral constant
15158 expression. However, as an extension, we allow VLAs
15159 in function scopes as long as they aren't part of a
15160 parameter declaration. */
15161 else if (!parser->in_function_body
15162 || current_binding_level->kind == sk_function_parms)
15164 cp_parser_error (parser,
15165 "array bound is not an integer constant");
15166 bounds = error_mark_node;
15168 else if (processing_template_decl && !error_operand_p (bounds))
15170 /* Remember this wasn't a constant-expression. */
15171 bounds = build_nop (TREE_TYPE (bounds), bounds);
15172 TREE_SIDE_EFFECTS (bounds) = 1;
15176 bounds = NULL_TREE;
15177 /* Look for the closing `]'. */
15178 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
15180 declarator = cp_error_declarator;
15184 declarator = make_array_declarator (declarator, bounds);
15186 else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
15189 tree qualifying_scope;
15190 tree unqualified_name;
15191 special_function_kind sfk;
15193 bool pack_expansion_p = false;
15194 cp_token *declarator_id_start_token;
15196 /* Parse a declarator-id */
15197 abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
15200 cp_parser_parse_tentatively (parser);
15202 /* If we see an ellipsis, we should be looking at a
15204 if (token->type == CPP_ELLIPSIS)
15206 /* Consume the `...' */
15207 cp_lexer_consume_token (parser->lexer);
15209 pack_expansion_p = true;
15213 declarator_id_start_token = cp_lexer_peek_token (parser->lexer);
15215 = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
15216 qualifying_scope = parser->scope;
15221 if (!unqualified_name && pack_expansion_p)
15223 /* Check whether an error occurred. */
15224 okay = !cp_parser_error_occurred (parser);
15226 /* We already consumed the ellipsis to mark a
15227 parameter pack, but we have no way to report it,
15228 so abort the tentative parse. We will be exiting
15229 immediately anyway. */
15230 cp_parser_abort_tentative_parse (parser);
15233 okay = cp_parser_parse_definitely (parser);
15236 unqualified_name = error_mark_node;
15237 else if (unqualified_name
15238 && (qualifying_scope
15239 || (TREE_CODE (unqualified_name)
15240 != IDENTIFIER_NODE)))
15242 cp_parser_error (parser, "expected unqualified-id");
15243 unqualified_name = error_mark_node;
15247 if (!unqualified_name)
15249 if (unqualified_name == error_mark_node)
15251 declarator = cp_error_declarator;
15252 pack_expansion_p = false;
15253 declarator->parameter_pack_p = false;
15257 if (qualifying_scope && at_namespace_scope_p ()
15258 && TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
15260 /* In the declaration of a member of a template class
15261 outside of the class itself, the SCOPE will sometimes
15262 be a TYPENAME_TYPE. For example, given:
15264 template <typename T>
15265 int S<T>::R::i = 3;
15267 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
15268 this context, we must resolve S<T>::R to an ordinary
15269 type, rather than a typename type.
15271 The reason we normally avoid resolving TYPENAME_TYPEs
15272 is that a specialization of `S' might render
15273 `S<T>::R' not a type. However, if `S' is
15274 specialized, then this `i' will not be used, so there
15275 is no harm in resolving the types here. */
15278 /* Resolve the TYPENAME_TYPE. */
15279 type = resolve_typename_type (qualifying_scope,
15280 /*only_current_p=*/false);
15281 /* If that failed, the declarator is invalid. */
15282 if (TREE_CODE (type) == TYPENAME_TYPE)
15284 if (typedef_variant_p (type))
15285 error_at (declarator_id_start_token->location,
15286 "cannot define member of dependent typedef "
15289 error_at (declarator_id_start_token->location,
15290 "%<%T::%E%> is not a type",
15291 TYPE_CONTEXT (qualifying_scope),
15292 TYPE_IDENTIFIER (qualifying_scope));
15294 qualifying_scope = type;
15299 if (unqualified_name)
15303 if (qualifying_scope
15304 && CLASS_TYPE_P (qualifying_scope))
15305 class_type = qualifying_scope;
15307 class_type = current_class_type;
15309 if (TREE_CODE (unqualified_name) == TYPE_DECL)
15311 tree name_type = TREE_TYPE (unqualified_name);
15312 if (class_type && same_type_p (name_type, class_type))
15314 if (qualifying_scope
15315 && CLASSTYPE_USE_TEMPLATE (name_type))
15317 error_at (declarator_id_start_token->location,
15318 "invalid use of constructor as a template");
15319 inform (declarator_id_start_token->location,
15320 "use %<%T::%D%> instead of %<%T::%D%> to "
15321 "name the constructor in a qualified name",
15323 DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
15324 class_type, name_type);
15325 declarator = cp_error_declarator;
15329 unqualified_name = constructor_name (class_type);
15333 /* We do not attempt to print the declarator
15334 here because we do not have enough
15335 information about its original syntactic
15337 cp_parser_error (parser, "invalid declarator");
15338 declarator = cp_error_declarator;
15345 if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
15346 sfk = sfk_destructor;
15347 else if (IDENTIFIER_TYPENAME_P (unqualified_name))
15348 sfk = sfk_conversion;
15349 else if (/* There's no way to declare a constructor
15350 for an anonymous type, even if the type
15351 got a name for linkage purposes. */
15352 !TYPE_WAS_ANONYMOUS (class_type)
15353 && constructor_name_p (unqualified_name,
15356 unqualified_name = constructor_name (class_type);
15357 sfk = sfk_constructor;
15359 else if (is_overloaded_fn (unqualified_name)
15360 && DECL_CONSTRUCTOR_P (get_first_fn
15361 (unqualified_name)))
15362 sfk = sfk_constructor;
15364 if (ctor_dtor_or_conv_p && sfk != sfk_none)
15365 *ctor_dtor_or_conv_p = -1;
15368 declarator = make_id_declarator (qualifying_scope,
15371 declarator->id_loc = token->location;
15372 declarator->parameter_pack_p = pack_expansion_p;
15374 if (pack_expansion_p)
15375 maybe_warn_variadic_templates ();
15378 handle_declarator:;
15379 scope = get_scope_of_declarator (declarator);
15381 /* Any names that appear after the declarator-id for a
15382 member are looked up in the containing scope. */
15383 pushed_scope = push_scope (scope);
15384 parser->in_declarator_p = true;
15385 if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
15386 || (declarator && declarator->kind == cdk_id))
15387 /* Default args are only allowed on function
15389 parser->default_arg_ok_p = saved_default_arg_ok_p;
15391 parser->default_arg_ok_p = false;
15400 /* For an abstract declarator, we might wind up with nothing at this
15401 point. That's an error; the declarator is not optional. */
15403 cp_parser_error (parser, "expected declarator");
15405 /* If we entered a scope, we must exit it now. */
15407 pop_scope (pushed_scope);
15409 parser->default_arg_ok_p = saved_default_arg_ok_p;
15410 parser->in_declarator_p = saved_in_declarator_p;
15415 /* Parse a ptr-operator.
15418 * cv-qualifier-seq [opt]
15420 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
15425 & cv-qualifier-seq [opt]
15427 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
15428 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
15429 an rvalue reference. In the case of a pointer-to-member, *TYPE is
15430 filled in with the TYPE containing the member. *CV_QUALS is
15431 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
15432 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
15433 Note that the tree codes returned by this function have nothing
15434 to do with the types of trees that will be eventually be created
15435 to represent the pointer or reference type being parsed. They are
15436 just constants with suggestive names. */
15437 static enum tree_code
15438 cp_parser_ptr_operator (cp_parser* parser,
15440 cp_cv_quals *cv_quals)
15442 enum tree_code code = ERROR_MARK;
15445 /* Assume that it's not a pointer-to-member. */
15447 /* And that there are no cv-qualifiers. */
15448 *cv_quals = TYPE_UNQUALIFIED;
15450 /* Peek at the next token. */
15451 token = cp_lexer_peek_token (parser->lexer);
15453 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
15454 if (token->type == CPP_MULT)
15455 code = INDIRECT_REF;
15456 else if (token->type == CPP_AND)
15458 else if ((cxx_dialect != cxx98) &&
15459 token->type == CPP_AND_AND) /* C++0x only */
15460 code = NON_LVALUE_EXPR;
15462 if (code != ERROR_MARK)
15464 /* Consume the `*', `&' or `&&'. */
15465 cp_lexer_consume_token (parser->lexer);
15467 /* A `*' can be followed by a cv-qualifier-seq, and so can a
15468 `&', if we are allowing GNU extensions. (The only qualifier
15469 that can legally appear after `&' is `restrict', but that is
15470 enforced during semantic analysis. */
15471 if (code == INDIRECT_REF
15472 || cp_parser_allow_gnu_extensions_p (parser))
15473 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
15477 /* Try the pointer-to-member case. */
15478 cp_parser_parse_tentatively (parser);
15479 /* Look for the optional `::' operator. */
15480 cp_parser_global_scope_opt (parser,
15481 /*current_scope_valid_p=*/false);
15482 /* Look for the nested-name specifier. */
15483 token = cp_lexer_peek_token (parser->lexer);
15484 cp_parser_nested_name_specifier (parser,
15485 /*typename_keyword_p=*/false,
15486 /*check_dependency_p=*/true,
15488 /*is_declaration=*/false);
15489 /* If we found it, and the next token is a `*', then we are
15490 indeed looking at a pointer-to-member operator. */
15491 if (!cp_parser_error_occurred (parser)
15492 && cp_parser_require (parser, CPP_MULT, RT_MULT))
15494 /* Indicate that the `*' operator was used. */
15495 code = INDIRECT_REF;
15497 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
15498 error_at (token->location, "%qD is a namespace", parser->scope);
15501 /* The type of which the member is a member is given by the
15503 *type = parser->scope;
15504 /* The next name will not be qualified. */
15505 parser->scope = NULL_TREE;
15506 parser->qualifying_scope = NULL_TREE;
15507 parser->object_scope = NULL_TREE;
15508 /* Look for the optional cv-qualifier-seq. */
15509 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
15512 /* If that didn't work we don't have a ptr-operator. */
15513 if (!cp_parser_parse_definitely (parser))
15514 cp_parser_error (parser, "expected ptr-operator");
15520 /* Parse an (optional) cv-qualifier-seq.
15523 cv-qualifier cv-qualifier-seq [opt]
15534 Returns a bitmask representing the cv-qualifiers. */
15537 cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
15539 cp_cv_quals cv_quals = TYPE_UNQUALIFIED;
15544 cp_cv_quals cv_qualifier;
15546 /* Peek at the next token. */
15547 token = cp_lexer_peek_token (parser->lexer);
15548 /* See if it's a cv-qualifier. */
15549 switch (token->keyword)
15552 cv_qualifier = TYPE_QUAL_CONST;
15556 cv_qualifier = TYPE_QUAL_VOLATILE;
15560 cv_qualifier = TYPE_QUAL_RESTRICT;
15564 cv_qualifier = TYPE_UNQUALIFIED;
15571 if (cv_quals & cv_qualifier)
15573 error_at (token->location, "duplicate cv-qualifier");
15574 cp_lexer_purge_token (parser->lexer);
15578 cp_lexer_consume_token (parser->lexer);
15579 cv_quals |= cv_qualifier;
15586 /* Parse an (optional) virt-specifier-seq.
15588 virt-specifier-seq:
15589 virt-specifier virt-specifier-seq [opt]
15595 Returns a bitmask representing the virt-specifiers. */
15597 static cp_virt_specifiers
15598 cp_parser_virt_specifier_seq_opt (cp_parser* parser)
15600 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
15605 cp_virt_specifiers virt_specifier;
15607 /* Peek at the next token. */
15608 token = cp_lexer_peek_token (parser->lexer);
15609 /* See if it's a virt-specifier-qualifier. */
15610 if (token->type != CPP_NAME)
15612 if (!strcmp (IDENTIFIER_POINTER(token->u.value), "override"))
15614 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS);
15615 virt_specifier = VIRT_SPEC_OVERRIDE;
15617 else if (!strcmp (IDENTIFIER_POINTER(token->u.value), "final"))
15619 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS);
15620 virt_specifier = VIRT_SPEC_FINAL;
15622 else if (!strcmp (IDENTIFIER_POINTER(token->u.value), "__final"))
15624 virt_specifier = VIRT_SPEC_FINAL;
15629 if (virt_specifiers & virt_specifier)
15631 error_at (token->location, "duplicate virt-specifier");
15632 cp_lexer_purge_token (parser->lexer);
15636 cp_lexer_consume_token (parser->lexer);
15637 virt_specifiers |= virt_specifier;
15640 return virt_specifiers;
15643 /* Parse a late-specified return type, if any. This is not a separate
15644 non-terminal, but part of a function declarator, which looks like
15646 -> trailing-type-specifier-seq abstract-declarator(opt)
15648 Returns the type indicated by the type-id.
15650 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
15654 cp_parser_late_return_type_opt (cp_parser* parser, cp_cv_quals quals)
15659 /* Peek at the next token. */
15660 token = cp_lexer_peek_token (parser->lexer);
15661 /* A late-specified return type is indicated by an initial '->'. */
15662 if (token->type != CPP_DEREF)
15665 /* Consume the ->. */
15666 cp_lexer_consume_token (parser->lexer);
15670 /* DR 1207: 'this' is in scope in the trailing return type. */
15671 tree this_parm = build_this_parm (current_class_type, quals);
15672 gcc_assert (current_class_ptr == NULL_TREE);
15674 = cp_build_indirect_ref (this_parm, RO_NULL, tf_warning_or_error);
15675 /* Set this second to avoid shortcut in cp_build_indirect_ref. */
15676 current_class_ptr = this_parm;
15679 type = cp_parser_trailing_type_id (parser);
15681 if (current_class_type)
15682 current_class_ptr = current_class_ref = NULL_TREE;
15687 /* Parse a declarator-id.
15691 :: [opt] nested-name-specifier [opt] type-name
15693 In the `id-expression' case, the value returned is as for
15694 cp_parser_id_expression if the id-expression was an unqualified-id.
15695 If the id-expression was a qualified-id, then a SCOPE_REF is
15696 returned. The first operand is the scope (either a NAMESPACE_DECL
15697 or TREE_TYPE), but the second is still just a representation of an
15701 cp_parser_declarator_id (cp_parser* parser, bool optional_p)
15704 /* The expression must be an id-expression. Assume that qualified
15705 names are the names of types so that:
15708 int S<T>::R::i = 3;
15710 will work; we must treat `S<T>::R' as the name of a type.
15711 Similarly, assume that qualified names are templates, where
15715 int S<T>::R<T>::i = 3;
15718 id = cp_parser_id_expression (parser,
15719 /*template_keyword_p=*/false,
15720 /*check_dependency_p=*/false,
15721 /*template_p=*/NULL,
15722 /*declarator_p=*/true,
15724 if (id && BASELINK_P (id))
15725 id = BASELINK_FUNCTIONS (id);
15729 /* Parse a type-id.
15732 type-specifier-seq abstract-declarator [opt]
15734 Returns the TYPE specified. */
15737 cp_parser_type_id_1 (cp_parser* parser, bool is_template_arg,
15738 bool is_trailing_return)
15740 cp_decl_specifier_seq type_specifier_seq;
15741 cp_declarator *abstract_declarator;
15743 /* Parse the type-specifier-seq. */
15744 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
15745 is_trailing_return,
15746 &type_specifier_seq);
15747 if (type_specifier_seq.type == error_mark_node)
15748 return error_mark_node;
15750 /* There might or might not be an abstract declarator. */
15751 cp_parser_parse_tentatively (parser);
15752 /* Look for the declarator. */
15753 abstract_declarator
15754 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
15755 /*parenthesized_p=*/NULL,
15756 /*member_p=*/false);
15757 /* Check to see if there really was a declarator. */
15758 if (!cp_parser_parse_definitely (parser))
15759 abstract_declarator = NULL;
15761 if (type_specifier_seq.type
15762 && type_uses_auto (type_specifier_seq.type))
15764 /* A type-id with type 'auto' is only ok if the abstract declarator
15765 is a function declarator with a late-specified return type. */
15766 if (abstract_declarator
15767 && abstract_declarator->kind == cdk_function
15768 && abstract_declarator->u.function.late_return_type)
15772 error ("invalid use of %<auto%>");
15773 return error_mark_node;
15777 return groktypename (&type_specifier_seq, abstract_declarator,
15781 static tree cp_parser_type_id (cp_parser *parser)
15783 return cp_parser_type_id_1 (parser, false, false);
15786 static tree cp_parser_template_type_arg (cp_parser *parser)
15789 const char *saved_message = parser->type_definition_forbidden_message;
15790 parser->type_definition_forbidden_message
15791 = G_("types may not be defined in template arguments");
15792 r = cp_parser_type_id_1 (parser, true, false);
15793 parser->type_definition_forbidden_message = saved_message;
15797 static tree cp_parser_trailing_type_id (cp_parser *parser)
15799 return cp_parser_type_id_1 (parser, false, true);
15802 /* Parse a type-specifier-seq.
15804 type-specifier-seq:
15805 type-specifier type-specifier-seq [opt]
15809 type-specifier-seq:
15810 attributes type-specifier-seq [opt]
15812 If IS_DECLARATION is true, we are at the start of a "condition" or
15813 exception-declaration, so we might be followed by a declarator-id.
15815 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
15816 i.e. we've just seen "->".
15818 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
15821 cp_parser_type_specifier_seq (cp_parser* parser,
15822 bool is_declaration,
15823 bool is_trailing_return,
15824 cp_decl_specifier_seq *type_specifier_seq)
15826 bool seen_type_specifier = false;
15827 cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;
15828 cp_token *start_token = NULL;
15830 /* Clear the TYPE_SPECIFIER_SEQ. */
15831 clear_decl_specs (type_specifier_seq);
15833 /* In the context of a trailing return type, enum E { } is an
15834 elaborated-type-specifier followed by a function-body, not an
15836 if (is_trailing_return)
15837 flags |= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS;
15839 /* Parse the type-specifiers and attributes. */
15842 tree type_specifier;
15843 bool is_cv_qualifier;
15845 /* Check for attributes first. */
15846 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
15848 type_specifier_seq->attributes =
15849 chainon (type_specifier_seq->attributes,
15850 cp_parser_attributes_opt (parser));
15854 /* record the token of the beginning of the type specifier seq,
15855 for error reporting purposes*/
15857 start_token = cp_lexer_peek_token (parser->lexer);
15859 /* Look for the type-specifier. */
15860 type_specifier = cp_parser_type_specifier (parser,
15862 type_specifier_seq,
15863 /*is_declaration=*/false,
15866 if (!type_specifier)
15868 /* If the first type-specifier could not be found, this is not a
15869 type-specifier-seq at all. */
15870 if (!seen_type_specifier)
15872 cp_parser_error (parser, "expected type-specifier");
15873 type_specifier_seq->type = error_mark_node;
15876 /* If subsequent type-specifiers could not be found, the
15877 type-specifier-seq is complete. */
15881 seen_type_specifier = true;
15882 /* The standard says that a condition can be:
15884 type-specifier-seq declarator = assignment-expression
15891 we should treat the "S" as a declarator, not as a
15892 type-specifier. The standard doesn't say that explicitly for
15893 type-specifier-seq, but it does say that for
15894 decl-specifier-seq in an ordinary declaration. Perhaps it
15895 would be clearer just to allow a decl-specifier-seq here, and
15896 then add a semantic restriction that if any decl-specifiers
15897 that are not type-specifiers appear, the program is invalid. */
15898 if (is_declaration && !is_cv_qualifier)
15899 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
15902 cp_parser_check_decl_spec (type_specifier_seq, start_token->location);
15905 /* Parse a parameter-declaration-clause.
15907 parameter-declaration-clause:
15908 parameter-declaration-list [opt] ... [opt]
15909 parameter-declaration-list , ...
15911 Returns a representation for the parameter declarations. A return
15912 value of NULL indicates a parameter-declaration-clause consisting
15913 only of an ellipsis. */
15916 cp_parser_parameter_declaration_clause (cp_parser* parser)
15923 /* Peek at the next token. */
15924 token = cp_lexer_peek_token (parser->lexer);
15925 /* Check for trivial parameter-declaration-clauses. */
15926 if (token->type == CPP_ELLIPSIS)
15928 /* Consume the `...' token. */
15929 cp_lexer_consume_token (parser->lexer);
15932 else if (token->type == CPP_CLOSE_PAREN)
15933 /* There are no parameters. */
15935 #ifndef NO_IMPLICIT_EXTERN_C
15936 if (in_system_header && current_class_type == NULL
15937 && current_lang_name == lang_name_c)
15941 return void_list_node;
15943 /* Check for `(void)', too, which is a special case. */
15944 else if (token->keyword == RID_VOID
15945 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
15946 == CPP_CLOSE_PAREN))
15948 /* Consume the `void' token. */
15949 cp_lexer_consume_token (parser->lexer);
15950 /* There are no parameters. */
15951 return void_list_node;
15954 /* Parse the parameter-declaration-list. */
15955 parameters = cp_parser_parameter_declaration_list (parser, &is_error);
15956 /* If a parse error occurred while parsing the
15957 parameter-declaration-list, then the entire
15958 parameter-declaration-clause is erroneous. */
15962 /* Peek at the next token. */
15963 token = cp_lexer_peek_token (parser->lexer);
15964 /* If it's a `,', the clause should terminate with an ellipsis. */
15965 if (token->type == CPP_COMMA)
15967 /* Consume the `,'. */
15968 cp_lexer_consume_token (parser->lexer);
15969 /* Expect an ellipsis. */
15971 = (cp_parser_require (parser, CPP_ELLIPSIS, RT_ELLIPSIS) != NULL);
15973 /* It might also be `...' if the optional trailing `,' was
15975 else if (token->type == CPP_ELLIPSIS)
15977 /* Consume the `...' token. */
15978 cp_lexer_consume_token (parser->lexer);
15979 /* And remember that we saw it. */
15983 ellipsis_p = false;
15985 /* Finish the parameter list. */
15987 parameters = chainon (parameters, void_list_node);
15992 /* Parse a parameter-declaration-list.
15994 parameter-declaration-list:
15995 parameter-declaration
15996 parameter-declaration-list , parameter-declaration
15998 Returns a representation of the parameter-declaration-list, as for
15999 cp_parser_parameter_declaration_clause. However, the
16000 `void_list_node' is never appended to the list. Upon return,
16001 *IS_ERROR will be true iff an error occurred. */
16004 cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error)
16006 tree parameters = NULL_TREE;
16007 tree *tail = ¶meters;
16008 bool saved_in_unbraced_linkage_specification_p;
16011 /* Assume all will go well. */
16013 /* The special considerations that apply to a function within an
16014 unbraced linkage specifications do not apply to the parameters
16015 to the function. */
16016 saved_in_unbraced_linkage_specification_p
16017 = parser->in_unbraced_linkage_specification_p;
16018 parser->in_unbraced_linkage_specification_p = false;
16020 /* Look for more parameters. */
16023 cp_parameter_declarator *parameter;
16024 tree decl = error_mark_node;
16025 bool parenthesized_p = false;
16026 /* Parse the parameter. */
16028 = cp_parser_parameter_declaration (parser,
16029 /*template_parm_p=*/false,
16032 /* We don't know yet if the enclosing context is deprecated, so wait
16033 and warn in grokparms if appropriate. */
16034 deprecated_state = DEPRECATED_SUPPRESS;
16037 decl = grokdeclarator (parameter->declarator,
16038 ¶meter->decl_specifiers,
16040 parameter->default_argument != NULL_TREE,
16041 ¶meter->decl_specifiers.attributes);
16043 deprecated_state = DEPRECATED_NORMAL;
16045 /* If a parse error occurred parsing the parameter declaration,
16046 then the entire parameter-declaration-list is erroneous. */
16047 if (decl == error_mark_node)
16050 parameters = error_mark_node;
16054 if (parameter->decl_specifiers.attributes)
16055 cplus_decl_attributes (&decl,
16056 parameter->decl_specifiers.attributes,
16058 if (DECL_NAME (decl))
16059 decl = pushdecl (decl);
16061 if (decl != error_mark_node)
16063 retrofit_lang_decl (decl);
16064 DECL_PARM_INDEX (decl) = ++index;
16065 DECL_PARM_LEVEL (decl) = function_parm_depth ();
16068 /* Add the new parameter to the list. */
16069 *tail = build_tree_list (parameter->default_argument, decl);
16070 tail = &TREE_CHAIN (*tail);
16072 /* Peek at the next token. */
16073 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
16074 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
16075 /* These are for Objective-C++ */
16076 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
16077 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
16078 /* The parameter-declaration-list is complete. */
16080 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
16084 /* Peek at the next token. */
16085 token = cp_lexer_peek_nth_token (parser->lexer, 2);
16086 /* If it's an ellipsis, then the list is complete. */
16087 if (token->type == CPP_ELLIPSIS)
16089 /* Otherwise, there must be more parameters. Consume the
16091 cp_lexer_consume_token (parser->lexer);
16092 /* When parsing something like:
16094 int i(float f, double d)
16096 we can tell after seeing the declaration for "f" that we
16097 are not looking at an initialization of a variable "i",
16098 but rather at the declaration of a function "i".
16100 Due to the fact that the parsing of template arguments
16101 (as specified to a template-id) requires backtracking we
16102 cannot use this technique when inside a template argument
16104 if (!parser->in_template_argument_list_p
16105 && !parser->in_type_id_in_expr_p
16106 && cp_parser_uncommitted_to_tentative_parse_p (parser)
16107 /* However, a parameter-declaration of the form
16108 "foat(f)" (which is a valid declaration of a
16109 parameter "f") can also be interpreted as an
16110 expression (the conversion of "f" to "float"). */
16111 && !parenthesized_p)
16112 cp_parser_commit_to_tentative_parse (parser);
16116 cp_parser_error (parser, "expected %<,%> or %<...%>");
16117 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
16118 cp_parser_skip_to_closing_parenthesis (parser,
16119 /*recovering=*/true,
16120 /*or_comma=*/false,
16121 /*consume_paren=*/false);
16126 parser->in_unbraced_linkage_specification_p
16127 = saved_in_unbraced_linkage_specification_p;
16132 /* Parse a parameter declaration.
16134 parameter-declaration:
16135 decl-specifier-seq ... [opt] declarator
16136 decl-specifier-seq declarator = assignment-expression
16137 decl-specifier-seq ... [opt] abstract-declarator [opt]
16138 decl-specifier-seq abstract-declarator [opt] = assignment-expression
16140 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
16141 declares a template parameter. (In that case, a non-nested `>'
16142 token encountered during the parsing of the assignment-expression
16143 is not interpreted as a greater-than operator.)
16145 Returns a representation of the parameter, or NULL if an error
16146 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
16147 true iff the declarator is of the form "(p)". */
16149 static cp_parameter_declarator *
16150 cp_parser_parameter_declaration (cp_parser *parser,
16151 bool template_parm_p,
16152 bool *parenthesized_p)
16154 int declares_class_or_enum;
16155 cp_decl_specifier_seq decl_specifiers;
16156 cp_declarator *declarator;
16157 tree default_argument;
16158 cp_token *token = NULL, *declarator_token_start = NULL;
16159 const char *saved_message;
16161 /* In a template parameter, `>' is not an operator.
16165 When parsing a default template-argument for a non-type
16166 template-parameter, the first non-nested `>' is taken as the end
16167 of the template parameter-list rather than a greater-than
16170 /* Type definitions may not appear in parameter types. */
16171 saved_message = parser->type_definition_forbidden_message;
16172 parser->type_definition_forbidden_message
16173 = G_("types may not be defined in parameter types");
16175 /* Parse the declaration-specifiers. */
16176 cp_parser_decl_specifier_seq (parser,
16177 CP_PARSER_FLAGS_NONE,
16179 &declares_class_or_enum);
16181 /* Complain about missing 'typename' or other invalid type names. */
16182 if (!decl_specifiers.any_type_specifiers_p)
16183 cp_parser_parse_and_diagnose_invalid_type_name (parser);
16185 /* If an error occurred, there's no reason to attempt to parse the
16186 rest of the declaration. */
16187 if (cp_parser_error_occurred (parser))
16189 parser->type_definition_forbidden_message = saved_message;
16193 /* Peek at the next token. */
16194 token = cp_lexer_peek_token (parser->lexer);
16196 /* If the next token is a `)', `,', `=', `>', or `...', then there
16197 is no declarator. However, when variadic templates are enabled,
16198 there may be a declarator following `...'. */
16199 if (token->type == CPP_CLOSE_PAREN
16200 || token->type == CPP_COMMA
16201 || token->type == CPP_EQ
16202 || token->type == CPP_GREATER)
16205 if (parenthesized_p)
16206 *parenthesized_p = false;
16208 /* Otherwise, there should be a declarator. */
16211 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
16212 parser->default_arg_ok_p = false;
16214 /* After seeing a decl-specifier-seq, if the next token is not a
16215 "(", there is no possibility that the code is a valid
16216 expression. Therefore, if parsing tentatively, we commit at
16218 if (!parser->in_template_argument_list_p
16219 /* In an expression context, having seen:
16223 we cannot be sure whether we are looking at a
16224 function-type (taking a "char" as a parameter) or a cast
16225 of some object of type "char" to "int". */
16226 && !parser->in_type_id_in_expr_p
16227 && cp_parser_uncommitted_to_tentative_parse_p (parser)
16228 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
16229 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
16230 cp_parser_commit_to_tentative_parse (parser);
16231 /* Parse the declarator. */
16232 declarator_token_start = token;
16233 declarator = cp_parser_declarator (parser,
16234 CP_PARSER_DECLARATOR_EITHER,
16235 /*ctor_dtor_or_conv_p=*/NULL,
16237 /*member_p=*/false);
16238 parser->default_arg_ok_p = saved_default_arg_ok_p;
16239 /* After the declarator, allow more attributes. */
16240 decl_specifiers.attributes
16241 = chainon (decl_specifiers.attributes,
16242 cp_parser_attributes_opt (parser));
16245 /* If the next token is an ellipsis, and we have not seen a
16246 declarator name, and the type of the declarator contains parameter
16247 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
16248 a parameter pack expansion expression. Otherwise, leave the
16249 ellipsis for a C-style variadic function. */
16250 token = cp_lexer_peek_token (parser->lexer);
16251 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16253 tree type = decl_specifiers.type;
16255 if (type && DECL_P (type))
16256 type = TREE_TYPE (type);
16259 && TREE_CODE (type) != TYPE_PACK_EXPANSION
16260 && declarator_can_be_parameter_pack (declarator)
16261 && (!declarator || !declarator->parameter_pack_p)
16262 && uses_parameter_packs (type))
16264 /* Consume the `...'. */
16265 cp_lexer_consume_token (parser->lexer);
16266 maybe_warn_variadic_templates ();
16268 /* Build a pack expansion type */
16270 declarator->parameter_pack_p = true;
16272 decl_specifiers.type = make_pack_expansion (type);
16276 /* The restriction on defining new types applies only to the type
16277 of the parameter, not to the default argument. */
16278 parser->type_definition_forbidden_message = saved_message;
16280 /* If the next token is `=', then process a default argument. */
16281 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
16283 /* Consume the `='. */
16284 cp_lexer_consume_token (parser->lexer);
16286 /* If we are defining a class, then the tokens that make up the
16287 default argument must be saved and processed later. */
16288 if (!template_parm_p && at_class_scope_p ()
16289 && TYPE_BEING_DEFINED (current_class_type)
16290 && !LAMBDA_TYPE_P (current_class_type))
16292 unsigned depth = 0;
16293 int maybe_template_id = 0;
16294 cp_token *first_token;
16297 /* Add tokens until we have processed the entire default
16298 argument. We add the range [first_token, token). */
16299 first_token = cp_lexer_peek_token (parser->lexer);
16304 /* Peek at the next token. */
16305 token = cp_lexer_peek_token (parser->lexer);
16306 /* What we do depends on what token we have. */
16307 switch (token->type)
16309 /* In valid code, a default argument must be
16310 immediately followed by a `,' `)', or `...'. */
16312 if (depth == 0 && maybe_template_id)
16314 /* If we've seen a '<', we might be in a
16315 template-argument-list. Until Core issue 325 is
16316 resolved, we don't know how this situation ought
16317 to be handled, so try to DTRT. We check whether
16318 what comes after the comma is a valid parameter
16319 declaration list. If it is, then the comma ends
16320 the default argument; otherwise the default
16321 argument continues. */
16322 bool error = false;
16325 /* Set ITALP so cp_parser_parameter_declaration_list
16326 doesn't decide to commit to this parse. */
16327 bool saved_italp = parser->in_template_argument_list_p;
16328 parser->in_template_argument_list_p = true;
16330 cp_parser_parse_tentatively (parser);
16331 cp_lexer_consume_token (parser->lexer);
16332 begin_scope (sk_function_parms, NULL_TREE);
16333 cp_parser_parameter_declaration_list (parser, &error);
16334 for (t = current_binding_level->names; t; t = DECL_CHAIN (t))
16335 pop_binding (DECL_NAME (t), t);
16337 if (!cp_parser_error_occurred (parser) && !error)
16339 cp_parser_abort_tentative_parse (parser);
16341 parser->in_template_argument_list_p = saved_italp;
16344 case CPP_CLOSE_PAREN:
16346 /* If we run into a non-nested `;', `}', or `]',
16347 then the code is invalid -- but the default
16348 argument is certainly over. */
16349 case CPP_SEMICOLON:
16350 case CPP_CLOSE_BRACE:
16351 case CPP_CLOSE_SQUARE:
16354 /* Update DEPTH, if necessary. */
16355 else if (token->type == CPP_CLOSE_PAREN
16356 || token->type == CPP_CLOSE_BRACE
16357 || token->type == CPP_CLOSE_SQUARE)
16361 case CPP_OPEN_PAREN:
16362 case CPP_OPEN_SQUARE:
16363 case CPP_OPEN_BRACE:
16369 /* This might be the comparison operator, or it might
16370 start a template argument list. */
16371 ++maybe_template_id;
16375 if (cxx_dialect == cxx98)
16377 /* Fall through for C++0x, which treats the `>>'
16378 operator like two `>' tokens in certain
16384 /* This might be an operator, or it might close a
16385 template argument list. But if a previous '<'
16386 started a template argument list, this will have
16387 closed it, so we can't be in one anymore. */
16388 maybe_template_id -= 1 + (token->type == CPP_RSHIFT);
16389 if (maybe_template_id < 0)
16390 maybe_template_id = 0;
16394 /* If we run out of tokens, issue an error message. */
16396 case CPP_PRAGMA_EOL:
16397 error_at (token->location, "file ends in default argument");
16403 /* In these cases, we should look for template-ids.
16404 For example, if the default argument is
16405 `X<int, double>()', we need to do name lookup to
16406 figure out whether or not `X' is a template; if
16407 so, the `,' does not end the default argument.
16409 That is not yet done. */
16416 /* If we've reached the end, stop. */
16420 /* Add the token to the token block. */
16421 token = cp_lexer_consume_token (parser->lexer);
16424 /* Create a DEFAULT_ARG to represent the unparsed default
16426 default_argument = make_node (DEFAULT_ARG);
16427 DEFARG_TOKENS (default_argument)
16428 = cp_token_cache_new (first_token, token);
16429 DEFARG_INSTANTIATIONS (default_argument) = NULL;
16431 /* Outside of a class definition, we can just parse the
16432 assignment-expression. */
16435 token = cp_lexer_peek_token (parser->lexer);
16437 = cp_parser_default_argument (parser, template_parm_p);
16440 if (!parser->default_arg_ok_p)
16442 if (flag_permissive)
16443 warning (0, "deprecated use of default argument for parameter of non-function");
16446 error_at (token->location,
16447 "default arguments are only "
16448 "permitted for function parameters");
16449 default_argument = NULL_TREE;
16452 else if ((declarator && declarator->parameter_pack_p)
16453 || (decl_specifiers.type
16454 && PACK_EXPANSION_P (decl_specifiers.type)))
16456 /* Find the name of the parameter pack. */
16457 cp_declarator *id_declarator = declarator;
16458 while (id_declarator && id_declarator->kind != cdk_id)
16459 id_declarator = id_declarator->declarator;
16461 if (id_declarator && id_declarator->kind == cdk_id)
16462 error_at (declarator_token_start->location,
16464 ? "template parameter pack %qD"
16465 " cannot have a default argument"
16466 : "parameter pack %qD cannot have a default argument",
16467 id_declarator->u.id.unqualified_name);
16469 error_at (declarator_token_start->location,
16471 ? "template parameter pack cannot have a default argument"
16472 : "parameter pack cannot have a default argument");
16474 default_argument = NULL_TREE;
16478 default_argument = NULL_TREE;
16480 return make_parameter_declarator (&decl_specifiers,
16485 /* Parse a default argument and return it.
16487 TEMPLATE_PARM_P is true if this is a default argument for a
16488 non-type template parameter. */
16490 cp_parser_default_argument (cp_parser *parser, bool template_parm_p)
16492 tree default_argument = NULL_TREE;
16493 bool saved_greater_than_is_operator_p;
16494 bool saved_local_variables_forbidden_p;
16496 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
16498 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
16499 parser->greater_than_is_operator_p = !template_parm_p;
16500 /* Local variable names (and the `this' keyword) may not
16501 appear in a default argument. */
16502 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
16503 parser->local_variables_forbidden_p = true;
16504 /* Parse the assignment-expression. */
16505 if (template_parm_p)
16506 push_deferring_access_checks (dk_no_deferred);
16508 = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
16509 if (template_parm_p)
16510 pop_deferring_access_checks ();
16511 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
16512 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
16514 return default_argument;
16517 /* Parse a function-body.
16520 compound_statement */
16523 cp_parser_function_body (cp_parser *parser)
16525 cp_parser_compound_statement (parser, NULL, false, true);
16528 /* Parse a ctor-initializer-opt followed by a function-body. Return
16529 true if a ctor-initializer was present. */
16532 cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser)
16535 bool ctor_initializer_p;
16536 const bool check_body_p =
16537 DECL_CONSTRUCTOR_P (current_function_decl)
16538 && DECL_DECLARED_CONSTEXPR_P (current_function_decl);
16541 /* Begin the function body. */
16542 body = begin_function_body ();
16543 /* Parse the optional ctor-initializer. */
16544 ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
16546 /* If we're parsing a constexpr constructor definition, we need
16547 to check that the constructor body is indeed empty. However,
16548 before we get to cp_parser_function_body lot of junk has been
16549 generated, so we can't just check that we have an empty block.
16550 Rather we take a snapshot of the outermost block, and check whether
16551 cp_parser_function_body changed its state. */
16555 if (TREE_CODE (list) == BIND_EXPR)
16556 list = BIND_EXPR_BODY (list);
16557 if (TREE_CODE (list) == STATEMENT_LIST
16558 && STATEMENT_LIST_TAIL (list) != NULL)
16559 last = STATEMENT_LIST_TAIL (list)->stmt;
16561 /* Parse the function-body. */
16562 cp_parser_function_body (parser);
16564 check_constexpr_ctor_body (last, list);
16565 /* Finish the function body. */
16566 finish_function_body (body);
16568 return ctor_initializer_p;
16571 /* Parse an initializer.
16574 = initializer-clause
16575 ( expression-list )
16577 Returns an expression representing the initializer. If no
16578 initializer is present, NULL_TREE is returned.
16580 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
16581 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
16582 set to TRUE if there is no initializer present. If there is an
16583 initializer, and it is not a constant-expression, *NON_CONSTANT_P
16584 is set to true; otherwise it is set to false. */
16587 cp_parser_initializer (cp_parser* parser, bool* is_direct_init,
16588 bool* non_constant_p)
16593 /* Peek at the next token. */
16594 token = cp_lexer_peek_token (parser->lexer);
16596 /* Let our caller know whether or not this initializer was
16598 *is_direct_init = (token->type != CPP_EQ);
16599 /* Assume that the initializer is constant. */
16600 *non_constant_p = false;
16602 if (token->type == CPP_EQ)
16604 /* Consume the `='. */
16605 cp_lexer_consume_token (parser->lexer);
16606 /* Parse the initializer-clause. */
16607 init = cp_parser_initializer_clause (parser, non_constant_p);
16609 else if (token->type == CPP_OPEN_PAREN)
16612 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
16614 /*allow_expansion_p=*/true,
16617 return error_mark_node;
16618 init = build_tree_list_vec (vec);
16619 release_tree_vector (vec);
16621 else if (token->type == CPP_OPEN_BRACE)
16623 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
16624 init = cp_parser_braced_list (parser, non_constant_p);
16625 CONSTRUCTOR_IS_DIRECT_INIT (init) = 1;
16629 /* Anything else is an error. */
16630 cp_parser_error (parser, "expected initializer");
16631 init = error_mark_node;
16637 /* Parse an initializer-clause.
16639 initializer-clause:
16640 assignment-expression
16643 Returns an expression representing the initializer.
16645 If the `assignment-expression' production is used the value
16646 returned is simply a representation for the expression.
16648 Otherwise, calls cp_parser_braced_list. */
16651 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
16655 /* Assume the expression is constant. */
16656 *non_constant_p = false;
16658 /* If it is not a `{', then we are looking at an
16659 assignment-expression. */
16660 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
16663 = cp_parser_constant_expression (parser,
16664 /*allow_non_constant_p=*/true,
16668 initializer = cp_parser_braced_list (parser, non_constant_p);
16670 return initializer;
16673 /* Parse a brace-enclosed initializer list.
16676 { initializer-list , [opt] }
16679 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
16680 the elements of the initializer-list (or NULL, if the last
16681 production is used). The TREE_TYPE for the CONSTRUCTOR will be
16682 NULL_TREE. There is no way to detect whether or not the optional
16683 trailing `,' was provided. NON_CONSTANT_P is as for
16684 cp_parser_initializer. */
16687 cp_parser_braced_list (cp_parser* parser, bool* non_constant_p)
16691 /* Consume the `{' token. */
16692 cp_lexer_consume_token (parser->lexer);
16693 /* Create a CONSTRUCTOR to represent the braced-initializer. */
16694 initializer = make_node (CONSTRUCTOR);
16695 /* If it's not a `}', then there is a non-trivial initializer. */
16696 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
16698 /* Parse the initializer list. */
16699 CONSTRUCTOR_ELTS (initializer)
16700 = cp_parser_initializer_list (parser, non_constant_p);
16701 /* A trailing `,' token is allowed. */
16702 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
16703 cp_lexer_consume_token (parser->lexer);
16705 /* Now, there should be a trailing `}'. */
16706 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
16707 TREE_TYPE (initializer) = init_list_type_node;
16708 return initializer;
16711 /* Parse an initializer-list.
16714 initializer-clause ... [opt]
16715 initializer-list , initializer-clause ... [opt]
16720 designation initializer-clause ...[opt]
16721 initializer-list , designation initializer-clause ...[opt]
16726 [ constant-expression ] =
16728 Returns a VEC of constructor_elt. The VALUE of each elt is an expression
16729 for the initializer. If the INDEX of the elt is non-NULL, it is the
16730 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
16731 as for cp_parser_initializer. */
16733 static VEC(constructor_elt,gc) *
16734 cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
16736 VEC(constructor_elt,gc) *v = NULL;
16738 /* Assume all of the expressions are constant. */
16739 *non_constant_p = false;
16741 /* Parse the rest of the list. */
16747 bool clause_non_constant_p;
16749 /* If the next token is an identifier and the following one is a
16750 colon, we are looking at the GNU designated-initializer
16752 if (cp_parser_allow_gnu_extensions_p (parser)
16753 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
16754 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
16756 /* Warn the user that they are using an extension. */
16757 pedwarn (input_location, OPT_pedantic,
16758 "ISO C++ does not allow designated initializers");
16759 /* Consume the identifier. */
16760 designator = cp_lexer_consume_token (parser->lexer)->u.value;
16761 /* Consume the `:'. */
16762 cp_lexer_consume_token (parser->lexer);
16764 /* Also handle the C99 syntax, '. id ='. */
16765 else if (cp_parser_allow_gnu_extensions_p (parser)
16766 && cp_lexer_next_token_is (parser->lexer, CPP_DOT)
16767 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME
16768 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
16770 /* Warn the user that they are using an extension. */
16771 pedwarn (input_location, OPT_pedantic,
16772 "ISO C++ does not allow C99 designated initializers");
16773 /* Consume the `.'. */
16774 cp_lexer_consume_token (parser->lexer);
16775 /* Consume the identifier. */
16776 designator = cp_lexer_consume_token (parser->lexer)->u.value;
16777 /* Consume the `='. */
16778 cp_lexer_consume_token (parser->lexer);
16780 /* Also handle C99 array designators, '[ const ] ='. */
16781 else if (cp_parser_allow_gnu_extensions_p (parser)
16782 && !c_dialect_objc ()
16783 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
16785 cp_lexer_consume_token (parser->lexer);
16786 designator = cp_parser_constant_expression (parser, false, NULL);
16787 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
16788 cp_parser_require (parser, CPP_EQ, RT_EQ);
16791 designator = NULL_TREE;
16793 /* Parse the initializer. */
16794 initializer = cp_parser_initializer_clause (parser,
16795 &clause_non_constant_p);
16796 /* If any clause is non-constant, so is the entire initializer. */
16797 if (clause_non_constant_p)
16798 *non_constant_p = true;
16800 /* If we have an ellipsis, this is an initializer pack
16802 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16804 /* Consume the `...'. */
16805 cp_lexer_consume_token (parser->lexer);
16807 /* Turn the initializer into an initializer expansion. */
16808 initializer = make_pack_expansion (initializer);
16811 /* Add it to the vector. */
16812 CONSTRUCTOR_APPEND_ELT (v, designator, initializer);
16814 /* If the next token is not a comma, we have reached the end of
16816 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16819 /* Peek at the next token. */
16820 token = cp_lexer_peek_nth_token (parser->lexer, 2);
16821 /* If the next token is a `}', then we're still done. An
16822 initializer-clause can have a trailing `,' after the
16823 initializer-list and before the closing `}'. */
16824 if (token->type == CPP_CLOSE_BRACE)
16827 /* Consume the `,' token. */
16828 cp_lexer_consume_token (parser->lexer);
16834 /* Classes [gram.class] */
16836 /* Parse a class-name.
16842 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
16843 to indicate that names looked up in dependent types should be
16844 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
16845 keyword has been used to indicate that the name that appears next
16846 is a template. TAG_TYPE indicates the explicit tag given before
16847 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
16848 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
16849 is the class being defined in a class-head.
16851 Returns the TYPE_DECL representing the class. */
16854 cp_parser_class_name (cp_parser *parser,
16855 bool typename_keyword_p,
16856 bool template_keyword_p,
16857 enum tag_types tag_type,
16858 bool check_dependency_p,
16860 bool is_declaration)
16866 tree identifier = NULL_TREE;
16868 /* All class-names start with an identifier. */
16869 token = cp_lexer_peek_token (parser->lexer);
16870 if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
16872 cp_parser_error (parser, "expected class-name");
16873 return error_mark_node;
16876 /* PARSER->SCOPE can be cleared when parsing the template-arguments
16877 to a template-id, so we save it here. */
16878 scope = parser->scope;
16879 if (scope == error_mark_node)
16880 return error_mark_node;
16882 /* Any name names a type if we're following the `typename' keyword
16883 in a qualified name where the enclosing scope is type-dependent. */
16884 typename_p = (typename_keyword_p && scope && TYPE_P (scope)
16885 && dependent_type_p (scope));
16886 /* Handle the common case (an identifier, but not a template-id)
16888 if (token->type == CPP_NAME
16889 && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
16891 cp_token *identifier_token;
16894 /* Look for the identifier. */
16895 identifier_token = cp_lexer_peek_token (parser->lexer);
16896 ambiguous_p = identifier_token->ambiguous_p;
16897 identifier = cp_parser_identifier (parser);
16898 /* If the next token isn't an identifier, we are certainly not
16899 looking at a class-name. */
16900 if (identifier == error_mark_node)
16901 decl = error_mark_node;
16902 /* If we know this is a type-name, there's no need to look it
16904 else if (typename_p)
16908 tree ambiguous_decls;
16909 /* If we already know that this lookup is ambiguous, then
16910 we've already issued an error message; there's no reason
16914 cp_parser_simulate_error (parser);
16915 return error_mark_node;
16917 /* If the next token is a `::', then the name must be a type
16920 [basic.lookup.qual]
16922 During the lookup for a name preceding the :: scope
16923 resolution operator, object, function, and enumerator
16924 names are ignored. */
16925 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16926 tag_type = typename_type;
16927 /* Look up the name. */
16928 decl = cp_parser_lookup_name (parser, identifier,
16930 /*is_template=*/false,
16931 /*is_namespace=*/false,
16932 check_dependency_p,
16934 identifier_token->location);
16935 if (ambiguous_decls)
16937 if (cp_parser_parsing_tentatively (parser))
16938 cp_parser_simulate_error (parser);
16939 return error_mark_node;
16945 /* Try a template-id. */
16946 decl = cp_parser_template_id (parser, template_keyword_p,
16947 check_dependency_p,
16949 if (decl == error_mark_node)
16950 return error_mark_node;
16953 decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
16955 /* If this is a typename, create a TYPENAME_TYPE. */
16956 if (typename_p && decl != error_mark_node)
16958 decl = make_typename_type (scope, decl, typename_type,
16959 /*complain=*/tf_error);
16960 if (decl != error_mark_node)
16961 decl = TYPE_NAME (decl);
16964 /* Check to see that it is really the name of a class. */
16965 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
16966 && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE
16967 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16968 /* Situations like this:
16970 template <typename T> struct A {
16971 typename T::template X<int>::I i;
16974 are problematic. Is `T::template X<int>' a class-name? The
16975 standard does not seem to be definitive, but there is no other
16976 valid interpretation of the following `::'. Therefore, those
16977 names are considered class-names. */
16979 decl = make_typename_type (scope, decl, tag_type, tf_error);
16980 if (decl != error_mark_node)
16981 decl = TYPE_NAME (decl);
16983 else if (TREE_CODE (decl) != TYPE_DECL
16984 || TREE_TYPE (decl) == error_mark_node
16985 || !MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))
16986 /* In Objective-C 2.0, a classname followed by '.' starts a
16987 dot-syntax expression, and it's not a type-name. */
16988 || (c_dialect_objc ()
16989 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
16990 && objc_is_class_name (decl)))
16991 decl = error_mark_node;
16993 if (decl == error_mark_node)
16994 cp_parser_error (parser, "expected class-name");
16995 else if (identifier && !parser->scope)
16996 maybe_note_name_used_in_class (identifier, decl);
17001 /* Parse a class-specifier.
17004 class-head { member-specification [opt] }
17006 Returns the TREE_TYPE representing the class. */
17009 cp_parser_class_specifier_1 (cp_parser* parser)
17012 tree attributes = NULL_TREE;
17013 bool nested_name_specifier_p;
17014 unsigned saved_num_template_parameter_lists;
17015 bool saved_in_function_body;
17016 unsigned char in_statement;
17017 bool in_switch_statement_p;
17018 bool saved_in_unbraced_linkage_specification_p;
17019 tree old_scope = NULL_TREE;
17020 tree scope = NULL_TREE;
17022 cp_token *closing_brace;
17024 push_deferring_access_checks (dk_no_deferred);
17026 /* Parse the class-head. */
17027 type = cp_parser_class_head (parser,
17028 &nested_name_specifier_p,
17031 /* If the class-head was a semantic disaster, skip the entire body
17035 cp_parser_skip_to_end_of_block_or_statement (parser);
17036 pop_deferring_access_checks ();
17037 return error_mark_node;
17040 /* Look for the `{'. */
17041 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
17043 pop_deferring_access_checks ();
17044 return error_mark_node;
17047 /* Process the base classes. If they're invalid, skip the
17048 entire class body. */
17049 if (!xref_basetypes (type, bases))
17051 /* Consuming the closing brace yields better error messages
17053 if (cp_parser_skip_to_closing_brace (parser))
17054 cp_lexer_consume_token (parser->lexer);
17055 pop_deferring_access_checks ();
17056 return error_mark_node;
17059 /* Issue an error message if type-definitions are forbidden here. */
17060 cp_parser_check_type_definition (parser);
17061 /* Remember that we are defining one more class. */
17062 ++parser->num_classes_being_defined;
17063 /* Inside the class, surrounding template-parameter-lists do not
17065 saved_num_template_parameter_lists
17066 = parser->num_template_parameter_lists;
17067 parser->num_template_parameter_lists = 0;
17068 /* We are not in a function body. */
17069 saved_in_function_body = parser->in_function_body;
17070 parser->in_function_body = false;
17071 /* Or in a loop. */
17072 in_statement = parser->in_statement;
17073 parser->in_statement = 0;
17074 /* Or in a switch. */
17075 in_switch_statement_p = parser->in_switch_statement_p;
17076 parser->in_switch_statement_p = false;
17077 /* We are not immediately inside an extern "lang" block. */
17078 saved_in_unbraced_linkage_specification_p
17079 = parser->in_unbraced_linkage_specification_p;
17080 parser->in_unbraced_linkage_specification_p = false;
17082 /* Start the class. */
17083 if (nested_name_specifier_p)
17085 scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
17086 old_scope = push_inner_scope (scope);
17088 type = begin_class_definition (type, attributes);
17090 if (type == error_mark_node)
17091 /* If the type is erroneous, skip the entire body of the class. */
17092 cp_parser_skip_to_closing_brace (parser);
17094 /* Parse the member-specification. */
17095 cp_parser_member_specification_opt (parser);
17097 /* Look for the trailing `}'. */
17098 closing_brace = cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
17099 /* Look for trailing attributes to apply to this class. */
17100 if (cp_parser_allow_gnu_extensions_p (parser))
17101 attributes = cp_parser_attributes_opt (parser);
17102 if (type != error_mark_node)
17103 type = finish_struct (type, attributes);
17104 if (nested_name_specifier_p)
17105 pop_inner_scope (old_scope, scope);
17107 /* We've finished a type definition. Check for the common syntax
17108 error of forgetting a semicolon after the definition. We need to
17109 be careful, as we can't just check for not-a-semicolon and be done
17110 with it; the user might have typed:
17112 class X { } c = ...;
17113 class X { } *p = ...;
17115 and so forth. Instead, enumerate all the possible tokens that
17116 might follow this production; if we don't see one of them, then
17117 complain and silently insert the semicolon. */
17119 cp_token *token = cp_lexer_peek_token (parser->lexer);
17120 bool want_semicolon = true;
17122 switch (token->type)
17125 case CPP_SEMICOLON:
17128 case CPP_OPEN_PAREN:
17129 case CPP_CLOSE_PAREN:
17131 want_semicolon = false;
17134 /* While it's legal for type qualifiers and storage class
17135 specifiers to follow type definitions in the grammar, only
17136 compiler testsuites contain code like that. Assume that if
17137 we see such code, then what we're really seeing is a case
17141 const <type> var = ...;
17146 static <type> func (...) ...
17148 i.e. the qualifier or specifier applies to the next
17149 declaration. To do so, however, we need to look ahead one
17150 more token to see if *that* token is a type specifier.
17152 This code could be improved to handle:
17155 static const <type> var = ...; */
17157 if (keyword_is_decl_specifier (token->keyword))
17159 cp_token *lookahead = cp_lexer_peek_nth_token (parser->lexer, 2);
17161 /* Handling user-defined types here would be nice, but very
17164 = (lookahead->type == CPP_KEYWORD
17165 && keyword_begins_type_specifier (lookahead->keyword));
17172 /* If we don't have a type, then something is very wrong and we
17173 shouldn't try to do anything clever. Likewise for not seeing the
17175 if (closing_brace && TYPE_P (type) && want_semicolon)
17177 cp_token_position prev
17178 = cp_lexer_previous_token_position (parser->lexer);
17179 cp_token *prev_token = cp_lexer_token_at (parser->lexer, prev);
17180 location_t loc = prev_token->location;
17182 if (CLASSTYPE_DECLARED_CLASS (type))
17183 error_at (loc, "expected %<;%> after class definition");
17184 else if (TREE_CODE (type) == RECORD_TYPE)
17185 error_at (loc, "expected %<;%> after struct definition");
17186 else if (TREE_CODE (type) == UNION_TYPE)
17187 error_at (loc, "expected %<;%> after union definition");
17189 gcc_unreachable ();
17191 /* Unget one token and smash it to look as though we encountered
17192 a semicolon in the input stream. */
17193 cp_lexer_set_token_position (parser->lexer, prev);
17194 token = cp_lexer_peek_token (parser->lexer);
17195 token->type = CPP_SEMICOLON;
17196 token->keyword = RID_MAX;
17200 /* If this class is not itself within the scope of another class,
17201 then we need to parse the bodies of all of the queued function
17202 definitions. Note that the queued functions defined in a class
17203 are not always processed immediately following the
17204 class-specifier for that class. Consider:
17207 struct B { void f() { sizeof (A); } };
17210 If `f' were processed before the processing of `A' were
17211 completed, there would be no way to compute the size of `A'.
17212 Note that the nesting we are interested in here is lexical --
17213 not the semantic nesting given by TYPE_CONTEXT. In particular,
17216 struct A { struct B; };
17217 struct A::B { void f() { } };
17219 there is no need to delay the parsing of `A::B::f'. */
17220 if (--parser->num_classes_being_defined == 0)
17223 tree class_type = NULL_TREE;
17224 tree pushed_scope = NULL_TREE;
17226 cp_default_arg_entry *e;
17228 /* In a first pass, parse default arguments to the functions.
17229 Then, in a second pass, parse the bodies of the functions.
17230 This two-phased approach handles cases like:
17238 FOR_EACH_VEC_ELT (cp_default_arg_entry, unparsed_funs_with_default_args,
17242 /* If there are default arguments that have not yet been processed,
17243 take care of them now. */
17244 if (class_type != e->class_type)
17247 pop_scope (pushed_scope);
17248 class_type = e->class_type;
17249 pushed_scope = push_scope (class_type);
17251 /* Make sure that any template parameters are in scope. */
17252 maybe_begin_member_template_processing (fn);
17253 /* Parse the default argument expressions. */
17254 cp_parser_late_parsing_default_args (parser, fn);
17255 /* Remove any template parameters from the symbol table. */
17256 maybe_end_member_template_processing ();
17259 pop_scope (pushed_scope);
17260 VEC_truncate (cp_default_arg_entry, unparsed_funs_with_default_args, 0);
17261 /* Now parse the body of the functions. */
17262 FOR_EACH_VEC_ELT (tree, unparsed_funs_with_definitions, ix, fn)
17263 cp_parser_late_parsing_for_member (parser, fn);
17264 VEC_truncate (tree, unparsed_funs_with_definitions, 0);
17267 /* Put back any saved access checks. */
17268 pop_deferring_access_checks ();
17270 /* Restore saved state. */
17271 parser->in_switch_statement_p = in_switch_statement_p;
17272 parser->in_statement = in_statement;
17273 parser->in_function_body = saved_in_function_body;
17274 parser->num_template_parameter_lists
17275 = saved_num_template_parameter_lists;
17276 parser->in_unbraced_linkage_specification_p
17277 = saved_in_unbraced_linkage_specification_p;
17283 cp_parser_class_specifier (cp_parser* parser)
17286 timevar_push (TV_PARSE_STRUCT);
17287 ret = cp_parser_class_specifier_1 (parser);
17288 timevar_pop (TV_PARSE_STRUCT);
17292 /* Parse a class-head.
17295 class-key identifier [opt] base-clause [opt]
17296 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
17297 class-key nested-name-specifier [opt] template-id
17300 class-virt-specifier:
17304 class-key attributes identifier [opt] base-clause [opt]
17305 class-key attributes nested-name-specifier identifier base-clause [opt]
17306 class-key attributes nested-name-specifier [opt] template-id
17309 Upon return BASES is initialized to the list of base classes (or
17310 NULL, if there are none) in the same form returned by
17311 cp_parser_base_clause.
17313 Returns the TYPE of the indicated class. Sets
17314 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
17315 involving a nested-name-specifier was used, and FALSE otherwise.
17317 Returns error_mark_node if this is not a class-head.
17319 Returns NULL_TREE if the class-head is syntactically valid, but
17320 semantically invalid in a way that means we should skip the entire
17321 body of the class. */
17324 cp_parser_class_head (cp_parser* parser,
17325 bool* nested_name_specifier_p,
17326 tree *attributes_p,
17329 tree nested_name_specifier;
17330 enum tag_types class_key;
17331 tree id = NULL_TREE;
17332 tree type = NULL_TREE;
17334 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
17335 bool template_id_p = false;
17336 bool qualified_p = false;
17337 bool invalid_nested_name_p = false;
17338 bool invalid_explicit_specialization_p = false;
17339 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
17340 tree pushed_scope = NULL_TREE;
17341 unsigned num_templates;
17342 cp_token *type_start_token = NULL, *nested_name_specifier_token_start = NULL;
17343 /* Assume no nested-name-specifier will be present. */
17344 *nested_name_specifier_p = false;
17345 /* Assume no template parameter lists will be used in defining the
17348 parser->colon_corrects_to_scope_p = false;
17350 *bases = NULL_TREE;
17352 /* Look for the class-key. */
17353 class_key = cp_parser_class_key (parser);
17354 if (class_key == none_type)
17355 return error_mark_node;
17357 /* Parse the attributes. */
17358 attributes = cp_parser_attributes_opt (parser);
17360 /* If the next token is `::', that is invalid -- but sometimes
17361 people do try to write:
17365 Handle this gracefully by accepting the extra qualifier, and then
17366 issuing an error about it later if this really is a
17367 class-head. If it turns out just to be an elaborated type
17368 specifier, remain silent. */
17369 if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
17370 qualified_p = true;
17372 push_deferring_access_checks (dk_no_check);
17374 /* Determine the name of the class. Begin by looking for an
17375 optional nested-name-specifier. */
17376 nested_name_specifier_token_start = cp_lexer_peek_token (parser->lexer);
17377 nested_name_specifier
17378 = cp_parser_nested_name_specifier_opt (parser,
17379 /*typename_keyword_p=*/false,
17380 /*check_dependency_p=*/false,
17382 /*is_declaration=*/false);
17383 /* If there was a nested-name-specifier, then there *must* be an
17385 if (nested_name_specifier)
17387 type_start_token = cp_lexer_peek_token (parser->lexer);
17388 /* Although the grammar says `identifier', it really means
17389 `class-name' or `template-name'. You are only allowed to
17390 define a class that has already been declared with this
17393 The proposed resolution for Core Issue 180 says that wherever
17394 you see `class T::X' you should treat `X' as a type-name.
17396 It is OK to define an inaccessible class; for example:
17398 class A { class B; };
17401 We do not know if we will see a class-name, or a
17402 template-name. We look for a class-name first, in case the
17403 class-name is a template-id; if we looked for the
17404 template-name first we would stop after the template-name. */
17405 cp_parser_parse_tentatively (parser);
17406 type = cp_parser_class_name (parser,
17407 /*typename_keyword_p=*/false,
17408 /*template_keyword_p=*/false,
17410 /*check_dependency_p=*/false,
17411 /*class_head_p=*/true,
17412 /*is_declaration=*/false);
17413 /* If that didn't work, ignore the nested-name-specifier. */
17414 if (!cp_parser_parse_definitely (parser))
17416 invalid_nested_name_p = true;
17417 type_start_token = cp_lexer_peek_token (parser->lexer);
17418 id = cp_parser_identifier (parser);
17419 if (id == error_mark_node)
17422 /* If we could not find a corresponding TYPE, treat this
17423 declaration like an unqualified declaration. */
17424 if (type == error_mark_node)
17425 nested_name_specifier = NULL_TREE;
17426 /* Otherwise, count the number of templates used in TYPE and its
17427 containing scopes. */
17432 for (scope = TREE_TYPE (type);
17433 scope && TREE_CODE (scope) != NAMESPACE_DECL;
17434 scope = (TYPE_P (scope)
17435 ? TYPE_CONTEXT (scope)
17436 : DECL_CONTEXT (scope)))
17438 && CLASS_TYPE_P (scope)
17439 && CLASSTYPE_TEMPLATE_INFO (scope)
17440 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
17441 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope))
17445 /* Otherwise, the identifier is optional. */
17448 /* We don't know whether what comes next is a template-id,
17449 an identifier, or nothing at all. */
17450 cp_parser_parse_tentatively (parser);
17451 /* Check for a template-id. */
17452 type_start_token = cp_lexer_peek_token (parser->lexer);
17453 id = cp_parser_template_id (parser,
17454 /*template_keyword_p=*/false,
17455 /*check_dependency_p=*/true,
17456 /*is_declaration=*/true);
17457 /* If that didn't work, it could still be an identifier. */
17458 if (!cp_parser_parse_definitely (parser))
17460 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
17462 type_start_token = cp_lexer_peek_token (parser->lexer);
17463 id = cp_parser_identifier (parser);
17470 template_id_p = true;
17475 pop_deferring_access_checks ();
17479 cp_parser_check_for_invalid_template_id (parser, id,
17480 type_start_token->location);
17481 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
17484 /* If it's not a `:' or a `{' then we can't really be looking at a
17485 class-head, since a class-head only appears as part of a
17486 class-specifier. We have to detect this situation before calling
17487 xref_tag, since that has irreversible side-effects. */
17488 if (!cp_parser_next_token_starts_class_definition_p (parser))
17490 cp_parser_error (parser, "expected %<{%> or %<:%>");
17491 type = error_mark_node;
17495 /* At this point, we're going ahead with the class-specifier, even
17496 if some other problem occurs. */
17497 cp_parser_commit_to_tentative_parse (parser);
17498 if (virt_specifiers & VIRT_SPEC_OVERRIDE)
17500 cp_parser_error (parser,
17501 "cannot specify %<override%> for a class");
17502 type = error_mark_node;
17505 /* Issue the error about the overly-qualified name now. */
17508 cp_parser_error (parser,
17509 "global qualification of class name is invalid");
17510 type = error_mark_node;
17513 else if (invalid_nested_name_p)
17515 cp_parser_error (parser,
17516 "qualified name does not name a class");
17517 type = error_mark_node;
17520 else if (nested_name_specifier)
17524 /* Reject typedef-names in class heads. */
17525 if (!DECL_IMPLICIT_TYPEDEF_P (type))
17527 error_at (type_start_token->location,
17528 "invalid class name in declaration of %qD",
17534 /* Figure out in what scope the declaration is being placed. */
17535 scope = current_scope ();
17536 /* If that scope does not contain the scope in which the
17537 class was originally declared, the program is invalid. */
17538 if (scope && !is_ancestor (scope, nested_name_specifier))
17540 if (at_namespace_scope_p ())
17541 error_at (type_start_token->location,
17542 "declaration of %qD in namespace %qD which does not "
17544 type, scope, nested_name_specifier);
17546 error_at (type_start_token->location,
17547 "declaration of %qD in %qD which does not enclose %qD",
17548 type, scope, nested_name_specifier);
17554 A declarator-id shall not be qualified except for the
17555 definition of a ... nested class outside of its class
17556 ... [or] the definition or explicit instantiation of a
17557 class member of a namespace outside of its namespace. */
17558 if (scope == nested_name_specifier)
17560 permerror (nested_name_specifier_token_start->location,
17561 "extra qualification not allowed");
17562 nested_name_specifier = NULL_TREE;
17566 /* An explicit-specialization must be preceded by "template <>". If
17567 it is not, try to recover gracefully. */
17568 if (at_namespace_scope_p ()
17569 && parser->num_template_parameter_lists == 0
17572 error_at (type_start_token->location,
17573 "an explicit specialization must be preceded by %<template <>%>");
17574 invalid_explicit_specialization_p = true;
17575 /* Take the same action that would have been taken by
17576 cp_parser_explicit_specialization. */
17577 ++parser->num_template_parameter_lists;
17578 begin_specialization ();
17580 /* There must be no "return" statements between this point and the
17581 end of this function; set "type "to the correct return value and
17582 use "goto done;" to return. */
17583 /* Make sure that the right number of template parameters were
17585 if (!cp_parser_check_template_parameters (parser, num_templates,
17586 type_start_token->location,
17587 /*declarator=*/NULL))
17589 /* If something went wrong, there is no point in even trying to
17590 process the class-definition. */
17595 /* Look up the type. */
17598 if (TREE_CODE (id) == TEMPLATE_ID_EXPR
17599 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id, 0))
17600 || TREE_CODE (TREE_OPERAND (id, 0)) == OVERLOAD))
17602 error_at (type_start_token->location,
17603 "function template %qD redeclared as a class template", id);
17604 type = error_mark_node;
17608 type = TREE_TYPE (id);
17609 type = maybe_process_partial_specialization (type);
17611 if (nested_name_specifier)
17612 pushed_scope = push_scope (nested_name_specifier);
17614 else if (nested_name_specifier)
17620 template <typename T> struct S { struct T };
17621 template <typename T> struct S<T>::T { };
17623 we will get a TYPENAME_TYPE when processing the definition of
17624 `S::T'. We need to resolve it to the actual type before we
17625 try to define it. */
17626 if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
17628 class_type = resolve_typename_type (TREE_TYPE (type),
17629 /*only_current_p=*/false);
17630 if (TREE_CODE (class_type) != TYPENAME_TYPE)
17631 type = TYPE_NAME (class_type);
17634 cp_parser_error (parser, "could not resolve typename type");
17635 type = error_mark_node;
17639 if (maybe_process_partial_specialization (TREE_TYPE (type))
17640 == error_mark_node)
17646 class_type = current_class_type;
17647 /* Enter the scope indicated by the nested-name-specifier. */
17648 pushed_scope = push_scope (nested_name_specifier);
17649 /* Get the canonical version of this type. */
17650 type = TYPE_MAIN_DECL (TREE_TYPE (type));
17651 if (PROCESSING_REAL_TEMPLATE_DECL_P ()
17652 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
17654 type = push_template_decl (type);
17655 if (type == error_mark_node)
17662 type = TREE_TYPE (type);
17663 *nested_name_specifier_p = true;
17665 else /* The name is not a nested name. */
17667 /* If the class was unnamed, create a dummy name. */
17669 id = make_anon_name ();
17670 type = xref_tag (class_key, id, /*tag_scope=*/ts_current,
17671 parser->num_template_parameter_lists);
17674 /* Indicate whether this class was declared as a `class' or as a
17676 if (TREE_CODE (type) == RECORD_TYPE)
17677 CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
17678 cp_parser_check_class_key (class_key, type);
17680 /* If this type was already complete, and we see another definition,
17681 that's an error. */
17682 if (type != error_mark_node && COMPLETE_TYPE_P (type))
17684 error_at (type_start_token->location, "redefinition of %q#T",
17686 error_at (type_start_token->location, "previous definition of %q+#T",
17691 else if (type == error_mark_node)
17694 /* We will have entered the scope containing the class; the names of
17695 base classes should be looked up in that context. For example:
17697 struct A { struct B {}; struct C; };
17698 struct A::C : B {};
17702 /* Get the list of base-classes, if there is one. */
17703 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
17704 *bases = cp_parser_base_clause (parser);
17707 /* Leave the scope given by the nested-name-specifier. We will
17708 enter the class scope itself while processing the members. */
17710 pop_scope (pushed_scope);
17712 if (invalid_explicit_specialization_p)
17714 end_specialization ();
17715 --parser->num_template_parameter_lists;
17719 DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
17720 *attributes_p = attributes;
17721 if (type && (virt_specifiers & VIRT_SPEC_FINAL))
17722 CLASSTYPE_FINAL (type) = 1;
17724 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
17728 /* Parse a class-key.
17735 Returns the kind of class-key specified, or none_type to indicate
17738 static enum tag_types
17739 cp_parser_class_key (cp_parser* parser)
17742 enum tag_types tag_type;
17744 /* Look for the class-key. */
17745 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_KEY);
17749 /* Check to see if the TOKEN is a class-key. */
17750 tag_type = cp_parser_token_is_class_key (token);
17752 cp_parser_error (parser, "expected class-key");
17756 /* Parse an (optional) member-specification.
17758 member-specification:
17759 member-declaration member-specification [opt]
17760 access-specifier : member-specification [opt] */
17763 cp_parser_member_specification_opt (cp_parser* parser)
17770 /* Peek at the next token. */
17771 token = cp_lexer_peek_token (parser->lexer);
17772 /* If it's a `}', or EOF then we've seen all the members. */
17773 if (token->type == CPP_CLOSE_BRACE
17774 || token->type == CPP_EOF
17775 || token->type == CPP_PRAGMA_EOL)
17778 /* See if this token is a keyword. */
17779 keyword = token->keyword;
17783 case RID_PROTECTED:
17785 /* Consume the access-specifier. */
17786 cp_lexer_consume_token (parser->lexer);
17787 /* Remember which access-specifier is active. */
17788 current_access_specifier = token->u.value;
17789 /* Look for the `:'. */
17790 cp_parser_require (parser, CPP_COLON, RT_COLON);
17794 /* Accept #pragmas at class scope. */
17795 if (token->type == CPP_PRAGMA)
17797 cp_parser_pragma (parser, pragma_external);
17801 /* Otherwise, the next construction must be a
17802 member-declaration. */
17803 cp_parser_member_declaration (parser);
17808 /* Parse a member-declaration.
17810 member-declaration:
17811 decl-specifier-seq [opt] member-declarator-list [opt] ;
17812 function-definition ; [opt]
17813 :: [opt] nested-name-specifier template [opt] unqualified-id ;
17815 template-declaration
17817 member-declarator-list:
17819 member-declarator-list , member-declarator
17822 declarator pure-specifier [opt]
17823 declarator constant-initializer [opt]
17824 identifier [opt] : constant-expression
17828 member-declaration:
17829 __extension__ member-declaration
17832 declarator attributes [opt] pure-specifier [opt]
17833 declarator attributes [opt] constant-initializer [opt]
17834 identifier [opt] attributes [opt] : constant-expression
17838 member-declaration:
17839 static_assert-declaration */
17842 cp_parser_member_declaration (cp_parser* parser)
17844 cp_decl_specifier_seq decl_specifiers;
17845 tree prefix_attributes;
17847 int declares_class_or_enum;
17849 cp_token *token = NULL;
17850 cp_token *decl_spec_token_start = NULL;
17851 cp_token *initializer_token_start = NULL;
17852 int saved_pedantic;
17853 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
17855 /* Check for the `__extension__' keyword. */
17856 if (cp_parser_extension_opt (parser, &saved_pedantic))
17859 cp_parser_member_declaration (parser);
17860 /* Restore the old value of the PEDANTIC flag. */
17861 pedantic = saved_pedantic;
17866 /* Check for a template-declaration. */
17867 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
17869 /* An explicit specialization here is an error condition, and we
17870 expect the specialization handler to detect and report this. */
17871 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
17872 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
17873 cp_parser_explicit_specialization (parser);
17875 cp_parser_template_declaration (parser, /*member_p=*/true);
17880 /* Check for a using-declaration. */
17881 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
17883 /* Parse the using-declaration. */
17884 cp_parser_using_declaration (parser,
17885 /*access_declaration_p=*/false);
17889 /* Check for @defs. */
17890 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
17893 tree ivar_chains = cp_parser_objc_defs_expression (parser);
17894 ivar = ivar_chains;
17898 ivar = TREE_CHAIN (member);
17899 TREE_CHAIN (member) = NULL_TREE;
17900 finish_member_declaration (member);
17905 /* If the next token is `static_assert' we have a static assertion. */
17906 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
17908 cp_parser_static_assert (parser, /*member_p=*/true);
17912 parser->colon_corrects_to_scope_p = false;
17914 if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
17917 /* Parse the decl-specifier-seq. */
17918 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
17919 cp_parser_decl_specifier_seq (parser,
17920 CP_PARSER_FLAGS_OPTIONAL,
17922 &declares_class_or_enum);
17923 prefix_attributes = decl_specifiers.attributes;
17924 decl_specifiers.attributes = NULL_TREE;
17925 /* Check for an invalid type-name. */
17926 if (!decl_specifiers.any_type_specifiers_p
17927 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
17929 /* If there is no declarator, then the decl-specifier-seq should
17931 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
17933 /* If there was no decl-specifier-seq, and the next token is a
17934 `;', then we have something like:
17940 Each member-declaration shall declare at least one member
17941 name of the class. */
17942 if (!decl_specifiers.any_specifiers_p)
17944 cp_token *token = cp_lexer_peek_token (parser->lexer);
17945 if (!in_system_header_at (token->location))
17946 pedwarn (token->location, OPT_pedantic, "extra %<;%>");
17952 /* See if this declaration is a friend. */
17953 friend_p = cp_parser_friend_p (&decl_specifiers);
17954 /* If there were decl-specifiers, check to see if there was
17955 a class-declaration. */
17956 type = check_tag_decl (&decl_specifiers);
17957 /* Nested classes have already been added to the class, but
17958 a `friend' needs to be explicitly registered. */
17961 /* If the `friend' keyword was present, the friend must
17962 be introduced with a class-key. */
17963 if (!declares_class_or_enum && cxx_dialect < cxx0x)
17964 pedwarn (decl_spec_token_start->location, OPT_pedantic,
17965 "in C++03 a class-key must be used "
17966 "when declaring a friend");
17969 template <typename T> struct A {
17970 friend struct A<T>::B;
17973 A<T>::B will be represented by a TYPENAME_TYPE, and
17974 therefore not recognized by check_tag_decl. */
17977 type = decl_specifiers.type;
17978 if (type && TREE_CODE (type) == TYPE_DECL)
17979 type = TREE_TYPE (type);
17981 if (!type || !TYPE_P (type))
17982 error_at (decl_spec_token_start->location,
17983 "friend declaration does not name a class or "
17986 make_friend_class (current_class_type, type,
17987 /*complain=*/true);
17989 /* If there is no TYPE, an error message will already have
17991 else if (!type || type == error_mark_node)
17993 /* An anonymous aggregate has to be handled specially; such
17994 a declaration really declares a data member (with a
17995 particular type), as opposed to a nested class. */
17996 else if (ANON_AGGR_TYPE_P (type))
17998 /* Remove constructors and such from TYPE, now that we
17999 know it is an anonymous aggregate. */
18000 fixup_anonymous_aggr (type);
18001 /* And make the corresponding data member. */
18002 decl = build_decl (decl_spec_token_start->location,
18003 FIELD_DECL, NULL_TREE, type);
18004 /* Add it to the class. */
18005 finish_member_declaration (decl);
18008 cp_parser_check_access_in_redeclaration
18010 decl_spec_token_start->location);
18015 bool assume_semicolon = false;
18017 /* See if these declarations will be friends. */
18018 friend_p = cp_parser_friend_p (&decl_specifiers);
18020 /* Keep going until we hit the `;' at the end of the
18022 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
18024 tree attributes = NULL_TREE;
18025 tree first_attribute;
18027 /* Peek at the next token. */
18028 token = cp_lexer_peek_token (parser->lexer);
18030 /* Check for a bitfield declaration. */
18031 if (token->type == CPP_COLON
18032 || (token->type == CPP_NAME
18033 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
18039 /* Get the name of the bitfield. Note that we cannot just
18040 check TOKEN here because it may have been invalidated by
18041 the call to cp_lexer_peek_nth_token above. */
18042 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
18043 identifier = cp_parser_identifier (parser);
18045 identifier = NULL_TREE;
18047 /* Consume the `:' token. */
18048 cp_lexer_consume_token (parser->lexer);
18049 /* Get the width of the bitfield. */
18051 = cp_parser_constant_expression (parser,
18052 /*allow_non_constant=*/false,
18055 /* Look for attributes that apply to the bitfield. */
18056 attributes = cp_parser_attributes_opt (parser);
18057 /* Remember which attributes are prefix attributes and
18059 first_attribute = attributes;
18060 /* Combine the attributes. */
18061 attributes = chainon (prefix_attributes, attributes);
18063 /* Create the bitfield declaration. */
18064 decl = grokbitfield (identifier
18065 ? make_id_declarator (NULL_TREE,
18075 cp_declarator *declarator;
18077 tree asm_specification;
18078 int ctor_dtor_or_conv_p;
18080 /* Parse the declarator. */
18082 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
18083 &ctor_dtor_or_conv_p,
18084 /*parenthesized_p=*/NULL,
18085 /*member_p=*/true);
18087 /* If something went wrong parsing the declarator, make sure
18088 that we at least consume some tokens. */
18089 if (declarator == cp_error_declarator)
18091 /* Skip to the end of the statement. */
18092 cp_parser_skip_to_end_of_statement (parser);
18093 /* If the next token is not a semicolon, that is
18094 probably because we just skipped over the body of
18095 a function. So, we consume a semicolon if
18096 present, but do not issue an error message if it
18098 if (cp_lexer_next_token_is (parser->lexer,
18100 cp_lexer_consume_token (parser->lexer);
18104 if (declares_class_or_enum & 2)
18105 cp_parser_check_for_definition_in_return_type
18106 (declarator, decl_specifiers.type,
18107 decl_specifiers.type_location);
18109 /* Look for an asm-specification. */
18110 asm_specification = cp_parser_asm_specification_opt (parser);
18111 /* Look for attributes that apply to the declaration. */
18112 attributes = cp_parser_attributes_opt (parser);
18113 /* Remember which attributes are prefix attributes and
18115 first_attribute = attributes;
18116 /* Combine the attributes. */
18117 attributes = chainon (prefix_attributes, attributes);
18119 /* If it's an `=', then we have a constant-initializer or a
18120 pure-specifier. It is not correct to parse the
18121 initializer before registering the member declaration
18122 since the member declaration should be in scope while
18123 its initializer is processed. However, the rest of the
18124 front end does not yet provide an interface that allows
18125 us to handle this correctly. */
18126 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
18130 A pure-specifier shall be used only in the declaration of
18131 a virtual function.
18133 A member-declarator can contain a constant-initializer
18134 only if it declares a static member of integral or
18137 Therefore, if the DECLARATOR is for a function, we look
18138 for a pure-specifier; otherwise, we look for a
18139 constant-initializer. When we call `grokfield', it will
18140 perform more stringent semantics checks. */
18141 initializer_token_start = cp_lexer_peek_token (parser->lexer);
18142 if (function_declarator_p (declarator))
18143 initializer = cp_parser_pure_specifier (parser);
18145 /* Parse the initializer. */
18146 initializer = cp_parser_constant_initializer (parser);
18148 /* Otherwise, there is no initializer. */
18150 initializer = NULL_TREE;
18152 /* See if we are probably looking at a function
18153 definition. We are certainly not looking at a
18154 member-declarator. Calling `grokfield' has
18155 side-effects, so we must not do it unless we are sure
18156 that we are looking at a member-declarator. */
18157 if (cp_parser_token_starts_function_definition_p
18158 (cp_lexer_peek_token (parser->lexer)))
18160 /* The grammar does not allow a pure-specifier to be
18161 used when a member function is defined. (It is
18162 possible that this fact is an oversight in the
18163 standard, since a pure function may be defined
18164 outside of the class-specifier. */
18166 error_at (initializer_token_start->location,
18167 "pure-specifier on function-definition");
18168 decl = cp_parser_save_member_function_body (parser,
18172 /* If the member was not a friend, declare it here. */
18174 finish_member_declaration (decl);
18175 /* Peek at the next token. */
18176 token = cp_lexer_peek_token (parser->lexer);
18177 /* If the next token is a semicolon, consume it. */
18178 if (token->type == CPP_SEMICOLON)
18179 cp_lexer_consume_token (parser->lexer);
18183 if (declarator->kind == cdk_function)
18184 declarator->id_loc = token->location;
18185 /* Create the declaration. */
18186 decl = grokfield (declarator, &decl_specifiers,
18187 initializer, /*init_const_expr_p=*/true,
18192 /* Reset PREFIX_ATTRIBUTES. */
18193 while (attributes && TREE_CHAIN (attributes) != first_attribute)
18194 attributes = TREE_CHAIN (attributes);
18196 TREE_CHAIN (attributes) = NULL_TREE;
18198 /* If there is any qualification still in effect, clear it
18199 now; we will be starting fresh with the next declarator. */
18200 parser->scope = NULL_TREE;
18201 parser->qualifying_scope = NULL_TREE;
18202 parser->object_scope = NULL_TREE;
18203 /* If it's a `,', then there are more declarators. */
18204 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
18205 cp_lexer_consume_token (parser->lexer);
18206 /* If the next token isn't a `;', then we have a parse error. */
18207 else if (cp_lexer_next_token_is_not (parser->lexer,
18210 /* The next token might be a ways away from where the
18211 actual semicolon is missing. Find the previous token
18212 and use that for our error position. */
18213 cp_token *token = cp_lexer_previous_token (parser->lexer);
18214 error_at (token->location,
18215 "expected %<;%> at end of member declaration");
18217 /* Assume that the user meant to provide a semicolon. If
18218 we were to cp_parser_skip_to_end_of_statement, we might
18219 skip to a semicolon inside a member function definition
18220 and issue nonsensical error messages. */
18221 assume_semicolon = true;
18226 /* Add DECL to the list of members. */
18228 finish_member_declaration (decl);
18230 if (TREE_CODE (decl) == FUNCTION_DECL)
18231 cp_parser_save_default_args (parser, decl);
18234 if (assume_semicolon)
18239 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
18241 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
18244 /* Parse a pure-specifier.
18249 Returns INTEGER_ZERO_NODE if a pure specifier is found.
18250 Otherwise, ERROR_MARK_NODE is returned. */
18253 cp_parser_pure_specifier (cp_parser* parser)
18257 /* Look for the `=' token. */
18258 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
18259 return error_mark_node;
18260 /* Look for the `0' token. */
18261 token = cp_lexer_peek_token (parser->lexer);
18263 if (token->type == CPP_EOF
18264 || token->type == CPP_PRAGMA_EOL)
18265 return error_mark_node;
18267 cp_lexer_consume_token (parser->lexer);
18269 /* Accept = default or = delete in c++0x mode. */
18270 if (token->keyword == RID_DEFAULT
18271 || token->keyword == RID_DELETE)
18273 maybe_warn_cpp0x (CPP0X_DEFAULTED_DELETED);
18274 return token->u.value;
18277 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
18278 if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO))
18280 cp_parser_error (parser,
18281 "invalid pure specifier (only %<= 0%> is allowed)");
18282 cp_parser_skip_to_end_of_statement (parser);
18283 return error_mark_node;
18285 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
18287 error_at (token->location, "templates may not be %<virtual%>");
18288 return error_mark_node;
18291 return integer_zero_node;
18294 /* Parse a constant-initializer.
18296 constant-initializer:
18297 = constant-expression
18299 Returns a representation of the constant-expression. */
18302 cp_parser_constant_initializer (cp_parser* parser)
18304 /* Look for the `=' token. */
18305 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
18306 return error_mark_node;
18308 /* It is invalid to write:
18310 struct S { static const int i = { 7 }; };
18313 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
18315 cp_parser_error (parser,
18316 "a brace-enclosed initializer is not allowed here");
18317 /* Consume the opening brace. */
18318 cp_lexer_consume_token (parser->lexer);
18319 /* Skip the initializer. */
18320 cp_parser_skip_to_closing_brace (parser);
18321 /* Look for the trailing `}'. */
18322 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
18324 return error_mark_node;
18327 return cp_parser_constant_expression (parser,
18328 /*allow_non_constant=*/false,
18332 /* Derived classes [gram.class.derived] */
18334 /* Parse a base-clause.
18337 : base-specifier-list
18339 base-specifier-list:
18340 base-specifier ... [opt]
18341 base-specifier-list , base-specifier ... [opt]
18343 Returns a TREE_LIST representing the base-classes, in the order in
18344 which they were declared. The representation of each node is as
18345 described by cp_parser_base_specifier.
18347 In the case that no bases are specified, this function will return
18348 NULL_TREE, not ERROR_MARK_NODE. */
18351 cp_parser_base_clause (cp_parser* parser)
18353 tree bases = NULL_TREE;
18355 /* Look for the `:' that begins the list. */
18356 cp_parser_require (parser, CPP_COLON, RT_COLON);
18358 /* Scan the base-specifier-list. */
18363 bool pack_expansion_p = false;
18365 /* Look for the base-specifier. */
18366 base = cp_parser_base_specifier (parser);
18367 /* Look for the (optional) ellipsis. */
18368 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18370 /* Consume the `...'. */
18371 cp_lexer_consume_token (parser->lexer);
18373 pack_expansion_p = true;
18376 /* Add BASE to the front of the list. */
18377 if (base && base != error_mark_node)
18379 if (pack_expansion_p)
18380 /* Make this a pack expansion type. */
18381 TREE_VALUE (base) = make_pack_expansion (TREE_VALUE (base));
18383 if (!check_for_bare_parameter_packs (TREE_VALUE (base)))
18385 TREE_CHAIN (base) = bases;
18389 /* Peek at the next token. */
18390 token = cp_lexer_peek_token (parser->lexer);
18391 /* If it's not a comma, then the list is complete. */
18392 if (token->type != CPP_COMMA)
18394 /* Consume the `,'. */
18395 cp_lexer_consume_token (parser->lexer);
18398 /* PARSER->SCOPE may still be non-NULL at this point, if the last
18399 base class had a qualified name. However, the next name that
18400 appears is certainly not qualified. */
18401 parser->scope = NULL_TREE;
18402 parser->qualifying_scope = NULL_TREE;
18403 parser->object_scope = NULL_TREE;
18405 return nreverse (bases);
18408 /* Parse a base-specifier.
18411 :: [opt] nested-name-specifier [opt] class-name
18412 virtual access-specifier [opt] :: [opt] nested-name-specifier
18414 access-specifier virtual [opt] :: [opt] nested-name-specifier
18417 Returns a TREE_LIST. The TREE_PURPOSE will be one of
18418 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
18419 indicate the specifiers provided. The TREE_VALUE will be a TYPE
18420 (or the ERROR_MARK_NODE) indicating the type that was specified. */
18423 cp_parser_base_specifier (cp_parser* parser)
18427 bool virtual_p = false;
18428 bool duplicate_virtual_error_issued_p = false;
18429 bool duplicate_access_error_issued_p = false;
18430 bool class_scope_p, template_p;
18431 tree access = access_default_node;
18434 /* Process the optional `virtual' and `access-specifier'. */
18437 /* Peek at the next token. */
18438 token = cp_lexer_peek_token (parser->lexer);
18439 /* Process `virtual'. */
18440 switch (token->keyword)
18443 /* If `virtual' appears more than once, issue an error. */
18444 if (virtual_p && !duplicate_virtual_error_issued_p)
18446 cp_parser_error (parser,
18447 "%<virtual%> specified more than once in base-specified");
18448 duplicate_virtual_error_issued_p = true;
18453 /* Consume the `virtual' token. */
18454 cp_lexer_consume_token (parser->lexer);
18459 case RID_PROTECTED:
18461 /* If more than one access specifier appears, issue an
18463 if (access != access_default_node
18464 && !duplicate_access_error_issued_p)
18466 cp_parser_error (parser,
18467 "more than one access specifier in base-specified");
18468 duplicate_access_error_issued_p = true;
18471 access = ridpointers[(int) token->keyword];
18473 /* Consume the access-specifier. */
18474 cp_lexer_consume_token (parser->lexer);
18483 /* It is not uncommon to see programs mechanically, erroneously, use
18484 the 'typename' keyword to denote (dependent) qualified types
18485 as base classes. */
18486 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
18488 token = cp_lexer_peek_token (parser->lexer);
18489 if (!processing_template_decl)
18490 error_at (token->location,
18491 "keyword %<typename%> not allowed outside of templates");
18493 error_at (token->location,
18494 "keyword %<typename%> not allowed in this context "
18495 "(the base class is implicitly a type)");
18496 cp_lexer_consume_token (parser->lexer);
18499 /* Look for the optional `::' operator. */
18500 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
18501 /* Look for the nested-name-specifier. The simplest way to
18506 The keyword `typename' is not permitted in a base-specifier or
18507 mem-initializer; in these contexts a qualified name that
18508 depends on a template-parameter is implicitly assumed to be a
18511 is to pretend that we have seen the `typename' keyword at this
18513 cp_parser_nested_name_specifier_opt (parser,
18514 /*typename_keyword_p=*/true,
18515 /*check_dependency_p=*/true,
18517 /*is_declaration=*/true);
18518 /* If the base class is given by a qualified name, assume that names
18519 we see are type names or templates, as appropriate. */
18520 class_scope_p = (parser->scope && TYPE_P (parser->scope));
18521 template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
18524 && cp_lexer_next_token_is_decltype (parser->lexer))
18525 /* DR 950 allows decltype as a base-specifier. */
18526 type = cp_parser_decltype (parser);
18529 /* Otherwise, look for the class-name. */
18530 type = cp_parser_class_name (parser,
18534 /*check_dependency_p=*/true,
18535 /*class_head_p=*/false,
18536 /*is_declaration=*/true);
18537 type = TREE_TYPE (type);
18540 if (type == error_mark_node)
18541 return error_mark_node;
18543 return finish_base_specifier (type, access, virtual_p);
18546 /* Exception handling [gram.exception] */
18548 /* Parse an (optional) exception-specification.
18550 exception-specification:
18551 throw ( type-id-list [opt] )
18553 Returns a TREE_LIST representing the exception-specification. The
18554 TREE_VALUE of each node is a type. */
18557 cp_parser_exception_specification_opt (cp_parser* parser)
18561 const char *saved_message;
18563 /* Peek at the next token. */
18564 token = cp_lexer_peek_token (parser->lexer);
18566 /* Is it a noexcept-specification? */
18567 if (cp_parser_is_keyword (token, RID_NOEXCEPT))
18570 cp_lexer_consume_token (parser->lexer);
18572 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
18574 cp_lexer_consume_token (parser->lexer);
18576 /* Types may not be defined in an exception-specification. */
18577 saved_message = parser->type_definition_forbidden_message;
18578 parser->type_definition_forbidden_message
18579 = G_("types may not be defined in an exception-specification");
18581 expr = cp_parser_constant_expression (parser, false, NULL);
18583 /* Restore the saved message. */
18584 parser->type_definition_forbidden_message = saved_message;
18586 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18589 expr = boolean_true_node;
18591 return build_noexcept_spec (expr, tf_warning_or_error);
18594 /* If it's not `throw', then there's no exception-specification. */
18595 if (!cp_parser_is_keyword (token, RID_THROW))
18599 /* Enable this once a lot of code has transitioned to noexcept? */
18600 if (cxx_dialect == cxx0x && !in_system_header)
18601 warning (OPT_Wdeprecated, "dynamic exception specifications are "
18602 "deprecated in C++0x; use %<noexcept%> instead");
18605 /* Consume the `throw'. */
18606 cp_lexer_consume_token (parser->lexer);
18608 /* Look for the `('. */
18609 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18611 /* Peek at the next token. */
18612 token = cp_lexer_peek_token (parser->lexer);
18613 /* If it's not a `)', then there is a type-id-list. */
18614 if (token->type != CPP_CLOSE_PAREN)
18616 /* Types may not be defined in an exception-specification. */
18617 saved_message = parser->type_definition_forbidden_message;
18618 parser->type_definition_forbidden_message
18619 = G_("types may not be defined in an exception-specification");
18620 /* Parse the type-id-list. */
18621 type_id_list = cp_parser_type_id_list (parser);
18622 /* Restore the saved message. */
18623 parser->type_definition_forbidden_message = saved_message;
18626 type_id_list = empty_except_spec;
18628 /* Look for the `)'. */
18629 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18631 return type_id_list;
18634 /* Parse an (optional) type-id-list.
18638 type-id-list , type-id ... [opt]
18640 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
18641 in the order that the types were presented. */
18644 cp_parser_type_id_list (cp_parser* parser)
18646 tree types = NULL_TREE;
18653 /* Get the next type-id. */
18654 type = cp_parser_type_id (parser);
18655 /* Parse the optional ellipsis. */
18656 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18658 /* Consume the `...'. */
18659 cp_lexer_consume_token (parser->lexer);
18661 /* Turn the type into a pack expansion expression. */
18662 type = make_pack_expansion (type);
18664 /* Add it to the list. */
18665 types = add_exception_specifier (types, type, /*complain=*/1);
18666 /* Peek at the next token. */
18667 token = cp_lexer_peek_token (parser->lexer);
18668 /* If it is not a `,', we are done. */
18669 if (token->type != CPP_COMMA)
18671 /* Consume the `,'. */
18672 cp_lexer_consume_token (parser->lexer);
18675 return nreverse (types);
18678 /* Parse a try-block.
18681 try compound-statement handler-seq */
18684 cp_parser_try_block (cp_parser* parser)
18688 cp_parser_require_keyword (parser, RID_TRY, RT_TRY);
18689 try_block = begin_try_block ();
18690 cp_parser_compound_statement (parser, NULL, true, false);
18691 finish_try_block (try_block);
18692 cp_parser_handler_seq (parser);
18693 finish_handler_sequence (try_block);
18698 /* Parse a function-try-block.
18700 function-try-block:
18701 try ctor-initializer [opt] function-body handler-seq */
18704 cp_parser_function_try_block (cp_parser* parser)
18706 tree compound_stmt;
18708 bool ctor_initializer_p;
18710 /* Look for the `try' keyword. */
18711 if (!cp_parser_require_keyword (parser, RID_TRY, RT_TRY))
18713 /* Let the rest of the front end know where we are. */
18714 try_block = begin_function_try_block (&compound_stmt);
18715 /* Parse the function-body. */
18717 = cp_parser_ctor_initializer_opt_and_function_body (parser);
18718 /* We're done with the `try' part. */
18719 finish_function_try_block (try_block);
18720 /* Parse the handlers. */
18721 cp_parser_handler_seq (parser);
18722 /* We're done with the handlers. */
18723 finish_function_handler_sequence (try_block, compound_stmt);
18725 return ctor_initializer_p;
18728 /* Parse a handler-seq.
18731 handler handler-seq [opt] */
18734 cp_parser_handler_seq (cp_parser* parser)
18740 /* Parse the handler. */
18741 cp_parser_handler (parser);
18742 /* Peek at the next token. */
18743 token = cp_lexer_peek_token (parser->lexer);
18744 /* If it's not `catch' then there are no more handlers. */
18745 if (!cp_parser_is_keyword (token, RID_CATCH))
18750 /* Parse a handler.
18753 catch ( exception-declaration ) compound-statement */
18756 cp_parser_handler (cp_parser* parser)
18761 cp_parser_require_keyword (parser, RID_CATCH, RT_CATCH);
18762 handler = begin_handler ();
18763 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18764 declaration = cp_parser_exception_declaration (parser);
18765 finish_handler_parms (declaration, handler);
18766 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18767 cp_parser_compound_statement (parser, NULL, false, false);
18768 finish_handler (handler);
18771 /* Parse an exception-declaration.
18773 exception-declaration:
18774 type-specifier-seq declarator
18775 type-specifier-seq abstract-declarator
18779 Returns a VAR_DECL for the declaration, or NULL_TREE if the
18780 ellipsis variant is used. */
18783 cp_parser_exception_declaration (cp_parser* parser)
18785 cp_decl_specifier_seq type_specifiers;
18786 cp_declarator *declarator;
18787 const char *saved_message;
18789 /* If it's an ellipsis, it's easy to handle. */
18790 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
18792 /* Consume the `...' token. */
18793 cp_lexer_consume_token (parser->lexer);
18797 /* Types may not be defined in exception-declarations. */
18798 saved_message = parser->type_definition_forbidden_message;
18799 parser->type_definition_forbidden_message
18800 = G_("types may not be defined in exception-declarations");
18802 /* Parse the type-specifier-seq. */
18803 cp_parser_type_specifier_seq (parser, /*is_declaration=*/true,
18804 /*is_trailing_return=*/false,
18806 /* If it's a `)', then there is no declarator. */
18807 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
18810 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
18811 /*ctor_dtor_or_conv_p=*/NULL,
18812 /*parenthesized_p=*/NULL,
18813 /*member_p=*/false);
18815 /* Restore the saved message. */
18816 parser->type_definition_forbidden_message = saved_message;
18818 if (!type_specifiers.any_specifiers_p)
18819 return error_mark_node;
18821 return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL);
18824 /* Parse a throw-expression.
18827 throw assignment-expression [opt]
18829 Returns a THROW_EXPR representing the throw-expression. */
18832 cp_parser_throw_expression (cp_parser* parser)
18837 cp_parser_require_keyword (parser, RID_THROW, RT_THROW);
18838 token = cp_lexer_peek_token (parser->lexer);
18839 /* Figure out whether or not there is an assignment-expression
18840 following the "throw" keyword. */
18841 if (token->type == CPP_COMMA
18842 || token->type == CPP_SEMICOLON
18843 || token->type == CPP_CLOSE_PAREN
18844 || token->type == CPP_CLOSE_SQUARE
18845 || token->type == CPP_CLOSE_BRACE
18846 || token->type == CPP_COLON)
18847 expression = NULL_TREE;
18849 expression = cp_parser_assignment_expression (parser,
18850 /*cast_p=*/false, NULL);
18852 return build_throw (expression);
18855 /* GNU Extensions */
18857 /* Parse an (optional) asm-specification.
18860 asm ( string-literal )
18862 If the asm-specification is present, returns a STRING_CST
18863 corresponding to the string-literal. Otherwise, returns
18867 cp_parser_asm_specification_opt (cp_parser* parser)
18870 tree asm_specification;
18872 /* Peek at the next token. */
18873 token = cp_lexer_peek_token (parser->lexer);
18874 /* If the next token isn't the `asm' keyword, then there's no
18875 asm-specification. */
18876 if (!cp_parser_is_keyword (token, RID_ASM))
18879 /* Consume the `asm' token. */
18880 cp_lexer_consume_token (parser->lexer);
18881 /* Look for the `('. */
18882 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18884 /* Look for the string-literal. */
18885 asm_specification = cp_parser_string_literal (parser, false, false);
18887 /* Look for the `)'. */
18888 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18890 return asm_specification;
18893 /* Parse an asm-operand-list.
18897 asm-operand-list , asm-operand
18900 string-literal ( expression )
18901 [ string-literal ] string-literal ( expression )
18903 Returns a TREE_LIST representing the operands. The TREE_VALUE of
18904 each node is the expression. The TREE_PURPOSE is itself a
18905 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
18906 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
18907 is a STRING_CST for the string literal before the parenthesis. Returns
18908 ERROR_MARK_NODE if any of the operands are invalid. */
18911 cp_parser_asm_operand_list (cp_parser* parser)
18913 tree asm_operands = NULL_TREE;
18914 bool invalid_operands = false;
18918 tree string_literal;
18922 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
18924 /* Consume the `[' token. */
18925 cp_lexer_consume_token (parser->lexer);
18926 /* Read the operand name. */
18927 name = cp_parser_identifier (parser);
18928 if (name != error_mark_node)
18929 name = build_string (IDENTIFIER_LENGTH (name),
18930 IDENTIFIER_POINTER (name));
18931 /* Look for the closing `]'. */
18932 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
18936 /* Look for the string-literal. */
18937 string_literal = cp_parser_string_literal (parser, false, false);
18939 /* Look for the `('. */
18940 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
18941 /* Parse the expression. */
18942 expression = cp_parser_expression (parser, /*cast_p=*/false, NULL);
18943 /* Look for the `)'. */
18944 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
18946 if (name == error_mark_node
18947 || string_literal == error_mark_node
18948 || expression == error_mark_node)
18949 invalid_operands = true;
18951 /* Add this operand to the list. */
18952 asm_operands = tree_cons (build_tree_list (name, string_literal),
18955 /* If the next token is not a `,', there are no more
18957 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18959 /* Consume the `,'. */
18960 cp_lexer_consume_token (parser->lexer);
18963 return invalid_operands ? error_mark_node : nreverse (asm_operands);
18966 /* Parse an asm-clobber-list.
18970 asm-clobber-list , string-literal
18972 Returns a TREE_LIST, indicating the clobbers in the order that they
18973 appeared. The TREE_VALUE of each node is a STRING_CST. */
18976 cp_parser_asm_clobber_list (cp_parser* parser)
18978 tree clobbers = NULL_TREE;
18982 tree string_literal;
18984 /* Look for the string literal. */
18985 string_literal = cp_parser_string_literal (parser, false, false);
18986 /* Add it to the list. */
18987 clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
18988 /* If the next token is not a `,', then the list is
18990 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
18992 /* Consume the `,' token. */
18993 cp_lexer_consume_token (parser->lexer);
18999 /* Parse an asm-label-list.
19003 asm-label-list , identifier
19005 Returns a TREE_LIST, indicating the labels in the order that they
19006 appeared. The TREE_VALUE of each node is a label. */
19009 cp_parser_asm_label_list (cp_parser* parser)
19011 tree labels = NULL_TREE;
19015 tree identifier, label, name;
19017 /* Look for the identifier. */
19018 identifier = cp_parser_identifier (parser);
19019 if (!error_operand_p (identifier))
19021 label = lookup_label (identifier);
19022 if (TREE_CODE (label) == LABEL_DECL)
19024 TREE_USED (label) = 1;
19025 check_goto (label);
19026 name = build_string (IDENTIFIER_LENGTH (identifier),
19027 IDENTIFIER_POINTER (identifier));
19028 labels = tree_cons (name, label, labels);
19031 /* If the next token is not a `,', then the list is
19033 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
19035 /* Consume the `,' token. */
19036 cp_lexer_consume_token (parser->lexer);
19039 return nreverse (labels);
19042 /* Parse an (optional) series of attributes.
19045 attributes attribute
19048 __attribute__ (( attribute-list [opt] ))
19050 The return value is as for cp_parser_attribute_list. */
19053 cp_parser_attributes_opt (cp_parser* parser)
19055 tree attributes = NULL_TREE;
19060 tree attribute_list;
19062 /* Peek at the next token. */
19063 token = cp_lexer_peek_token (parser->lexer);
19064 /* If it's not `__attribute__', then we're done. */
19065 if (token->keyword != RID_ATTRIBUTE)
19068 /* Consume the `__attribute__' keyword. */
19069 cp_lexer_consume_token (parser->lexer);
19070 /* Look for the two `(' tokens. */
19071 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
19072 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
19074 /* Peek at the next token. */
19075 token = cp_lexer_peek_token (parser->lexer);
19076 if (token->type != CPP_CLOSE_PAREN)
19077 /* Parse the attribute-list. */
19078 attribute_list = cp_parser_attribute_list (parser);
19080 /* If the next token is a `)', then there is no attribute
19082 attribute_list = NULL;
19084 /* Look for the two `)' tokens. */
19085 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
19086 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
19088 /* Add these new attributes to the list. */
19089 attributes = chainon (attributes, attribute_list);
19095 /* Parse an attribute-list.
19099 attribute-list , attribute
19103 identifier ( identifier )
19104 identifier ( identifier , expression-list )
19105 identifier ( expression-list )
19107 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
19108 to an attribute. The TREE_PURPOSE of each node is the identifier
19109 indicating which attribute is in use. The TREE_VALUE represents
19110 the arguments, if any. */
19113 cp_parser_attribute_list (cp_parser* parser)
19115 tree attribute_list = NULL_TREE;
19116 bool save_translate_strings_p = parser->translate_strings_p;
19118 parser->translate_strings_p = false;
19125 /* Look for the identifier. We also allow keywords here; for
19126 example `__attribute__ ((const))' is legal. */
19127 token = cp_lexer_peek_token (parser->lexer);
19128 if (token->type == CPP_NAME
19129 || token->type == CPP_KEYWORD)
19131 tree arguments = NULL_TREE;
19133 /* Consume the token. */
19134 token = cp_lexer_consume_token (parser->lexer);
19136 /* Save away the identifier that indicates which attribute
19138 identifier = (token->type == CPP_KEYWORD)
19139 /* For keywords, use the canonical spelling, not the
19140 parsed identifier. */
19141 ? ridpointers[(int) token->keyword]
19144 attribute = build_tree_list (identifier, NULL_TREE);
19146 /* Peek at the next token. */
19147 token = cp_lexer_peek_token (parser->lexer);
19148 /* If it's an `(', then parse the attribute arguments. */
19149 if (token->type == CPP_OPEN_PAREN)
19152 int attr_flag = (attribute_takes_identifier_p (identifier)
19153 ? id_attr : normal_attr);
19154 vec = cp_parser_parenthesized_expression_list
19155 (parser, attr_flag, /*cast_p=*/false,
19156 /*allow_expansion_p=*/false,
19157 /*non_constant_p=*/NULL);
19159 arguments = error_mark_node;
19162 arguments = build_tree_list_vec (vec);
19163 release_tree_vector (vec);
19165 /* Save the arguments away. */
19166 TREE_VALUE (attribute) = arguments;
19169 if (arguments != error_mark_node)
19171 /* Add this attribute to the list. */
19172 TREE_CHAIN (attribute) = attribute_list;
19173 attribute_list = attribute;
19176 token = cp_lexer_peek_token (parser->lexer);
19178 /* Now, look for more attributes. If the next token isn't a
19179 `,', we're done. */
19180 if (token->type != CPP_COMMA)
19183 /* Consume the comma and keep going. */
19184 cp_lexer_consume_token (parser->lexer);
19186 parser->translate_strings_p = save_translate_strings_p;
19188 /* We built up the list in reverse order. */
19189 return nreverse (attribute_list);
19192 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
19193 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
19194 current value of the PEDANTIC flag, regardless of whether or not
19195 the `__extension__' keyword is present. The caller is responsible
19196 for restoring the value of the PEDANTIC flag. */
19199 cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
19201 /* Save the old value of the PEDANTIC flag. */
19202 *saved_pedantic = pedantic;
19204 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
19206 /* Consume the `__extension__' token. */
19207 cp_lexer_consume_token (parser->lexer);
19208 /* We're not being pedantic while the `__extension__' keyword is
19218 /* Parse a label declaration.
19221 __label__ label-declarator-seq ;
19223 label-declarator-seq:
19224 identifier , label-declarator-seq
19228 cp_parser_label_declaration (cp_parser* parser)
19230 /* Look for the `__label__' keyword. */
19231 cp_parser_require_keyword (parser, RID_LABEL, RT_LABEL);
19237 /* Look for an identifier. */
19238 identifier = cp_parser_identifier (parser);
19239 /* If we failed, stop. */
19240 if (identifier == error_mark_node)
19242 /* Declare it as a label. */
19243 finish_label_decl (identifier);
19244 /* If the next token is a `;', stop. */
19245 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
19247 /* Look for the `,' separating the label declarations. */
19248 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
19251 /* Look for the final `;'. */
19252 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
19255 /* Support Functions */
19257 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
19258 NAME should have one of the representations used for an
19259 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
19260 is returned. If PARSER->SCOPE is a dependent type, then a
19261 SCOPE_REF is returned.
19263 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
19264 returned; the name was already resolved when the TEMPLATE_ID_EXPR
19265 was formed. Abstractly, such entities should not be passed to this
19266 function, because they do not need to be looked up, but it is
19267 simpler to check for this special case here, rather than at the
19270 In cases not explicitly covered above, this function returns a
19271 DECL, OVERLOAD, or baselink representing the result of the lookup.
19272 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
19275 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
19276 (e.g., "struct") that was used. In that case bindings that do not
19277 refer to types are ignored.
19279 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
19282 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
19285 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
19288 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
19289 TREE_LIST of candidates if name-lookup results in an ambiguity, and
19290 NULL_TREE otherwise. */
19293 cp_parser_lookup_name (cp_parser *parser, tree name,
19294 enum tag_types tag_type,
19297 bool check_dependency,
19298 tree *ambiguous_decls,
19299 location_t name_location)
19303 tree object_type = parser->context->object_type;
19305 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
19306 flags |= LOOKUP_COMPLAIN;
19308 /* Assume that the lookup will be unambiguous. */
19309 if (ambiguous_decls)
19310 *ambiguous_decls = NULL_TREE;
19312 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
19313 no longer valid. Note that if we are parsing tentatively, and
19314 the parse fails, OBJECT_TYPE will be automatically restored. */
19315 parser->context->object_type = NULL_TREE;
19317 if (name == error_mark_node)
19318 return error_mark_node;
19320 /* A template-id has already been resolved; there is no lookup to
19322 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
19324 if (BASELINK_P (name))
19326 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
19327 == TEMPLATE_ID_EXPR);
19331 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
19332 it should already have been checked to make sure that the name
19333 used matches the type being destroyed. */
19334 if (TREE_CODE (name) == BIT_NOT_EXPR)
19338 /* Figure out to which type this destructor applies. */
19340 type = parser->scope;
19341 else if (object_type)
19342 type = object_type;
19344 type = current_class_type;
19345 /* If that's not a class type, there is no destructor. */
19346 if (!type || !CLASS_TYPE_P (type))
19347 return error_mark_node;
19348 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
19349 lazily_declare_fn (sfk_destructor, type);
19350 if (!CLASSTYPE_DESTRUCTORS (type))
19351 return error_mark_node;
19352 /* If it was a class type, return the destructor. */
19353 return CLASSTYPE_DESTRUCTORS (type);
19356 /* By this point, the NAME should be an ordinary identifier. If
19357 the id-expression was a qualified name, the qualifying scope is
19358 stored in PARSER->SCOPE at this point. */
19359 gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
19361 /* Perform the lookup. */
19366 if (parser->scope == error_mark_node)
19367 return error_mark_node;
19369 /* If the SCOPE is dependent, the lookup must be deferred until
19370 the template is instantiated -- unless we are explicitly
19371 looking up names in uninstantiated templates. Even then, we
19372 cannot look up the name if the scope is not a class type; it
19373 might, for example, be a template type parameter. */
19374 dependent_p = (TYPE_P (parser->scope)
19375 && dependent_scope_p (parser->scope));
19376 if ((check_dependency || !CLASS_TYPE_P (parser->scope))
19378 /* Defer lookup. */
19379 decl = error_mark_node;
19382 tree pushed_scope = NULL_TREE;
19384 /* If PARSER->SCOPE is a dependent type, then it must be a
19385 class type, and we must not be checking dependencies;
19386 otherwise, we would have processed this lookup above. So
19387 that PARSER->SCOPE is not considered a dependent base by
19388 lookup_member, we must enter the scope here. */
19390 pushed_scope = push_scope (parser->scope);
19392 /* If the PARSER->SCOPE is a template specialization, it
19393 may be instantiated during name lookup. In that case,
19394 errors may be issued. Even if we rollback the current
19395 tentative parse, those errors are valid. */
19396 decl = lookup_qualified_name (parser->scope, name,
19397 tag_type != none_type,
19398 /*complain=*/true);
19400 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
19401 lookup result and the nested-name-specifier nominates a class C:
19402 * if the name specified after the nested-name-specifier, when
19403 looked up in C, is the injected-class-name of C (Clause 9), or
19404 * if the name specified after the nested-name-specifier is the
19405 same as the identifier or the simple-template-id's template-
19406 name in the last component of the nested-name-specifier,
19407 the name is instead considered to name the constructor of
19408 class C. [ Note: for example, the constructor is not an
19409 acceptable lookup result in an elaborated-type-specifier so
19410 the constructor would not be used in place of the
19411 injected-class-name. --end note ] Such a constructor name
19412 shall be used only in the declarator-id of a declaration that
19413 names a constructor or in a using-declaration. */
19414 if (tag_type == none_type
19415 && DECL_SELF_REFERENCE_P (decl)
19416 && same_type_p (DECL_CONTEXT (decl), parser->scope))
19417 decl = lookup_qualified_name (parser->scope, ctor_identifier,
19418 tag_type != none_type,
19419 /*complain=*/true);
19421 /* If we have a single function from a using decl, pull it out. */
19422 if (TREE_CODE (decl) == OVERLOAD
19423 && !really_overloaded_fn (decl))
19424 decl = OVL_FUNCTION (decl);
19427 pop_scope (pushed_scope);
19430 /* If the scope is a dependent type and either we deferred lookup or
19431 we did lookup but didn't find the name, rememeber the name. */
19432 if (decl == error_mark_node && TYPE_P (parser->scope)
19433 && dependent_type_p (parser->scope))
19439 /* The resolution to Core Issue 180 says that `struct
19440 A::B' should be considered a type-name, even if `A'
19442 type = make_typename_type (parser->scope, name, tag_type,
19443 /*complain=*/tf_error);
19444 decl = TYPE_NAME (type);
19446 else if (is_template
19447 && (cp_parser_next_token_ends_template_argument_p (parser)
19448 || cp_lexer_next_token_is (parser->lexer,
19450 decl = make_unbound_class_template (parser->scope,
19452 /*complain=*/tf_error);
19454 decl = build_qualified_name (/*type=*/NULL_TREE,
19455 parser->scope, name,
19458 parser->qualifying_scope = parser->scope;
19459 parser->object_scope = NULL_TREE;
19461 else if (object_type)
19463 tree object_decl = NULL_TREE;
19464 /* Look up the name in the scope of the OBJECT_TYPE, unless the
19465 OBJECT_TYPE is not a class. */
19466 if (CLASS_TYPE_P (object_type))
19467 /* If the OBJECT_TYPE is a template specialization, it may
19468 be instantiated during name lookup. In that case, errors
19469 may be issued. Even if we rollback the current tentative
19470 parse, those errors are valid. */
19471 object_decl = lookup_member (object_type,
19474 tag_type != none_type);
19475 /* Look it up in the enclosing context, too. */
19476 decl = lookup_name_real (name, tag_type != none_type,
19478 /*block_p=*/true, is_namespace, flags);
19479 parser->object_scope = object_type;
19480 parser->qualifying_scope = NULL_TREE;
19482 decl = object_decl;
19486 decl = lookup_name_real (name, tag_type != none_type,
19488 /*block_p=*/true, is_namespace, flags);
19489 parser->qualifying_scope = NULL_TREE;
19490 parser->object_scope = NULL_TREE;
19493 /* If the lookup failed, let our caller know. */
19494 if (!decl || decl == error_mark_node)
19495 return error_mark_node;
19497 /* Pull out the template from an injected-class-name (or multiple). */
19499 decl = maybe_get_template_decl_from_type_decl (decl);
19501 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
19502 if (TREE_CODE (decl) == TREE_LIST)
19504 if (ambiguous_decls)
19505 *ambiguous_decls = decl;
19506 /* The error message we have to print is too complicated for
19507 cp_parser_error, so we incorporate its actions directly. */
19508 if (!cp_parser_simulate_error (parser))
19510 error_at (name_location, "reference to %qD is ambiguous",
19512 print_candidates (decl);
19514 return error_mark_node;
19517 gcc_assert (DECL_P (decl)
19518 || TREE_CODE (decl) == OVERLOAD
19519 || TREE_CODE (decl) == SCOPE_REF
19520 || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
19521 || BASELINK_P (decl));
19523 /* If we have resolved the name of a member declaration, check to
19524 see if the declaration is accessible. When the name resolves to
19525 set of overloaded functions, accessibility is checked when
19526 overload resolution is done.
19528 During an explicit instantiation, access is not checked at all,
19529 as per [temp.explicit]. */
19531 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
19536 /* Like cp_parser_lookup_name, but for use in the typical case where
19537 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
19538 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
19541 cp_parser_lookup_name_simple (cp_parser* parser, tree name, location_t location)
19543 return cp_parser_lookup_name (parser, name,
19545 /*is_template=*/false,
19546 /*is_namespace=*/false,
19547 /*check_dependency=*/true,
19548 /*ambiguous_decls=*/NULL,
19552 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
19553 the current context, return the TYPE_DECL. If TAG_NAME_P is
19554 true, the DECL indicates the class being defined in a class-head,
19555 or declared in an elaborated-type-specifier.
19557 Otherwise, return DECL. */
19560 cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
19562 /* If the TEMPLATE_DECL is being declared as part of a class-head,
19563 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
19566 template <typename T> struct B;
19569 template <typename T> struct A::B {};
19571 Similarly, in an elaborated-type-specifier:
19573 namespace N { struct X{}; }
19576 template <typename T> friend struct N::X;
19579 However, if the DECL refers to a class type, and we are in
19580 the scope of the class, then the name lookup automatically
19581 finds the TYPE_DECL created by build_self_reference rather
19582 than a TEMPLATE_DECL. For example, in:
19584 template <class T> struct S {
19588 there is no need to handle such case. */
19590 if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
19591 return DECL_TEMPLATE_RESULT (decl);
19596 /* If too many, or too few, template-parameter lists apply to the
19597 declarator, issue an error message. Returns TRUE if all went well,
19598 and FALSE otherwise. */
19601 cp_parser_check_declarator_template_parameters (cp_parser* parser,
19602 cp_declarator *declarator,
19603 location_t declarator_location)
19605 unsigned num_templates;
19607 /* We haven't seen any classes that involve template parameters yet. */
19610 switch (declarator->kind)
19613 if (declarator->u.id.qualifying_scope)
19617 scope = declarator->u.id.qualifying_scope;
19619 while (scope && CLASS_TYPE_P (scope))
19621 /* You're supposed to have one `template <...>'
19622 for every template class, but you don't need one
19623 for a full specialization. For example:
19625 template <class T> struct S{};
19626 template <> struct S<int> { void f(); };
19627 void S<int>::f () {}
19629 is correct; there shouldn't be a `template <>' for
19630 the definition of `S<int>::f'. */
19631 if (!CLASSTYPE_TEMPLATE_INFO (scope))
19632 /* If SCOPE does not have template information of any
19633 kind, then it is not a template, nor is it nested
19634 within a template. */
19636 if (explicit_class_specialization_p (scope))
19638 if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)))
19641 scope = TYPE_CONTEXT (scope);
19644 else if (TREE_CODE (declarator->u.id.unqualified_name)
19645 == TEMPLATE_ID_EXPR)
19646 /* If the DECLARATOR has the form `X<y>' then it uses one
19647 additional level of template parameters. */
19650 return cp_parser_check_template_parameters
19651 (parser, num_templates, declarator_location, declarator);
19657 case cdk_reference:
19659 return (cp_parser_check_declarator_template_parameters
19660 (parser, declarator->declarator, declarator_location));
19666 gcc_unreachable ();
19671 /* NUM_TEMPLATES were used in the current declaration. If that is
19672 invalid, return FALSE and issue an error messages. Otherwise,
19673 return TRUE. If DECLARATOR is non-NULL, then we are checking a
19674 declarator and we can print more accurate diagnostics. */
19677 cp_parser_check_template_parameters (cp_parser* parser,
19678 unsigned num_templates,
19679 location_t location,
19680 cp_declarator *declarator)
19682 /* If there are the same number of template classes and parameter
19683 lists, that's OK. */
19684 if (parser->num_template_parameter_lists == num_templates)
19686 /* If there are more, but only one more, then we are referring to a
19687 member template. That's OK too. */
19688 if (parser->num_template_parameter_lists == num_templates + 1)
19690 /* If there are more template classes than parameter lists, we have
19693 template <class T> void S<T>::R<T>::f (); */
19694 if (parser->num_template_parameter_lists < num_templates)
19696 if (declarator && !current_function_decl)
19697 error_at (location, "specializing member %<%T::%E%> "
19698 "requires %<template<>%> syntax",
19699 declarator->u.id.qualifying_scope,
19700 declarator->u.id.unqualified_name);
19701 else if (declarator)
19702 error_at (location, "invalid declaration of %<%T::%E%>",
19703 declarator->u.id.qualifying_scope,
19704 declarator->u.id.unqualified_name);
19706 error_at (location, "too few template-parameter-lists");
19709 /* Otherwise, there are too many template parameter lists. We have
19712 template <class T> template <class U> void S::f(); */
19713 error_at (location, "too many template-parameter-lists");
19717 /* Parse an optional `::' token indicating that the following name is
19718 from the global namespace. If so, PARSER->SCOPE is set to the
19719 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
19720 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
19721 Returns the new value of PARSER->SCOPE, if the `::' token is
19722 present, and NULL_TREE otherwise. */
19725 cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
19729 /* Peek at the next token. */
19730 token = cp_lexer_peek_token (parser->lexer);
19731 /* If we're looking at a `::' token then we're starting from the
19732 global namespace, not our current location. */
19733 if (token->type == CPP_SCOPE)
19735 /* Consume the `::' token. */
19736 cp_lexer_consume_token (parser->lexer);
19737 /* Set the SCOPE so that we know where to start the lookup. */
19738 parser->scope = global_namespace;
19739 parser->qualifying_scope = global_namespace;
19740 parser->object_scope = NULL_TREE;
19742 return parser->scope;
19744 else if (!current_scope_valid_p)
19746 parser->scope = NULL_TREE;
19747 parser->qualifying_scope = NULL_TREE;
19748 parser->object_scope = NULL_TREE;
19754 /* Returns TRUE if the upcoming token sequence is the start of a
19755 constructor declarator. If FRIEND_P is true, the declarator is
19756 preceded by the `friend' specifier. */
19759 cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
19761 bool constructor_p;
19762 tree nested_name_specifier;
19763 cp_token *next_token;
19765 /* The common case is that this is not a constructor declarator, so
19766 try to avoid doing lots of work if at all possible. It's not
19767 valid declare a constructor at function scope. */
19768 if (parser->in_function_body)
19770 /* And only certain tokens can begin a constructor declarator. */
19771 next_token = cp_lexer_peek_token (parser->lexer);
19772 if (next_token->type != CPP_NAME
19773 && next_token->type != CPP_SCOPE
19774 && next_token->type != CPP_NESTED_NAME_SPECIFIER
19775 && next_token->type != CPP_TEMPLATE_ID)
19778 /* Parse tentatively; we are going to roll back all of the tokens
19780 cp_parser_parse_tentatively (parser);
19781 /* Assume that we are looking at a constructor declarator. */
19782 constructor_p = true;
19784 /* Look for the optional `::' operator. */
19785 cp_parser_global_scope_opt (parser,
19786 /*current_scope_valid_p=*/false);
19787 /* Look for the nested-name-specifier. */
19788 nested_name_specifier
19789 = (cp_parser_nested_name_specifier_opt (parser,
19790 /*typename_keyword_p=*/false,
19791 /*check_dependency_p=*/false,
19793 /*is_declaration=*/false));
19794 /* Outside of a class-specifier, there must be a
19795 nested-name-specifier. */
19796 if (!nested_name_specifier &&
19797 (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type)
19799 constructor_p = false;
19800 else if (nested_name_specifier == error_mark_node)
19801 constructor_p = false;
19803 /* If we have a class scope, this is easy; DR 147 says that S::S always
19804 names the constructor, and no other qualified name could. */
19805 if (constructor_p && nested_name_specifier
19806 && CLASS_TYPE_P (nested_name_specifier))
19808 tree id = cp_parser_unqualified_id (parser,
19809 /*template_keyword_p=*/false,
19810 /*check_dependency_p=*/false,
19811 /*declarator_p=*/true,
19812 /*optional_p=*/false);
19813 if (is_overloaded_fn (id))
19814 id = DECL_NAME (get_first_fn (id));
19815 if (!constructor_name_p (id, nested_name_specifier))
19816 constructor_p = false;
19818 /* If we still think that this might be a constructor-declarator,
19819 look for a class-name. */
19820 else if (constructor_p)
19824 template <typename T> struct S {
19828 we must recognize that the nested `S' names a class. */
19830 type_decl = cp_parser_class_name (parser,
19831 /*typename_keyword_p=*/false,
19832 /*template_keyword_p=*/false,
19834 /*check_dependency_p=*/false,
19835 /*class_head_p=*/false,
19836 /*is_declaration=*/false);
19837 /* If there was no class-name, then this is not a constructor. */
19838 constructor_p = !cp_parser_error_occurred (parser);
19840 /* If we're still considering a constructor, we have to see a `(',
19841 to begin the parameter-declaration-clause, followed by either a
19842 `)', an `...', or a decl-specifier. We need to check for a
19843 type-specifier to avoid being fooled into thinking that:
19847 is a constructor. (It is actually a function named `f' that
19848 takes one parameter (of type `int') and returns a value of type
19851 && !cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
19852 constructor_p = false;
19855 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
19856 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
19857 /* A parameter declaration begins with a decl-specifier,
19858 which is either the "attribute" keyword, a storage class
19859 specifier, or (usually) a type-specifier. */
19860 && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
19863 tree pushed_scope = NULL_TREE;
19864 unsigned saved_num_template_parameter_lists;
19866 /* Names appearing in the type-specifier should be looked up
19867 in the scope of the class. */
19868 if (current_class_type)
19872 type = TREE_TYPE (type_decl);
19873 if (TREE_CODE (type) == TYPENAME_TYPE)
19875 type = resolve_typename_type (type,
19876 /*only_current_p=*/false);
19877 if (TREE_CODE (type) == TYPENAME_TYPE)
19879 cp_parser_abort_tentative_parse (parser);
19883 pushed_scope = push_scope (type);
19886 /* Inside the constructor parameter list, surrounding
19887 template-parameter-lists do not apply. */
19888 saved_num_template_parameter_lists
19889 = parser->num_template_parameter_lists;
19890 parser->num_template_parameter_lists = 0;
19892 /* Look for the type-specifier. */
19893 cp_parser_type_specifier (parser,
19894 CP_PARSER_FLAGS_NONE,
19895 /*decl_specs=*/NULL,
19896 /*is_declarator=*/true,
19897 /*declares_class_or_enum=*/NULL,
19898 /*is_cv_qualifier=*/NULL);
19900 parser->num_template_parameter_lists
19901 = saved_num_template_parameter_lists;
19903 /* Leave the scope of the class. */
19905 pop_scope (pushed_scope);
19907 constructor_p = !cp_parser_error_occurred (parser);
19911 /* We did not really want to consume any tokens. */
19912 cp_parser_abort_tentative_parse (parser);
19914 return constructor_p;
19917 /* Parse the definition of the function given by the DECL_SPECIFIERS,
19918 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
19919 they must be performed once we are in the scope of the function.
19921 Returns the function defined. */
19924 cp_parser_function_definition_from_specifiers_and_declarator
19925 (cp_parser* parser,
19926 cp_decl_specifier_seq *decl_specifiers,
19928 const cp_declarator *declarator)
19933 /* Begin the function-definition. */
19934 success_p = start_function (decl_specifiers, declarator, attributes);
19936 /* The things we're about to see are not directly qualified by any
19937 template headers we've seen thus far. */
19938 reset_specialization ();
19940 /* If there were names looked up in the decl-specifier-seq that we
19941 did not check, check them now. We must wait until we are in the
19942 scope of the function to perform the checks, since the function
19943 might be a friend. */
19944 perform_deferred_access_checks ();
19948 /* Skip the entire function. */
19949 cp_parser_skip_to_end_of_block_or_statement (parser);
19950 fn = error_mark_node;
19952 else if (DECL_INITIAL (current_function_decl) != error_mark_node)
19954 /* Seen already, skip it. An error message has already been output. */
19955 cp_parser_skip_to_end_of_block_or_statement (parser);
19956 fn = current_function_decl;
19957 current_function_decl = NULL_TREE;
19958 /* If this is a function from a class, pop the nested class. */
19959 if (current_class_name)
19960 pop_nested_class ();
19965 if (DECL_DECLARED_INLINE_P (current_function_decl))
19966 tv = TV_PARSE_INLINE;
19968 tv = TV_PARSE_FUNC;
19970 fn = cp_parser_function_definition_after_declarator (parser,
19971 /*inline_p=*/false);
19978 /* Parse the part of a function-definition that follows the
19979 declarator. INLINE_P is TRUE iff this function is an inline
19980 function defined within a class-specifier.
19982 Returns the function defined. */
19985 cp_parser_function_definition_after_declarator (cp_parser* parser,
19989 bool ctor_initializer_p = false;
19990 bool saved_in_unbraced_linkage_specification_p;
19991 bool saved_in_function_body;
19992 unsigned saved_num_template_parameter_lists;
19995 saved_in_function_body = parser->in_function_body;
19996 parser->in_function_body = true;
19997 /* If the next token is `return', then the code may be trying to
19998 make use of the "named return value" extension that G++ used to
20000 token = cp_lexer_peek_token (parser->lexer);
20001 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
20003 /* Consume the `return' keyword. */
20004 cp_lexer_consume_token (parser->lexer);
20005 /* Look for the identifier that indicates what value is to be
20007 cp_parser_identifier (parser);
20008 /* Issue an error message. */
20009 error_at (token->location,
20010 "named return values are no longer supported");
20011 /* Skip tokens until we reach the start of the function body. */
20014 cp_token *token = cp_lexer_peek_token (parser->lexer);
20015 if (token->type == CPP_OPEN_BRACE
20016 || token->type == CPP_EOF
20017 || token->type == CPP_PRAGMA_EOL)
20019 cp_lexer_consume_token (parser->lexer);
20022 /* The `extern' in `extern "C" void f () { ... }' does not apply to
20023 anything declared inside `f'. */
20024 saved_in_unbraced_linkage_specification_p
20025 = parser->in_unbraced_linkage_specification_p;
20026 parser->in_unbraced_linkage_specification_p = false;
20027 /* Inside the function, surrounding template-parameter-lists do not
20029 saved_num_template_parameter_lists
20030 = parser->num_template_parameter_lists;
20031 parser->num_template_parameter_lists = 0;
20033 start_lambda_scope (current_function_decl);
20035 /* If the next token is `try', then we are looking at a
20036 function-try-block. */
20037 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
20038 ctor_initializer_p = cp_parser_function_try_block (parser);
20039 /* A function-try-block includes the function-body, so we only do
20040 this next part if we're not processing a function-try-block. */
20043 = cp_parser_ctor_initializer_opt_and_function_body (parser);
20045 finish_lambda_scope ();
20047 /* Finish the function. */
20048 fn = finish_function ((ctor_initializer_p ? 1 : 0) |
20049 (inline_p ? 2 : 0));
20050 /* Generate code for it, if necessary. */
20051 expand_or_defer_fn (fn);
20052 /* Restore the saved values. */
20053 parser->in_unbraced_linkage_specification_p
20054 = saved_in_unbraced_linkage_specification_p;
20055 parser->num_template_parameter_lists
20056 = saved_num_template_parameter_lists;
20057 parser->in_function_body = saved_in_function_body;
20062 /* Parse a template-declaration, assuming that the `export' (and
20063 `extern') keywords, if present, has already been scanned. MEMBER_P
20064 is as for cp_parser_template_declaration. */
20067 cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
20069 tree decl = NULL_TREE;
20070 VEC (deferred_access_check,gc) *checks;
20071 tree parameter_list;
20072 bool friend_p = false;
20073 bool need_lang_pop;
20076 /* Look for the `template' keyword. */
20077 token = cp_lexer_peek_token (parser->lexer);
20078 if (!cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE))
20082 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
20084 if (at_class_scope_p () && current_function_decl)
20086 /* 14.5.2.2 [temp.mem]
20088 A local class shall not have member templates. */
20089 error_at (token->location,
20090 "invalid declaration of member template in local class");
20091 cp_parser_skip_to_end_of_block_or_statement (parser);
20096 A template ... shall not have C linkage. */
20097 if (current_lang_name == lang_name_c)
20099 error_at (token->location, "template with C linkage");
20100 /* Give it C++ linkage to avoid confusing other parts of the
20102 push_lang_context (lang_name_cplusplus);
20103 need_lang_pop = true;
20106 need_lang_pop = false;
20108 /* We cannot perform access checks on the template parameter
20109 declarations until we know what is being declared, just as we
20110 cannot check the decl-specifier list. */
20111 push_deferring_access_checks (dk_deferred);
20113 /* If the next token is `>', then we have an invalid
20114 specialization. Rather than complain about an invalid template
20115 parameter, issue an error message here. */
20116 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
20118 cp_parser_error (parser, "invalid explicit specialization");
20119 begin_specialization ();
20120 parameter_list = NULL_TREE;
20124 /* Parse the template parameters. */
20125 parameter_list = cp_parser_template_parameter_list (parser);
20126 fixup_template_parms ();
20129 /* Get the deferred access checks from the parameter list. These
20130 will be checked once we know what is being declared, as for a
20131 member template the checks must be performed in the scope of the
20132 class containing the member. */
20133 checks = get_deferred_access_checks ();
20135 /* Look for the `>'. */
20136 cp_parser_skip_to_end_of_template_parameter_list (parser);
20137 /* We just processed one more parameter list. */
20138 ++parser->num_template_parameter_lists;
20139 /* If the next token is `template', there are more template
20141 if (cp_lexer_next_token_is_keyword (parser->lexer,
20143 cp_parser_template_declaration_after_export (parser, member_p);
20146 /* There are no access checks when parsing a template, as we do not
20147 know if a specialization will be a friend. */
20148 push_deferring_access_checks (dk_no_check);
20149 token = cp_lexer_peek_token (parser->lexer);
20150 decl = cp_parser_single_declaration (parser,
20153 /*explicit_specialization_p=*/false,
20155 pop_deferring_access_checks ();
20157 /* If this is a member template declaration, let the front
20159 if (member_p && !friend_p && decl)
20161 if (TREE_CODE (decl) == TYPE_DECL)
20162 cp_parser_check_access_in_redeclaration (decl, token->location);
20164 decl = finish_member_template_decl (decl);
20166 else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL)
20167 make_friend_class (current_class_type, TREE_TYPE (decl),
20168 /*complain=*/true);
20170 /* We are done with the current parameter list. */
20171 --parser->num_template_parameter_lists;
20173 pop_deferring_access_checks ();
20176 finish_template_decl (parameter_list);
20178 /* Register member declarations. */
20179 if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
20180 finish_member_declaration (decl);
20181 /* For the erroneous case of a template with C linkage, we pushed an
20182 implicit C++ linkage scope; exit that scope now. */
20184 pop_lang_context ();
20185 /* If DECL is a function template, we must return to parse it later.
20186 (Even though there is no definition, there might be default
20187 arguments that need handling.) */
20188 if (member_p && decl
20189 && (TREE_CODE (decl) == FUNCTION_DECL
20190 || DECL_FUNCTION_TEMPLATE_P (decl)))
20191 VEC_safe_push (tree, gc, unparsed_funs_with_definitions, decl);
20194 /* Perform the deferred access checks from a template-parameter-list.
20195 CHECKS is a TREE_LIST of access checks, as returned by
20196 get_deferred_access_checks. */
20199 cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check,gc)* checks)
20201 ++processing_template_parmlist;
20202 perform_access_checks (checks);
20203 --processing_template_parmlist;
20206 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
20207 `function-definition' sequence. MEMBER_P is true, this declaration
20208 appears in a class scope.
20210 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
20211 *FRIEND_P is set to TRUE iff the declaration is a friend. */
20214 cp_parser_single_declaration (cp_parser* parser,
20215 VEC (deferred_access_check,gc)* checks,
20217 bool explicit_specialization_p,
20220 int declares_class_or_enum;
20221 tree decl = NULL_TREE;
20222 cp_decl_specifier_seq decl_specifiers;
20223 bool function_definition_p = false;
20224 cp_token *decl_spec_token_start;
20226 /* This function is only used when processing a template
20228 gcc_assert (innermost_scope_kind () == sk_template_parms
20229 || innermost_scope_kind () == sk_template_spec);
20231 /* Defer access checks until we know what is being declared. */
20232 push_deferring_access_checks (dk_deferred);
20234 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
20236 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
20237 cp_parser_decl_specifier_seq (parser,
20238 CP_PARSER_FLAGS_OPTIONAL,
20240 &declares_class_or_enum);
20242 *friend_p = cp_parser_friend_p (&decl_specifiers);
20244 /* There are no template typedefs. */
20245 if (decl_specifiers.specs[(int) ds_typedef])
20247 error_at (decl_spec_token_start->location,
20248 "template declaration of %<typedef%>");
20249 decl = error_mark_node;
20252 /* Gather up the access checks that occurred the
20253 decl-specifier-seq. */
20254 stop_deferring_access_checks ();
20256 /* Check for the declaration of a template class. */
20257 if (declares_class_or_enum)
20259 if (cp_parser_declares_only_class_p (parser))
20261 decl = shadow_tag (&decl_specifiers);
20266 friend template <typename T> struct A<T>::B;
20269 A<T>::B will be represented by a TYPENAME_TYPE, and
20270 therefore not recognized by shadow_tag. */
20271 if (friend_p && *friend_p
20273 && decl_specifiers.type
20274 && TYPE_P (decl_specifiers.type))
20275 decl = decl_specifiers.type;
20277 if (decl && decl != error_mark_node)
20278 decl = TYPE_NAME (decl);
20280 decl = error_mark_node;
20282 /* Perform access checks for template parameters. */
20283 cp_parser_perform_template_parameter_access_checks (checks);
20287 /* Complain about missing 'typename' or other invalid type names. */
20288 if (!decl_specifiers.any_type_specifiers_p
20289 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
20291 /* cp_parser_parse_and_diagnose_invalid_type_name calls
20292 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
20293 the rest of this declaration. */
20294 decl = error_mark_node;
20298 /* If it's not a template class, try for a template function. If
20299 the next token is a `;', then this declaration does not declare
20300 anything. But, if there were errors in the decl-specifiers, then
20301 the error might well have come from an attempted class-specifier.
20302 In that case, there's no need to warn about a missing declarator. */
20304 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
20305 || decl_specifiers.type != error_mark_node))
20307 decl = cp_parser_init_declarator (parser,
20310 /*function_definition_allowed_p=*/true,
20312 declares_class_or_enum,
20313 &function_definition_p,
20316 /* 7.1.1-1 [dcl.stc]
20318 A storage-class-specifier shall not be specified in an explicit
20319 specialization... */
20321 && explicit_specialization_p
20322 && decl_specifiers.storage_class != sc_none)
20324 error_at (decl_spec_token_start->location,
20325 "explicit template specialization cannot have a storage class");
20326 decl = error_mark_node;
20330 /* Look for a trailing `;' after the declaration. */
20331 if (!function_definition_p
20332 && (decl == error_mark_node
20333 || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON)))
20334 cp_parser_skip_to_end_of_block_or_statement (parser);
20337 pop_deferring_access_checks ();
20339 /* Clear any current qualification; whatever comes next is the start
20340 of something new. */
20341 parser->scope = NULL_TREE;
20342 parser->qualifying_scope = NULL_TREE;
20343 parser->object_scope = NULL_TREE;
20348 /* Parse a cast-expression that is not the operand of a unary "&". */
20351 cp_parser_simple_cast_expression (cp_parser *parser)
20353 return cp_parser_cast_expression (parser, /*address_p=*/false,
20354 /*cast_p=*/false, NULL);
20357 /* Parse a functional cast to TYPE. Returns an expression
20358 representing the cast. */
20361 cp_parser_functional_cast (cp_parser* parser, tree type)
20364 tree expression_list;
20368 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
20370 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
20371 expression_list = cp_parser_braced_list (parser, &nonconst_p);
20372 CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
20373 if (TREE_CODE (type) == TYPE_DECL)
20374 type = TREE_TYPE (type);
20375 return finish_compound_literal (type, expression_list,
20376 tf_warning_or_error);
20380 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
20382 /*allow_expansion_p=*/true,
20383 /*non_constant_p=*/NULL);
20385 expression_list = error_mark_node;
20388 expression_list = build_tree_list_vec (vec);
20389 release_tree_vector (vec);
20392 cast = build_functional_cast (type, expression_list,
20393 tf_warning_or_error);
20394 /* [expr.const]/1: In an integral constant expression "only type
20395 conversions to integral or enumeration type can be used". */
20396 if (TREE_CODE (type) == TYPE_DECL)
20397 type = TREE_TYPE (type);
20398 if (cast != error_mark_node
20399 && !cast_valid_in_integral_constant_expression_p (type)
20400 && cp_parser_non_integral_constant_expression (parser,
20402 return error_mark_node;
20406 /* Save the tokens that make up the body of a member function defined
20407 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
20408 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
20409 specifiers applied to the declaration. Returns the FUNCTION_DECL
20410 for the member function. */
20413 cp_parser_save_member_function_body (cp_parser* parser,
20414 cp_decl_specifier_seq *decl_specifiers,
20415 cp_declarator *declarator,
20422 /* Create the FUNCTION_DECL. */
20423 fn = grokmethod (decl_specifiers, declarator, attributes);
20424 /* If something went badly wrong, bail out now. */
20425 if (fn == error_mark_node)
20427 /* If there's a function-body, skip it. */
20428 if (cp_parser_token_starts_function_definition_p
20429 (cp_lexer_peek_token (parser->lexer)))
20430 cp_parser_skip_to_end_of_block_or_statement (parser);
20431 return error_mark_node;
20434 /* Remember it, if there default args to post process. */
20435 cp_parser_save_default_args (parser, fn);
20437 /* Save away the tokens that make up the body of the
20439 first = parser->lexer->next_token;
20440 /* We can have braced-init-list mem-initializers before the fn body. */
20441 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20443 cp_lexer_consume_token (parser->lexer);
20444 while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
20445 && cp_lexer_next_token_is_not_keyword (parser->lexer, RID_TRY))
20447 /* cache_group will stop after an un-nested { } pair, too. */
20448 if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
20451 /* variadic mem-inits have ... after the ')'. */
20452 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
20453 cp_lexer_consume_token (parser->lexer);
20456 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
20457 /* Handle function try blocks. */
20458 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
20459 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
20460 last = parser->lexer->next_token;
20462 /* Save away the inline definition; we will process it when the
20463 class is complete. */
20464 DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
20465 DECL_PENDING_INLINE_P (fn) = 1;
20467 /* We need to know that this was defined in the class, so that
20468 friend templates are handled correctly. */
20469 DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
20471 /* Add FN to the queue of functions to be parsed later. */
20472 VEC_safe_push (tree, gc, unparsed_funs_with_definitions, fn);
20477 /* Parse a template-argument-list, as well as the trailing ">" (but
20478 not the opening ">"). See cp_parser_template_argument_list for the
20482 cp_parser_enclosed_template_argument_list (cp_parser* parser)
20486 tree saved_qualifying_scope;
20487 tree saved_object_scope;
20488 bool saved_greater_than_is_operator_p;
20489 int saved_unevaluated_operand;
20490 int saved_inhibit_evaluation_warnings;
20494 When parsing a template-id, the first non-nested `>' is taken as
20495 the end of the template-argument-list rather than a greater-than
20497 saved_greater_than_is_operator_p
20498 = parser->greater_than_is_operator_p;
20499 parser->greater_than_is_operator_p = false;
20500 /* Parsing the argument list may modify SCOPE, so we save it
20502 saved_scope = parser->scope;
20503 saved_qualifying_scope = parser->qualifying_scope;
20504 saved_object_scope = parser->object_scope;
20505 /* We need to evaluate the template arguments, even though this
20506 template-id may be nested within a "sizeof". */
20507 saved_unevaluated_operand = cp_unevaluated_operand;
20508 cp_unevaluated_operand = 0;
20509 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
20510 c_inhibit_evaluation_warnings = 0;
20511 /* Parse the template-argument-list itself. */
20512 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
20513 || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
20514 arguments = NULL_TREE;
20516 arguments = cp_parser_template_argument_list (parser);
20517 /* Look for the `>' that ends the template-argument-list. If we find
20518 a '>>' instead, it's probably just a typo. */
20519 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
20521 if (cxx_dialect != cxx98)
20523 /* In C++0x, a `>>' in a template argument list or cast
20524 expression is considered to be two separate `>'
20525 tokens. So, change the current token to a `>', but don't
20526 consume it: it will be consumed later when the outer
20527 template argument list (or cast expression) is parsed.
20528 Note that this replacement of `>' for `>>' is necessary
20529 even if we are parsing tentatively: in the tentative
20530 case, after calling
20531 cp_parser_enclosed_template_argument_list we will always
20532 throw away all of the template arguments and the first
20533 closing `>', either because the template argument list
20534 was erroneous or because we are replacing those tokens
20535 with a CPP_TEMPLATE_ID token. The second `>' (which will
20536 not have been thrown away) is needed either to close an
20537 outer template argument list or to complete a new-style
20539 cp_token *token = cp_lexer_peek_token (parser->lexer);
20540 token->type = CPP_GREATER;
20542 else if (!saved_greater_than_is_operator_p)
20544 /* If we're in a nested template argument list, the '>>' has
20545 to be a typo for '> >'. We emit the error message, but we
20546 continue parsing and we push a '>' as next token, so that
20547 the argument list will be parsed correctly. Note that the
20548 global source location is still on the token before the
20549 '>>', so we need to say explicitly where we want it. */
20550 cp_token *token = cp_lexer_peek_token (parser->lexer);
20551 error_at (token->location, "%<>>%> should be %<> >%> "
20552 "within a nested template argument list");
20554 token->type = CPP_GREATER;
20558 /* If this is not a nested template argument list, the '>>'
20559 is a typo for '>'. Emit an error message and continue.
20560 Same deal about the token location, but here we can get it
20561 right by consuming the '>>' before issuing the diagnostic. */
20562 cp_token *token = cp_lexer_consume_token (parser->lexer);
20563 error_at (token->location,
20564 "spurious %<>>%>, use %<>%> to terminate "
20565 "a template argument list");
20569 cp_parser_skip_to_end_of_template_parameter_list (parser);
20570 /* The `>' token might be a greater-than operator again now. */
20571 parser->greater_than_is_operator_p
20572 = saved_greater_than_is_operator_p;
20573 /* Restore the SAVED_SCOPE. */
20574 parser->scope = saved_scope;
20575 parser->qualifying_scope = saved_qualifying_scope;
20576 parser->object_scope = saved_object_scope;
20577 cp_unevaluated_operand = saved_unevaluated_operand;
20578 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
20583 /* MEMBER_FUNCTION is a member function, or a friend. If default
20584 arguments, or the body of the function have not yet been parsed,
20588 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
20590 timevar_push (TV_PARSE_INMETH);
20591 /* If this member is a template, get the underlying
20593 if (DECL_FUNCTION_TEMPLATE_P (member_function))
20594 member_function = DECL_TEMPLATE_RESULT (member_function);
20596 /* There should not be any class definitions in progress at this
20597 point; the bodies of members are only parsed outside of all class
20599 gcc_assert (parser->num_classes_being_defined == 0);
20600 /* While we're parsing the member functions we might encounter more
20601 classes. We want to handle them right away, but we don't want
20602 them getting mixed up with functions that are currently in the
20604 push_unparsed_function_queues (parser);
20606 /* Make sure that any template parameters are in scope. */
20607 maybe_begin_member_template_processing (member_function);
20609 /* If the body of the function has not yet been parsed, parse it
20611 if (DECL_PENDING_INLINE_P (member_function))
20613 tree function_scope;
20614 cp_token_cache *tokens;
20616 /* The function is no longer pending; we are processing it. */
20617 tokens = DECL_PENDING_INLINE_INFO (member_function);
20618 DECL_PENDING_INLINE_INFO (member_function) = NULL;
20619 DECL_PENDING_INLINE_P (member_function) = 0;
20621 /* If this is a local class, enter the scope of the containing
20623 function_scope = current_function_decl;
20624 if (function_scope)
20625 push_function_context ();
20627 /* Push the body of the function onto the lexer stack. */
20628 cp_parser_push_lexer_for_tokens (parser, tokens);
20630 /* Let the front end know that we going to be defining this
20632 start_preparsed_function (member_function, NULL_TREE,
20633 SF_PRE_PARSED | SF_INCLASS_INLINE);
20635 /* Don't do access checking if it is a templated function. */
20636 if (processing_template_decl)
20637 push_deferring_access_checks (dk_no_check);
20639 /* Now, parse the body of the function. */
20640 cp_parser_function_definition_after_declarator (parser,
20641 /*inline_p=*/true);
20643 if (processing_template_decl)
20644 pop_deferring_access_checks ();
20646 /* Leave the scope of the containing function. */
20647 if (function_scope)
20648 pop_function_context ();
20649 cp_parser_pop_lexer (parser);
20652 /* Remove any template parameters from the symbol table. */
20653 maybe_end_member_template_processing ();
20655 /* Restore the queue. */
20656 pop_unparsed_function_queues (parser);
20657 timevar_pop (TV_PARSE_INMETH);
20660 /* If DECL contains any default args, remember it on the unparsed
20661 functions queue. */
20664 cp_parser_save_default_args (cp_parser* parser, tree decl)
20668 for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
20670 probe = TREE_CHAIN (probe))
20671 if (TREE_PURPOSE (probe))
20673 cp_default_arg_entry *entry
20674 = VEC_safe_push (cp_default_arg_entry, gc,
20675 unparsed_funs_with_default_args, NULL);
20676 entry->class_type = current_class_type;
20677 entry->decl = decl;
20682 /* FN is a FUNCTION_DECL which may contains a parameter with an
20683 unparsed DEFAULT_ARG. Parse the default args now. This function
20684 assumes that the current scope is the scope in which the default
20685 argument should be processed. */
20688 cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
20690 bool saved_local_variables_forbidden_p;
20691 tree parm, parmdecl;
20693 /* While we're parsing the default args, we might (due to the
20694 statement expression extension) encounter more classes. We want
20695 to handle them right away, but we don't want them getting mixed
20696 up with default args that are currently in the queue. */
20697 push_unparsed_function_queues (parser);
20699 /* Local variable names (and the `this' keyword) may not appear
20700 in a default argument. */
20701 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
20702 parser->local_variables_forbidden_p = true;
20704 push_defarg_context (fn);
20706 for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn)),
20707 parmdecl = DECL_ARGUMENTS (fn);
20708 parm && parm != void_list_node;
20709 parm = TREE_CHAIN (parm),
20710 parmdecl = DECL_CHAIN (parmdecl))
20712 cp_token_cache *tokens;
20713 tree default_arg = TREE_PURPOSE (parm);
20715 VEC(tree,gc) *insts;
20722 if (TREE_CODE (default_arg) != DEFAULT_ARG)
20723 /* This can happen for a friend declaration for a function
20724 already declared with default arguments. */
20727 /* Push the saved tokens for the default argument onto the parser's
20729 tokens = DEFARG_TOKENS (default_arg);
20730 cp_parser_push_lexer_for_tokens (parser, tokens);
20732 start_lambda_scope (parmdecl);
20734 /* Parse the assignment-expression. */
20735 parsed_arg = cp_parser_assignment_expression (parser, /*cast_p=*/false, NULL);
20736 if (parsed_arg == error_mark_node)
20738 cp_parser_pop_lexer (parser);
20742 if (!processing_template_decl)
20743 parsed_arg = check_default_argument (TREE_VALUE (parm), parsed_arg);
20745 TREE_PURPOSE (parm) = parsed_arg;
20747 /* Update any instantiations we've already created. */
20748 for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0;
20749 VEC_iterate (tree, insts, ix, copy); ix++)
20750 TREE_PURPOSE (copy) = parsed_arg;
20752 finish_lambda_scope ();
20754 /* If the token stream has not been completely used up, then
20755 there was extra junk after the end of the default
20757 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
20758 cp_parser_error (parser, "expected %<,%>");
20760 /* Revert to the main lexer. */
20761 cp_parser_pop_lexer (parser);
20764 pop_defarg_context ();
20766 /* Make sure no default arg is missing. */
20767 check_default_args (fn);
20769 /* Restore the state of local_variables_forbidden_p. */
20770 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
20772 /* Restore the queue. */
20773 pop_unparsed_function_queues (parser);
20776 /* Parse the operand of `sizeof' (or a similar operator). Returns
20777 either a TYPE or an expression, depending on the form of the
20778 input. The KEYWORD indicates which kind of expression we have
20782 cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
20784 tree expr = NULL_TREE;
20785 const char *saved_message;
20787 bool saved_integral_constant_expression_p;
20788 bool saved_non_integral_constant_expression_p;
20789 bool pack_expansion_p = false;
20791 /* Types cannot be defined in a `sizeof' expression. Save away the
20793 saved_message = parser->type_definition_forbidden_message;
20794 /* And create the new one. */
20795 tmp = concat ("types may not be defined in %<",
20796 IDENTIFIER_POINTER (ridpointers[keyword]),
20797 "%> expressions", NULL);
20798 parser->type_definition_forbidden_message = tmp;
20800 /* The restrictions on constant-expressions do not apply inside
20801 sizeof expressions. */
20802 saved_integral_constant_expression_p
20803 = parser->integral_constant_expression_p;
20804 saved_non_integral_constant_expression_p
20805 = parser->non_integral_constant_expression_p;
20806 parser->integral_constant_expression_p = false;
20808 /* If it's a `...', then we are computing the length of a parameter
20810 if (keyword == RID_SIZEOF
20811 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
20813 /* Consume the `...'. */
20814 cp_lexer_consume_token (parser->lexer);
20815 maybe_warn_variadic_templates ();
20817 /* Note that this is an expansion. */
20818 pack_expansion_p = true;
20821 /* Do not actually evaluate the expression. */
20822 ++cp_unevaluated_operand;
20823 ++c_inhibit_evaluation_warnings;
20824 /* If it's a `(', then we might be looking at the type-id
20826 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
20829 bool saved_in_type_id_in_expr_p;
20831 /* We can't be sure yet whether we're looking at a type-id or an
20833 cp_parser_parse_tentatively (parser);
20834 /* Consume the `('. */
20835 cp_lexer_consume_token (parser->lexer);
20836 /* Parse the type-id. */
20837 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
20838 parser->in_type_id_in_expr_p = true;
20839 type = cp_parser_type_id (parser);
20840 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
20841 /* Now, look for the trailing `)'. */
20842 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
20843 /* If all went well, then we're done. */
20844 if (cp_parser_parse_definitely (parser))
20846 cp_decl_specifier_seq decl_specs;
20848 /* Build a trivial decl-specifier-seq. */
20849 clear_decl_specs (&decl_specs);
20850 decl_specs.type = type;
20852 /* Call grokdeclarator to figure out what type this is. */
20853 expr = grokdeclarator (NULL,
20857 /*attrlist=*/NULL);
20861 /* If the type-id production did not work out, then we must be
20862 looking at the unary-expression production. */
20864 expr = cp_parser_unary_expression (parser, /*address_p=*/false,
20865 /*cast_p=*/false, NULL);
20867 if (pack_expansion_p)
20868 /* Build a pack expansion. */
20869 expr = make_pack_expansion (expr);
20871 /* Go back to evaluating expressions. */
20872 --cp_unevaluated_operand;
20873 --c_inhibit_evaluation_warnings;
20875 /* Free the message we created. */
20877 /* And restore the old one. */
20878 parser->type_definition_forbidden_message = saved_message;
20879 parser->integral_constant_expression_p
20880 = saved_integral_constant_expression_p;
20881 parser->non_integral_constant_expression_p
20882 = saved_non_integral_constant_expression_p;
20887 /* If the current declaration has no declarator, return true. */
20890 cp_parser_declares_only_class_p (cp_parser *parser)
20892 /* If the next token is a `;' or a `,' then there is no
20894 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
20895 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
20898 /* Update the DECL_SPECS to reflect the storage class indicated by
20902 cp_parser_set_storage_class (cp_parser *parser,
20903 cp_decl_specifier_seq *decl_specs,
20905 location_t location)
20907 cp_storage_class storage_class;
20909 if (parser->in_unbraced_linkage_specification_p)
20911 error_at (location, "invalid use of %qD in linkage specification",
20912 ridpointers[keyword]);
20915 else if (decl_specs->storage_class != sc_none)
20917 decl_specs->conflicting_specifiers_p = true;
20921 if ((keyword == RID_EXTERN || keyword == RID_STATIC)
20922 && decl_specs->specs[(int) ds_thread])
20924 error_at (location, "%<__thread%> before %qD", ridpointers[keyword]);
20925 decl_specs->specs[(int) ds_thread] = 0;
20931 storage_class = sc_auto;
20934 storage_class = sc_register;
20937 storage_class = sc_static;
20940 storage_class = sc_extern;
20943 storage_class = sc_mutable;
20946 gcc_unreachable ();
20948 decl_specs->storage_class = storage_class;
20950 /* A storage class specifier cannot be applied alongside a typedef
20951 specifier. If there is a typedef specifier present then set
20952 conflicting_specifiers_p which will trigger an error later
20953 on in grokdeclarator. */
20954 if (decl_specs->specs[(int)ds_typedef])
20955 decl_specs->conflicting_specifiers_p = true;
20958 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P
20959 is true, the type is a user-defined type; otherwise it is a
20960 built-in type specified by a keyword. */
20963 cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
20965 location_t location,
20966 bool user_defined_p)
20968 decl_specs->any_specifiers_p = true;
20970 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
20971 (with, for example, in "typedef int wchar_t;") we remember that
20972 this is what happened. In system headers, we ignore these
20973 declarations so that G++ can work with system headers that are not
20975 if (decl_specs->specs[(int) ds_typedef]
20977 && (type_spec == boolean_type_node
20978 || type_spec == char16_type_node
20979 || type_spec == char32_type_node
20980 || type_spec == wchar_type_node)
20981 && (decl_specs->type
20982 || decl_specs->specs[(int) ds_long]
20983 || decl_specs->specs[(int) ds_short]
20984 || decl_specs->specs[(int) ds_unsigned]
20985 || decl_specs->specs[(int) ds_signed]))
20987 decl_specs->redefined_builtin_type = type_spec;
20988 if (!decl_specs->type)
20990 decl_specs->type = type_spec;
20991 decl_specs->user_defined_type_p = false;
20992 decl_specs->type_location = location;
20995 else if (decl_specs->type)
20996 decl_specs->multiple_types_p = true;
20999 decl_specs->type = type_spec;
21000 decl_specs->user_defined_type_p = user_defined_p;
21001 decl_specs->redefined_builtin_type = NULL_TREE;
21002 decl_specs->type_location = location;
21006 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
21007 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
21010 cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
21012 return decl_specifiers->specs[(int) ds_friend] != 0;
21015 /* Issue an error message indicating that TOKEN_DESC was expected.
21016 If KEYWORD is true, it indicated this function is called by
21017 cp_parser_require_keword and the required token can only be
21018 a indicated keyword. */
21021 cp_parser_required_error (cp_parser *parser,
21022 required_token token_desc,
21025 switch (token_desc)
21028 cp_parser_error (parser, "expected %<new%>");
21031 cp_parser_error (parser, "expected %<delete%>");
21034 cp_parser_error (parser, "expected %<return%>");
21037 cp_parser_error (parser, "expected %<while%>");
21040 cp_parser_error (parser, "expected %<extern%>");
21042 case RT_STATIC_ASSERT:
21043 cp_parser_error (parser, "expected %<static_assert%>");
21046 cp_parser_error (parser, "expected %<decltype%>");
21049 cp_parser_error (parser, "expected %<operator%>");
21052 cp_parser_error (parser, "expected %<class%>");
21055 cp_parser_error (parser, "expected %<template%>");
21058 cp_parser_error (parser, "expected %<namespace%>");
21061 cp_parser_error (parser, "expected %<using%>");
21064 cp_parser_error (parser, "expected %<asm%>");
21067 cp_parser_error (parser, "expected %<try%>");
21070 cp_parser_error (parser, "expected %<catch%>");
21073 cp_parser_error (parser, "expected %<throw%>");
21076 cp_parser_error (parser, "expected %<__label__%>");
21079 cp_parser_error (parser, "expected %<@try%>");
21081 case RT_AT_SYNCHRONIZED:
21082 cp_parser_error (parser, "expected %<@synchronized%>");
21085 cp_parser_error (parser, "expected %<@throw%>");
21092 switch (token_desc)
21095 cp_parser_error (parser, "expected %<;%>");
21097 case RT_OPEN_PAREN:
21098 cp_parser_error (parser, "expected %<(%>");
21100 case RT_CLOSE_BRACE:
21101 cp_parser_error (parser, "expected %<}%>");
21103 case RT_OPEN_BRACE:
21104 cp_parser_error (parser, "expected %<{%>");
21106 case RT_CLOSE_SQUARE:
21107 cp_parser_error (parser, "expected %<]%>");
21109 case RT_OPEN_SQUARE:
21110 cp_parser_error (parser, "expected %<[%>");
21113 cp_parser_error (parser, "expected %<,%>");
21116 cp_parser_error (parser, "expected %<::%>");
21119 cp_parser_error (parser, "expected %<<%>");
21122 cp_parser_error (parser, "expected %<>%>");
21125 cp_parser_error (parser, "expected %<=%>");
21128 cp_parser_error (parser, "expected %<...%>");
21131 cp_parser_error (parser, "expected %<*%>");
21134 cp_parser_error (parser, "expected %<~%>");
21137 cp_parser_error (parser, "expected %<:%>");
21139 case RT_COLON_SCOPE:
21140 cp_parser_error (parser, "expected %<:%> or %<::%>");
21142 case RT_CLOSE_PAREN:
21143 cp_parser_error (parser, "expected %<)%>");
21145 case RT_COMMA_CLOSE_PAREN:
21146 cp_parser_error (parser, "expected %<,%> or %<)%>");
21148 case RT_PRAGMA_EOL:
21149 cp_parser_error (parser, "expected end of line");
21152 cp_parser_error (parser, "expected identifier");
21155 cp_parser_error (parser, "expected selection-statement");
21157 case RT_INTERATION:
21158 cp_parser_error (parser, "expected iteration-statement");
21161 cp_parser_error (parser, "expected jump-statement");
21164 cp_parser_error (parser, "expected class-key");
21166 case RT_CLASS_TYPENAME_TEMPLATE:
21167 cp_parser_error (parser,
21168 "expected %<class%>, %<typename%>, or %<template%>");
21171 gcc_unreachable ();
21175 gcc_unreachable ();
21180 /* If the next token is of the indicated TYPE, consume it. Otherwise,
21181 issue an error message indicating that TOKEN_DESC was expected.
21183 Returns the token consumed, if the token had the appropriate type.
21184 Otherwise, returns NULL. */
21187 cp_parser_require (cp_parser* parser,
21188 enum cpp_ttype type,
21189 required_token token_desc)
21191 if (cp_lexer_next_token_is (parser->lexer, type))
21192 return cp_lexer_consume_token (parser->lexer);
21195 /* Output the MESSAGE -- unless we're parsing tentatively. */
21196 if (!cp_parser_simulate_error (parser))
21197 cp_parser_required_error (parser, token_desc, /*keyword=*/false);
21202 /* An error message is produced if the next token is not '>'.
21203 All further tokens are skipped until the desired token is
21204 found or '{', '}', ';' or an unbalanced ')' or ']'. */
21207 cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
21209 /* Current level of '< ... >'. */
21210 unsigned level = 0;
21211 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
21212 unsigned nesting_depth = 0;
21214 /* Are we ready, yet? If not, issue error message. */
21215 if (cp_parser_require (parser, CPP_GREATER, RT_GREATER))
21218 /* Skip tokens until the desired token is found. */
21221 /* Peek at the next token. */
21222 switch (cp_lexer_peek_token (parser->lexer)->type)
21225 if (!nesting_depth)
21230 if (cxx_dialect == cxx98)
21231 /* C++0x views the `>>' operator as two `>' tokens, but
21234 else if (!nesting_depth && level-- == 0)
21236 /* We've hit a `>>' where the first `>' closes the
21237 template argument list, and the second `>' is
21238 spurious. Just consume the `>>' and stop; we've
21239 already produced at least one error. */
21240 cp_lexer_consume_token (parser->lexer);
21243 /* Fall through for C++0x, so we handle the second `>' in
21247 if (!nesting_depth && level-- == 0)
21249 /* We've reached the token we want, consume it and stop. */
21250 cp_lexer_consume_token (parser->lexer);
21255 case CPP_OPEN_PAREN:
21256 case CPP_OPEN_SQUARE:
21260 case CPP_CLOSE_PAREN:
21261 case CPP_CLOSE_SQUARE:
21262 if (nesting_depth-- == 0)
21267 case CPP_PRAGMA_EOL:
21268 case CPP_SEMICOLON:
21269 case CPP_OPEN_BRACE:
21270 case CPP_CLOSE_BRACE:
21271 /* The '>' was probably forgotten, don't look further. */
21278 /* Consume this token. */
21279 cp_lexer_consume_token (parser->lexer);
21283 /* If the next token is the indicated keyword, consume it. Otherwise,
21284 issue an error message indicating that TOKEN_DESC was expected.
21286 Returns the token consumed, if the token had the appropriate type.
21287 Otherwise, returns NULL. */
21290 cp_parser_require_keyword (cp_parser* parser,
21292 required_token token_desc)
21294 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
21296 if (token && token->keyword != keyword)
21298 cp_parser_required_error (parser, token_desc, /*keyword=*/true);
21305 /* Returns TRUE iff TOKEN is a token that can begin the body of a
21306 function-definition. */
21309 cp_parser_token_starts_function_definition_p (cp_token* token)
21311 return (/* An ordinary function-body begins with an `{'. */
21312 token->type == CPP_OPEN_BRACE
21313 /* A ctor-initializer begins with a `:'. */
21314 || token->type == CPP_COLON
21315 /* A function-try-block begins with `try'. */
21316 || token->keyword == RID_TRY
21317 /* The named return value extension begins with `return'. */
21318 || token->keyword == RID_RETURN);
21321 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
21325 cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
21329 token = cp_lexer_peek_token (parser->lexer);
21330 return (token->type == CPP_OPEN_BRACE || token->type == CPP_COLON);
21333 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
21334 C++0x) ending a template-argument. */
21337 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
21341 token = cp_lexer_peek_token (parser->lexer);
21342 return (token->type == CPP_COMMA
21343 || token->type == CPP_GREATER
21344 || token->type == CPP_ELLIPSIS
21345 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT));
21348 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
21349 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
21352 cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
21357 token = cp_lexer_peek_nth_token (parser->lexer, n);
21358 if (token->type == CPP_LESS)
21360 /* Check for the sequence `<::' in the original code. It would be lexed as
21361 `[:', where `[' is a digraph, and there is no whitespace before
21363 if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
21366 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
21367 if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
21373 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
21374 or none_type otherwise. */
21376 static enum tag_types
21377 cp_parser_token_is_class_key (cp_token* token)
21379 switch (token->keyword)
21384 return record_type;
21393 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
21396 cp_parser_check_class_key (enum tag_types class_key, tree type)
21398 if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
21399 permerror (input_location, "%qs tag used in naming %q#T",
21400 class_key == union_type ? "union"
21401 : class_key == record_type ? "struct" : "class",
21405 /* Issue an error message if DECL is redeclared with different
21406 access than its original declaration [class.access.spec/3].
21407 This applies to nested classes and nested class templates.
21411 cp_parser_check_access_in_redeclaration (tree decl, location_t location)
21413 if (!decl || !CLASS_TYPE_P (TREE_TYPE (decl)))
21416 if ((TREE_PRIVATE (decl)
21417 != (current_access_specifier == access_private_node))
21418 || (TREE_PROTECTED (decl)
21419 != (current_access_specifier == access_protected_node)))
21420 error_at (location, "%qD redeclared with different access", decl);
21423 /* Look for the `template' keyword, as a syntactic disambiguator.
21424 Return TRUE iff it is present, in which case it will be
21428 cp_parser_optional_template_keyword (cp_parser *parser)
21430 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
21432 /* The `template' keyword can only be used within templates;
21433 outside templates the parser can always figure out what is a
21434 template and what is not. */
21435 if (!processing_template_decl)
21437 cp_token *token = cp_lexer_peek_token (parser->lexer);
21438 error_at (token->location,
21439 "%<template%> (as a disambiguator) is only allowed "
21440 "within templates");
21441 /* If this part of the token stream is rescanned, the same
21442 error message would be generated. So, we purge the token
21443 from the stream. */
21444 cp_lexer_purge_token (parser->lexer);
21449 /* Consume the `template' keyword. */
21450 cp_lexer_consume_token (parser->lexer);
21458 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
21459 set PARSER->SCOPE, and perform other related actions. */
21462 cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
21465 struct tree_check *check_value;
21466 deferred_access_check *chk;
21467 VEC (deferred_access_check,gc) *checks;
21469 /* Get the stored value. */
21470 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
21471 /* Perform any access checks that were deferred. */
21472 checks = check_value->checks;
21475 FOR_EACH_VEC_ELT (deferred_access_check, checks, i, chk)
21476 perform_or_defer_access_check (chk->binfo,
21480 /* Set the scope from the stored value. */
21481 parser->scope = check_value->value;
21482 parser->qualifying_scope = check_value->qualifying_scope;
21483 parser->object_scope = NULL_TREE;
21486 /* Consume tokens up through a non-nested END token. Returns TRUE if we
21487 encounter the end of a block before what we were looking for. */
21490 cp_parser_cache_group (cp_parser *parser,
21491 enum cpp_ttype end,
21496 cp_token *token = cp_lexer_peek_token (parser->lexer);
21498 /* Abort a parenthesized expression if we encounter a semicolon. */
21499 if ((end == CPP_CLOSE_PAREN || depth == 0)
21500 && token->type == CPP_SEMICOLON)
21502 /* If we've reached the end of the file, stop. */
21503 if (token->type == CPP_EOF
21504 || (end != CPP_PRAGMA_EOL
21505 && token->type == CPP_PRAGMA_EOL))
21507 if (token->type == CPP_CLOSE_BRACE && depth == 0)
21508 /* We've hit the end of an enclosing block, so there's been some
21509 kind of syntax error. */
21512 /* Consume the token. */
21513 cp_lexer_consume_token (parser->lexer);
21514 /* See if it starts a new group. */
21515 if (token->type == CPP_OPEN_BRACE)
21517 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
21518 /* In theory this should probably check end == '}', but
21519 cp_parser_save_member_function_body needs it to exit
21520 after either '}' or ')' when called with ')'. */
21524 else if (token->type == CPP_OPEN_PAREN)
21526 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
21527 if (depth == 0 && end == CPP_CLOSE_PAREN)
21530 else if (token->type == CPP_PRAGMA)
21531 cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
21532 else if (token->type == end)
21537 /* Begin parsing tentatively. We always save tokens while parsing
21538 tentatively so that if the tentative parsing fails we can restore the
21542 cp_parser_parse_tentatively (cp_parser* parser)
21544 /* Enter a new parsing context. */
21545 parser->context = cp_parser_context_new (parser->context);
21546 /* Begin saving tokens. */
21547 cp_lexer_save_tokens (parser->lexer);
21548 /* In order to avoid repetitive access control error messages,
21549 access checks are queued up until we are no longer parsing
21551 push_deferring_access_checks (dk_deferred);
21554 /* Commit to the currently active tentative parse. */
21557 cp_parser_commit_to_tentative_parse (cp_parser* parser)
21559 cp_parser_context *context;
21562 /* Mark all of the levels as committed. */
21563 lexer = parser->lexer;
21564 for (context = parser->context; context->next; context = context->next)
21566 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
21568 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
21569 while (!cp_lexer_saving_tokens (lexer))
21570 lexer = lexer->next;
21571 cp_lexer_commit_tokens (lexer);
21575 /* Abort the currently active tentative parse. All consumed tokens
21576 will be rolled back, and no diagnostics will be issued. */
21579 cp_parser_abort_tentative_parse (cp_parser* parser)
21581 gcc_assert (parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED
21582 || errorcount > 0);
21583 cp_parser_simulate_error (parser);
21584 /* Now, pretend that we want to see if the construct was
21585 successfully parsed. */
21586 cp_parser_parse_definitely (parser);
21589 /* Stop parsing tentatively. If a parse error has occurred, restore the
21590 token stream. Otherwise, commit to the tokens we have consumed.
21591 Returns true if no error occurred; false otherwise. */
21594 cp_parser_parse_definitely (cp_parser* parser)
21596 bool error_occurred;
21597 cp_parser_context *context;
21599 /* Remember whether or not an error occurred, since we are about to
21600 destroy that information. */
21601 error_occurred = cp_parser_error_occurred (parser);
21602 /* Remove the topmost context from the stack. */
21603 context = parser->context;
21604 parser->context = context->next;
21605 /* If no parse errors occurred, commit to the tentative parse. */
21606 if (!error_occurred)
21608 /* Commit to the tokens read tentatively, unless that was
21610 if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
21611 cp_lexer_commit_tokens (parser->lexer);
21613 pop_to_parent_deferring_access_checks ();
21615 /* Otherwise, if errors occurred, roll back our state so that things
21616 are just as they were before we began the tentative parse. */
21619 cp_lexer_rollback_tokens (parser->lexer);
21620 pop_deferring_access_checks ();
21622 /* Add the context to the front of the free list. */
21623 context->next = cp_parser_context_free_list;
21624 cp_parser_context_free_list = context;
21626 return !error_occurred;
21629 /* Returns true if we are parsing tentatively and are not committed to
21630 this tentative parse. */
21633 cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
21635 return (cp_parser_parsing_tentatively (parser)
21636 && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
21639 /* Returns nonzero iff an error has occurred during the most recent
21640 tentative parse. */
21643 cp_parser_error_occurred (cp_parser* parser)
21645 return (cp_parser_parsing_tentatively (parser)
21646 && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
21649 /* Returns nonzero if GNU extensions are allowed. */
21652 cp_parser_allow_gnu_extensions_p (cp_parser* parser)
21654 return parser->allow_gnu_extensions_p;
21657 /* Objective-C++ Productions */
21660 /* Parse an Objective-C expression, which feeds into a primary-expression
21664 objc-message-expression
21665 objc-string-literal
21666 objc-encode-expression
21667 objc-protocol-expression
21668 objc-selector-expression
21670 Returns a tree representation of the expression. */
21673 cp_parser_objc_expression (cp_parser* parser)
21675 /* Try to figure out what kind of declaration is present. */
21676 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
21680 case CPP_OPEN_SQUARE:
21681 return cp_parser_objc_message_expression (parser);
21683 case CPP_OBJC_STRING:
21684 kwd = cp_lexer_consume_token (parser->lexer);
21685 return objc_build_string_object (kwd->u.value);
21688 switch (kwd->keyword)
21690 case RID_AT_ENCODE:
21691 return cp_parser_objc_encode_expression (parser);
21693 case RID_AT_PROTOCOL:
21694 return cp_parser_objc_protocol_expression (parser);
21696 case RID_AT_SELECTOR:
21697 return cp_parser_objc_selector_expression (parser);
21703 error_at (kwd->location,
21704 "misplaced %<@%D%> Objective-C++ construct",
21706 cp_parser_skip_to_end_of_block_or_statement (parser);
21709 return error_mark_node;
21712 /* Parse an Objective-C message expression.
21714 objc-message-expression:
21715 [ objc-message-receiver objc-message-args ]
21717 Returns a representation of an Objective-C message. */
21720 cp_parser_objc_message_expression (cp_parser* parser)
21722 tree receiver, messageargs;
21724 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
21725 receiver = cp_parser_objc_message_receiver (parser);
21726 messageargs = cp_parser_objc_message_args (parser);
21727 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
21729 return objc_build_message_expr (receiver, messageargs);
21732 /* Parse an objc-message-receiver.
21734 objc-message-receiver:
21736 simple-type-specifier
21738 Returns a representation of the type or expression. */
21741 cp_parser_objc_message_receiver (cp_parser* parser)
21745 /* An Objective-C message receiver may be either (1) a type
21746 or (2) an expression. */
21747 cp_parser_parse_tentatively (parser);
21748 rcv = cp_parser_expression (parser, false, NULL);
21750 if (cp_parser_parse_definitely (parser))
21753 rcv = cp_parser_simple_type_specifier (parser,
21754 /*decl_specs=*/NULL,
21755 CP_PARSER_FLAGS_NONE);
21757 return objc_get_class_reference (rcv);
21760 /* Parse the arguments and selectors comprising an Objective-C message.
21765 objc-selector-args , objc-comma-args
21767 objc-selector-args:
21768 objc-selector [opt] : assignment-expression
21769 objc-selector-args objc-selector [opt] : assignment-expression
21772 assignment-expression
21773 objc-comma-args , assignment-expression
21775 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
21776 selector arguments and TREE_VALUE containing a list of comma
21780 cp_parser_objc_message_args (cp_parser* parser)
21782 tree sel_args = NULL_TREE, addl_args = NULL_TREE;
21783 bool maybe_unary_selector_p = true;
21784 cp_token *token = cp_lexer_peek_token (parser->lexer);
21786 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
21788 tree selector = NULL_TREE, arg;
21790 if (token->type != CPP_COLON)
21791 selector = cp_parser_objc_selector (parser);
21793 /* Detect if we have a unary selector. */
21794 if (maybe_unary_selector_p
21795 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
21796 return build_tree_list (selector, NULL_TREE);
21798 maybe_unary_selector_p = false;
21799 cp_parser_require (parser, CPP_COLON, RT_COLON);
21800 arg = cp_parser_assignment_expression (parser, false, NULL);
21803 = chainon (sel_args,
21804 build_tree_list (selector, arg));
21806 token = cp_lexer_peek_token (parser->lexer);
21809 /* Handle non-selector arguments, if any. */
21810 while (token->type == CPP_COMMA)
21814 cp_lexer_consume_token (parser->lexer);
21815 arg = cp_parser_assignment_expression (parser, false, NULL);
21818 = chainon (addl_args,
21819 build_tree_list (NULL_TREE, arg));
21821 token = cp_lexer_peek_token (parser->lexer);
21824 if (sel_args == NULL_TREE && addl_args == NULL_TREE)
21826 cp_parser_error (parser, "objective-c++ message argument(s) are expected");
21827 return build_tree_list (error_mark_node, error_mark_node);
21830 return build_tree_list (sel_args, addl_args);
21833 /* Parse an Objective-C encode expression.
21835 objc-encode-expression:
21836 @encode objc-typename
21838 Returns an encoded representation of the type argument. */
21841 cp_parser_objc_encode_expression (cp_parser* parser)
21846 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
21847 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21848 token = cp_lexer_peek_token (parser->lexer);
21849 type = complete_type (cp_parser_type_id (parser));
21850 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21854 error_at (token->location,
21855 "%<@encode%> must specify a type as an argument");
21856 return error_mark_node;
21859 /* This happens if we find @encode(T) (where T is a template
21860 typename or something dependent on a template typename) when
21861 parsing a template. In that case, we can't compile it
21862 immediately, but we rather create an AT_ENCODE_EXPR which will
21863 need to be instantiated when the template is used.
21865 if (dependent_type_p (type))
21867 tree value = build_min (AT_ENCODE_EXPR, size_type_node, type);
21868 TREE_READONLY (value) = 1;
21872 return objc_build_encode_expr (type);
21875 /* Parse an Objective-C @defs expression. */
21878 cp_parser_objc_defs_expression (cp_parser *parser)
21882 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
21883 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21884 name = cp_parser_identifier (parser);
21885 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21887 return objc_get_class_ivars (name);
21890 /* Parse an Objective-C protocol expression.
21892 objc-protocol-expression:
21893 @protocol ( identifier )
21895 Returns a representation of the protocol expression. */
21898 cp_parser_objc_protocol_expression (cp_parser* parser)
21902 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
21903 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21904 proto = cp_parser_identifier (parser);
21905 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21907 return objc_build_protocol_expr (proto);
21910 /* Parse an Objective-C selector expression.
21912 objc-selector-expression:
21913 @selector ( objc-method-signature )
21915 objc-method-signature:
21921 objc-selector-seq objc-selector :
21923 Returns a representation of the method selector. */
21926 cp_parser_objc_selector_expression (cp_parser* parser)
21928 tree sel_seq = NULL_TREE;
21929 bool maybe_unary_selector_p = true;
21931 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
21933 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
21934 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21935 token = cp_lexer_peek_token (parser->lexer);
21937 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON
21938 || token->type == CPP_SCOPE)
21940 tree selector = NULL_TREE;
21942 if (token->type != CPP_COLON
21943 || token->type == CPP_SCOPE)
21944 selector = cp_parser_objc_selector (parser);
21946 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
21947 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
21949 /* Detect if we have a unary selector. */
21950 if (maybe_unary_selector_p)
21952 sel_seq = selector;
21953 goto finish_selector;
21957 cp_parser_error (parser, "expected %<:%>");
21960 maybe_unary_selector_p = false;
21961 token = cp_lexer_consume_token (parser->lexer);
21963 if (token->type == CPP_SCOPE)
21966 = chainon (sel_seq,
21967 build_tree_list (selector, NULL_TREE));
21969 = chainon (sel_seq,
21970 build_tree_list (NULL_TREE, NULL_TREE));
21974 = chainon (sel_seq,
21975 build_tree_list (selector, NULL_TREE));
21977 token = cp_lexer_peek_token (parser->lexer);
21981 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21983 return objc_build_selector_expr (loc, sel_seq);
21986 /* Parse a list of identifiers.
21988 objc-identifier-list:
21990 objc-identifier-list , identifier
21992 Returns a TREE_LIST of identifier nodes. */
21995 cp_parser_objc_identifier_list (cp_parser* parser)
22001 identifier = cp_parser_identifier (parser);
22002 if (identifier == error_mark_node)
22003 return error_mark_node;
22005 list = build_tree_list (NULL_TREE, identifier);
22006 sep = cp_lexer_peek_token (parser->lexer);
22008 while (sep->type == CPP_COMMA)
22010 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
22011 identifier = cp_parser_identifier (parser);
22012 if (identifier == error_mark_node)
22015 list = chainon (list, build_tree_list (NULL_TREE,
22017 sep = cp_lexer_peek_token (parser->lexer);
22023 /* Parse an Objective-C alias declaration.
22025 objc-alias-declaration:
22026 @compatibility_alias identifier identifier ;
22028 This function registers the alias mapping with the Objective-C front end.
22029 It returns nothing. */
22032 cp_parser_objc_alias_declaration (cp_parser* parser)
22036 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
22037 alias = cp_parser_identifier (parser);
22038 orig = cp_parser_identifier (parser);
22039 objc_declare_alias (alias, orig);
22040 cp_parser_consume_semicolon_at_end_of_statement (parser);
22043 /* Parse an Objective-C class forward-declaration.
22045 objc-class-declaration:
22046 @class objc-identifier-list ;
22048 The function registers the forward declarations with the Objective-C
22049 front end. It returns nothing. */
22052 cp_parser_objc_class_declaration (cp_parser* parser)
22054 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
22059 id = cp_parser_identifier (parser);
22060 if (id == error_mark_node)
22063 objc_declare_class (id);
22065 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
22066 cp_lexer_consume_token (parser->lexer);
22070 cp_parser_consume_semicolon_at_end_of_statement (parser);
22073 /* Parse a list of Objective-C protocol references.
22075 objc-protocol-refs-opt:
22076 objc-protocol-refs [opt]
22078 objc-protocol-refs:
22079 < objc-identifier-list >
22081 Returns a TREE_LIST of identifiers, if any. */
22084 cp_parser_objc_protocol_refs_opt (cp_parser* parser)
22086 tree protorefs = NULL_TREE;
22088 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
22090 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
22091 protorefs = cp_parser_objc_identifier_list (parser);
22092 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
22098 /* Parse a Objective-C visibility specification. */
22101 cp_parser_objc_visibility_spec (cp_parser* parser)
22103 cp_token *vis = cp_lexer_peek_token (parser->lexer);
22105 switch (vis->keyword)
22107 case RID_AT_PRIVATE:
22108 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE);
22110 case RID_AT_PROTECTED:
22111 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED);
22113 case RID_AT_PUBLIC:
22114 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC);
22116 case RID_AT_PACKAGE:
22117 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE);
22123 /* Eat '@private'/'@protected'/'@public'. */
22124 cp_lexer_consume_token (parser->lexer);
22127 /* Parse an Objective-C method type. Return 'true' if it is a class
22128 (+) method, and 'false' if it is an instance (-) method. */
22131 cp_parser_objc_method_type (cp_parser* parser)
22133 if (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS)
22139 /* Parse an Objective-C protocol qualifier. */
22142 cp_parser_objc_protocol_qualifiers (cp_parser* parser)
22144 tree quals = NULL_TREE, node;
22145 cp_token *token = cp_lexer_peek_token (parser->lexer);
22147 node = token->u.value;
22149 while (node && TREE_CODE (node) == IDENTIFIER_NODE
22150 && (node == ridpointers [(int) RID_IN]
22151 || node == ridpointers [(int) RID_OUT]
22152 || node == ridpointers [(int) RID_INOUT]
22153 || node == ridpointers [(int) RID_BYCOPY]
22154 || node == ridpointers [(int) RID_BYREF]
22155 || node == ridpointers [(int) RID_ONEWAY]))
22157 quals = tree_cons (NULL_TREE, node, quals);
22158 cp_lexer_consume_token (parser->lexer);
22159 token = cp_lexer_peek_token (parser->lexer);
22160 node = token->u.value;
22166 /* Parse an Objective-C typename. */
22169 cp_parser_objc_typename (cp_parser* parser)
22171 tree type_name = NULL_TREE;
22173 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
22175 tree proto_quals, cp_type = NULL_TREE;
22177 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
22178 proto_quals = cp_parser_objc_protocol_qualifiers (parser);
22180 /* An ObjC type name may consist of just protocol qualifiers, in which
22181 case the type shall default to 'id'. */
22182 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
22184 cp_type = cp_parser_type_id (parser);
22186 /* If the type could not be parsed, an error has already
22187 been produced. For error recovery, behave as if it had
22188 not been specified, which will use the default type
22190 if (cp_type == error_mark_node)
22192 cp_type = NULL_TREE;
22193 /* We need to skip to the closing parenthesis as
22194 cp_parser_type_id() does not seem to do it for
22196 cp_parser_skip_to_closing_parenthesis (parser,
22197 /*recovering=*/true,
22198 /*or_comma=*/false,
22199 /*consume_paren=*/false);
22203 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
22204 type_name = build_tree_list (proto_quals, cp_type);
22210 /* Check to see if TYPE refers to an Objective-C selector name. */
22213 cp_parser_objc_selector_p (enum cpp_ttype type)
22215 return (type == CPP_NAME || type == CPP_KEYWORD
22216 || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND
22217 || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT
22218 || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ
22219 || type == CPP_XOR || type == CPP_XOR_EQ);
22222 /* Parse an Objective-C selector. */
22225 cp_parser_objc_selector (cp_parser* parser)
22227 cp_token *token = cp_lexer_consume_token (parser->lexer);
22229 if (!cp_parser_objc_selector_p (token->type))
22231 error_at (token->location, "invalid Objective-C++ selector name");
22232 return error_mark_node;
22235 /* C++ operator names are allowed to appear in ObjC selectors. */
22236 switch (token->type)
22238 case CPP_AND_AND: return get_identifier ("and");
22239 case CPP_AND_EQ: return get_identifier ("and_eq");
22240 case CPP_AND: return get_identifier ("bitand");
22241 case CPP_OR: return get_identifier ("bitor");
22242 case CPP_COMPL: return get_identifier ("compl");
22243 case CPP_NOT: return get_identifier ("not");
22244 case CPP_NOT_EQ: return get_identifier ("not_eq");
22245 case CPP_OR_OR: return get_identifier ("or");
22246 case CPP_OR_EQ: return get_identifier ("or_eq");
22247 case CPP_XOR: return get_identifier ("xor");
22248 case CPP_XOR_EQ: return get_identifier ("xor_eq");
22249 default: return token->u.value;
22253 /* Parse an Objective-C params list. */
22256 cp_parser_objc_method_keyword_params (cp_parser* parser, tree* attributes)
22258 tree params = NULL_TREE;
22259 bool maybe_unary_selector_p = true;
22260 cp_token *token = cp_lexer_peek_token (parser->lexer);
22262 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
22264 tree selector = NULL_TREE, type_name, identifier;
22265 tree parm_attr = NULL_TREE;
22267 if (token->keyword == RID_ATTRIBUTE)
22270 if (token->type != CPP_COLON)
22271 selector = cp_parser_objc_selector (parser);
22273 /* Detect if we have a unary selector. */
22274 if (maybe_unary_selector_p
22275 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
22277 params = selector; /* Might be followed by attributes. */
22281 maybe_unary_selector_p = false;
22282 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
22284 /* Something went quite wrong. There should be a colon
22285 here, but there is not. Stop parsing parameters. */
22288 type_name = cp_parser_objc_typename (parser);
22289 /* New ObjC allows attributes on parameters too. */
22290 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
22291 parm_attr = cp_parser_attributes_opt (parser);
22292 identifier = cp_parser_identifier (parser);
22296 objc_build_keyword_decl (selector,
22301 token = cp_lexer_peek_token (parser->lexer);
22304 if (params == NULL_TREE)
22306 cp_parser_error (parser, "objective-c++ method declaration is expected");
22307 return error_mark_node;
22310 /* We allow tail attributes for the method. */
22311 if (token->keyword == RID_ATTRIBUTE)
22313 *attributes = cp_parser_attributes_opt (parser);
22314 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
22315 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22317 cp_parser_error (parser,
22318 "method attributes must be specified at the end");
22319 return error_mark_node;
22322 if (params == NULL_TREE)
22324 cp_parser_error (parser, "objective-c++ method declaration is expected");
22325 return error_mark_node;
22330 /* Parse the non-keyword Objective-C params. */
22333 cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp,
22336 tree params = make_node (TREE_LIST);
22337 cp_token *token = cp_lexer_peek_token (parser->lexer);
22338 *ellipsisp = false; /* Initially, assume no ellipsis. */
22340 while (token->type == CPP_COMMA)
22342 cp_parameter_declarator *parmdecl;
22345 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
22346 token = cp_lexer_peek_token (parser->lexer);
22348 if (token->type == CPP_ELLIPSIS)
22350 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
22352 token = cp_lexer_peek_token (parser->lexer);
22356 /* TODO: parse attributes for tail parameters. */
22357 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
22358 parm = grokdeclarator (parmdecl->declarator,
22359 &parmdecl->decl_specifiers,
22360 PARM, /*initialized=*/0,
22361 /*attrlist=*/NULL);
22363 chainon (params, build_tree_list (NULL_TREE, parm));
22364 token = cp_lexer_peek_token (parser->lexer);
22367 /* We allow tail attributes for the method. */
22368 if (token->keyword == RID_ATTRIBUTE)
22370 if (*attributes == NULL_TREE)
22372 *attributes = cp_parser_attributes_opt (parser);
22373 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
22374 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22378 /* We have an error, but parse the attributes, so that we can
22380 *attributes = cp_parser_attributes_opt (parser);
22382 cp_parser_error (parser,
22383 "method attributes must be specified at the end");
22384 return error_mark_node;
22390 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
22393 cp_parser_objc_interstitial_code (cp_parser* parser)
22395 cp_token *token = cp_lexer_peek_token (parser->lexer);
22397 /* If the next token is `extern' and the following token is a string
22398 literal, then we have a linkage specification. */
22399 if (token->keyword == RID_EXTERN
22400 && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2)))
22401 cp_parser_linkage_specification (parser);
22402 /* Handle #pragma, if any. */
22403 else if (token->type == CPP_PRAGMA)
22404 cp_parser_pragma (parser, pragma_external);
22405 /* Allow stray semicolons. */
22406 else if (token->type == CPP_SEMICOLON)
22407 cp_lexer_consume_token (parser->lexer);
22408 /* Mark methods as optional or required, when building protocols. */
22409 else if (token->keyword == RID_AT_OPTIONAL)
22411 cp_lexer_consume_token (parser->lexer);
22412 objc_set_method_opt (true);
22414 else if (token->keyword == RID_AT_REQUIRED)
22416 cp_lexer_consume_token (parser->lexer);
22417 objc_set_method_opt (false);
22419 else if (token->keyword == RID_NAMESPACE)
22420 cp_parser_namespace_definition (parser);
22421 /* Other stray characters must generate errors. */
22422 else if (token->type == CPP_OPEN_BRACE || token->type == CPP_CLOSE_BRACE)
22424 cp_lexer_consume_token (parser->lexer);
22425 error ("stray %qs between Objective-C++ methods",
22426 token->type == CPP_OPEN_BRACE ? "{" : "}");
22428 /* Finally, try to parse a block-declaration, or a function-definition. */
22430 cp_parser_block_declaration (parser, /*statement_p=*/false);
22433 /* Parse a method signature. */
22436 cp_parser_objc_method_signature (cp_parser* parser, tree* attributes)
22438 tree rettype, kwdparms, optparms;
22439 bool ellipsis = false;
22440 bool is_class_method;
22442 is_class_method = cp_parser_objc_method_type (parser);
22443 rettype = cp_parser_objc_typename (parser);
22444 *attributes = NULL_TREE;
22445 kwdparms = cp_parser_objc_method_keyword_params (parser, attributes);
22446 if (kwdparms == error_mark_node)
22447 return error_mark_node;
22448 optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis, attributes);
22449 if (optparms == error_mark_node)
22450 return error_mark_node;
22452 return objc_build_method_signature (is_class_method, rettype, kwdparms, optparms, ellipsis);
22456 cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser* parser)
22459 cp_lexer_save_tokens (parser->lexer);
22460 tattr = cp_parser_attributes_opt (parser);
22461 gcc_assert (tattr) ;
22463 /* If the attributes are followed by a method introducer, this is not allowed.
22464 Dump the attributes and flag the situation. */
22465 if (cp_lexer_next_token_is (parser->lexer, CPP_PLUS)
22466 || cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
22469 /* Otherwise, the attributes introduce some interstitial code, possibly so
22470 rewind to allow that check. */
22471 cp_lexer_rollback_tokens (parser->lexer);
22475 /* Parse an Objective-C method prototype list. */
22478 cp_parser_objc_method_prototype_list (cp_parser* parser)
22480 cp_token *token = cp_lexer_peek_token (parser->lexer);
22482 while (token->keyword != RID_AT_END && token->type != CPP_EOF)
22484 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
22486 tree attributes, sig;
22487 bool is_class_method;
22488 if (token->type == CPP_PLUS)
22489 is_class_method = true;
22491 is_class_method = false;
22492 sig = cp_parser_objc_method_signature (parser, &attributes);
22493 if (sig == error_mark_node)
22495 cp_parser_skip_to_end_of_block_or_statement (parser);
22496 token = cp_lexer_peek_token (parser->lexer);
22499 objc_add_method_declaration (is_class_method, sig, attributes);
22500 cp_parser_consume_semicolon_at_end_of_statement (parser);
22502 else if (token->keyword == RID_AT_PROPERTY)
22503 cp_parser_objc_at_property_declaration (parser);
22504 else if (token->keyword == RID_ATTRIBUTE
22505 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
22506 warning_at (cp_lexer_peek_token (parser->lexer)->location,
22508 "prefix attributes are ignored for methods");
22510 /* Allow for interspersed non-ObjC++ code. */
22511 cp_parser_objc_interstitial_code (parser);
22513 token = cp_lexer_peek_token (parser->lexer);
22516 if (token->type != CPP_EOF)
22517 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
22519 cp_parser_error (parser, "expected %<@end%>");
22521 objc_finish_interface ();
22524 /* Parse an Objective-C method definition list. */
22527 cp_parser_objc_method_definition_list (cp_parser* parser)
22529 cp_token *token = cp_lexer_peek_token (parser->lexer);
22531 while (token->keyword != RID_AT_END && token->type != CPP_EOF)
22535 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
22538 tree sig, attribute;
22539 bool is_class_method;
22540 if (token->type == CPP_PLUS)
22541 is_class_method = true;
22543 is_class_method = false;
22544 push_deferring_access_checks (dk_deferred);
22545 sig = cp_parser_objc_method_signature (parser, &attribute);
22546 if (sig == error_mark_node)
22548 cp_parser_skip_to_end_of_block_or_statement (parser);
22549 token = cp_lexer_peek_token (parser->lexer);
22552 objc_start_method_definition (is_class_method, sig, attribute,
22555 /* For historical reasons, we accept an optional semicolon. */
22556 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
22557 cp_lexer_consume_token (parser->lexer);
22559 ptk = cp_lexer_peek_token (parser->lexer);
22560 if (!(ptk->type == CPP_PLUS || ptk->type == CPP_MINUS
22561 || ptk->type == CPP_EOF || ptk->keyword == RID_AT_END))
22563 perform_deferred_access_checks ();
22564 stop_deferring_access_checks ();
22565 meth = cp_parser_function_definition_after_declarator (parser,
22567 pop_deferring_access_checks ();
22568 objc_finish_method_definition (meth);
22571 /* The following case will be removed once @synthesize is
22572 completely implemented. */
22573 else if (token->keyword == RID_AT_PROPERTY)
22574 cp_parser_objc_at_property_declaration (parser);
22575 else if (token->keyword == RID_AT_SYNTHESIZE)
22576 cp_parser_objc_at_synthesize_declaration (parser);
22577 else if (token->keyword == RID_AT_DYNAMIC)
22578 cp_parser_objc_at_dynamic_declaration (parser);
22579 else if (token->keyword == RID_ATTRIBUTE
22580 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
22581 warning_at (token->location, OPT_Wattributes,
22582 "prefix attributes are ignored for methods");
22584 /* Allow for interspersed non-ObjC++ code. */
22585 cp_parser_objc_interstitial_code (parser);
22587 token = cp_lexer_peek_token (parser->lexer);
22590 if (token->type != CPP_EOF)
22591 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
22593 cp_parser_error (parser, "expected %<@end%>");
22595 objc_finish_implementation ();
22598 /* Parse Objective-C ivars. */
22601 cp_parser_objc_class_ivars (cp_parser* parser)
22603 cp_token *token = cp_lexer_peek_token (parser->lexer);
22605 if (token->type != CPP_OPEN_BRACE)
22606 return; /* No ivars specified. */
22608 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
22609 token = cp_lexer_peek_token (parser->lexer);
22611 while (token->type != CPP_CLOSE_BRACE
22612 && token->keyword != RID_AT_END && token->type != CPP_EOF)
22614 cp_decl_specifier_seq declspecs;
22615 int decl_class_or_enum_p;
22616 tree prefix_attributes;
22618 cp_parser_objc_visibility_spec (parser);
22620 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
22623 cp_parser_decl_specifier_seq (parser,
22624 CP_PARSER_FLAGS_OPTIONAL,
22626 &decl_class_or_enum_p);
22628 /* auto, register, static, extern, mutable. */
22629 if (declspecs.storage_class != sc_none)
22631 cp_parser_error (parser, "invalid type for instance variable");
22632 declspecs.storage_class = sc_none;
22636 if (declspecs.specs[(int) ds_thread])
22638 cp_parser_error (parser, "invalid type for instance variable");
22639 declspecs.specs[(int) ds_thread] = 0;
22643 if (declspecs.specs[(int) ds_typedef])
22645 cp_parser_error (parser, "invalid type for instance variable");
22646 declspecs.specs[(int) ds_typedef] = 0;
22649 prefix_attributes = declspecs.attributes;
22650 declspecs.attributes = NULL_TREE;
22652 /* Keep going until we hit the `;' at the end of the
22654 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
22656 tree width = NULL_TREE, attributes, first_attribute, decl;
22657 cp_declarator *declarator = NULL;
22658 int ctor_dtor_or_conv_p;
22660 /* Check for a (possibly unnamed) bitfield declaration. */
22661 token = cp_lexer_peek_token (parser->lexer);
22662 if (token->type == CPP_COLON)
22665 if (token->type == CPP_NAME
22666 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
22669 /* Get the name of the bitfield. */
22670 declarator = make_id_declarator (NULL_TREE,
22671 cp_parser_identifier (parser),
22675 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
22676 /* Get the width of the bitfield. */
22678 = cp_parser_constant_expression (parser,
22679 /*allow_non_constant=*/false,
22684 /* Parse the declarator. */
22686 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
22687 &ctor_dtor_or_conv_p,
22688 /*parenthesized_p=*/NULL,
22689 /*member_p=*/false);
22692 /* Look for attributes that apply to the ivar. */
22693 attributes = cp_parser_attributes_opt (parser);
22694 /* Remember which attributes are prefix attributes and
22696 first_attribute = attributes;
22697 /* Combine the attributes. */
22698 attributes = chainon (prefix_attributes, attributes);
22701 /* Create the bitfield declaration. */
22702 decl = grokbitfield (declarator, &declspecs,
22706 decl = grokfield (declarator, &declspecs,
22707 NULL_TREE, /*init_const_expr_p=*/false,
22708 NULL_TREE, attributes);
22710 /* Add the instance variable. */
22711 if (decl != error_mark_node && decl != NULL_TREE)
22712 objc_add_instance_variable (decl);
22714 /* Reset PREFIX_ATTRIBUTES. */
22715 while (attributes && TREE_CHAIN (attributes) != first_attribute)
22716 attributes = TREE_CHAIN (attributes);
22718 TREE_CHAIN (attributes) = NULL_TREE;
22720 token = cp_lexer_peek_token (parser->lexer);
22722 if (token->type == CPP_COMMA)
22724 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
22730 cp_parser_consume_semicolon_at_end_of_statement (parser);
22731 token = cp_lexer_peek_token (parser->lexer);
22734 if (token->keyword == RID_AT_END)
22735 cp_parser_error (parser, "expected %<}%>");
22737 /* Do not consume the RID_AT_END, so it will be read again as terminating
22738 the @interface of @implementation. */
22739 if (token->keyword != RID_AT_END && token->type != CPP_EOF)
22740 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
22742 /* For historical reasons, we accept an optional semicolon. */
22743 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
22744 cp_lexer_consume_token (parser->lexer);
22747 /* Parse an Objective-C protocol declaration. */
22750 cp_parser_objc_protocol_declaration (cp_parser* parser, tree attributes)
22752 tree proto, protorefs;
22755 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
22756 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
22758 tok = cp_lexer_peek_token (parser->lexer);
22759 error_at (tok->location, "identifier expected after %<@protocol%>");
22760 cp_parser_consume_semicolon_at_end_of_statement (parser);
22764 /* See if we have a forward declaration or a definition. */
22765 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
22767 /* Try a forward declaration first. */
22768 if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON)
22774 id = cp_parser_identifier (parser);
22775 if (id == error_mark_node)
22778 objc_declare_protocol (id, attributes);
22780 if(cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
22781 cp_lexer_consume_token (parser->lexer);
22785 cp_parser_consume_semicolon_at_end_of_statement (parser);
22788 /* Ok, we got a full-fledged definition (or at least should). */
22791 proto = cp_parser_identifier (parser);
22792 protorefs = cp_parser_objc_protocol_refs_opt (parser);
22793 objc_start_protocol (proto, protorefs, attributes);
22794 cp_parser_objc_method_prototype_list (parser);
22798 /* Parse an Objective-C superclass or category. */
22801 cp_parser_objc_superclass_or_category (cp_parser *parser,
22804 tree *categ, bool *is_class_extension)
22806 cp_token *next = cp_lexer_peek_token (parser->lexer);
22808 *super = *categ = NULL_TREE;
22809 *is_class_extension = false;
22810 if (next->type == CPP_COLON)
22812 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
22813 *super = cp_parser_identifier (parser);
22815 else if (next->type == CPP_OPEN_PAREN)
22817 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
22819 /* If there is no category name, and this is an @interface, we
22820 have a class extension. */
22821 if (iface_p && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
22823 *categ = NULL_TREE;
22824 *is_class_extension = true;
22827 *categ = cp_parser_identifier (parser);
22829 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
22833 /* Parse an Objective-C class interface. */
22836 cp_parser_objc_class_interface (cp_parser* parser, tree attributes)
22838 tree name, super, categ, protos;
22839 bool is_class_extension;
22841 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
22842 name = cp_parser_identifier (parser);
22843 if (name == error_mark_node)
22845 /* It's hard to recover because even if valid @interface stuff
22846 is to follow, we can't compile it (or validate it) if we
22847 don't even know which class it refers to. Let's assume this
22848 was a stray '@interface' token in the stream and skip it.
22852 cp_parser_objc_superclass_or_category (parser, true, &super, &categ,
22853 &is_class_extension);
22854 protos = cp_parser_objc_protocol_refs_opt (parser);
22856 /* We have either a class or a category on our hands. */
22857 if (categ || is_class_extension)
22858 objc_start_category_interface (name, categ, protos, attributes);
22861 objc_start_class_interface (name, super, protos, attributes);
22862 /* Handle instance variable declarations, if any. */
22863 cp_parser_objc_class_ivars (parser);
22864 objc_continue_interface ();
22867 cp_parser_objc_method_prototype_list (parser);
22870 /* Parse an Objective-C class implementation. */
22873 cp_parser_objc_class_implementation (cp_parser* parser)
22875 tree name, super, categ;
22876 bool is_class_extension;
22878 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
22879 name = cp_parser_identifier (parser);
22880 if (name == error_mark_node)
22882 /* It's hard to recover because even if valid @implementation
22883 stuff is to follow, we can't compile it (or validate it) if
22884 we don't even know which class it refers to. Let's assume
22885 this was a stray '@implementation' token in the stream and
22890 cp_parser_objc_superclass_or_category (parser, false, &super, &categ,
22891 &is_class_extension);
22893 /* We have either a class or a category on our hands. */
22895 objc_start_category_implementation (name, categ);
22898 objc_start_class_implementation (name, super);
22899 /* Handle instance variable declarations, if any. */
22900 cp_parser_objc_class_ivars (parser);
22901 objc_continue_implementation ();
22904 cp_parser_objc_method_definition_list (parser);
22907 /* Consume the @end token and finish off the implementation. */
22910 cp_parser_objc_end_implementation (cp_parser* parser)
22912 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
22913 objc_finish_implementation ();
22916 /* Parse an Objective-C declaration. */
22919 cp_parser_objc_declaration (cp_parser* parser, tree attributes)
22921 /* Try to figure out what kind of declaration is present. */
22922 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
22925 switch (kwd->keyword)
22930 error_at (kwd->location, "attributes may not be specified before"
22931 " the %<@%D%> Objective-C++ keyword",
22935 case RID_AT_IMPLEMENTATION:
22936 warning_at (kwd->location, OPT_Wattributes,
22937 "prefix attributes are ignored before %<@%D%>",
22944 switch (kwd->keyword)
22947 cp_parser_objc_alias_declaration (parser);
22950 cp_parser_objc_class_declaration (parser);
22952 case RID_AT_PROTOCOL:
22953 cp_parser_objc_protocol_declaration (parser, attributes);
22955 case RID_AT_INTERFACE:
22956 cp_parser_objc_class_interface (parser, attributes);
22958 case RID_AT_IMPLEMENTATION:
22959 cp_parser_objc_class_implementation (parser);
22962 cp_parser_objc_end_implementation (parser);
22965 error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
22967 cp_parser_skip_to_end_of_block_or_statement (parser);
22971 /* Parse an Objective-C try-catch-finally statement.
22973 objc-try-catch-finally-stmt:
22974 @try compound-statement objc-catch-clause-seq [opt]
22975 objc-finally-clause [opt]
22977 objc-catch-clause-seq:
22978 objc-catch-clause objc-catch-clause-seq [opt]
22981 @catch ( objc-exception-declaration ) compound-statement
22983 objc-finally-clause:
22984 @finally compound-statement
22986 objc-exception-declaration:
22987 parameter-declaration
22990 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
22994 PS: This function is identical to c_parser_objc_try_catch_finally_statement
22995 for C. Keep them in sync. */
22998 cp_parser_objc_try_catch_finally_statement (cp_parser *parser)
23000 location_t location;
23003 cp_parser_require_keyword (parser, RID_AT_TRY, RT_AT_TRY);
23004 location = cp_lexer_peek_token (parser->lexer)->location;
23005 objc_maybe_warn_exceptions (location);
23006 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
23007 node, lest it get absorbed into the surrounding block. */
23008 stmt = push_stmt_list ();
23009 cp_parser_compound_statement (parser, NULL, false, false);
23010 objc_begin_try_stmt (location, pop_stmt_list (stmt));
23012 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
23014 cp_parameter_declarator *parm;
23015 tree parameter_declaration = error_mark_node;
23016 bool seen_open_paren = false;
23018 cp_lexer_consume_token (parser->lexer);
23019 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23020 seen_open_paren = true;
23021 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
23023 /* We have "@catch (...)" (where the '...' are literally
23024 what is in the code). Skip the '...'.
23025 parameter_declaration is set to NULL_TREE, and
23026 objc_being_catch_clauses() knows that that means
23028 cp_lexer_consume_token (parser->lexer);
23029 parameter_declaration = NULL_TREE;
23033 /* We have "@catch (NSException *exception)" or something
23034 like that. Parse the parameter declaration. */
23035 parm = cp_parser_parameter_declaration (parser, false, NULL);
23037 parameter_declaration = error_mark_node;
23039 parameter_declaration = grokdeclarator (parm->declarator,
23040 &parm->decl_specifiers,
23041 PARM, /*initialized=*/0,
23042 /*attrlist=*/NULL);
23044 if (seen_open_paren)
23045 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
23048 /* If there was no open parenthesis, we are recovering from
23049 an error, and we are trying to figure out what mistake
23050 the user has made. */
23052 /* If there is an immediate closing parenthesis, the user
23053 probably forgot the opening one (ie, they typed "@catch
23054 NSException *e)". Parse the closing parenthesis and keep
23056 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
23057 cp_lexer_consume_token (parser->lexer);
23059 /* If these is no immediate closing parenthesis, the user
23060 probably doesn't know that parenthesis are required at
23061 all (ie, they typed "@catch NSException *e"). So, just
23062 forget about the closing parenthesis and keep going. */
23064 objc_begin_catch_clause (parameter_declaration);
23065 cp_parser_compound_statement (parser, NULL, false, false);
23066 objc_finish_catch_clause ();
23068 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
23070 cp_lexer_consume_token (parser->lexer);
23071 location = cp_lexer_peek_token (parser->lexer)->location;
23072 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
23073 node, lest it get absorbed into the surrounding block. */
23074 stmt = push_stmt_list ();
23075 cp_parser_compound_statement (parser, NULL, false, false);
23076 objc_build_finally_clause (location, pop_stmt_list (stmt));
23079 return objc_finish_try_stmt ();
23082 /* Parse an Objective-C synchronized statement.
23084 objc-synchronized-stmt:
23085 @synchronized ( expression ) compound-statement
23087 Returns NULL_TREE. */
23090 cp_parser_objc_synchronized_statement (cp_parser *parser)
23092 location_t location;
23095 cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, RT_AT_SYNCHRONIZED);
23097 location = cp_lexer_peek_token (parser->lexer)->location;
23098 objc_maybe_warn_exceptions (location);
23099 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
23100 lock = cp_parser_expression (parser, false, NULL);
23101 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
23103 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
23104 node, lest it get absorbed into the surrounding block. */
23105 stmt = push_stmt_list ();
23106 cp_parser_compound_statement (parser, NULL, false, false);
23108 return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
23111 /* Parse an Objective-C throw statement.
23114 @throw assignment-expression [opt] ;
23116 Returns a constructed '@throw' statement. */
23119 cp_parser_objc_throw_statement (cp_parser *parser)
23121 tree expr = NULL_TREE;
23122 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
23124 cp_parser_require_keyword (parser, RID_AT_THROW, RT_AT_THROW);
23126 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
23127 expr = cp_parser_expression (parser, /*cast_p=*/false, NULL);
23129 cp_parser_consume_semicolon_at_end_of_statement (parser);
23131 return objc_build_throw_stmt (loc, expr);
23134 /* Parse an Objective-C statement. */
23137 cp_parser_objc_statement (cp_parser * parser)
23139 /* Try to figure out what kind of declaration is present. */
23140 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
23142 switch (kwd->keyword)
23145 return cp_parser_objc_try_catch_finally_statement (parser);
23146 case RID_AT_SYNCHRONIZED:
23147 return cp_parser_objc_synchronized_statement (parser);
23149 return cp_parser_objc_throw_statement (parser);
23151 error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
23153 cp_parser_skip_to_end_of_block_or_statement (parser);
23156 return error_mark_node;
23159 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
23160 look ahead to see if an objc keyword follows the attributes. This
23161 is to detect the use of prefix attributes on ObjC @interface and
23165 cp_parser_objc_valid_prefix_attributes (cp_parser* parser, tree *attrib)
23167 cp_lexer_save_tokens (parser->lexer);
23168 *attrib = cp_parser_attributes_opt (parser);
23169 gcc_assert (*attrib);
23170 if (OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser->lexer)->keyword))
23172 cp_lexer_commit_tokens (parser->lexer);
23175 cp_lexer_rollback_tokens (parser->lexer);
23179 /* This routine is a minimal replacement for
23180 c_parser_struct_declaration () used when parsing the list of
23181 types/names or ObjC++ properties. For example, when parsing the
23184 @property (readonly) int a, b, c;
23186 this function is responsible for parsing "int a, int b, int c" and
23187 returning the declarations as CHAIN of DECLs.
23189 TODO: Share this code with cp_parser_objc_class_ivars. It's very
23190 similar parsing. */
23192 cp_parser_objc_struct_declaration (cp_parser *parser)
23194 tree decls = NULL_TREE;
23195 cp_decl_specifier_seq declspecs;
23196 int decl_class_or_enum_p;
23197 tree prefix_attributes;
23199 cp_parser_decl_specifier_seq (parser,
23200 CP_PARSER_FLAGS_NONE,
23202 &decl_class_or_enum_p);
23204 if (declspecs.type == error_mark_node)
23205 return error_mark_node;
23207 /* auto, register, static, extern, mutable. */
23208 if (declspecs.storage_class != sc_none)
23210 cp_parser_error (parser, "invalid type for property");
23211 declspecs.storage_class = sc_none;
23215 if (declspecs.specs[(int) ds_thread])
23217 cp_parser_error (parser, "invalid type for property");
23218 declspecs.specs[(int) ds_thread] = 0;
23222 if (declspecs.specs[(int) ds_typedef])
23224 cp_parser_error (parser, "invalid type for property");
23225 declspecs.specs[(int) ds_typedef] = 0;
23228 prefix_attributes = declspecs.attributes;
23229 declspecs.attributes = NULL_TREE;
23231 /* Keep going until we hit the `;' at the end of the declaration. */
23232 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
23234 tree attributes, first_attribute, decl;
23235 cp_declarator *declarator;
23238 /* Parse the declarator. */
23239 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
23240 NULL, NULL, false);
23242 /* Look for attributes that apply to the ivar. */
23243 attributes = cp_parser_attributes_opt (parser);
23244 /* Remember which attributes are prefix attributes and
23246 first_attribute = attributes;
23247 /* Combine the attributes. */
23248 attributes = chainon (prefix_attributes, attributes);
23250 decl = grokfield (declarator, &declspecs,
23251 NULL_TREE, /*init_const_expr_p=*/false,
23252 NULL_TREE, attributes);
23254 if (decl == error_mark_node || decl == NULL_TREE)
23255 return error_mark_node;
23257 /* Reset PREFIX_ATTRIBUTES. */
23258 while (attributes && TREE_CHAIN (attributes) != first_attribute)
23259 attributes = TREE_CHAIN (attributes);
23261 TREE_CHAIN (attributes) = NULL_TREE;
23263 DECL_CHAIN (decl) = decls;
23266 token = cp_lexer_peek_token (parser->lexer);
23267 if (token->type == CPP_COMMA)
23269 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
23278 /* Parse an Objective-C @property declaration. The syntax is:
23280 objc-property-declaration:
23281 '@property' objc-property-attributes[opt] struct-declaration ;
23283 objc-property-attributes:
23284 '(' objc-property-attribute-list ')'
23286 objc-property-attribute-list:
23287 objc-property-attribute
23288 objc-property-attribute-list, objc-property-attribute
23290 objc-property-attribute
23291 'getter' = identifier
23292 'setter' = identifier
23301 @property NSString *name;
23302 @property (readonly) id object;
23303 @property (retain, nonatomic, getter=getTheName) id name;
23304 @property int a, b, c;
23306 PS: This function is identical to
23307 c_parser_objc_at_property_declaration for C. Keep them in sync. */
23309 cp_parser_objc_at_property_declaration (cp_parser *parser)
23311 /* The following variables hold the attributes of the properties as
23312 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
23313 seen. When we see an attribute, we set them to 'true' (if they
23314 are boolean properties) or to the identifier (if they have an
23315 argument, ie, for getter and setter). Note that here we only
23316 parse the list of attributes, check the syntax and accumulate the
23317 attributes that we find. objc_add_property_declaration() will
23318 then process the information. */
23319 bool property_assign = false;
23320 bool property_copy = false;
23321 tree property_getter_ident = NULL_TREE;
23322 bool property_nonatomic = false;
23323 bool property_readonly = false;
23324 bool property_readwrite = false;
23325 bool property_retain = false;
23326 tree property_setter_ident = NULL_TREE;
23328 /* 'properties' is the list of properties that we read. Usually a
23329 single one, but maybe more (eg, in "@property int a, b, c;" there
23334 loc = cp_lexer_peek_token (parser->lexer)->location;
23336 cp_lexer_consume_token (parser->lexer); /* Eat '@property'. */
23338 /* Parse the optional attribute list... */
23339 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
23342 cp_lexer_consume_token (parser->lexer);
23346 bool syntax_error = false;
23347 cp_token *token = cp_lexer_peek_token (parser->lexer);
23350 if (token->type != CPP_NAME)
23352 cp_parser_error (parser, "expected identifier");
23355 keyword = C_RID_CODE (token->u.value);
23356 cp_lexer_consume_token (parser->lexer);
23359 case RID_ASSIGN: property_assign = true; break;
23360 case RID_COPY: property_copy = true; break;
23361 case RID_NONATOMIC: property_nonatomic = true; break;
23362 case RID_READONLY: property_readonly = true; break;
23363 case RID_READWRITE: property_readwrite = true; break;
23364 case RID_RETAIN: property_retain = true; break;
23368 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
23370 if (keyword == RID_GETTER)
23371 cp_parser_error (parser,
23372 "missing %<=%> (after %<getter%> attribute)");
23374 cp_parser_error (parser,
23375 "missing %<=%> (after %<setter%> attribute)");
23376 syntax_error = true;
23379 cp_lexer_consume_token (parser->lexer); /* eat the = */
23380 if (!cp_parser_objc_selector_p (cp_lexer_peek_token (parser->lexer)->type))
23382 cp_parser_error (parser, "expected identifier");
23383 syntax_error = true;
23386 if (keyword == RID_SETTER)
23388 if (property_setter_ident != NULL_TREE)
23390 cp_parser_error (parser, "the %<setter%> attribute may only be specified once");
23391 cp_lexer_consume_token (parser->lexer);
23394 property_setter_ident = cp_parser_objc_selector (parser);
23395 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
23396 cp_parser_error (parser, "setter name must terminate with %<:%>");
23398 cp_lexer_consume_token (parser->lexer);
23402 if (property_getter_ident != NULL_TREE)
23404 cp_parser_error (parser, "the %<getter%> attribute may only be specified once");
23405 cp_lexer_consume_token (parser->lexer);
23408 property_getter_ident = cp_parser_objc_selector (parser);
23412 cp_parser_error (parser, "unknown property attribute");
23413 syntax_error = true;
23420 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23421 cp_lexer_consume_token (parser->lexer);
23426 /* FIXME: "@property (setter, assign);" will generate a spurious
23427 "error: expected ‘)’ before ‘,’ token". This is because
23428 cp_parser_require, unlike the C counterpart, will produce an
23429 error even if we are in error recovery. */
23430 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23432 cp_parser_skip_to_closing_parenthesis (parser,
23433 /*recovering=*/true,
23434 /*or_comma=*/false,
23435 /*consume_paren=*/true);
23439 /* ... and the property declaration(s). */
23440 properties = cp_parser_objc_struct_declaration (parser);
23442 if (properties == error_mark_node)
23444 cp_parser_skip_to_end_of_statement (parser);
23445 /* If the next token is now a `;', consume it. */
23446 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
23447 cp_lexer_consume_token (parser->lexer);
23451 if (properties == NULL_TREE)
23452 cp_parser_error (parser, "expected identifier");
23455 /* Comma-separated properties are chained together in
23456 reverse order; add them one by one. */
23457 properties = nreverse (properties);
23459 for (; properties; properties = TREE_CHAIN (properties))
23460 objc_add_property_declaration (loc, copy_node (properties),
23461 property_readonly, property_readwrite,
23462 property_assign, property_retain,
23463 property_copy, property_nonatomic,
23464 property_getter_ident, property_setter_ident);
23467 cp_parser_consume_semicolon_at_end_of_statement (parser);
23470 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
23472 objc-synthesize-declaration:
23473 @synthesize objc-synthesize-identifier-list ;
23475 objc-synthesize-identifier-list:
23476 objc-synthesize-identifier
23477 objc-synthesize-identifier-list, objc-synthesize-identifier
23479 objc-synthesize-identifier
23481 identifier = identifier
23484 @synthesize MyProperty;
23485 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
23487 PS: This function is identical to c_parser_objc_at_synthesize_declaration
23488 for C. Keep them in sync.
23491 cp_parser_objc_at_synthesize_declaration (cp_parser *parser)
23493 tree list = NULL_TREE;
23495 loc = cp_lexer_peek_token (parser->lexer)->location;
23497 cp_lexer_consume_token (parser->lexer); /* Eat '@synthesize'. */
23500 tree property, ivar;
23501 property = cp_parser_identifier (parser);
23502 if (property == error_mark_node)
23504 cp_parser_consume_semicolon_at_end_of_statement (parser);
23507 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
23509 cp_lexer_consume_token (parser->lexer);
23510 ivar = cp_parser_identifier (parser);
23511 if (ivar == error_mark_node)
23513 cp_parser_consume_semicolon_at_end_of_statement (parser);
23519 list = chainon (list, build_tree_list (ivar, property));
23520 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23521 cp_lexer_consume_token (parser->lexer);
23525 cp_parser_consume_semicolon_at_end_of_statement (parser);
23526 objc_add_synthesize_declaration (loc, list);
23529 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
23531 objc-dynamic-declaration:
23532 @dynamic identifier-list ;
23535 @dynamic MyProperty;
23536 @dynamic MyProperty, AnotherProperty;
23538 PS: This function is identical to c_parser_objc_at_dynamic_declaration
23539 for C. Keep them in sync.
23542 cp_parser_objc_at_dynamic_declaration (cp_parser *parser)
23544 tree list = NULL_TREE;
23546 loc = cp_lexer_peek_token (parser->lexer)->location;
23548 cp_lexer_consume_token (parser->lexer); /* Eat '@dynamic'. */
23552 property = cp_parser_identifier (parser);
23553 if (property == error_mark_node)
23555 cp_parser_consume_semicolon_at_end_of_statement (parser);
23558 list = chainon (list, build_tree_list (NULL, property));
23559 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23560 cp_lexer_consume_token (parser->lexer);
23564 cp_parser_consume_semicolon_at_end_of_statement (parser);
23565 objc_add_dynamic_declaration (loc, list);
23569 /* OpenMP 2.5 parsing routines. */
23571 /* Returns name of the next clause.
23572 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
23573 the token is not consumed. Otherwise appropriate pragma_omp_clause is
23574 returned and the token is consumed. */
23576 static pragma_omp_clause
23577 cp_parser_omp_clause_name (cp_parser *parser)
23579 pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
23581 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
23582 result = PRAGMA_OMP_CLAUSE_IF;
23583 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
23584 result = PRAGMA_OMP_CLAUSE_DEFAULT;
23585 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
23586 result = PRAGMA_OMP_CLAUSE_PRIVATE;
23587 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
23589 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
23590 const char *p = IDENTIFIER_POINTER (id);
23595 if (!strcmp ("collapse", p))
23596 result = PRAGMA_OMP_CLAUSE_COLLAPSE;
23597 else if (!strcmp ("copyin", p))
23598 result = PRAGMA_OMP_CLAUSE_COPYIN;
23599 else if (!strcmp ("copyprivate", p))
23600 result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
23603 if (!strcmp ("firstprivate", p))
23604 result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
23607 if (!strcmp ("lastprivate", p))
23608 result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
23611 if (!strcmp ("nowait", p))
23612 result = PRAGMA_OMP_CLAUSE_NOWAIT;
23613 else if (!strcmp ("num_threads", p))
23614 result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
23617 if (!strcmp ("ordered", p))
23618 result = PRAGMA_OMP_CLAUSE_ORDERED;
23621 if (!strcmp ("reduction", p))
23622 result = PRAGMA_OMP_CLAUSE_REDUCTION;
23625 if (!strcmp ("schedule", p))
23626 result = PRAGMA_OMP_CLAUSE_SCHEDULE;
23627 else if (!strcmp ("shared", p))
23628 result = PRAGMA_OMP_CLAUSE_SHARED;
23631 if (!strcmp ("untied", p))
23632 result = PRAGMA_OMP_CLAUSE_UNTIED;
23637 if (result != PRAGMA_OMP_CLAUSE_NONE)
23638 cp_lexer_consume_token (parser->lexer);
23643 /* Validate that a clause of the given type does not already exist. */
23646 check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
23647 const char *name, location_t location)
23651 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
23652 if (OMP_CLAUSE_CODE (c) == code)
23654 error_at (location, "too many %qs clauses", name);
23662 variable-list , identifier
23664 In addition, we match a closing parenthesis. An opening parenthesis
23665 will have been consumed by the caller.
23667 If KIND is nonzero, create the appropriate node and install the decl
23668 in OMP_CLAUSE_DECL and add the node to the head of the list.
23670 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
23671 return the list created. */
23674 cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
23682 token = cp_lexer_peek_token (parser->lexer);
23683 name = cp_parser_id_expression (parser, /*template_p=*/false,
23684 /*check_dependency_p=*/true,
23685 /*template_p=*/NULL,
23686 /*declarator_p=*/false,
23687 /*optional_p=*/false);
23688 if (name == error_mark_node)
23691 decl = cp_parser_lookup_name_simple (parser, name, token->location);
23692 if (decl == error_mark_node)
23693 cp_parser_name_lookup_error (parser, name, decl, NLE_NULL,
23695 else if (kind != 0)
23697 tree u = build_omp_clause (token->location, kind);
23698 OMP_CLAUSE_DECL (u) = decl;
23699 OMP_CLAUSE_CHAIN (u) = list;
23703 list = tree_cons (decl, NULL_TREE, list);
23706 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
23708 cp_lexer_consume_token (parser->lexer);
23711 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23715 /* Try to resync to an unnested comma. Copied from
23716 cp_parser_parenthesized_expression_list. */
23718 ending = cp_parser_skip_to_closing_parenthesis (parser,
23719 /*recovering=*/true,
23721 /*consume_paren=*/true);
23729 /* Similarly, but expect leading and trailing parenthesis. This is a very
23730 common case for omp clauses. */
23733 cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list)
23735 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23736 return cp_parser_omp_var_list_no_open (parser, kind, list);
23741 collapse ( constant-expression ) */
23744 cp_parser_omp_clause_collapse (cp_parser *parser, tree list, location_t location)
23750 loc = cp_lexer_peek_token (parser->lexer)->location;
23751 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23754 num = cp_parser_constant_expression (parser, false, NULL);
23756 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23757 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23758 /*or_comma=*/false,
23759 /*consume_paren=*/true);
23761 if (num == error_mark_node)
23763 num = fold_non_dependent_expr (num);
23764 if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
23765 || !host_integerp (num, 0)
23766 || (n = tree_low_cst (num, 0)) <= 0
23769 error_at (loc, "collapse argument needs positive constant integer expression");
23773 check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse", location);
23774 c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
23775 OMP_CLAUSE_CHAIN (c) = list;
23776 OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
23782 default ( shared | none ) */
23785 cp_parser_omp_clause_default (cp_parser *parser, tree list, location_t location)
23787 enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
23790 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23792 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
23794 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
23795 const char *p = IDENTIFIER_POINTER (id);
23800 if (strcmp ("none", p) != 0)
23802 kind = OMP_CLAUSE_DEFAULT_NONE;
23806 if (strcmp ("shared", p) != 0)
23808 kind = OMP_CLAUSE_DEFAULT_SHARED;
23815 cp_lexer_consume_token (parser->lexer);
23820 cp_parser_error (parser, "expected %<none%> or %<shared%>");
23823 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23824 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23825 /*or_comma=*/false,
23826 /*consume_paren=*/true);
23828 if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
23831 check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default", location);
23832 c = build_omp_clause (location, OMP_CLAUSE_DEFAULT);
23833 OMP_CLAUSE_CHAIN (c) = list;
23834 OMP_CLAUSE_DEFAULT_KIND (c) = kind;
23840 if ( expression ) */
23843 cp_parser_omp_clause_if (cp_parser *parser, tree list, location_t location)
23847 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23850 t = cp_parser_condition (parser);
23852 if (t == error_mark_node
23853 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23854 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23855 /*or_comma=*/false,
23856 /*consume_paren=*/true);
23858 check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if", location);
23860 c = build_omp_clause (location, OMP_CLAUSE_IF);
23861 OMP_CLAUSE_IF_EXPR (c) = t;
23862 OMP_CLAUSE_CHAIN (c) = list;
23871 cp_parser_omp_clause_nowait (cp_parser *parser ATTRIBUTE_UNUSED,
23872 tree list, location_t location)
23876 check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait", location);
23878 c = build_omp_clause (location, OMP_CLAUSE_NOWAIT);
23879 OMP_CLAUSE_CHAIN (c) = list;
23884 num_threads ( expression ) */
23887 cp_parser_omp_clause_num_threads (cp_parser *parser, tree list,
23888 location_t location)
23892 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23895 t = cp_parser_expression (parser, false, NULL);
23897 if (t == error_mark_node
23898 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
23899 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23900 /*or_comma=*/false,
23901 /*consume_paren=*/true);
23903 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS,
23904 "num_threads", location);
23906 c = build_omp_clause (location, OMP_CLAUSE_NUM_THREADS);
23907 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
23908 OMP_CLAUSE_CHAIN (c) = list;
23917 cp_parser_omp_clause_ordered (cp_parser *parser ATTRIBUTE_UNUSED,
23918 tree list, location_t location)
23922 check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED,
23923 "ordered", location);
23925 c = build_omp_clause (location, OMP_CLAUSE_ORDERED);
23926 OMP_CLAUSE_CHAIN (c) = list;
23931 reduction ( reduction-operator : variable-list )
23933 reduction-operator:
23934 One of: + * - & ^ | && || */
23937 cp_parser_omp_clause_reduction (cp_parser *parser, tree list)
23939 enum tree_code code;
23942 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23945 switch (cp_lexer_peek_token (parser->lexer)->type)
23957 code = BIT_AND_EXPR;
23960 code = BIT_XOR_EXPR;
23963 code = BIT_IOR_EXPR;
23966 code = TRUTH_ANDIF_EXPR;
23969 code = TRUTH_ORIF_EXPR;
23972 cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
23973 "%<|%>, %<&&%>, or %<||%>");
23975 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
23976 /*or_comma=*/false,
23977 /*consume_paren=*/true);
23980 cp_lexer_consume_token (parser->lexer);
23982 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
23985 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list);
23986 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
23987 OMP_CLAUSE_REDUCTION_CODE (c) = code;
23993 schedule ( schedule-kind )
23994 schedule ( schedule-kind , expression )
23997 static | dynamic | guided | runtime | auto */
24000 cp_parser_omp_clause_schedule (cp_parser *parser, tree list, location_t location)
24004 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
24007 c = build_omp_clause (location, OMP_CLAUSE_SCHEDULE);
24009 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
24011 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
24012 const char *p = IDENTIFIER_POINTER (id);
24017 if (strcmp ("dynamic", p) != 0)
24019 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
24023 if (strcmp ("guided", p) != 0)
24025 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
24029 if (strcmp ("runtime", p) != 0)
24031 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
24038 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
24039 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
24040 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
24041 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
24044 cp_lexer_consume_token (parser->lexer);
24046 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
24049 cp_lexer_consume_token (parser->lexer);
24051 token = cp_lexer_peek_token (parser->lexer);
24052 t = cp_parser_assignment_expression (parser, false, NULL);
24054 if (t == error_mark_node)
24056 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
24057 error_at (token->location, "schedule %<runtime%> does not take "
24058 "a %<chunk_size%> parameter");
24059 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
24060 error_at (token->location, "schedule %<auto%> does not take "
24061 "a %<chunk_size%> parameter");
24063 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
24065 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
24068 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
24071 check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule", location);
24072 OMP_CLAUSE_CHAIN (c) = list;
24076 cp_parser_error (parser, "invalid schedule kind");
24078 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
24079 /*or_comma=*/false,
24080 /*consume_paren=*/true);
24088 cp_parser_omp_clause_untied (cp_parser *parser ATTRIBUTE_UNUSED,
24089 tree list, location_t location)
24093 check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied", location);
24095 c = build_omp_clause (location, OMP_CLAUSE_UNTIED);
24096 OMP_CLAUSE_CHAIN (c) = list;
24100 /* Parse all OpenMP clauses. The set clauses allowed by the directive
24101 is a bitmask in MASK. Return the list of clauses found; the result
24102 of clause default goes in *pdefault. */
24105 cp_parser_omp_all_clauses (cp_parser *parser, unsigned int mask,
24106 const char *where, cp_token *pragma_tok)
24108 tree clauses = NULL;
24110 cp_token *token = NULL;
24112 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
24114 pragma_omp_clause c_kind;
24115 const char *c_name;
24116 tree prev = clauses;
24118 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
24119 cp_lexer_consume_token (parser->lexer);
24121 token = cp_lexer_peek_token (parser->lexer);
24122 c_kind = cp_parser_omp_clause_name (parser);
24127 case PRAGMA_OMP_CLAUSE_COLLAPSE:
24128 clauses = cp_parser_omp_clause_collapse (parser, clauses,
24130 c_name = "collapse";
24132 case PRAGMA_OMP_CLAUSE_COPYIN:
24133 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
24136 case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
24137 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
24139 c_name = "copyprivate";
24141 case PRAGMA_OMP_CLAUSE_DEFAULT:
24142 clauses = cp_parser_omp_clause_default (parser, clauses,
24144 c_name = "default";
24146 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
24147 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
24149 c_name = "firstprivate";
24151 case PRAGMA_OMP_CLAUSE_IF:
24152 clauses = cp_parser_omp_clause_if (parser, clauses, token->location);
24155 case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
24156 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
24158 c_name = "lastprivate";
24160 case PRAGMA_OMP_CLAUSE_NOWAIT:
24161 clauses = cp_parser_omp_clause_nowait (parser, clauses, token->location);
24164 case PRAGMA_OMP_CLAUSE_NUM_THREADS:
24165 clauses = cp_parser_omp_clause_num_threads (parser, clauses,
24167 c_name = "num_threads";
24169 case PRAGMA_OMP_CLAUSE_ORDERED:
24170 clauses = cp_parser_omp_clause_ordered (parser, clauses,
24172 c_name = "ordered";
24174 case PRAGMA_OMP_CLAUSE_PRIVATE:
24175 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
24177 c_name = "private";
24179 case PRAGMA_OMP_CLAUSE_REDUCTION:
24180 clauses = cp_parser_omp_clause_reduction (parser, clauses);
24181 c_name = "reduction";
24183 case PRAGMA_OMP_CLAUSE_SCHEDULE:
24184 clauses = cp_parser_omp_clause_schedule (parser, clauses,
24186 c_name = "schedule";
24188 case PRAGMA_OMP_CLAUSE_SHARED:
24189 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
24193 case PRAGMA_OMP_CLAUSE_UNTIED:
24194 clauses = cp_parser_omp_clause_untied (parser, clauses,
24199 cp_parser_error (parser, "expected %<#pragma omp%> clause");
24203 if (((mask >> c_kind) & 1) == 0)
24205 /* Remove the invalid clause(s) from the list to avoid
24206 confusing the rest of the compiler. */
24208 error_at (token->location, "%qs is not valid for %qs", c_name, where);
24212 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
24213 return finish_omp_clauses (clauses);
24220 In practice, we're also interested in adding the statement to an
24221 outer node. So it is convenient if we work around the fact that
24222 cp_parser_statement calls add_stmt. */
24225 cp_parser_begin_omp_structured_block (cp_parser *parser)
24227 unsigned save = parser->in_statement;
24229 /* Only move the values to IN_OMP_BLOCK if they weren't false.
24230 This preserves the "not within loop or switch" style error messages
24231 for nonsense cases like
24237 if (parser->in_statement)
24238 parser->in_statement = IN_OMP_BLOCK;
24244 cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
24246 parser->in_statement = save;
24250 cp_parser_omp_structured_block (cp_parser *parser)
24252 tree stmt = begin_omp_structured_block ();
24253 unsigned int save = cp_parser_begin_omp_structured_block (parser);
24255 cp_parser_statement (parser, NULL_TREE, false, NULL);
24257 cp_parser_end_omp_structured_block (parser, save);
24258 return finish_omp_structured_block (stmt);
24262 # pragma omp atomic new-line
24266 x binop= expr | x++ | ++x | x-- | --x
24268 +, *, -, /, &, ^, |, <<, >>
24270 where x is an lvalue expression with scalar type. */
24273 cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok)
24276 enum tree_code code;
24278 cp_parser_require_pragma_eol (parser, pragma_tok);
24280 lhs = cp_parser_unary_expression (parser, /*address_p=*/false,
24281 /*cast_p=*/false, NULL);
24282 switch (TREE_CODE (lhs))
24287 case PREINCREMENT_EXPR:
24288 case POSTINCREMENT_EXPR:
24289 lhs = TREE_OPERAND (lhs, 0);
24291 rhs = integer_one_node;
24294 case PREDECREMENT_EXPR:
24295 case POSTDECREMENT_EXPR:
24296 lhs = TREE_OPERAND (lhs, 0);
24298 rhs = integer_one_node;
24301 case COMPOUND_EXPR:
24302 if (TREE_CODE (TREE_OPERAND (lhs, 0)) == SAVE_EXPR
24303 && TREE_CODE (TREE_OPERAND (lhs, 1)) == COMPOUND_EXPR
24304 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs, 1), 0)) == MODIFY_EXPR
24305 && TREE_OPERAND (TREE_OPERAND (lhs, 1), 1) == TREE_OPERAND (lhs, 0)
24306 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
24307 (TREE_OPERAND (lhs, 1), 0), 0)))
24309 /* Undo effects of boolean_increment for post {in,de}crement. */
24310 lhs = TREE_OPERAND (TREE_OPERAND (lhs, 1), 0);
24313 if (TREE_CODE (lhs) == MODIFY_EXPR
24314 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) == BOOLEAN_TYPE)
24316 /* Undo effects of boolean_increment. */
24317 if (integer_onep (TREE_OPERAND (lhs, 1)))
24319 /* This is pre or post increment. */
24320 rhs = TREE_OPERAND (lhs, 1);
24321 lhs = TREE_OPERAND (lhs, 0);
24328 switch (cp_lexer_peek_token (parser->lexer)->type)
24334 code = TRUNC_DIV_EXPR;
24342 case CPP_LSHIFT_EQ:
24343 code = LSHIFT_EXPR;
24345 case CPP_RSHIFT_EQ:
24346 code = RSHIFT_EXPR;
24349 code = BIT_AND_EXPR;
24352 code = BIT_IOR_EXPR;
24355 code = BIT_XOR_EXPR;
24358 cp_parser_error (parser,
24359 "invalid operator for %<#pragma omp atomic%>");
24362 cp_lexer_consume_token (parser->lexer);
24364 rhs = cp_parser_expression (parser, false, NULL);
24365 if (rhs == error_mark_node)
24369 finish_omp_atomic (code, lhs, rhs);
24370 cp_parser_consume_semicolon_at_end_of_statement (parser);
24374 cp_parser_skip_to_end_of_block_or_statement (parser);
24379 # pragma omp barrier new-line */
24382 cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
24384 cp_parser_require_pragma_eol (parser, pragma_tok);
24385 finish_omp_barrier ();
24389 # pragma omp critical [(name)] new-line
24390 structured-block */
24393 cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok)
24395 tree stmt, name = NULL;
24397 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
24399 cp_lexer_consume_token (parser->lexer);
24401 name = cp_parser_identifier (parser);
24403 if (name == error_mark_node
24404 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
24405 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
24406 /*or_comma=*/false,
24407 /*consume_paren=*/true);
24408 if (name == error_mark_node)
24411 cp_parser_require_pragma_eol (parser, pragma_tok);
24413 stmt = cp_parser_omp_structured_block (parser);
24414 return c_finish_omp_critical (input_location, stmt, name);
24418 # pragma omp flush flush-vars[opt] new-line
24421 ( variable-list ) */
24424 cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
24426 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
24427 (void) cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
24428 cp_parser_require_pragma_eol (parser, pragma_tok);
24430 finish_omp_flush ();
24433 /* Helper function, to parse omp for increment expression. */
24436 cp_parser_omp_for_cond (cp_parser *parser, tree decl)
24438 tree cond = cp_parser_binary_expression (parser, false, true,
24439 PREC_NOT_OPERATOR, NULL);
24440 if (cond == error_mark_node
24441 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
24443 cp_parser_skip_to_end_of_statement (parser);
24444 return error_mark_node;
24447 switch (TREE_CODE (cond))
24455 return error_mark_node;
24458 /* If decl is an iterator, preserve LHS and RHS of the relational
24459 expr until finish_omp_for. */
24461 && (type_dependent_expression_p (decl)
24462 || CLASS_TYPE_P (TREE_TYPE (decl))))
24465 return build_x_binary_op (TREE_CODE (cond),
24466 TREE_OPERAND (cond, 0), ERROR_MARK,
24467 TREE_OPERAND (cond, 1), ERROR_MARK,
24468 /*overload=*/NULL, tf_warning_or_error);
24471 /* Helper function, to parse omp for increment expression. */
24474 cp_parser_omp_for_incr (cp_parser *parser, tree decl)
24476 cp_token *token = cp_lexer_peek_token (parser->lexer);
24482 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
24484 op = (token->type == CPP_PLUS_PLUS
24485 ? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
24486 cp_lexer_consume_token (parser->lexer);
24487 lhs = cp_parser_cast_expression (parser, false, false, NULL);
24489 return error_mark_node;
24490 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
24493 lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
24495 return error_mark_node;
24497 token = cp_lexer_peek_token (parser->lexer);
24498 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
24500 op = (token->type == CPP_PLUS_PLUS
24501 ? POSTINCREMENT_EXPR : POSTDECREMENT_EXPR);
24502 cp_lexer_consume_token (parser->lexer);
24503 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
24506 op = cp_parser_assignment_operator_opt (parser);
24507 if (op == ERROR_MARK)
24508 return error_mark_node;
24510 if (op != NOP_EXPR)
24512 rhs = cp_parser_assignment_expression (parser, false, NULL);
24513 rhs = build2 (op, TREE_TYPE (decl), decl, rhs);
24514 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
24517 lhs = cp_parser_binary_expression (parser, false, false,
24518 PREC_ADDITIVE_EXPRESSION, NULL);
24519 token = cp_lexer_peek_token (parser->lexer);
24520 decl_first = lhs == decl;
24523 if (token->type != CPP_PLUS
24524 && token->type != CPP_MINUS)
24525 return error_mark_node;
24529 op = token->type == CPP_PLUS ? PLUS_EXPR : MINUS_EXPR;
24530 cp_lexer_consume_token (parser->lexer);
24531 rhs = cp_parser_binary_expression (parser, false, false,
24532 PREC_ADDITIVE_EXPRESSION, NULL);
24533 token = cp_lexer_peek_token (parser->lexer);
24534 if (token->type == CPP_PLUS || token->type == CPP_MINUS || decl_first)
24536 if (lhs == NULL_TREE)
24538 if (op == PLUS_EXPR)
24541 lhs = build_x_unary_op (NEGATE_EXPR, rhs, tf_warning_or_error);
24544 lhs = build_x_binary_op (op, lhs, ERROR_MARK, rhs, ERROR_MARK,
24545 NULL, tf_warning_or_error);
24548 while (token->type == CPP_PLUS || token->type == CPP_MINUS);
24552 if (rhs != decl || op == MINUS_EXPR)
24553 return error_mark_node;
24554 rhs = build2 (op, TREE_TYPE (decl), lhs, decl);
24557 rhs = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, lhs);
24559 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
24562 /* Parse the restricted form of the for statement allowed by OpenMP. */
24565 cp_parser_omp_for_loop (cp_parser *parser, tree clauses, tree *par_clauses)
24567 tree init, cond, incr, body, decl, pre_body = NULL_TREE, ret;
24568 tree real_decl, initv, condv, incrv, declv;
24569 tree this_pre_body, cl;
24570 location_t loc_first;
24571 bool collapse_err = false;
24572 int i, collapse = 1, nbraces = 0;
24573 VEC(tree,gc) *for_block = make_tree_vector ();
24575 for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
24576 if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
24577 collapse = tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl), 0);
24579 gcc_assert (collapse >= 1);
24581 declv = make_tree_vec (collapse);
24582 initv = make_tree_vec (collapse);
24583 condv = make_tree_vec (collapse);
24584 incrv = make_tree_vec (collapse);
24586 loc_first = cp_lexer_peek_token (parser->lexer)->location;
24588 for (i = 0; i < collapse; i++)
24590 int bracecount = 0;
24591 bool add_private_clause = false;
24594 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
24596 cp_parser_error (parser, "for statement expected");
24599 loc = cp_lexer_consume_token (parser->lexer)->location;
24601 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
24604 init = decl = real_decl = NULL;
24605 this_pre_body = push_stmt_list ();
24606 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
24608 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
24612 integer-type var = lb
24613 random-access-iterator-type var = lb
24614 pointer-type var = lb
24616 cp_decl_specifier_seq type_specifiers;
24618 /* First, try to parse as an initialized declaration. See
24619 cp_parser_condition, from whence the bulk of this is copied. */
24621 cp_parser_parse_tentatively (parser);
24622 cp_parser_type_specifier_seq (parser, /*is_declaration=*/true,
24623 /*is_trailing_return=*/false,
24625 if (cp_parser_parse_definitely (parser))
24627 /* If parsing a type specifier seq succeeded, then this
24628 MUST be a initialized declaration. */
24629 tree asm_specification, attributes;
24630 cp_declarator *declarator;
24632 declarator = cp_parser_declarator (parser,
24633 CP_PARSER_DECLARATOR_NAMED,
24634 /*ctor_dtor_or_conv_p=*/NULL,
24635 /*parenthesized_p=*/NULL,
24636 /*member_p=*/false);
24637 attributes = cp_parser_attributes_opt (parser);
24638 asm_specification = cp_parser_asm_specification_opt (parser);
24640 if (declarator == cp_error_declarator)
24641 cp_parser_skip_to_end_of_statement (parser);
24645 tree pushed_scope, auto_node;
24647 decl = start_decl (declarator, &type_specifiers,
24648 SD_INITIALIZED, attributes,
24649 /*prefix_attributes=*/NULL_TREE,
24652 auto_node = type_uses_auto (TREE_TYPE (decl));
24653 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
24655 if (cp_lexer_next_token_is (parser->lexer,
24657 error ("parenthesized initialization is not allowed in "
24658 "OpenMP %<for%> loop");
24660 /* Trigger an error. */
24661 cp_parser_require (parser, CPP_EQ, RT_EQ);
24663 init = error_mark_node;
24664 cp_parser_skip_to_end_of_statement (parser);
24666 else if (CLASS_TYPE_P (TREE_TYPE (decl))
24667 || type_dependent_expression_p (decl)
24670 bool is_direct_init, is_non_constant_init;
24672 init = cp_parser_initializer (parser,
24674 &is_non_constant_init);
24679 = do_auto_deduction (TREE_TYPE (decl), init,
24682 if (!CLASS_TYPE_P (TREE_TYPE (decl))
24683 && !type_dependent_expression_p (decl))
24687 cp_finish_decl (decl, init, !is_non_constant_init,
24689 LOOKUP_ONLYCONVERTING);
24690 if (CLASS_TYPE_P (TREE_TYPE (decl)))
24692 VEC_safe_push (tree, gc, for_block, this_pre_body);
24696 init = pop_stmt_list (this_pre_body);
24697 this_pre_body = NULL_TREE;
24702 cp_lexer_consume_token (parser->lexer);
24703 init = cp_parser_assignment_expression (parser, false, NULL);
24706 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
24707 init = error_mark_node;
24709 cp_finish_decl (decl, NULL_TREE,
24710 /*init_const_expr_p=*/false,
24712 LOOKUP_ONLYCONVERTING);
24716 pop_scope (pushed_scope);
24722 /* If parsing a type specifier sequence failed, then
24723 this MUST be a simple expression. */
24724 cp_parser_parse_tentatively (parser);
24725 decl = cp_parser_primary_expression (parser, false, false,
24727 if (!cp_parser_error_occurred (parser)
24730 && CLASS_TYPE_P (TREE_TYPE (decl)))
24734 cp_parser_parse_definitely (parser);
24735 cp_parser_require (parser, CPP_EQ, RT_EQ);
24736 rhs = cp_parser_assignment_expression (parser, false, NULL);
24737 finish_expr_stmt (build_x_modify_expr (decl, NOP_EXPR,
24739 tf_warning_or_error));
24740 add_private_clause = true;
24745 cp_parser_abort_tentative_parse (parser);
24746 init = cp_parser_expression (parser, false, NULL);
24749 if (TREE_CODE (init) == MODIFY_EXPR
24750 || TREE_CODE (init) == MODOP_EXPR)
24751 real_decl = TREE_OPERAND (init, 0);
24756 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
24759 this_pre_body = pop_stmt_list (this_pre_body);
24763 pre_body = push_stmt_list ();
24765 add_stmt (this_pre_body);
24766 pre_body = pop_stmt_list (pre_body);
24769 pre_body = this_pre_body;
24774 if (par_clauses != NULL && real_decl != NULL_TREE)
24777 for (c = par_clauses; *c ; )
24778 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE
24779 && OMP_CLAUSE_DECL (*c) == real_decl)
24781 error_at (loc, "iteration variable %qD"
24782 " should not be firstprivate", real_decl);
24783 *c = OMP_CLAUSE_CHAIN (*c);
24785 else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_LASTPRIVATE
24786 && OMP_CLAUSE_DECL (*c) == real_decl)
24788 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
24789 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
24790 tree l = build_omp_clause (loc, OMP_CLAUSE_LASTPRIVATE);
24791 OMP_CLAUSE_DECL (l) = real_decl;
24792 OMP_CLAUSE_CHAIN (l) = clauses;
24793 CP_OMP_CLAUSE_INFO (l) = CP_OMP_CLAUSE_INFO (*c);
24795 OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
24796 CP_OMP_CLAUSE_INFO (*c) = NULL;
24797 add_private_clause = false;
24801 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_PRIVATE
24802 && OMP_CLAUSE_DECL (*c) == real_decl)
24803 add_private_clause = false;
24804 c = &OMP_CLAUSE_CHAIN (*c);
24808 if (add_private_clause)
24811 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
24813 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
24814 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
24815 && OMP_CLAUSE_DECL (c) == decl)
24817 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
24818 && OMP_CLAUSE_DECL (c) == decl)
24819 error_at (loc, "iteration variable %qD "
24820 "should not be firstprivate",
24822 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
24823 && OMP_CLAUSE_DECL (c) == decl)
24824 error_at (loc, "iteration variable %qD should not be reduction",
24829 c = build_omp_clause (loc, OMP_CLAUSE_PRIVATE);
24830 OMP_CLAUSE_DECL (c) = decl;
24831 c = finish_omp_clauses (c);
24834 OMP_CLAUSE_CHAIN (c) = clauses;
24841 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
24842 cond = cp_parser_omp_for_cond (parser, decl);
24843 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
24846 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
24848 /* If decl is an iterator, preserve the operator on decl
24849 until finish_omp_for. */
24851 && ((type_dependent_expression_p (decl)
24852 && !POINTER_TYPE_P (TREE_TYPE (decl)))
24853 || CLASS_TYPE_P (TREE_TYPE (decl))))
24854 incr = cp_parser_omp_for_incr (parser, decl);
24856 incr = cp_parser_expression (parser, false, NULL);
24859 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
24860 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
24861 /*or_comma=*/false,
24862 /*consume_paren=*/true);
24864 TREE_VEC_ELT (declv, i) = decl;
24865 TREE_VEC_ELT (initv, i) = init;
24866 TREE_VEC_ELT (condv, i) = cond;
24867 TREE_VEC_ELT (incrv, i) = incr;
24869 if (i == collapse - 1)
24872 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
24873 in between the collapsed for loops to be still considered perfectly
24874 nested. Hopefully the final version clarifies this.
24875 For now handle (multiple) {'s and empty statements. */
24876 cp_parser_parse_tentatively (parser);
24879 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
24881 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
24883 cp_lexer_consume_token (parser->lexer);
24886 else if (bracecount
24887 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
24888 cp_lexer_consume_token (parser->lexer);
24891 loc = cp_lexer_peek_token (parser->lexer)->location;
24892 error_at (loc, "not enough collapsed for loops");
24893 collapse_err = true;
24894 cp_parser_abort_tentative_parse (parser);
24903 cp_parser_parse_definitely (parser);
24904 nbraces += bracecount;
24908 /* Note that we saved the original contents of this flag when we entered
24909 the structured block, and so we don't need to re-save it here. */
24910 parser->in_statement = IN_OMP_FOR;
24912 /* Note that the grammar doesn't call for a structured block here,
24913 though the loop as a whole is a structured block. */
24914 body = push_stmt_list ();
24915 cp_parser_statement (parser, NULL_TREE, false, NULL);
24916 body = pop_stmt_list (body);
24918 if (declv == NULL_TREE)
24921 ret = finish_omp_for (loc_first, declv, initv, condv, incrv, body,
24922 pre_body, clauses);
24926 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
24928 cp_lexer_consume_token (parser->lexer);
24931 else if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
24932 cp_lexer_consume_token (parser->lexer);
24937 error_at (cp_lexer_peek_token (parser->lexer)->location,
24938 "collapsed loops not perfectly nested");
24940 collapse_err = true;
24941 cp_parser_statement_seq_opt (parser, NULL);
24942 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
24947 while (!VEC_empty (tree, for_block))
24948 add_stmt (pop_stmt_list (VEC_pop (tree, for_block)));
24949 release_tree_vector (for_block);
24955 #pragma omp for for-clause[optseq] new-line
24958 #define OMP_FOR_CLAUSE_MASK \
24959 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
24960 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
24961 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
24962 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
24963 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
24964 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
24965 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT) \
24966 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE))
24969 cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok)
24971 tree clauses, sb, ret;
24974 clauses = cp_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK,
24975 "#pragma omp for", pragma_tok);
24977 sb = begin_omp_structured_block ();
24978 save = cp_parser_begin_omp_structured_block (parser);
24980 ret = cp_parser_omp_for_loop (parser, clauses, NULL);
24982 cp_parser_end_omp_structured_block (parser, save);
24983 add_stmt (finish_omp_structured_block (sb));
24989 # pragma omp master new-line
24990 structured-block */
24993 cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok)
24995 cp_parser_require_pragma_eol (parser, pragma_tok);
24996 return c_finish_omp_master (input_location,
24997 cp_parser_omp_structured_block (parser));
25001 # pragma omp ordered new-line
25002 structured-block */
25005 cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok)
25007 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
25008 cp_parser_require_pragma_eol (parser, pragma_tok);
25009 return c_finish_omp_ordered (loc, cp_parser_omp_structured_block (parser));
25015 { section-sequence }
25018 section-directive[opt] structured-block
25019 section-sequence section-directive structured-block */
25022 cp_parser_omp_sections_scope (cp_parser *parser)
25024 tree stmt, substmt;
25025 bool error_suppress = false;
25028 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
25031 stmt = push_stmt_list ();
25033 if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
25037 substmt = begin_omp_structured_block ();
25038 save = cp_parser_begin_omp_structured_block (parser);
25042 cp_parser_statement (parser, NULL_TREE, false, NULL);
25044 tok = cp_lexer_peek_token (parser->lexer);
25045 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
25047 if (tok->type == CPP_CLOSE_BRACE)
25049 if (tok->type == CPP_EOF)
25053 cp_parser_end_omp_structured_block (parser, save);
25054 substmt = finish_omp_structured_block (substmt);
25055 substmt = build1 (OMP_SECTION, void_type_node, substmt);
25056 add_stmt (substmt);
25061 tok = cp_lexer_peek_token (parser->lexer);
25062 if (tok->type == CPP_CLOSE_BRACE)
25064 if (tok->type == CPP_EOF)
25067 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
25069 cp_lexer_consume_token (parser->lexer);
25070 cp_parser_require_pragma_eol (parser, tok);
25071 error_suppress = false;
25073 else if (!error_suppress)
25075 cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
25076 error_suppress = true;
25079 substmt = cp_parser_omp_structured_block (parser);
25080 substmt = build1 (OMP_SECTION, void_type_node, substmt);
25081 add_stmt (substmt);
25083 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
25085 substmt = pop_stmt_list (stmt);
25087 stmt = make_node (OMP_SECTIONS);
25088 TREE_TYPE (stmt) = void_type_node;
25089 OMP_SECTIONS_BODY (stmt) = substmt;
25096 # pragma omp sections sections-clause[optseq] newline
25099 #define OMP_SECTIONS_CLAUSE_MASK \
25100 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
25101 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25102 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
25103 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
25104 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
25107 cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok)
25111 clauses = cp_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK,
25112 "#pragma omp sections", pragma_tok);
25114 ret = cp_parser_omp_sections_scope (parser);
25116 OMP_SECTIONS_CLAUSES (ret) = clauses;
25122 # pragma parallel parallel-clause new-line
25123 # pragma parallel for parallel-for-clause new-line
25124 # pragma parallel sections parallel-sections-clause new-line */
25126 #define OMP_PARALLEL_CLAUSE_MASK \
25127 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
25128 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
25129 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25130 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
25131 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
25132 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
25133 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
25134 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
25137 cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok)
25139 enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL;
25140 const char *p_name = "#pragma omp parallel";
25141 tree stmt, clauses, par_clause, ws_clause, block;
25142 unsigned int mask = OMP_PARALLEL_CLAUSE_MASK;
25144 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
25146 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
25148 cp_lexer_consume_token (parser->lexer);
25149 p_kind = PRAGMA_OMP_PARALLEL_FOR;
25150 p_name = "#pragma omp parallel for";
25151 mask |= OMP_FOR_CLAUSE_MASK;
25152 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
25154 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
25156 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
25157 const char *p = IDENTIFIER_POINTER (id);
25158 if (strcmp (p, "sections") == 0)
25160 cp_lexer_consume_token (parser->lexer);
25161 p_kind = PRAGMA_OMP_PARALLEL_SECTIONS;
25162 p_name = "#pragma omp parallel sections";
25163 mask |= OMP_SECTIONS_CLAUSE_MASK;
25164 mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT);
25168 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
25169 block = begin_omp_parallel ();
25170 save = cp_parser_begin_omp_structured_block (parser);
25174 case PRAGMA_OMP_PARALLEL:
25175 cp_parser_statement (parser, NULL_TREE, false, NULL);
25176 par_clause = clauses;
25179 case PRAGMA_OMP_PARALLEL_FOR:
25180 c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
25181 cp_parser_omp_for_loop (parser, ws_clause, &par_clause);
25184 case PRAGMA_OMP_PARALLEL_SECTIONS:
25185 c_split_parallel_clauses (loc, clauses, &par_clause, &ws_clause);
25186 stmt = cp_parser_omp_sections_scope (parser);
25188 OMP_SECTIONS_CLAUSES (stmt) = ws_clause;
25192 gcc_unreachable ();
25195 cp_parser_end_omp_structured_block (parser, save);
25196 stmt = finish_omp_parallel (par_clause, block);
25197 if (p_kind != PRAGMA_OMP_PARALLEL)
25198 OMP_PARALLEL_COMBINED (stmt) = 1;
25203 # pragma omp single single-clause[optseq] new-line
25204 structured-block */
25206 #define OMP_SINGLE_CLAUSE_MASK \
25207 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
25208 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25209 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
25210 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
25213 cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok)
25215 tree stmt = make_node (OMP_SINGLE);
25216 TREE_TYPE (stmt) = void_type_node;
25218 OMP_SINGLE_CLAUSES (stmt)
25219 = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
25220 "#pragma omp single", pragma_tok);
25221 OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser);
25223 return add_stmt (stmt);
25227 # pragma omp task task-clause[optseq] new-line
25228 structured-block */
25230 #define OMP_TASK_CLAUSE_MASK \
25231 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
25232 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
25233 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
25234 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
25235 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
25236 | (1u << PRAGMA_OMP_CLAUSE_SHARED))
25239 cp_parser_omp_task (cp_parser *parser, cp_token *pragma_tok)
25241 tree clauses, block;
25244 clauses = cp_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
25245 "#pragma omp task", pragma_tok);
25246 block = begin_omp_task ();
25247 save = cp_parser_begin_omp_structured_block (parser);
25248 cp_parser_statement (parser, NULL_TREE, false, NULL);
25249 cp_parser_end_omp_structured_block (parser, save);
25250 return finish_omp_task (clauses, block);
25254 # pragma omp taskwait new-line */
25257 cp_parser_omp_taskwait (cp_parser *parser, cp_token *pragma_tok)
25259 cp_parser_require_pragma_eol (parser, pragma_tok);
25260 finish_omp_taskwait ();
25264 # pragma omp threadprivate (variable-list) */
25267 cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
25271 vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
25272 cp_parser_require_pragma_eol (parser, pragma_tok);
25274 finish_omp_threadprivate (vars);
25277 /* Main entry point to OpenMP statement pragmas. */
25280 cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
25284 switch (pragma_tok->pragma_kind)
25286 case PRAGMA_OMP_ATOMIC:
25287 cp_parser_omp_atomic (parser, pragma_tok);
25289 case PRAGMA_OMP_CRITICAL:
25290 stmt = cp_parser_omp_critical (parser, pragma_tok);
25292 case PRAGMA_OMP_FOR:
25293 stmt = cp_parser_omp_for (parser, pragma_tok);
25295 case PRAGMA_OMP_MASTER:
25296 stmt = cp_parser_omp_master (parser, pragma_tok);
25298 case PRAGMA_OMP_ORDERED:
25299 stmt = cp_parser_omp_ordered (parser, pragma_tok);
25301 case PRAGMA_OMP_PARALLEL:
25302 stmt = cp_parser_omp_parallel (parser, pragma_tok);
25304 case PRAGMA_OMP_SECTIONS:
25305 stmt = cp_parser_omp_sections (parser, pragma_tok);
25307 case PRAGMA_OMP_SINGLE:
25308 stmt = cp_parser_omp_single (parser, pragma_tok);
25310 case PRAGMA_OMP_TASK:
25311 stmt = cp_parser_omp_task (parser, pragma_tok);
25314 gcc_unreachable ();
25318 SET_EXPR_LOCATION (stmt, pragma_tok->location);
25323 static GTY (()) cp_parser *the_parser;
25326 /* Special handling for the first token or line in the file. The first
25327 thing in the file might be #pragma GCC pch_preprocess, which loads a
25328 PCH file, which is a GC collection point. So we need to handle this
25329 first pragma without benefit of an existing lexer structure.
25331 Always returns one token to the caller in *FIRST_TOKEN. This is
25332 either the true first token of the file, or the first token after
25333 the initial pragma. */
25336 cp_parser_initial_pragma (cp_token *first_token)
25340 cp_lexer_get_preprocessor_token (NULL, first_token);
25341 if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS)
25344 cp_lexer_get_preprocessor_token (NULL, first_token);
25345 if (first_token->type == CPP_STRING)
25347 name = first_token->u.value;
25349 cp_lexer_get_preprocessor_token (NULL, first_token);
25350 if (first_token->type != CPP_PRAGMA_EOL)
25351 error_at (first_token->location,
25352 "junk at end of %<#pragma GCC pch_preprocess%>");
25355 error_at (first_token->location, "expected string literal");
25357 /* Skip to the end of the pragma. */
25358 while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF)
25359 cp_lexer_get_preprocessor_token (NULL, first_token);
25361 /* Now actually load the PCH file. */
25363 c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
25365 /* Read one more token to return to our caller. We have to do this
25366 after reading the PCH file in, since its pointers have to be
25368 cp_lexer_get_preprocessor_token (NULL, first_token);
25371 /* Normal parsing of a pragma token. Here we can (and must) use the
25375 cp_parser_pragma (cp_parser *parser, enum pragma_context context)
25377 cp_token *pragma_tok;
25380 pragma_tok = cp_lexer_consume_token (parser->lexer);
25381 gcc_assert (pragma_tok->type == CPP_PRAGMA);
25382 parser->lexer->in_pragma = true;
25384 id = pragma_tok->pragma_kind;
25387 case PRAGMA_GCC_PCH_PREPROCESS:
25388 error_at (pragma_tok->location,
25389 "%<#pragma GCC pch_preprocess%> must be first");
25392 case PRAGMA_OMP_BARRIER:
25395 case pragma_compound:
25396 cp_parser_omp_barrier (parser, pragma_tok);
25399 error_at (pragma_tok->location, "%<#pragma omp barrier%> may only be "
25400 "used in compound statements");
25407 case PRAGMA_OMP_FLUSH:
25410 case pragma_compound:
25411 cp_parser_omp_flush (parser, pragma_tok);
25414 error_at (pragma_tok->location, "%<#pragma omp flush%> may only be "
25415 "used in compound statements");
25422 case PRAGMA_OMP_TASKWAIT:
25425 case pragma_compound:
25426 cp_parser_omp_taskwait (parser, pragma_tok);
25429 error_at (pragma_tok->location,
25430 "%<#pragma omp taskwait%> may only be "
25431 "used in compound statements");
25438 case PRAGMA_OMP_THREADPRIVATE:
25439 cp_parser_omp_threadprivate (parser, pragma_tok);
25442 case PRAGMA_OMP_ATOMIC:
25443 case PRAGMA_OMP_CRITICAL:
25444 case PRAGMA_OMP_FOR:
25445 case PRAGMA_OMP_MASTER:
25446 case PRAGMA_OMP_ORDERED:
25447 case PRAGMA_OMP_PARALLEL:
25448 case PRAGMA_OMP_SECTIONS:
25449 case PRAGMA_OMP_SINGLE:
25450 case PRAGMA_OMP_TASK:
25451 if (context == pragma_external)
25453 cp_parser_omp_construct (parser, pragma_tok);
25456 case PRAGMA_OMP_SECTION:
25457 error_at (pragma_tok->location,
25458 "%<#pragma omp section%> may only be used in "
25459 "%<#pragma omp sections%> construct");
25463 gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
25464 c_invoke_pragma_handler (id);
25468 cp_parser_error (parser, "expected declaration specifiers");
25472 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
25476 /* The interface the pragma parsers have to the lexer. */
25479 pragma_lex (tree *value)
25482 enum cpp_ttype ret;
25484 tok = cp_lexer_peek_token (the_parser->lexer);
25487 *value = tok->u.value;
25489 if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
25491 else if (ret == CPP_STRING)
25492 *value = cp_parser_string_literal (the_parser, false, false);
25495 cp_lexer_consume_token (the_parser->lexer);
25496 if (ret == CPP_KEYWORD)
25504 /* External interface. */
25506 /* Parse one entire translation unit. */
25509 c_parse_file (void)
25511 static bool already_called = false;
25513 if (already_called)
25515 sorry ("inter-module optimizations not implemented for C++");
25518 already_called = true;
25520 the_parser = cp_parser_new ();
25521 push_deferring_access_checks (flag_access_control
25522 ? dk_no_deferred : dk_no_check);
25523 cp_parser_translation_unit (the_parser);
25527 #include "gt-cp-parser.h"