2 Copyright (C) 2000-2015 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "double-int.h"
37 #include "print-tree.h"
38 #include "stringpool.h"
40 #include "trans-mem.h"
43 #include "c-family/c-pragma.h"
46 #include "diagnostic-core.h"
50 #include "plugin-api.h"
51 #include "hard-reg-set.h"
56 #include "c-family/c-common.h"
57 #include "c-family/c-objc.h"
59 #include "tree-pretty-print.h"
61 #include "type-utils.h"
63 #include "gomp-constants.h"
68 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
69 and c-lex.c) and the C++ parser. */
71 static cp_token eof_token =
73 CPP_EOF, RID_MAX, 0, PRAGMA_NONE, false, false, false, 0, { NULL }
76 /* The various kinds of non integral constant we encounter. */
77 typedef enum non_integral_constant {
79 /* floating-point literal */
83 /* %<__FUNCTION__%> */
85 /* %<__PRETTY_FUNCTION__%> */
93 /* %<typeid%> operator */
95 /* non-constant compound literals */
103 /* an array reference */
109 /* the address of a label */
123 /* calls to overloaded operators */
127 /* a comma operator */
129 /* a call to a constructor */
131 /* a transaction expression */
133 } non_integral_constant;
135 /* The various kinds of errors about name-lookup failing. */
136 typedef enum name_lookup_error {
141 /* is not a class or namespace */
143 /* is not a class, namespace, or enumeration */
147 /* The various kinds of required token */
148 typedef enum required_token {
150 RT_SEMICOLON, /* ';' */
151 RT_OPEN_PAREN, /* '(' */
152 RT_CLOSE_BRACE, /* '}' */
153 RT_OPEN_BRACE, /* '{' */
154 RT_CLOSE_SQUARE, /* ']' */
155 RT_OPEN_SQUARE, /* '[' */
159 RT_GREATER, /* '>' */
161 RT_ELLIPSIS, /* '...' */
165 RT_COLON_SCOPE, /* ':' or '::' */
166 RT_CLOSE_PAREN, /* ')' */
167 RT_COMMA_CLOSE_PAREN, /* ',' or ')' */
168 RT_PRAGMA_EOL, /* end of line */
169 RT_NAME, /* identifier */
171 /* The type is CPP_KEYWORD */
173 RT_DELETE, /* delete */
174 RT_RETURN, /* return */
175 RT_WHILE, /* while */
176 RT_EXTERN, /* extern */
177 RT_STATIC_ASSERT, /* static_assert */
178 RT_DECLTYPE, /* decltype */
179 RT_OPERATOR, /* operator */
180 RT_CLASS, /* class */
181 RT_TEMPLATE, /* template */
182 RT_NAMESPACE, /* namespace */
183 RT_USING, /* using */
186 RT_CATCH, /* catch */
187 RT_THROW, /* throw */
188 RT_LABEL, /* __label__ */
189 RT_AT_TRY, /* @try */
190 RT_AT_SYNCHRONIZED, /* @synchronized */
191 RT_AT_THROW, /* @throw */
193 RT_SELECT, /* selection-statement */
194 RT_INTERATION, /* iteration-statement */
195 RT_JUMP, /* jump-statement */
196 RT_CLASS_KEY, /* class-key */
197 RT_CLASS_TYPENAME_TEMPLATE, /* class, typename, or template */
198 RT_TRANSACTION_ATOMIC, /* __transaction_atomic */
199 RT_TRANSACTION_RELAXED, /* __transaction_relaxed */
200 RT_TRANSACTION_CANCEL /* __transaction_cancel */
205 static cp_lexer *cp_lexer_new_main
207 static cp_lexer *cp_lexer_new_from_tokens
208 (cp_token_cache *tokens);
209 static void cp_lexer_destroy
211 static int cp_lexer_saving_tokens
213 static cp_token *cp_lexer_token_at
214 (cp_lexer *, cp_token_position);
215 static void cp_lexer_get_preprocessor_token
216 (cp_lexer *, cp_token *);
217 static inline cp_token *cp_lexer_peek_token
219 static cp_token *cp_lexer_peek_nth_token
220 (cp_lexer *, size_t);
221 static inline bool cp_lexer_next_token_is
222 (cp_lexer *, enum cpp_ttype);
223 static bool cp_lexer_next_token_is_not
224 (cp_lexer *, enum cpp_ttype);
225 static bool cp_lexer_next_token_is_keyword
226 (cp_lexer *, enum rid);
227 static cp_token *cp_lexer_consume_token
229 static void cp_lexer_purge_token
231 static void cp_lexer_purge_tokens_after
232 (cp_lexer *, cp_token_position);
233 static void cp_lexer_save_tokens
235 static void cp_lexer_commit_tokens
237 static void cp_lexer_rollback_tokens
239 static void cp_lexer_print_token
240 (FILE *, cp_token *);
241 static inline bool cp_lexer_debugging_p
243 static void cp_lexer_start_debugging
244 (cp_lexer *) ATTRIBUTE_UNUSED;
245 static void cp_lexer_stop_debugging
246 (cp_lexer *) ATTRIBUTE_UNUSED;
248 static cp_token_cache *cp_token_cache_new
249 (cp_token *, cp_token *);
251 static void cp_parser_initial_pragma
254 static tree cp_literal_operator_id
257 static void cp_parser_cilk_simd
258 (cp_parser *, cp_token *);
259 static tree cp_parser_cilk_for
261 static bool cp_parser_omp_declare_reduction_exprs
263 static tree cp_parser_cilk_simd_vectorlength
264 (cp_parser *, tree, bool);
266 /* Manifest constants. */
267 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
268 #define CP_SAVED_TOKEN_STACK 5
272 /* The stream to which debugging output should be written. */
273 static FILE *cp_lexer_debug_stream;
275 /* Nonzero if we are parsing an unevaluated operand: an operand to
276 sizeof, typeof, or alignof. */
277 int cp_unevaluated_operand;
279 /* Dump up to NUM tokens in BUFFER to FILE starting with token
280 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
281 first token in BUFFER. If NUM is 0, dump all the tokens. If
282 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
283 highlighted by surrounding it in [[ ]]. */
286 cp_lexer_dump_tokens (FILE *file, vec<cp_token, va_gc> *buffer,
287 cp_token *start_token, unsigned num,
288 cp_token *curr_token)
290 unsigned i, nprinted;
294 fprintf (file, "%u tokens\n", vec_safe_length (buffer));
300 num = buffer->length ();
302 if (start_token == NULL)
303 start_token = buffer->address ();
305 if (start_token > buffer->address ())
307 cp_lexer_print_token (file, &(*buffer)[0]);
308 fprintf (file, " ... ");
313 for (i = 0; buffer->iterate (i, &token) && nprinted < num; i++)
315 if (token == start_token)
322 if (token == curr_token)
323 fprintf (file, "[[");
325 cp_lexer_print_token (file, token);
327 if (token == curr_token)
328 fprintf (file, "]]");
334 case CPP_CLOSE_BRACE:
344 if (i == num && i < buffer->length ())
346 fprintf (file, " ... ");
347 cp_lexer_print_token (file, &buffer->last ());
350 fprintf (file, "\n");
354 /* Dump all tokens in BUFFER to stderr. */
357 cp_lexer_debug_tokens (vec<cp_token, va_gc> *buffer)
359 cp_lexer_dump_tokens (stderr, buffer, NULL, 0, NULL);
363 debug (vec<cp_token, va_gc> &ref)
365 cp_lexer_dump_tokens (stderr, &ref, NULL, 0, NULL);
369 debug (vec<cp_token, va_gc> *ptr)
374 fprintf (stderr, "<nil>\n");
378 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
379 description for T. */
382 cp_debug_print_tree_if_set (FILE *file, const char *desc, tree t)
386 fprintf (file, "%s: ", desc);
387 print_node_brief (file, "", t, 0);
392 /* Dump parser context C to FILE. */
395 cp_debug_print_context (FILE *file, cp_parser_context *c)
397 const char *status_s[] = { "OK", "ERROR", "COMMITTED" };
398 fprintf (file, "{ status = %s, scope = ", status_s[c->status]);
399 print_node_brief (file, "", c->object_type, 0);
400 fprintf (file, "}\n");
404 /* Print the stack of parsing contexts to FILE starting with FIRST. */
407 cp_debug_print_context_stack (FILE *file, cp_parser_context *first)
410 cp_parser_context *c;
412 fprintf (file, "Parsing context stack:\n");
413 for (i = 0, c = first; c; c = c->next, i++)
415 fprintf (file, "\t#%u: ", i);
416 cp_debug_print_context (file, c);
421 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
424 cp_debug_print_flag (FILE *file, const char *desc, bool flag)
427 fprintf (file, "%s: true\n", desc);
431 /* Print an unparsed function entry UF to FILE. */
434 cp_debug_print_unparsed_function (FILE *file, cp_unparsed_functions_entry *uf)
437 cp_default_arg_entry *default_arg_fn;
440 fprintf (file, "\tFunctions with default args:\n");
442 vec_safe_iterate (uf->funs_with_default_args, i, &default_arg_fn);
445 fprintf (file, "\t\tClass type: ");
446 print_node_brief (file, "", default_arg_fn->class_type, 0);
447 fprintf (file, "\t\tDeclaration: ");
448 print_node_brief (file, "", default_arg_fn->decl, 0);
449 fprintf (file, "\n");
452 fprintf (file, "\n\tFunctions with definitions that require "
453 "post-processing\n\t\t");
454 for (i = 0; vec_safe_iterate (uf->funs_with_definitions, i, &fn); i++)
456 print_node_brief (file, "", fn, 0);
459 fprintf (file, "\n");
461 fprintf (file, "\n\tNon-static data members with initializers that require "
462 "post-processing\n\t\t");
463 for (i = 0; vec_safe_iterate (uf->nsdmis, i, &fn); i++)
465 print_node_brief (file, "", fn, 0);
468 fprintf (file, "\n");
472 /* Print the stack of unparsed member functions S to FILE. */
475 cp_debug_print_unparsed_queues (FILE *file,
476 vec<cp_unparsed_functions_entry, va_gc> *s)
479 cp_unparsed_functions_entry *uf;
481 fprintf (file, "Unparsed functions\n");
482 for (i = 0; vec_safe_iterate (s, i, &uf); i++)
484 fprintf (file, "#%u:\n", i);
485 cp_debug_print_unparsed_function (file, uf);
490 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
491 the given PARSER. If FILE is NULL, the output is printed on stderr. */
494 cp_debug_parser_tokens (FILE *file, cp_parser *parser, int window_size)
496 cp_token *next_token, *first_token, *start_token;
501 next_token = parser->lexer->next_token;
502 first_token = parser->lexer->buffer->address ();
503 start_token = (next_token > first_token + window_size / 2)
504 ? next_token - window_size / 2
506 cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
511 /* Dump debugging information for the given PARSER. If FILE is NULL,
512 the output is printed on stderr. */
515 cp_debug_parser (FILE *file, cp_parser *parser)
517 const size_t window_size = 20;
519 expanded_location eloc;
524 fprintf (file, "Parser state\n\n");
525 fprintf (file, "Number of tokens: %u\n",
526 vec_safe_length (parser->lexer->buffer));
527 cp_debug_print_tree_if_set (file, "Lookup scope", parser->scope);
528 cp_debug_print_tree_if_set (file, "Object scope",
529 parser->object_scope);
530 cp_debug_print_tree_if_set (file, "Qualifying scope",
531 parser->qualifying_scope);
532 cp_debug_print_context_stack (file, parser->context);
533 cp_debug_print_flag (file, "Allow GNU extensions",
534 parser->allow_gnu_extensions_p);
535 cp_debug_print_flag (file, "'>' token is greater-than",
536 parser->greater_than_is_operator_p);
537 cp_debug_print_flag (file, "Default args allowed in current "
538 "parameter list", parser->default_arg_ok_p);
539 cp_debug_print_flag (file, "Parsing integral constant-expression",
540 parser->integral_constant_expression_p);
541 cp_debug_print_flag (file, "Allow non-constant expression in current "
542 "constant-expression",
543 parser->allow_non_integral_constant_expression_p);
544 cp_debug_print_flag (file, "Seen non-constant expression",
545 parser->non_integral_constant_expression_p);
546 cp_debug_print_flag (file, "Local names and 'this' forbidden in "
548 parser->local_variables_forbidden_p);
549 cp_debug_print_flag (file, "In unbraced linkage specification",
550 parser->in_unbraced_linkage_specification_p);
551 cp_debug_print_flag (file, "Parsing a declarator",
552 parser->in_declarator_p);
553 cp_debug_print_flag (file, "In template argument list",
554 parser->in_template_argument_list_p);
555 cp_debug_print_flag (file, "Parsing an iteration statement",
556 parser->in_statement & IN_ITERATION_STMT);
557 cp_debug_print_flag (file, "Parsing a switch statement",
558 parser->in_statement & IN_SWITCH_STMT);
559 cp_debug_print_flag (file, "Parsing a structured OpenMP block",
560 parser->in_statement & IN_OMP_BLOCK);
561 cp_debug_print_flag (file, "Parsing a Cilk Plus for loop",
562 parser->in_statement & IN_CILK_SIMD_FOR);
563 cp_debug_print_flag (file, "Parsing a an OpenMP loop",
564 parser->in_statement & IN_OMP_FOR);
565 cp_debug_print_flag (file, "Parsing an if statement",
566 parser->in_statement & IN_IF_STMT);
567 cp_debug_print_flag (file, "Parsing a type-id in an expression "
568 "context", parser->in_type_id_in_expr_p);
569 cp_debug_print_flag (file, "Declarations are implicitly extern \"C\"",
570 parser->implicit_extern_c);
571 cp_debug_print_flag (file, "String expressions should be translated "
572 "to execution character set",
573 parser->translate_strings_p);
574 cp_debug_print_flag (file, "Parsing function body outside of a "
575 "local class", parser->in_function_body);
576 cp_debug_print_flag (file, "Auto correct a colon to a scope operator",
577 parser->colon_corrects_to_scope_p);
578 cp_debug_print_flag (file, "Colon doesn't start a class definition",
579 parser->colon_doesnt_start_class_def_p);
580 if (parser->type_definition_forbidden_message)
581 fprintf (file, "Error message for forbidden type definitions: %s\n",
582 parser->type_definition_forbidden_message);
583 cp_debug_print_unparsed_queues (file, parser->unparsed_queues);
584 fprintf (file, "Number of class definitions in progress: %u\n",
585 parser->num_classes_being_defined);
586 fprintf (file, "Number of template parameter lists for the current "
587 "declaration: %u\n", parser->num_template_parameter_lists);
588 cp_debug_parser_tokens (file, parser, window_size);
589 token = parser->lexer->next_token;
590 fprintf (file, "Next token to parse:\n");
591 fprintf (file, "\tToken: ");
592 cp_lexer_print_token (file, token);
593 eloc = expand_location (token->location);
594 fprintf (file, "\n\tFile: %s\n", eloc.file);
595 fprintf (file, "\tLine: %d\n", eloc.line);
596 fprintf (file, "\tColumn: %d\n", eloc.column);
600 debug (cp_parser &ref)
602 cp_debug_parser (stderr, &ref);
606 debug (cp_parser *ptr)
611 fprintf (stderr, "<nil>\n");
614 /* Allocate memory for a new lexer object and return it. */
617 cp_lexer_alloc (void)
621 c_common_no_more_pch ();
623 /* Allocate the memory. */
624 lexer = ggc_cleared_alloc<cp_lexer> ();
626 /* Initially we are not debugging. */
627 lexer->debugging_p = false;
629 lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
631 /* Create the buffer. */
632 vec_alloc (lexer->buffer, CP_LEXER_BUFFER_SIZE);
638 /* Create a new main C++ lexer, the lexer that gets tokens from the
642 cp_lexer_new_main (void)
647 /* It's possible that parsing the first pragma will load a PCH file,
648 which is a GC collection point. So we have to do that before
649 allocating any memory. */
650 cp_parser_initial_pragma (&token);
652 lexer = cp_lexer_alloc ();
654 /* Put the first token in the buffer. */
655 lexer->buffer->quick_push (token);
657 /* Get the remaining tokens from the preprocessor. */
658 while (token.type != CPP_EOF)
660 cp_lexer_get_preprocessor_token (lexer, &token);
661 vec_safe_push (lexer->buffer, token);
664 lexer->last_token = lexer->buffer->address ()
665 + lexer->buffer->length ()
667 lexer->next_token = lexer->buffer->length ()
668 ? lexer->buffer->address ()
671 /* Subsequent preprocessor diagnostics should use compiler
672 diagnostic functions to get the compiler source location. */
675 gcc_assert (!lexer->next_token->purged_p);
679 /* Create a new lexer whose token stream is primed with the tokens in
680 CACHE. When these tokens are exhausted, no new tokens will be read. */
683 cp_lexer_new_from_tokens (cp_token_cache *cache)
685 cp_token *first = cache->first;
686 cp_token *last = cache->last;
687 cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();
689 /* We do not own the buffer. */
690 lexer->buffer = NULL;
691 lexer->next_token = first == last ? &eof_token : first;
692 lexer->last_token = last;
694 lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK);
696 /* Initially we are not debugging. */
697 lexer->debugging_p = false;
699 gcc_assert (!lexer->next_token->purged_p);
703 /* Frees all resources associated with LEXER. */
706 cp_lexer_destroy (cp_lexer *lexer)
708 vec_free (lexer->buffer);
709 lexer->saved_tokens.release ();
713 /* Returns nonzero if debugging information should be output. */
716 cp_lexer_debugging_p (cp_lexer *lexer)
718 return lexer->debugging_p;
722 static inline cp_token_position
723 cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
725 gcc_assert (!previous_p || lexer->next_token != &eof_token);
727 return lexer->next_token - previous_p;
730 static inline cp_token *
731 cp_lexer_token_at (cp_lexer * /*lexer*/, cp_token_position pos)
737 cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
739 lexer->next_token = cp_lexer_token_at (lexer, pos);
742 static inline cp_token_position
743 cp_lexer_previous_token_position (cp_lexer *lexer)
745 if (lexer->next_token == &eof_token)
746 return lexer->last_token - 1;
748 return cp_lexer_token_position (lexer, true);
751 static inline cp_token *
752 cp_lexer_previous_token (cp_lexer *lexer)
754 cp_token_position tp = cp_lexer_previous_token_position (lexer);
756 return cp_lexer_token_at (lexer, tp);
759 /* nonzero if we are presently saving tokens. */
762 cp_lexer_saving_tokens (const cp_lexer* lexer)
764 return lexer->saved_tokens.length () != 0;
767 /* Store the next token from the preprocessor in *TOKEN. Return true
768 if we reach EOF. If LEXER is NULL, assume we are handling an
769 initial #pragma pch_preprocess, and thus want the lexer to return
770 processed strings. */
773 cp_lexer_get_preprocessor_token (cp_lexer *lexer, cp_token *token)
775 static int is_extern_c = 0;
777 /* Get a new token from the preprocessor. */
779 = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
780 lexer == NULL ? 0 : C_LEX_STRING_NO_JOIN);
781 token->keyword = RID_MAX;
782 token->pragma_kind = PRAGMA_NONE;
783 token->purged_p = false;
784 token->error_reported = false;
786 /* On some systems, some header files are surrounded by an
787 implicit extern "C" block. Set a flag in the token if it
788 comes from such a header. */
789 is_extern_c += pending_lang_change;
790 pending_lang_change = 0;
791 token->implicit_extern_c = is_extern_c > 0;
793 /* Check to see if this token is a keyword. */
794 if (token->type == CPP_NAME)
796 if (C_IS_RESERVED_WORD (token->u.value))
798 /* Mark this token as a keyword. */
799 token->type = CPP_KEYWORD;
800 /* Record which keyword. */
801 token->keyword = C_RID_CODE (token->u.value);
805 if (warn_cxx0x_compat
806 && C_RID_CODE (token->u.value) >= RID_FIRST_CXX0X
807 && C_RID_CODE (token->u.value) <= RID_LAST_CXX0X)
809 /* Warn about the C++0x keyword (but still treat it as
811 warning (OPT_Wc__0x_compat,
812 "identifier %qE is a keyword in C++11",
815 /* Clear out the C_RID_CODE so we don't warn about this
816 particular identifier-turned-keyword again. */
817 C_SET_RID_CODE (token->u.value, RID_MAX);
820 token->keyword = RID_MAX;
823 else if (token->type == CPP_AT_NAME)
825 /* This only happens in Objective-C++; it must be a keyword. */
826 token->type = CPP_KEYWORD;
827 switch (C_RID_CODE (token->u.value))
829 /* Replace 'class' with '@class', 'private' with '@private',
830 etc. This prevents confusion with the C++ keyword
831 'class', and makes the tokens consistent with other
832 Objective-C 'AT' keywords. For example '@class' is
833 reported as RID_AT_CLASS which is consistent with
834 '@synchronized', which is reported as
837 case RID_CLASS: token->keyword = RID_AT_CLASS; break;
838 case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break;
839 case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
840 case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break;
841 case RID_THROW: token->keyword = RID_AT_THROW; break;
842 case RID_TRY: token->keyword = RID_AT_TRY; break;
843 case RID_CATCH: token->keyword = RID_AT_CATCH; break;
844 default: token->keyword = C_RID_CODE (token->u.value);
847 else if (token->type == CPP_PRAGMA)
849 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
850 token->pragma_kind = ((enum pragma_kind)
851 TREE_INT_CST_LOW (token->u.value));
852 token->u.value = NULL_TREE;
856 /* Update the globals input_location and the input file stack from TOKEN. */
858 cp_lexer_set_source_position_from_token (cp_token *token)
860 if (token->type != CPP_EOF)
862 input_location = token->location;
866 /* Update the globals input_location and the input file stack from LEXER. */
868 cp_lexer_set_source_position (cp_lexer *lexer)
870 cp_token *token = cp_lexer_peek_token (lexer);
871 cp_lexer_set_source_position_from_token (token);
874 /* Return a pointer to the next token in the token stream, but do not
877 static inline cp_token *
878 cp_lexer_peek_token (cp_lexer *lexer)
880 if (cp_lexer_debugging_p (lexer))
882 fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
883 cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
884 putc ('\n', cp_lexer_debug_stream);
886 return lexer->next_token;
889 /* Return true if the next token has the indicated TYPE. */
892 cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
894 return cp_lexer_peek_token (lexer)->type == type;
897 /* Return true if the next token does not have the indicated TYPE. */
900 cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
902 return !cp_lexer_next_token_is (lexer, type);
905 /* Return true if the next token is the indicated KEYWORD. */
908 cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
910 return cp_lexer_peek_token (lexer)->keyword == keyword;
914 cp_lexer_nth_token_is (cp_lexer* lexer, size_t n, enum cpp_ttype type)
916 return cp_lexer_peek_nth_token (lexer, n)->type == type;
920 cp_lexer_nth_token_is_keyword (cp_lexer* lexer, size_t n, enum rid keyword)
922 return cp_lexer_peek_nth_token (lexer, n)->keyword == keyword;
925 /* Return true if the next token is not the indicated KEYWORD. */
928 cp_lexer_next_token_is_not_keyword (cp_lexer* lexer, enum rid keyword)
930 return cp_lexer_peek_token (lexer)->keyword != keyword;
933 /* Return true if the next token is a keyword for a decl-specifier. */
936 cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
940 token = cp_lexer_peek_token (lexer);
941 switch (token->keyword)
943 /* auto specifier: storage-class-specifier in C++,
944 simple-type-specifier in C++0x. */
946 /* Storage classes. */
952 /* Elaborated type specifiers. */
958 /* Simple type specifiers. */
972 /* GNU extensions. */
975 /* C++0x extensions. */
977 case RID_UNDERLYING_TYPE:
981 if (token->keyword >= RID_FIRST_INT_N
982 && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS
983 && int_n_enabled_p[token->keyword - RID_FIRST_INT_N])
989 /* Returns TRUE iff the token T begins a decltype type. */
992 token_is_decltype (cp_token *t)
994 return (t->keyword == RID_DECLTYPE
995 || t->type == CPP_DECLTYPE);
998 /* Returns TRUE iff the next token begins a decltype type. */
1001 cp_lexer_next_token_is_decltype (cp_lexer *lexer)
1003 cp_token *t = cp_lexer_peek_token (lexer);
1004 return token_is_decltype (t);
1007 /* Return a pointer to the Nth token in the token stream. If N is 1,
1008 then this is precisely equivalent to cp_lexer_peek_token (except
1009 that it is not inline). One would like to disallow that case, but
1010 there is one case (cp_parser_nth_token_starts_template_id) where
1011 the caller passes a variable for N and it might be 1. */
1014 cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
1018 /* N is 1-based, not zero-based. */
1021 if (cp_lexer_debugging_p (lexer))
1022 fprintf (cp_lexer_debug_stream,
1023 "cp_lexer: peeking ahead %ld at token: ", (long)n);
1026 token = lexer->next_token;
1027 gcc_assert (!n || token != &eof_token);
1031 if (token == lexer->last_token)
1037 if (!token->purged_p)
1041 if (cp_lexer_debugging_p (lexer))
1043 cp_lexer_print_token (cp_lexer_debug_stream, token);
1044 putc ('\n', cp_lexer_debug_stream);
1050 /* Return the next token, and advance the lexer's next_token pointer
1051 to point to the next non-purged token. */
1054 cp_lexer_consume_token (cp_lexer* lexer)
1056 cp_token *token = lexer->next_token;
1058 gcc_assert (token != &eof_token);
1059 gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
1063 lexer->next_token++;
1064 if (lexer->next_token == lexer->last_token)
1066 lexer->next_token = &eof_token;
1071 while (lexer->next_token->purged_p);
1073 cp_lexer_set_source_position_from_token (token);
1075 /* Provide debugging output. */
1076 if (cp_lexer_debugging_p (lexer))
1078 fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
1079 cp_lexer_print_token (cp_lexer_debug_stream, token);
1080 putc ('\n', cp_lexer_debug_stream);
1086 /* Permanently remove the next token from the token stream, and
1087 advance the next_token pointer to refer to the next non-purged
1091 cp_lexer_purge_token (cp_lexer *lexer)
1093 cp_token *tok = lexer->next_token;
1095 gcc_assert (tok != &eof_token);
1096 tok->purged_p = true;
1097 tok->location = UNKNOWN_LOCATION;
1098 tok->u.value = NULL_TREE;
1099 tok->keyword = RID_MAX;
1104 if (tok == lexer->last_token)
1110 while (tok->purged_p);
1111 lexer->next_token = tok;
1114 /* Permanently remove all tokens after TOK, up to, but not
1115 including, the token that will be returned next by
1116 cp_lexer_peek_token. */
1119 cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
1121 cp_token *peek = lexer->next_token;
1123 if (peek == &eof_token)
1124 peek = lexer->last_token;
1126 gcc_assert (tok < peek);
1128 for ( tok += 1; tok != peek; tok += 1)
1130 tok->purged_p = true;
1131 tok->location = UNKNOWN_LOCATION;
1132 tok->u.value = NULL_TREE;
1133 tok->keyword = RID_MAX;
1137 /* Begin saving tokens. All tokens consumed after this point will be
1141 cp_lexer_save_tokens (cp_lexer* lexer)
1143 /* Provide debugging output. */
1144 if (cp_lexer_debugging_p (lexer))
1145 fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");
1147 lexer->saved_tokens.safe_push (lexer->next_token);
1150 /* Commit to the portion of the token stream most recently saved. */
1153 cp_lexer_commit_tokens (cp_lexer* lexer)
1155 /* Provide debugging output. */
1156 if (cp_lexer_debugging_p (lexer))
1157 fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");
1159 lexer->saved_tokens.pop ();
1162 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1163 to the token stream. Stop saving tokens. */
1166 cp_lexer_rollback_tokens (cp_lexer* lexer)
1168 /* Provide debugging output. */
1169 if (cp_lexer_debugging_p (lexer))
1170 fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");
1172 lexer->next_token = lexer->saved_tokens.pop ();
1175 /* RAII wrapper around the above functions, with sanity checking. Creating
1176 a variable saves tokens, which are committed when the variable is
1177 destroyed unless they are explicitly rolled back by calling the rollback
1180 struct saved_token_sentinel
1185 saved_token_sentinel(cp_lexer *lexer): lexer(lexer), commit(true)
1187 len = lexer->saved_tokens.length ();
1188 cp_lexer_save_tokens (lexer);
1192 cp_lexer_rollback_tokens (lexer);
1195 ~saved_token_sentinel()
1198 cp_lexer_commit_tokens (lexer);
1199 gcc_assert (lexer->saved_tokens.length () == len);
1203 /* Print a representation of the TOKEN on the STREAM. */
1206 cp_lexer_print_token (FILE * stream, cp_token *token)
1208 /* We don't use cpp_type2name here because the parser defines
1209 a few tokens of its own. */
1210 static const char *const token_names[] = {
1211 /* cpplib-defined token types */
1212 #define OP(e, s) #e,
1213 #define TK(e, s) #e,
1217 /* C++ parser token types - see "Manifest constants", above. */
1220 "NESTED_NAME_SPECIFIER",
1223 /* For some tokens, print the associated data. */
1224 switch (token->type)
1227 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1228 For example, `struct' is mapped to an INTEGER_CST. */
1229 if (!identifier_p (token->u.value))
1231 /* else fall through */
1233 fputs (IDENTIFIER_POINTER (token->u.value), stream);
1240 case CPP_UTF8STRING:
1241 fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value));
1245 print_generic_expr (stream, token->u.value, 0);
1249 /* If we have a name for the token, print it out. Otherwise, we
1250 simply give the numeric code. */
1251 if (token->type < ARRAY_SIZE(token_names))
1252 fputs (token_names[token->type], stream);
1254 fprintf (stream, "[%d]", token->type);
1260 debug (cp_token &ref)
1262 cp_lexer_print_token (stderr, &ref);
1263 fprintf (stderr, "\n");
1267 debug (cp_token *ptr)
1272 fprintf (stderr, "<nil>\n");
1276 /* Start emitting debugging information. */
1279 cp_lexer_start_debugging (cp_lexer* lexer)
1281 lexer->debugging_p = true;
1282 cp_lexer_debug_stream = stderr;
1285 /* Stop emitting debugging information. */
1288 cp_lexer_stop_debugging (cp_lexer* lexer)
1290 lexer->debugging_p = false;
1291 cp_lexer_debug_stream = NULL;
1294 /* Create a new cp_token_cache, representing a range of tokens. */
1296 static cp_token_cache *
1297 cp_token_cache_new (cp_token *first, cp_token *last)
1299 cp_token_cache *cache = ggc_alloc<cp_token_cache> ();
1300 cache->first = first;
1305 /* Diagnose if #pragma omp declare simd isn't followed immediately
1306 by function declaration or definition. */
1309 cp_ensure_no_omp_declare_simd (cp_parser *parser)
1311 if (parser->omp_declare_simd && !parser->omp_declare_simd->error_seen)
1313 error ("%<#pragma omp declare simd%> not immediately followed by "
1314 "function declaration or definition");
1315 parser->omp_declare_simd = NULL;
1319 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1320 and put that into "omp declare simd" attribute. */
1323 cp_finalize_omp_declare_simd (cp_parser *parser, tree fndecl)
1325 if (__builtin_expect (parser->omp_declare_simd != NULL, 0))
1327 if (fndecl == error_mark_node)
1329 parser->omp_declare_simd = NULL;
1332 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1334 cp_ensure_no_omp_declare_simd (parser);
1340 /* Decl-specifiers. */
1342 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1345 clear_decl_specs (cp_decl_specifier_seq *decl_specs)
1347 memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
1352 /* Nothing other than the parser should be creating declarators;
1353 declarators are a semi-syntactic representation of C++ entities.
1354 Other parts of the front end that need to create entities (like
1355 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1357 static cp_declarator *make_call_declarator
1358 (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, cp_ref_qualifier, tree, tree);
1359 static cp_declarator *make_array_declarator
1360 (cp_declarator *, tree);
1361 static cp_declarator *make_pointer_declarator
1362 (cp_cv_quals, cp_declarator *, tree);
1363 static cp_declarator *make_reference_declarator
1364 (cp_cv_quals, cp_declarator *, bool, tree);
1365 static cp_parameter_declarator *make_parameter_declarator
1366 (cp_decl_specifier_seq *, cp_declarator *, tree);
1367 static cp_declarator *make_ptrmem_declarator
1368 (cp_cv_quals, tree, cp_declarator *, tree);
1370 /* An erroneous declarator. */
1371 static cp_declarator *cp_error_declarator;
1373 /* The obstack on which declarators and related data structures are
1375 static struct obstack declarator_obstack;
1377 /* Alloc BYTES from the declarator memory pool. */
1379 static inline void *
1380 alloc_declarator (size_t bytes)
1382 return obstack_alloc (&declarator_obstack, bytes);
1385 /* Allocate a declarator of the indicated KIND. Clear fields that are
1386 common to all declarators. */
1388 static cp_declarator *
1389 make_declarator (cp_declarator_kind kind)
1391 cp_declarator *declarator;
1393 declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
1394 declarator->kind = kind;
1395 declarator->attributes = NULL_TREE;
1396 declarator->std_attributes = NULL_TREE;
1397 declarator->declarator = NULL;
1398 declarator->parameter_pack_p = false;
1399 declarator->id_loc = UNKNOWN_LOCATION;
1404 /* Make a declarator for a generalized identifier. If
1405 QUALIFYING_SCOPE is non-NULL, the identifier is
1406 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1407 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1410 static cp_declarator *
1411 make_id_declarator (tree qualifying_scope, tree unqualified_name,
1412 special_function_kind sfk)
1414 cp_declarator *declarator;
1416 /* It is valid to write:
1418 class C { void f(); };
1422 The standard is not clear about whether `typedef const C D' is
1423 legal; as of 2002-09-15 the committee is considering that
1424 question. EDG 3.0 allows that syntax. Therefore, we do as
1426 if (qualifying_scope && TYPE_P (qualifying_scope))
1427 qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope);
1429 gcc_assert (identifier_p (unqualified_name)
1430 || TREE_CODE (unqualified_name) == BIT_NOT_EXPR
1431 || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR);
1433 declarator = make_declarator (cdk_id);
1434 declarator->u.id.qualifying_scope = qualifying_scope;
1435 declarator->u.id.unqualified_name = unqualified_name;
1436 declarator->u.id.sfk = sfk;
1441 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1442 of modifiers such as const or volatile to apply to the pointer
1443 type, represented as identifiers. ATTRIBUTES represent the attributes that
1444 appertain to the pointer or reference. */
1447 make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1450 cp_declarator *declarator;
1452 declarator = make_declarator (cdk_pointer);
1453 declarator->declarator = target;
1454 declarator->u.pointer.qualifiers = cv_qualifiers;
1455 declarator->u.pointer.class_type = NULL_TREE;
1458 declarator->id_loc = target->id_loc;
1459 declarator->parameter_pack_p = target->parameter_pack_p;
1460 target->parameter_pack_p = false;
1463 declarator->parameter_pack_p = false;
1465 declarator->std_attributes = attributes;
1470 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1471 represent the attributes that appertain to the pointer or
1475 make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
1476 bool rvalue_ref, tree attributes)
1478 cp_declarator *declarator;
1480 declarator = make_declarator (cdk_reference);
1481 declarator->declarator = target;
1482 declarator->u.reference.qualifiers = cv_qualifiers;
1483 declarator->u.reference.rvalue_ref = rvalue_ref;
1486 declarator->id_loc = target->id_loc;
1487 declarator->parameter_pack_p = target->parameter_pack_p;
1488 target->parameter_pack_p = false;
1491 declarator->parameter_pack_p = false;
1493 declarator->std_attributes = attributes;
1498 /* Like make_pointer_declarator -- but for a pointer to a non-static
1499 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1500 appertain to the pointer or reference. */
1503 make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
1504 cp_declarator *pointee,
1507 cp_declarator *declarator;
1509 declarator = make_declarator (cdk_ptrmem);
1510 declarator->declarator = pointee;
1511 declarator->u.pointer.qualifiers = cv_qualifiers;
1512 declarator->u.pointer.class_type = class_type;
1516 declarator->parameter_pack_p = pointee->parameter_pack_p;
1517 pointee->parameter_pack_p = false;
1520 declarator->parameter_pack_p = false;
1522 declarator->std_attributes = attributes;
1527 /* Make a declarator for the function given by TARGET, with the
1528 indicated PARMS. The CV_QUALIFIERS aply to the function, as in
1529 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1530 indicates what exceptions can be thrown. */
1533 make_call_declarator (cp_declarator *target,
1535 cp_cv_quals cv_qualifiers,
1536 cp_virt_specifiers virt_specifiers,
1537 cp_ref_qualifier ref_qualifier,
1538 tree exception_specification,
1539 tree late_return_type)
1541 cp_declarator *declarator;
1543 declarator = make_declarator (cdk_function);
1544 declarator->declarator = target;
1545 declarator->u.function.parameters = parms;
1546 declarator->u.function.qualifiers = cv_qualifiers;
1547 declarator->u.function.virt_specifiers = virt_specifiers;
1548 declarator->u.function.ref_qualifier = ref_qualifier;
1549 declarator->u.function.exception_specification = exception_specification;
1550 declarator->u.function.late_return_type = late_return_type;
1553 declarator->id_loc = target->id_loc;
1554 declarator->parameter_pack_p = target->parameter_pack_p;
1555 target->parameter_pack_p = false;
1558 declarator->parameter_pack_p = false;
1563 /* Make a declarator for an array of BOUNDS elements, each of which is
1564 defined by ELEMENT. */
1567 make_array_declarator (cp_declarator *element, tree bounds)
1569 cp_declarator *declarator;
1571 declarator = make_declarator (cdk_array);
1572 declarator->declarator = element;
1573 declarator->u.array.bounds = bounds;
1576 declarator->id_loc = element->id_loc;
1577 declarator->parameter_pack_p = element->parameter_pack_p;
1578 element->parameter_pack_p = false;
1581 declarator->parameter_pack_p = false;
1586 /* Determine whether the declarator we've seen so far can be a
1587 parameter pack, when followed by an ellipsis. */
1589 declarator_can_be_parameter_pack (cp_declarator *declarator)
1591 /* Search for a declarator name, or any other declarator that goes
1592 after the point where the ellipsis could appear in a parameter
1593 pack. If we find any of these, then this declarator can not be
1594 made into a parameter pack. */
1596 while (declarator && !found)
1598 switch ((int)declarator->kind)
1609 declarator = declarator->declarator;
1617 cp_parameter_declarator *no_parameters;
1619 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1620 DECLARATOR and DEFAULT_ARGUMENT. */
1622 cp_parameter_declarator *
1623 make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
1624 cp_declarator *declarator,
1625 tree default_argument)
1627 cp_parameter_declarator *parameter;
1629 parameter = ((cp_parameter_declarator *)
1630 alloc_declarator (sizeof (cp_parameter_declarator)));
1631 parameter->next = NULL;
1632 if (decl_specifiers)
1633 parameter->decl_specifiers = *decl_specifiers;
1635 clear_decl_specs (¶meter->decl_specifiers);
1636 parameter->declarator = declarator;
1637 parameter->default_argument = default_argument;
1638 parameter->ellipsis_p = false;
1643 /* Returns true iff DECLARATOR is a declaration for a function. */
1646 function_declarator_p (const cp_declarator *declarator)
1650 if (declarator->kind == cdk_function
1651 && declarator->declarator->kind == cdk_id)
1653 if (declarator->kind == cdk_id
1654 || declarator->kind == cdk_error)
1656 declarator = declarator->declarator;
1666 A cp_parser parses the token stream as specified by the C++
1667 grammar. Its job is purely parsing, not semantic analysis. For
1668 example, the parser breaks the token stream into declarators,
1669 expressions, statements, and other similar syntactic constructs.
1670 It does not check that the types of the expressions on either side
1671 of an assignment-statement are compatible, or that a function is
1672 not declared with a parameter of type `void'.
1674 The parser invokes routines elsewhere in the compiler to perform
1675 semantic analysis and to build up the abstract syntax tree for the
1678 The parser (and the template instantiation code, which is, in a
1679 way, a close relative of parsing) are the only parts of the
1680 compiler that should be calling push_scope and pop_scope, or
1681 related functions. The parser (and template instantiation code)
1682 keeps track of what scope is presently active; everything else
1683 should simply honor that. (The code that generates static
1684 initializers may also need to set the scope, in order to check
1685 access control correctly when emitting the initializers.)
1690 The parser is of the standard recursive-descent variety. Upcoming
1691 tokens in the token stream are examined in order to determine which
1692 production to use when parsing a non-terminal. Some C++ constructs
1693 require arbitrary look ahead to disambiguate. For example, it is
1694 impossible, in the general case, to tell whether a statement is an
1695 expression or declaration without scanning the entire statement.
1696 Therefore, the parser is capable of "parsing tentatively." When the
1697 parser is not sure what construct comes next, it enters this mode.
1698 Then, while we attempt to parse the construct, the parser queues up
1699 error messages, rather than issuing them immediately, and saves the
1700 tokens it consumes. If the construct is parsed successfully, the
1701 parser "commits", i.e., it issues any queued error messages and
1702 the tokens that were being preserved are permanently discarded.
1703 If, however, the construct is not parsed successfully, the parser
1704 rolls back its state completely so that it can resume parsing using
1705 a different alternative.
1710 The performance of the parser could probably be improved substantially.
1711 We could often eliminate the need to parse tentatively by looking ahead
1712 a little bit. In some places, this approach might not entirely eliminate
1713 the need to parse tentatively, but it might still speed up the average
1716 /* Flags that are passed to some parsing functions. These values can
1717 be bitwise-ored together. */
1722 CP_PARSER_FLAGS_NONE = 0x0,
1723 /* The construct is optional. If it is not present, then no error
1724 should be issued. */
1725 CP_PARSER_FLAGS_OPTIONAL = 0x1,
1726 /* When parsing a type-specifier, treat user-defined type-names
1727 as non-type identifiers. */
1728 CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
1729 /* When parsing a type-specifier, do not try to parse a class-specifier
1730 or enum-specifier. */
1731 CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
1732 /* When parsing a decl-specifier-seq, only allow type-specifier or
1734 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8
1737 /* This type is used for parameters and variables which hold
1738 combinations of the above flags. */
1739 typedef int cp_parser_flags;
1741 /* The different kinds of declarators we want to parse. */
1743 typedef enum cp_parser_declarator_kind
1745 /* We want an abstract declarator. */
1746 CP_PARSER_DECLARATOR_ABSTRACT,
1747 /* We want a named declarator. */
1748 CP_PARSER_DECLARATOR_NAMED,
1749 /* We don't mind, but the name must be an unqualified-id. */
1750 CP_PARSER_DECLARATOR_EITHER
1751 } cp_parser_declarator_kind;
1753 /* The precedence values used to parse binary expressions. The minimum value
1754 of PREC must be 1, because zero is reserved to quickly discriminate
1755 binary operators from other tokens. */
1760 PREC_LOGICAL_OR_EXPRESSION,
1761 PREC_LOGICAL_AND_EXPRESSION,
1762 PREC_INCLUSIVE_OR_EXPRESSION,
1763 PREC_EXCLUSIVE_OR_EXPRESSION,
1764 PREC_AND_EXPRESSION,
1765 PREC_EQUALITY_EXPRESSION,
1766 PREC_RELATIONAL_EXPRESSION,
1767 PREC_SHIFT_EXPRESSION,
1768 PREC_ADDITIVE_EXPRESSION,
1769 PREC_MULTIPLICATIVE_EXPRESSION,
1771 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1774 /* A mapping from a token type to a corresponding tree node type, with a
1775 precedence value. */
1777 typedef struct cp_parser_binary_operations_map_node
1779 /* The token type. */
1780 enum cpp_ttype token_type;
1781 /* The corresponding tree code. */
1782 enum tree_code tree_type;
1783 /* The precedence of this operator. */
1784 enum cp_parser_prec prec;
1785 } cp_parser_binary_operations_map_node;
1787 typedef struct cp_parser_expression_stack_entry
1789 /* Left hand side of the binary operation we are currently
1792 /* Original tree code for left hand side, if it was a binary
1793 expression itself (used for -Wparentheses). */
1794 enum tree_code lhs_type;
1795 /* Tree code for the binary operation we are parsing. */
1796 enum tree_code tree_type;
1797 /* Precedence of the binary operation we are parsing. */
1798 enum cp_parser_prec prec;
1799 /* Location of the binary operation we are parsing. */
1801 } cp_parser_expression_stack_entry;
1803 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1804 entries because precedence levels on the stack are monotonically
1806 typedef struct cp_parser_expression_stack_entry
1807 cp_parser_expression_stack[NUM_PREC_VALUES];
1811 /* Constructors and destructors. */
1813 static cp_parser_context *cp_parser_context_new
1814 (cp_parser_context *);
1816 /* Class variables. */
1818 static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;
1820 /* The operator-precedence table used by cp_parser_binary_expression.
1821 Transformed into an associative array (binops_by_token) by
1824 static const cp_parser_binary_operations_map_node binops[] = {
1825 { CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
1826 { CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },
1828 { CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1829 { CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1830 { CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
1832 { CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1833 { CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },
1835 { CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1836 { CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
1838 { CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
1839 { CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
1840 { CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
1841 { CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },
1843 { CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
1844 { CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },
1846 { CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },
1848 { CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },
1850 { CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },
1852 { CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },
1854 { CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1857 /* The same as binops, but initialized by cp_parser_new so that
1858 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1860 static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES];
1862 /* Constructors and destructors. */
1864 /* Construct a new context. The context below this one on the stack
1865 is given by NEXT. */
1867 static cp_parser_context *
1868 cp_parser_context_new (cp_parser_context* next)
1870 cp_parser_context *context;
1872 /* Allocate the storage. */
1873 if (cp_parser_context_free_list != NULL)
1875 /* Pull the first entry from the free list. */
1876 context = cp_parser_context_free_list;
1877 cp_parser_context_free_list = context->next;
1878 memset (context, 0, sizeof (*context));
1881 context = ggc_cleared_alloc<cp_parser_context> ();
1883 /* No errors have occurred yet in this context. */
1884 context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
1885 /* If this is not the bottommost context, copy information that we
1886 need from the previous context. */
1889 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1890 expression, then we are parsing one in this context, too. */
1891 context->object_type = next->object_type;
1892 /* Thread the stack. */
1893 context->next = next;
1899 /* Managing the unparsed function queues. */
1901 #define unparsed_funs_with_default_args \
1902 parser->unparsed_queues->last ().funs_with_default_args
1903 #define unparsed_funs_with_definitions \
1904 parser->unparsed_queues->last ().funs_with_definitions
1905 #define unparsed_nsdmis \
1906 parser->unparsed_queues->last ().nsdmis
1907 #define unparsed_classes \
1908 parser->unparsed_queues->last ().classes
1911 push_unparsed_function_queues (cp_parser *parser)
1913 cp_unparsed_functions_entry e = {NULL, make_tree_vector (), NULL, NULL};
1914 vec_safe_push (parser->unparsed_queues, e);
1918 pop_unparsed_function_queues (cp_parser *parser)
1920 release_tree_vector (unparsed_funs_with_definitions);
1921 parser->unparsed_queues->pop ();
1926 /* Constructors and destructors. */
1928 static cp_parser *cp_parser_new
1931 /* Routines to parse various constructs.
1933 Those that return `tree' will return the error_mark_node (rather
1934 than NULL_TREE) if a parse error occurs, unless otherwise noted.
1935 Sometimes, they will return an ordinary node if error-recovery was
1936 attempted, even though a parse error occurred. So, to check
1937 whether or not a parse error occurred, you should always use
1938 cp_parser_error_occurred. If the construct is optional (indicated
1939 either by an `_opt' in the name of the function that does the
1940 parsing or via a FLAGS parameter), then NULL_TREE is returned if
1941 the construct is not present. */
1943 /* Lexical conventions [gram.lex] */
1945 static tree cp_parser_identifier
1947 static tree cp_parser_string_literal
1948 (cp_parser *, bool, bool, bool);
1949 static tree cp_parser_userdef_char_literal
1951 static tree cp_parser_userdef_string_literal
1953 static tree cp_parser_userdef_numeric_literal
1956 /* Basic concepts [gram.basic] */
1958 static bool cp_parser_translation_unit
1961 /* Expressions [gram.expr] */
1963 static tree cp_parser_primary_expression
1964 (cp_parser *, bool, bool, bool, cp_id_kind *);
1965 static tree cp_parser_id_expression
1966 (cp_parser *, bool, bool, bool *, bool, bool);
1967 static tree cp_parser_unqualified_id
1968 (cp_parser *, bool, bool, bool, bool);
1969 static tree cp_parser_nested_name_specifier_opt
1970 (cp_parser *, bool, bool, bool, bool);
1971 static tree cp_parser_nested_name_specifier
1972 (cp_parser *, bool, bool, bool, bool);
1973 static tree cp_parser_qualifying_entity
1974 (cp_parser *, bool, bool, bool, bool, bool);
1975 static tree cp_parser_postfix_expression
1976 (cp_parser *, bool, bool, bool, bool, cp_id_kind *);
1977 static tree cp_parser_postfix_open_square_expression
1978 (cp_parser *, tree, bool, bool);
1979 static tree cp_parser_postfix_dot_deref_expression
1980 (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *, location_t);
1981 static vec<tree, va_gc> *cp_parser_parenthesized_expression_list
1982 (cp_parser *, int, bool, bool, bool *, bool = false);
1983 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
1984 enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
1985 static void cp_parser_pseudo_destructor_name
1986 (cp_parser *, tree, tree *, tree *);
1987 static tree cp_parser_unary_expression
1988 (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false, bool = false);
1989 static enum tree_code cp_parser_unary_operator
1991 static tree cp_parser_new_expression
1993 static vec<tree, va_gc> *cp_parser_new_placement
1995 static tree cp_parser_new_type_id
1996 (cp_parser *, tree *);
1997 static cp_declarator *cp_parser_new_declarator_opt
1999 static cp_declarator *cp_parser_direct_new_declarator
2001 static vec<tree, va_gc> *cp_parser_new_initializer
2003 static tree cp_parser_delete_expression
2005 static tree cp_parser_cast_expression
2006 (cp_parser *, bool, bool, bool, cp_id_kind *);
2007 static tree cp_parser_binary_expression
2008 (cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
2009 static tree cp_parser_question_colon_clause
2010 (cp_parser *, tree);
2011 static tree cp_parser_assignment_expression
2012 (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
2013 static enum tree_code cp_parser_assignment_operator_opt
2015 static tree cp_parser_expression
2016 (cp_parser *, cp_id_kind * = NULL, bool = false, bool = false);
2017 static tree cp_parser_constant_expression
2018 (cp_parser *, bool = false, bool * = NULL);
2019 static tree cp_parser_builtin_offsetof
2021 static tree cp_parser_lambda_expression
2023 static void cp_parser_lambda_introducer
2024 (cp_parser *, tree);
2025 static bool cp_parser_lambda_declarator_opt
2026 (cp_parser *, tree);
2027 static void cp_parser_lambda_body
2028 (cp_parser *, tree);
2030 /* Statements [gram.stmt.stmt] */
2032 static void cp_parser_statement
2033 (cp_parser *, tree, bool, bool *);
2034 static void cp_parser_label_for_labeled_statement
2035 (cp_parser *, tree);
2036 static tree cp_parser_expression_statement
2037 (cp_parser *, tree);
2038 static tree cp_parser_compound_statement
2039 (cp_parser *, tree, bool, bool);
2040 static void cp_parser_statement_seq_opt
2041 (cp_parser *, tree);
2042 static tree cp_parser_selection_statement
2043 (cp_parser *, bool *);
2044 static tree cp_parser_condition
2046 static tree cp_parser_iteration_statement
2047 (cp_parser *, bool);
2048 static bool cp_parser_for_init_statement
2049 (cp_parser *, tree *decl);
2050 static tree cp_parser_for
2051 (cp_parser *, bool);
2052 static tree cp_parser_c_for
2053 (cp_parser *, tree, tree, bool);
2054 static tree cp_parser_range_for
2055 (cp_parser *, tree, tree, tree, bool);
2056 static void do_range_for_auto_deduction
2058 static tree cp_parser_perform_range_for_lookup
2059 (tree, tree *, tree *);
2060 static tree cp_parser_range_for_member_function
2062 static tree cp_parser_jump_statement
2064 static void cp_parser_declaration_statement
2067 static tree cp_parser_implicitly_scoped_statement
2068 (cp_parser *, bool *);
2069 static void cp_parser_already_scoped_statement
2072 /* Declarations [gram.dcl.dcl] */
2074 static void cp_parser_declaration_seq_opt
2076 static void cp_parser_declaration
2078 static void cp_parser_block_declaration
2079 (cp_parser *, bool);
2080 static void cp_parser_simple_declaration
2081 (cp_parser *, bool, tree *);
2082 static void cp_parser_decl_specifier_seq
2083 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
2084 static tree cp_parser_storage_class_specifier_opt
2086 static tree cp_parser_function_specifier_opt
2087 (cp_parser *, cp_decl_specifier_seq *);
2088 static tree cp_parser_type_specifier
2089 (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
2091 static tree cp_parser_simple_type_specifier
2092 (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
2093 static tree cp_parser_type_name
2095 static tree cp_parser_nonclass_name
2096 (cp_parser* parser);
2097 static tree cp_parser_elaborated_type_specifier
2098 (cp_parser *, bool, bool);
2099 static tree cp_parser_enum_specifier
2101 static void cp_parser_enumerator_list
2102 (cp_parser *, tree);
2103 static void cp_parser_enumerator_definition
2104 (cp_parser *, tree);
2105 static tree cp_parser_namespace_name
2107 static void cp_parser_namespace_definition
2109 static void cp_parser_namespace_body
2111 static tree cp_parser_qualified_namespace_specifier
2113 static void cp_parser_namespace_alias_definition
2115 static bool cp_parser_using_declaration
2116 (cp_parser *, bool);
2117 static void cp_parser_using_directive
2119 static tree cp_parser_alias_declaration
2121 static void cp_parser_asm_definition
2123 static void cp_parser_linkage_specification
2125 static void cp_parser_static_assert
2126 (cp_parser *, bool);
2127 static tree cp_parser_decltype
2130 /* Declarators [gram.dcl.decl] */
2132 static tree cp_parser_init_declarator
2133 (cp_parser *, cp_decl_specifier_seq *, vec<deferred_access_check, va_gc> *,
2134 bool, bool, int, bool *, tree *, location_t *);
2135 static cp_declarator *cp_parser_declarator
2136 (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool, bool);
2137 static cp_declarator *cp_parser_direct_declarator
2138 (cp_parser *, cp_parser_declarator_kind, int *, bool, bool);
2139 static enum tree_code cp_parser_ptr_operator
2140 (cp_parser *, tree *, cp_cv_quals *, tree *);
2141 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2143 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2145 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2147 static tree cp_parser_late_return_type_opt
2148 (cp_parser *, cp_declarator *, cp_cv_quals);
2149 static tree cp_parser_declarator_id
2150 (cp_parser *, bool);
2151 static tree cp_parser_type_id
2153 static tree cp_parser_template_type_arg
2155 static tree cp_parser_trailing_type_id (cp_parser *);
2156 static tree cp_parser_type_id_1
2157 (cp_parser *, bool, bool);
2158 static void cp_parser_type_specifier_seq
2159 (cp_parser *, bool, bool, cp_decl_specifier_seq *);
2160 static tree cp_parser_parameter_declaration_clause
2162 static tree cp_parser_parameter_declaration_list
2163 (cp_parser *, bool *);
2164 static cp_parameter_declarator *cp_parser_parameter_declaration
2165 (cp_parser *, bool, bool *);
2166 static tree cp_parser_default_argument
2167 (cp_parser *, bool);
2168 static void cp_parser_function_body
2169 (cp_parser *, bool);
2170 static tree cp_parser_initializer
2171 (cp_parser *, bool *, bool *);
2172 static tree cp_parser_initializer_clause
2173 (cp_parser *, bool *);
2174 static tree cp_parser_braced_list
2175 (cp_parser*, bool*);
2176 static vec<constructor_elt, va_gc> *cp_parser_initializer_list
2177 (cp_parser *, bool *);
2179 static bool cp_parser_ctor_initializer_opt_and_function_body
2180 (cp_parser *, bool);
2182 static tree cp_parser_late_parsing_omp_declare_simd
2183 (cp_parser *, tree);
2185 static tree cp_parser_late_parsing_cilk_simd_fn_info
2186 (cp_parser *, tree);
2188 static tree synthesize_implicit_template_parm
2190 static tree finish_fully_implicit_template
2191 (cp_parser *, tree);
2193 /* Classes [gram.class] */
2195 static tree cp_parser_class_name
2196 (cp_parser *, bool, bool, enum tag_types, bool, bool, bool);
2197 static tree cp_parser_class_specifier
2199 static tree cp_parser_class_head
2200 (cp_parser *, bool *);
2201 static enum tag_types cp_parser_class_key
2203 static void cp_parser_type_parameter_key
2204 (cp_parser* parser);
2205 static void cp_parser_member_specification_opt
2207 static void cp_parser_member_declaration
2209 static tree cp_parser_pure_specifier
2211 static tree cp_parser_constant_initializer
2214 /* Derived classes [gram.class.derived] */
2216 static tree cp_parser_base_clause
2218 static tree cp_parser_base_specifier
2221 /* Special member functions [gram.special] */
2223 static tree cp_parser_conversion_function_id
2225 static tree cp_parser_conversion_type_id
2227 static cp_declarator *cp_parser_conversion_declarator_opt
2229 static bool cp_parser_ctor_initializer_opt
2231 static void cp_parser_mem_initializer_list
2233 static tree cp_parser_mem_initializer
2235 static tree cp_parser_mem_initializer_id
2238 /* Overloading [gram.over] */
2240 static tree cp_parser_operator_function_id
2242 static tree cp_parser_operator
2245 /* Templates [gram.temp] */
2247 static void cp_parser_template_declaration
2248 (cp_parser *, bool);
2249 static tree cp_parser_template_parameter_list
2251 static tree cp_parser_template_parameter
2252 (cp_parser *, bool *, bool *);
2253 static tree cp_parser_type_parameter
2254 (cp_parser *, bool *);
2255 static tree cp_parser_template_id
2256 (cp_parser *, bool, bool, enum tag_types, bool);
2257 static tree cp_parser_template_name
2258 (cp_parser *, bool, bool, bool, enum tag_types, bool *);
2259 static tree cp_parser_template_argument_list
2261 static tree cp_parser_template_argument
2263 static void cp_parser_explicit_instantiation
2265 static void cp_parser_explicit_specialization
2268 /* Exception handling [gram.exception] */
2270 static tree cp_parser_try_block
2272 static bool cp_parser_function_try_block
2274 static void cp_parser_handler_seq
2276 static void cp_parser_handler
2278 static tree cp_parser_exception_declaration
2280 static tree cp_parser_throw_expression
2282 static tree cp_parser_exception_specification_opt
2284 static tree cp_parser_type_id_list
2287 /* GNU Extensions */
2289 static tree cp_parser_asm_specification_opt
2291 static tree cp_parser_asm_operand_list
2293 static tree cp_parser_asm_clobber_list
2295 static tree cp_parser_asm_label_list
2297 static bool cp_next_tokens_can_be_attribute_p
2299 static bool cp_next_tokens_can_be_gnu_attribute_p
2301 static bool cp_next_tokens_can_be_std_attribute_p
2303 static bool cp_nth_tokens_can_be_std_attribute_p
2304 (cp_parser *, size_t);
2305 static bool cp_nth_tokens_can_be_gnu_attribute_p
2306 (cp_parser *, size_t);
2307 static bool cp_nth_tokens_can_be_attribute_p
2308 (cp_parser *, size_t);
2309 static tree cp_parser_attributes_opt
2311 static tree cp_parser_gnu_attributes_opt
2313 static tree cp_parser_gnu_attribute_list
2315 static tree cp_parser_std_attribute
2317 static tree cp_parser_std_attribute_spec
2319 static tree cp_parser_std_attribute_spec_seq
2321 static bool cp_parser_extension_opt
2322 (cp_parser *, int *);
2323 static void cp_parser_label_declaration
2326 /* Transactional Memory Extensions */
2328 static tree cp_parser_transaction
2329 (cp_parser *, enum rid);
2330 static tree cp_parser_transaction_expression
2331 (cp_parser *, enum rid);
2332 static bool cp_parser_function_transaction
2333 (cp_parser *, enum rid);
2334 static tree cp_parser_transaction_cancel
2337 enum pragma_context {
2344 static bool cp_parser_pragma
2345 (cp_parser *, enum pragma_context);
2347 /* Objective-C++ Productions */
2349 static tree cp_parser_objc_message_receiver
2351 static tree cp_parser_objc_message_args
2353 static tree cp_parser_objc_message_expression
2355 static tree cp_parser_objc_encode_expression
2357 static tree cp_parser_objc_defs_expression
2359 static tree cp_parser_objc_protocol_expression
2361 static tree cp_parser_objc_selector_expression
2363 static tree cp_parser_objc_expression
2365 static bool cp_parser_objc_selector_p
2367 static tree cp_parser_objc_selector
2369 static tree cp_parser_objc_protocol_refs_opt
2371 static void cp_parser_objc_declaration
2372 (cp_parser *, tree);
2373 static tree cp_parser_objc_statement
2375 static bool cp_parser_objc_valid_prefix_attributes
2376 (cp_parser *, tree *);
2377 static void cp_parser_objc_at_property_declaration
2379 static void cp_parser_objc_at_synthesize_declaration
2381 static void cp_parser_objc_at_dynamic_declaration
2383 static tree cp_parser_objc_struct_declaration
2386 /* Utility Routines */
2388 static tree cp_parser_lookup_name
2389 (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *, location_t);
2390 static tree cp_parser_lookup_name_simple
2391 (cp_parser *, tree, location_t);
2392 static tree cp_parser_maybe_treat_template_as_class
2394 static bool cp_parser_check_declarator_template_parameters
2395 (cp_parser *, cp_declarator *, location_t);
2396 static bool cp_parser_check_template_parameters
2397 (cp_parser *, unsigned, location_t, cp_declarator *);
2398 static tree cp_parser_simple_cast_expression
2400 static tree cp_parser_global_scope_opt
2401 (cp_parser *, bool);
2402 static bool cp_parser_constructor_declarator_p
2403 (cp_parser *, bool);
2404 static tree cp_parser_function_definition_from_specifiers_and_declarator
2405 (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
2406 static tree cp_parser_function_definition_after_declarator
2407 (cp_parser *, bool);
2408 static void cp_parser_template_declaration_after_export
2409 (cp_parser *, bool);
2410 static void cp_parser_perform_template_parameter_access_checks
2411 (vec<deferred_access_check, va_gc> *);
2412 static tree cp_parser_single_declaration
2413 (cp_parser *, vec<deferred_access_check, va_gc> *, bool, bool, bool *);
2414 static tree cp_parser_functional_cast
2415 (cp_parser *, tree);
2416 static tree cp_parser_save_member_function_body
2417 (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
2418 static tree cp_parser_save_nsdmi
2420 static tree cp_parser_enclosed_template_argument_list
2422 static void cp_parser_save_default_args
2423 (cp_parser *, tree);
2424 static void cp_parser_late_parsing_for_member
2425 (cp_parser *, tree);
2426 static tree cp_parser_late_parse_one_default_arg
2427 (cp_parser *, tree, tree, tree);
2428 static void cp_parser_late_parsing_nsdmi
2429 (cp_parser *, tree);
2430 static void cp_parser_late_parsing_default_args
2431 (cp_parser *, tree);
2432 static tree cp_parser_sizeof_operand
2433 (cp_parser *, enum rid);
2434 static tree cp_parser_trait_expr
2435 (cp_parser *, enum rid);
2436 static bool cp_parser_declares_only_class_p
2438 static void cp_parser_set_storage_class
2439 (cp_parser *, cp_decl_specifier_seq *, enum rid, cp_token *);
2440 static void cp_parser_set_decl_spec_type
2441 (cp_decl_specifier_seq *, tree, cp_token *, bool);
2442 static void set_and_check_decl_spec_loc
2443 (cp_decl_specifier_seq *decl_specs,
2444 cp_decl_spec ds, cp_token *);
2445 static bool cp_parser_friend_p
2446 (const cp_decl_specifier_seq *);
2447 static void cp_parser_required_error
2448 (cp_parser *, required_token, bool);
2449 static cp_token *cp_parser_require
2450 (cp_parser *, enum cpp_ttype, required_token);
2451 static cp_token *cp_parser_require_keyword
2452 (cp_parser *, enum rid, required_token);
2453 static bool cp_parser_token_starts_function_definition_p
2455 static bool cp_parser_next_token_starts_class_definition_p
2457 static bool cp_parser_next_token_ends_template_argument_p
2459 static bool cp_parser_nth_token_starts_template_argument_list_p
2460 (cp_parser *, size_t);
2461 static enum tag_types cp_parser_token_is_class_key
2463 static enum tag_types cp_parser_token_is_type_parameter_key
2465 static void cp_parser_check_class_key
2466 (enum tag_types, tree type);
2467 static void cp_parser_check_access_in_redeclaration
2468 (tree type, location_t location);
2469 static bool cp_parser_optional_template_keyword
2471 static void cp_parser_pre_parsed_nested_name_specifier
2473 static bool cp_parser_cache_group
2474 (cp_parser *, enum cpp_ttype, unsigned);
2475 static tree cp_parser_cache_defarg
2476 (cp_parser *parser, bool nsdmi);
2477 static void cp_parser_parse_tentatively
2479 static void cp_parser_commit_to_tentative_parse
2481 static void cp_parser_commit_to_topmost_tentative_parse
2483 static void cp_parser_abort_tentative_parse
2485 static bool cp_parser_parse_definitely
2487 static inline bool cp_parser_parsing_tentatively
2489 static bool cp_parser_uncommitted_to_tentative_parse_p
2491 static void cp_parser_error
2492 (cp_parser *, const char *);
2493 static void cp_parser_name_lookup_error
2494 (cp_parser *, tree, tree, name_lookup_error, location_t);
2495 static bool cp_parser_simulate_error
2497 static bool cp_parser_check_type_definition
2499 static void cp_parser_check_for_definition_in_return_type
2500 (cp_declarator *, tree, location_t type_location);
2501 static void cp_parser_check_for_invalid_template_id
2502 (cp_parser *, tree, enum tag_types, location_t location);
2503 static bool cp_parser_non_integral_constant_expression
2504 (cp_parser *, non_integral_constant);
2505 static void cp_parser_diagnose_invalid_type_name
2506 (cp_parser *, tree, location_t);
2507 static bool cp_parser_parse_and_diagnose_invalid_type_name
2509 static int cp_parser_skip_to_closing_parenthesis
2510 (cp_parser *, bool, bool, bool);
2511 static void cp_parser_skip_to_end_of_statement
2513 static void cp_parser_consume_semicolon_at_end_of_statement
2515 static void cp_parser_skip_to_end_of_block_or_statement
2517 static bool cp_parser_skip_to_closing_brace
2519 static void cp_parser_skip_to_end_of_template_parameter_list
2521 static void cp_parser_skip_to_pragma_eol
2522 (cp_parser*, cp_token *);
2523 static bool cp_parser_error_occurred
2525 static bool cp_parser_allow_gnu_extensions_p
2527 static bool cp_parser_is_pure_string_literal
2529 static bool cp_parser_is_string_literal
2531 static bool cp_parser_is_keyword
2532 (cp_token *, enum rid);
2533 static tree cp_parser_make_typename_type
2534 (cp_parser *, tree, location_t location);
2535 static cp_declarator * cp_parser_make_indirect_declarator
2536 (enum tree_code, tree, cp_cv_quals, cp_declarator *, tree);
2537 static bool cp_parser_compound_literal_p
2539 static bool cp_parser_array_designator_p
2541 static bool cp_parser_skip_to_closing_square_bracket
2544 /* Returns nonzero if we are parsing tentatively. */
2547 cp_parser_parsing_tentatively (cp_parser* parser)
2549 return parser->context->next != NULL;
2552 /* Returns nonzero if TOKEN is a string literal. */
2555 cp_parser_is_pure_string_literal (cp_token* token)
2557 return (token->type == CPP_STRING ||
2558 token->type == CPP_STRING16 ||
2559 token->type == CPP_STRING32 ||
2560 token->type == CPP_WSTRING ||
2561 token->type == CPP_UTF8STRING);
2564 /* Returns nonzero if TOKEN is a string literal
2565 of a user-defined string literal. */
2568 cp_parser_is_string_literal (cp_token* token)
2570 return (cp_parser_is_pure_string_literal (token) ||
2571 token->type == CPP_STRING_USERDEF ||
2572 token->type == CPP_STRING16_USERDEF ||
2573 token->type == CPP_STRING32_USERDEF ||
2574 token->type == CPP_WSTRING_USERDEF ||
2575 token->type == CPP_UTF8STRING_USERDEF);
2578 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2581 cp_parser_is_keyword (cp_token* token, enum rid keyword)
2583 return token->keyword == keyword;
2586 /* If not parsing tentatively, issue a diagnostic of the form
2587 FILE:LINE: MESSAGE before TOKEN
2588 where TOKEN is the next token in the input stream. MESSAGE
2589 (specified by the caller) is usually of the form "expected
2593 cp_parser_error (cp_parser* parser, const char* gmsgid)
2595 if (!cp_parser_simulate_error (parser))
2597 cp_token *token = cp_lexer_peek_token (parser->lexer);
2598 /* This diagnostic makes more sense if it is tagged to the line
2599 of the token we just peeked at. */
2600 cp_lexer_set_source_position_from_token (token);
2602 if (token->type == CPP_PRAGMA)
2604 error_at (token->location,
2605 "%<#pragma%> is not allowed here");
2606 cp_parser_skip_to_pragma_eol (parser, token);
2610 c_parse_error (gmsgid,
2611 /* Because c_parser_error does not understand
2612 CPP_KEYWORD, keywords are treated like
2614 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
2615 token->u.value, token->flags);
2619 /* Issue an error about name-lookup failing. NAME is the
2620 IDENTIFIER_NODE DECL is the result of
2621 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2622 the thing that we hoped to find. */
2625 cp_parser_name_lookup_error (cp_parser* parser,
2628 name_lookup_error desired,
2629 location_t location)
2631 /* If name lookup completely failed, tell the user that NAME was not
2633 if (decl == error_mark_node)
2635 if (parser->scope && parser->scope != global_namespace)
2636 error_at (location, "%<%E::%E%> has not been declared",
2637 parser->scope, name);
2638 else if (parser->scope == global_namespace)
2639 error_at (location, "%<::%E%> has not been declared", name);
2640 else if (parser->object_scope
2641 && !CLASS_TYPE_P (parser->object_scope))
2642 error_at (location, "request for member %qE in non-class type %qT",
2643 name, parser->object_scope);
2644 else if (parser->object_scope)
2645 error_at (location, "%<%T::%E%> has not been declared",
2646 parser->object_scope, name);
2648 error_at (location, "%qE has not been declared", name);
2650 else if (parser->scope && parser->scope != global_namespace)
2655 error_at (location, "%<%E::%E%> is not a type",
2656 parser->scope, name);
2659 error_at (location, "%<%E::%E%> is not a class or namespace",
2660 parser->scope, name);
2664 "%<%E::%E%> is not a class, namespace, or enumeration",
2665 parser->scope, name);
2672 else if (parser->scope == global_namespace)
2677 error_at (location, "%<::%E%> is not a type", name);
2680 error_at (location, "%<::%E%> is not a class or namespace", name);
2684 "%<::%E%> is not a class, namespace, or enumeration",
2696 error_at (location, "%qE is not a type", name);
2699 error_at (location, "%qE is not a class or namespace", name);
2703 "%qE is not a class, namespace, or enumeration", name);
2711 /* If we are parsing tentatively, remember that an error has occurred
2712 during this tentative parse. Returns true if the error was
2713 simulated; false if a message should be issued by the caller. */
2716 cp_parser_simulate_error (cp_parser* parser)
2718 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2720 parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
2726 /* This function is called when a type is defined. If type
2727 definitions are forbidden at this point, an error message is
2731 cp_parser_check_type_definition (cp_parser* parser)
2733 /* If types are forbidden here, issue a message. */
2734 if (parser->type_definition_forbidden_message)
2736 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
2737 in the message need to be interpreted. */
2738 error (parser->type_definition_forbidden_message);
2744 /* This function is called when the DECLARATOR is processed. The TYPE
2745 was a type defined in the decl-specifiers. If it is invalid to
2746 define a type in the decl-specifiers for DECLARATOR, an error is
2747 issued. TYPE_LOCATION is the location of TYPE and is used
2748 for error reporting. */
2751 cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
2752 tree type, location_t type_location)
2754 /* [dcl.fct] forbids type definitions in return types.
2755 Unfortunately, it's not easy to know whether or not we are
2756 processing a return type until after the fact. */
2758 && (declarator->kind == cdk_pointer
2759 || declarator->kind == cdk_reference
2760 || declarator->kind == cdk_ptrmem))
2761 declarator = declarator->declarator;
2763 && declarator->kind == cdk_function)
2765 error_at (type_location,
2766 "new types may not be defined in a return type");
2767 inform (type_location,
2768 "(perhaps a semicolon is missing after the definition of %qT)",
2773 /* A type-specifier (TYPE) has been parsed which cannot be followed by
2774 "<" in any valid C++ program. If the next token is indeed "<",
2775 issue a message warning the user about what appears to be an
2776 invalid attempt to form a template-id. LOCATION is the location
2777 of the type-specifier (TYPE) */
2780 cp_parser_check_for_invalid_template_id (cp_parser* parser,
2782 enum tag_types tag_type,
2783 location_t location)
2785 cp_token_position start = 0;
2787 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
2790 error_at (location, "%qT is not a template", type);
2791 else if (identifier_p (type))
2793 if (tag_type != none_type)
2794 error_at (location, "%qE is not a class template", type);
2796 error_at (location, "%qE is not a template", type);
2799 error_at (location, "invalid template-id");
2800 /* Remember the location of the invalid "<". */
2801 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
2802 start = cp_lexer_token_position (parser->lexer, true);
2803 /* Consume the "<". */
2804 cp_lexer_consume_token (parser->lexer);
2805 /* Parse the template arguments. */
2806 cp_parser_enclosed_template_argument_list (parser);
2807 /* Permanently remove the invalid template arguments so that
2808 this error message is not issued again. */
2810 cp_lexer_purge_tokens_after (parser->lexer, start);
2814 /* If parsing an integral constant-expression, issue an error message
2815 about the fact that THING appeared and return true. Otherwise,
2816 return false. In either case, set
2817 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
2820 cp_parser_non_integral_constant_expression (cp_parser *parser,
2821 non_integral_constant thing)
2823 parser->non_integral_constant_expression_p = true;
2824 if (parser->integral_constant_expression_p)
2826 if (!parser->allow_non_integral_constant_expression_p)
2828 const char *msg = NULL;
2832 error ("floating-point literal "
2833 "cannot appear in a constant-expression");
2836 error ("a cast to a type other than an integral or "
2837 "enumeration type cannot appear in a "
2838 "constant-expression");
2841 error ("%<typeid%> operator "
2842 "cannot appear in a constant-expression");
2845 error ("non-constant compound literals "
2846 "cannot appear in a constant-expression");
2849 error ("a function call "
2850 "cannot appear in a constant-expression");
2853 error ("an increment "
2854 "cannot appear in a constant-expression");
2857 error ("an decrement "
2858 "cannot appear in a constant-expression");
2861 error ("an array reference "
2862 "cannot appear in a constant-expression");
2864 case NIC_ADDR_LABEL:
2865 error ("the address of a label "
2866 "cannot appear in a constant-expression");
2868 case NIC_OVERLOADED:
2869 error ("calls to overloaded operators "
2870 "cannot appear in a constant-expression");
2872 case NIC_ASSIGNMENT:
2873 error ("an assignment cannot appear in a constant-expression");
2876 error ("a comma operator "
2877 "cannot appear in a constant-expression");
2879 case NIC_CONSTRUCTOR:
2880 error ("a call to a constructor "
2881 "cannot appear in a constant-expression");
2883 case NIC_TRANSACTION:
2884 error ("a transaction expression "
2885 "cannot appear in a constant-expression");
2891 msg = "__FUNCTION__";
2893 case NIC_PRETTY_FUNC:
2894 msg = "__PRETTY_FUNCTION__";
2914 case NIC_PREINCREMENT:
2917 case NIC_PREDECREMENT:
2930 error ("%qs cannot appear in a constant-expression", msg);
2937 /* Emit a diagnostic for an invalid type name. This function commits
2938 to the current active tentative parse, if any. (Otherwise, the
2939 problematic construct might be encountered again later, resulting
2940 in duplicate error messages.) LOCATION is the location of ID. */
2943 cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id,
2944 location_t location)
2946 tree decl, ambiguous_decls;
2947 cp_parser_commit_to_tentative_parse (parser);
2948 /* Try to lookup the identifier. */
2949 decl = cp_parser_lookup_name (parser, id, none_type,
2950 /*is_template=*/false,
2951 /*is_namespace=*/false,
2952 /*check_dependency=*/true,
2953 &ambiguous_decls, location);
2954 if (ambiguous_decls)
2955 /* If the lookup was ambiguous, an error will already have
2958 /* If the lookup found a template-name, it means that the user forgot
2959 to specify an argument list. Emit a useful error message. */
2960 if (TREE_CODE (decl) == TEMPLATE_DECL)
2962 "invalid use of template-name %qE without an argument list",
2964 else if (TREE_CODE (id) == BIT_NOT_EXPR)
2965 error_at (location, "invalid use of destructor %qD as a type", id);
2966 else if (TREE_CODE (decl) == TYPE_DECL)
2967 /* Something like 'unsigned A a;' */
2968 error_at (location, "invalid combination of multiple type-specifiers");
2969 else if (!parser->scope)
2971 /* Issue an error message. */
2972 error_at (location, "%qE does not name a type", id);
2973 /* If we're in a template class, it's possible that the user was
2974 referring to a type from a base class. For example:
2976 template <typename T> struct A { typedef T X; };
2977 template <typename T> struct B : public A<T> { X x; };
2979 The user should have said "typename A<T>::X". */
2980 if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_CONSTEXPR])
2981 inform (location, "C++11 %<constexpr%> only available with "
2982 "-std=c++11 or -std=gnu++11");
2983 else if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_NOEXCEPT])
2984 inform (location, "C++11 %<noexcept%> only available with "
2985 "-std=c++11 or -std=gnu++11");
2986 else if (cxx_dialect < cxx11
2987 && TREE_CODE (id) == IDENTIFIER_NODE
2988 && !strcmp (IDENTIFIER_POINTER (id), "thread_local"))
2989 inform (location, "C++11 %<thread_local%> only available with "
2990 "-std=c++11 or -std=gnu++11");
2991 else if (processing_template_decl && current_class_type
2992 && TYPE_BINFO (current_class_type))
2996 for (b = TREE_CHAIN (TYPE_BINFO (current_class_type));
3000 tree base_type = BINFO_TYPE (b);
3001 if (CLASS_TYPE_P (base_type)
3002 && dependent_type_p (base_type))
3005 /* Go from a particular instantiation of the
3006 template (which will have an empty TYPE_FIELDs),
3007 to the main version. */
3008 base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type);
3009 for (field = TYPE_FIELDS (base_type);
3011 field = DECL_CHAIN (field))
3012 if (TREE_CODE (field) == TYPE_DECL
3013 && DECL_NAME (field) == id)
3016 "(perhaps %<typename %T::%E%> was intended)",
3017 BINFO_TYPE (b), id);
3026 /* Here we diagnose qualified-ids where the scope is actually correct,
3027 but the identifier does not resolve to a valid type name. */
3028 else if (parser->scope != error_mark_node)
3030 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
3032 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3033 error_at (location_of (id),
3034 "%qE in namespace %qE does not name a template type",
3037 error_at (location_of (id),
3038 "%qE in namespace %qE does not name a type",
3041 else if (CLASS_TYPE_P (parser->scope)
3042 && constructor_name_p (id, parser->scope))
3045 error_at (location, "%<%T::%E%> names the constructor, not"
3046 " the type", parser->scope, id);
3047 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3048 error_at (location, "and %qT has no template constructors",
3051 else if (TYPE_P (parser->scope)
3052 && dependent_scope_p (parser->scope))
3053 error_at (location, "need %<typename%> before %<%T::%E%> because "
3054 "%qT is a dependent scope",
3055 parser->scope, id, parser->scope);
3056 else if (TYPE_P (parser->scope))
3058 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3059 error_at (location_of (id),
3060 "%qE in %q#T does not name a template type",
3063 error_at (location_of (id),
3064 "%qE in %q#T does not name a type",
3072 /* Check for a common situation where a type-name should be present,
3073 but is not, and issue a sensible error message. Returns true if an
3074 invalid type-name was detected.
3076 The situation handled by this function are variable declarations of the
3077 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3078 Usually, `ID' should name a type, but if we got here it means that it
3079 does not. We try to emit the best possible error message depending on
3080 how exactly the id-expression looks like. */
3083 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
3086 cp_token *token = cp_lexer_peek_token (parser->lexer);
3088 /* Avoid duplicate error about ambiguous lookup. */
3089 if (token->type == CPP_NESTED_NAME_SPECIFIER)
3091 cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
3092 if (next->type == CPP_NAME && next->error_reported)
3096 cp_parser_parse_tentatively (parser);
3097 id = cp_parser_id_expression (parser,
3098 /*template_keyword_p=*/false,
3099 /*check_dependency_p=*/true,
3100 /*template_p=*/NULL,
3101 /*declarator_p=*/true,
3102 /*optional_p=*/false);
3103 /* If the next token is a (, this is a function with no explicit return
3104 type, i.e. constructor, destructor or conversion op. */
3105 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
3106 || TREE_CODE (id) == TYPE_DECL)
3108 cp_parser_abort_tentative_parse (parser);
3111 if (!cp_parser_parse_definitely (parser))
3114 /* Emit a diagnostic for the invalid type. */
3115 cp_parser_diagnose_invalid_type_name (parser, id, token->location);
3117 /* If we aren't in the middle of a declarator (i.e. in a
3118 parameter-declaration-clause), skip to the end of the declaration;
3119 there's no point in trying to process it. */
3120 if (!parser->in_declarator_p)
3121 cp_parser_skip_to_end_of_block_or_statement (parser);
3125 /* Consume tokens up to, and including, the next non-nested closing `)'.
3126 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3127 are doing error recovery. Returns -1 if OR_COMMA is true and we
3128 found an unnested comma. */
3131 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
3136 unsigned paren_depth = 0;
3137 unsigned brace_depth = 0;
3138 unsigned square_depth = 0;
3140 if (recovering && !or_comma
3141 && cp_parser_uncommitted_to_tentative_parse_p (parser))
3146 cp_token * token = cp_lexer_peek_token (parser->lexer);
3148 switch (token->type)
3151 case CPP_PRAGMA_EOL:
3152 /* If we've run out of tokens, then there is no closing `)'. */
3155 /* This is good for lambda expression capture-lists. */
3156 case CPP_OPEN_SQUARE:
3159 case CPP_CLOSE_SQUARE:
3160 if (!square_depth--)
3165 /* This matches the processing in skip_to_end_of_statement. */
3170 case CPP_OPEN_BRACE:
3173 case CPP_CLOSE_BRACE:
3179 if (recovering && or_comma && !brace_depth && !paren_depth
3184 case CPP_OPEN_PAREN:
3189 case CPP_CLOSE_PAREN:
3190 if (!brace_depth && !paren_depth--)
3193 cp_lexer_consume_token (parser->lexer);
3202 /* Consume the token. */
3203 cp_lexer_consume_token (parser->lexer);
3207 /* Consume tokens until we reach the end of the current statement.
3208 Normally, that will be just before consuming a `;'. However, if a
3209 non-nested `}' comes first, then we stop before consuming that. */
3212 cp_parser_skip_to_end_of_statement (cp_parser* parser)
3214 unsigned nesting_depth = 0;
3216 /* Unwind generic function template scope if necessary. */
3217 if (parser->fully_implicit_function_template_p)
3218 finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
3222 cp_token *token = cp_lexer_peek_token (parser->lexer);
3224 switch (token->type)
3227 case CPP_PRAGMA_EOL:
3228 /* If we've run out of tokens, stop. */
3232 /* If the next token is a `;', we have reached the end of the
3238 case CPP_CLOSE_BRACE:
3239 /* If this is a non-nested '}', stop before consuming it.
3240 That way, when confronted with something like:
3244 we stop before consuming the closing '}', even though we
3245 have not yet reached a `;'. */
3246 if (nesting_depth == 0)
3249 /* If it is the closing '}' for a block that we have
3250 scanned, stop -- but only after consuming the token.
3256 we will stop after the body of the erroneously declared
3257 function, but before consuming the following `typedef'
3259 if (--nesting_depth == 0)
3261 cp_lexer_consume_token (parser->lexer);
3265 case CPP_OPEN_BRACE:
3273 /* Consume the token. */
3274 cp_lexer_consume_token (parser->lexer);
3278 /* This function is called at the end of a statement or declaration.
3279 If the next token is a semicolon, it is consumed; otherwise, error
3280 recovery is attempted. */
3283 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
3285 /* Look for the trailing `;'. */
3286 if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
3288 /* If there is additional (erroneous) input, skip to the end of
3290 cp_parser_skip_to_end_of_statement (parser);
3291 /* If the next token is now a `;', consume it. */
3292 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
3293 cp_lexer_consume_token (parser->lexer);
3297 /* Skip tokens until we have consumed an entire block, or until we
3298 have consumed a non-nested `;'. */
3301 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
3303 int nesting_depth = 0;
3305 /* Unwind generic function template scope if necessary. */
3306 if (parser->fully_implicit_function_template_p)
3307 finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
3309 while (nesting_depth >= 0)
3311 cp_token *token = cp_lexer_peek_token (parser->lexer);
3313 switch (token->type)
3316 case CPP_PRAGMA_EOL:
3317 /* If we've run out of tokens, stop. */
3321 /* Stop if this is an unnested ';'. */
3326 case CPP_CLOSE_BRACE:
3327 /* Stop if this is an unnested '}', or closes the outermost
3330 if (nesting_depth < 0)
3336 case CPP_OPEN_BRACE:
3345 /* Consume the token. */
3346 cp_lexer_consume_token (parser->lexer);
3350 /* Skip tokens until a non-nested closing curly brace is the next
3351 token, or there are no more tokens. Return true in the first case,
3355 cp_parser_skip_to_closing_brace (cp_parser *parser)
3357 unsigned nesting_depth = 0;
3361 cp_token *token = cp_lexer_peek_token (parser->lexer);
3363 switch (token->type)
3366 case CPP_PRAGMA_EOL:
3367 /* If we've run out of tokens, stop. */
3370 case CPP_CLOSE_BRACE:
3371 /* If the next token is a non-nested `}', then we have reached
3372 the end of the current block. */
3373 if (nesting_depth-- == 0)
3377 case CPP_OPEN_BRACE:
3378 /* If it the next token is a `{', then we are entering a new
3379 block. Consume the entire block. */
3387 /* Consume the token. */
3388 cp_lexer_consume_token (parser->lexer);
3392 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3393 parameter is the PRAGMA token, allowing us to purge the entire pragma
3397 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
3401 parser->lexer->in_pragma = false;
3404 token = cp_lexer_consume_token (parser->lexer);
3405 while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF);
3407 /* Ensure that the pragma is not parsed again. */
3408 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
3411 /* Require pragma end of line, resyncing with it as necessary. The
3412 arguments are as for cp_parser_skip_to_pragma_eol. */
3415 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
3417 parser->lexer->in_pragma = false;
3418 if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
3419 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
3422 /* This is a simple wrapper around make_typename_type. When the id is
3423 an unresolved identifier node, we can provide a superior diagnostic
3424 using cp_parser_diagnose_invalid_type_name. */
3427 cp_parser_make_typename_type (cp_parser *parser, tree id,
3428 location_t id_location)
3431 if (identifier_p (id))
3433 result = make_typename_type (parser->scope, id, typename_type,
3434 /*complain=*/tf_none);
3435 if (result == error_mark_node)
3436 cp_parser_diagnose_invalid_type_name (parser, id, id_location);
3439 return make_typename_type (parser->scope, id, typename_type, tf_error);
3442 /* This is a wrapper around the
3443 make_{pointer,ptrmem,reference}_declarator functions that decides
3444 which one to call based on the CODE and CLASS_TYPE arguments. The
3445 CODE argument should be one of the values returned by
3446 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3447 appertain to the pointer or reference. */
3449 static cp_declarator *
3450 cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
3451 cp_cv_quals cv_qualifiers,
3452 cp_declarator *target,
3455 if (code == ERROR_MARK)
3456 return cp_error_declarator;
3458 if (code == INDIRECT_REF)
3459 if (class_type == NULL_TREE)
3460 return make_pointer_declarator (cv_qualifiers, target, attributes);
3462 return make_ptrmem_declarator (cv_qualifiers, class_type,
3463 target, attributes);
3464 else if (code == ADDR_EXPR && class_type == NULL_TREE)
3465 return make_reference_declarator (cv_qualifiers, target,
3467 else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE)
3468 return make_reference_declarator (cv_qualifiers, target,
3473 /* Create a new C++ parser. */
3476 cp_parser_new (void)
3482 /* cp_lexer_new_main is called before doing GC allocation because
3483 cp_lexer_new_main might load a PCH file. */
3484 lexer = cp_lexer_new_main ();
3486 /* Initialize the binops_by_token so that we can get the tree
3487 directly from the token. */
3488 for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
3489 binops_by_token[binops[i].token_type] = binops[i];
3491 parser = ggc_cleared_alloc<cp_parser> ();
3492 parser->lexer = lexer;
3493 parser->context = cp_parser_context_new (NULL);
3495 /* For now, we always accept GNU extensions. */
3496 parser->allow_gnu_extensions_p = 1;
3498 /* The `>' token is a greater-than operator, not the end of a
3500 parser->greater_than_is_operator_p = true;
3502 parser->default_arg_ok_p = true;
3504 /* We are not parsing a constant-expression. */
3505 parser->integral_constant_expression_p = false;
3506 parser->allow_non_integral_constant_expression_p = false;
3507 parser->non_integral_constant_expression_p = false;
3509 /* Local variable names are not forbidden. */
3510 parser->local_variables_forbidden_p = false;
3512 /* We are not processing an `extern "C"' declaration. */
3513 parser->in_unbraced_linkage_specification_p = false;
3515 /* We are not processing a declarator. */
3516 parser->in_declarator_p = false;
3518 /* We are not processing a template-argument-list. */
3519 parser->in_template_argument_list_p = false;
3521 /* We are not in an iteration statement. */
3522 parser->in_statement = 0;
3524 /* We are not in a switch statement. */
3525 parser->in_switch_statement_p = false;
3527 /* We are not parsing a type-id inside an expression. */
3528 parser->in_type_id_in_expr_p = false;
3530 /* Declarations aren't implicitly extern "C". */
3531 parser->implicit_extern_c = false;
3533 /* String literals should be translated to the execution character set. */
3534 parser->translate_strings_p = true;
3536 /* We are not parsing a function body. */
3537 parser->in_function_body = false;
3539 /* We can correct until told otherwise. */
3540 parser->colon_corrects_to_scope_p = true;
3542 /* The unparsed function queue is empty. */
3543 push_unparsed_function_queues (parser);
3545 /* There are no classes being defined. */
3546 parser->num_classes_being_defined = 0;
3548 /* No template parameters apply. */
3549 parser->num_template_parameter_lists = 0;
3551 /* Not declaring an implicit function template. */
3552 parser->auto_is_implicit_function_template_parm_p = false;
3553 parser->fully_implicit_function_template_p = false;
3554 parser->implicit_template_parms = 0;
3555 parser->implicit_template_scope = 0;
3560 /* Create a cp_lexer structure which will emit the tokens in CACHE
3561 and push it onto the parser's lexer stack. This is used for delayed
3562 parsing of in-class method bodies and default arguments, and should
3563 not be confused with tentative parsing. */
3565 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
3567 cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
3568 lexer->next = parser->lexer;
3569 parser->lexer = lexer;
3571 /* Move the current source position to that of the first token in the
3573 cp_lexer_set_source_position_from_token (lexer->next_token);
3576 /* Pop the top lexer off the parser stack. This is never used for the
3577 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
3579 cp_parser_pop_lexer (cp_parser *parser)
3581 cp_lexer *lexer = parser->lexer;
3582 parser->lexer = lexer->next;
3583 cp_lexer_destroy (lexer);
3585 /* Put the current source position back where it was before this
3586 lexer was pushed. */
3587 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
3590 /* Lexical conventions [gram.lex] */
3592 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
3596 cp_parser_identifier (cp_parser* parser)
3600 /* Look for the identifier. */
3601 token = cp_parser_require (parser, CPP_NAME, RT_NAME);
3602 /* Return the value. */
3603 return token ? token->u.value : error_mark_node;
3606 /* Parse a sequence of adjacent string constants. Returns a
3607 TREE_STRING representing the combined, nul-terminated string
3608 constant. If TRANSLATE is true, translate the string to the
3609 execution character set. If WIDE_OK is true, a wide string is
3612 C++98 [lex.string] says that if a narrow string literal token is
3613 adjacent to a wide string literal token, the behavior is undefined.
3614 However, C99 6.4.5p4 says that this results in a wide string literal.
3615 We follow C99 here, for consistency with the C front end.
3617 This code is largely lifted from lex_string() in c-lex.c.
3619 FUTURE: ObjC++ will need to handle @-strings here. */
3621 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
3622 bool lookup_udlit = true)
3626 struct obstack str_ob;
3627 cpp_string str, istr, *strs;
3629 enum cpp_ttype type, curr_type;
3630 int have_suffix_p = 0;
3632 tree suffix_id = NULL_TREE;
3633 bool curr_tok_is_userdef_p = false;
3635 tok = cp_lexer_peek_token (parser->lexer);
3636 if (!cp_parser_is_string_literal (tok))
3638 cp_parser_error (parser, "expected string-literal");
3639 return error_mark_node;
3642 if (cpp_userdef_string_p (tok->type))
3644 string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3645 curr_type = cpp_userdef_string_remove_type (tok->type);
3646 curr_tok_is_userdef_p = true;
3650 string_tree = tok->u.value;
3651 curr_type = tok->type;
3655 /* Try to avoid the overhead of creating and destroying an obstack
3656 for the common case of just one string. */
3657 if (!cp_parser_is_string_literal
3658 (cp_lexer_peek_nth_token (parser->lexer, 2)))
3660 cp_lexer_consume_token (parser->lexer);
3662 str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3663 str.len = TREE_STRING_LENGTH (string_tree);
3666 if (curr_tok_is_userdef_p)
3668 suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3670 curr_type = cpp_userdef_string_remove_type (tok->type);
3673 curr_type = tok->type;
3679 gcc_obstack_init (&str_ob);
3684 cp_lexer_consume_token (parser->lexer);
3686 str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree);
3687 str.len = TREE_STRING_LENGTH (string_tree);
3689 if (curr_tok_is_userdef_p)
3691 tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value);
3692 if (have_suffix_p == 0)
3694 suffix_id = curr_suffix_id;
3697 else if (have_suffix_p == 1
3698 && curr_suffix_id != suffix_id)
3700 error ("inconsistent user-defined literal suffixes"
3701 " %qD and %qD in string literal",
3702 suffix_id, curr_suffix_id);
3705 curr_type = cpp_userdef_string_remove_type (tok->type);
3708 curr_type = tok->type;
3710 if (type != curr_type)
3712 if (type == CPP_STRING)
3714 else if (curr_type != CPP_STRING)
3715 error_at (tok->location,
3716 "unsupported non-standard concatenation "
3717 "of string literals");
3720 obstack_grow (&str_ob, &str, sizeof (cpp_string));
3722 tok = cp_lexer_peek_token (parser->lexer);
3723 if (cpp_userdef_string_p (tok->type))
3725 string_tree = USERDEF_LITERAL_VALUE (tok->u.value);
3726 curr_type = cpp_userdef_string_remove_type (tok->type);
3727 curr_tok_is_userdef_p = true;
3731 string_tree = tok->u.value;
3732 curr_type = tok->type;
3733 curr_tok_is_userdef_p = false;
3736 while (cp_parser_is_string_literal (tok));
3738 strs = (cpp_string *) obstack_finish (&str_ob);
3741 if (type != CPP_STRING && !wide_ok)
3743 cp_parser_error (parser, "a wide string is invalid in this context");
3747 if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
3748 (parse_in, strs, count, &istr, type))
3750 value = build_string (istr.len, (const char *)istr.text);
3751 free (CONST_CAST (unsigned char *, istr.text));
3757 case CPP_UTF8STRING:
3758 TREE_TYPE (value) = char_array_type_node;
3761 TREE_TYPE (value) = char16_array_type_node;
3764 TREE_TYPE (value) = char32_array_type_node;
3767 TREE_TYPE (value) = wchar_array_type_node;
3771 value = fix_string_type (value);
3775 tree literal = build_userdef_literal (suffix_id, value,
3776 OT_NONE, NULL_TREE);
3778 value = cp_parser_userdef_string_literal (literal);
3784 /* cpp_interpret_string has issued an error. */
3785 value = error_mark_node;
3788 obstack_free (&str_ob, 0);
3793 /* Look up a literal operator with the name and the exact arguments. */
3796 lookup_literal_operator (tree name, vec<tree, va_gc> *args)
3799 decl = lookup_name (name);
3800 if (!decl || !is_overloaded_fn (decl))
3801 return error_mark_node;
3803 for (fns = decl; fns; fns = OVL_NEXT (fns))
3807 tree fn = OVL_CURRENT (fns);
3808 tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (fn));
3809 if (parmtypes != NULL_TREE)
3811 for (ix = 0; ix < vec_safe_length (args) && parmtypes != NULL_TREE;
3812 ++ix, parmtypes = TREE_CHAIN (parmtypes))
3814 tree tparm = TREE_VALUE (parmtypes);
3815 tree targ = TREE_TYPE ((*args)[ix]);
3816 bool ptr = TYPE_PTR_P (tparm);
3817 bool arr = TREE_CODE (targ) == ARRAY_TYPE;
3818 if ((ptr || arr || !same_type_p (tparm, targ))
3820 || !same_type_p (TREE_TYPE (tparm),
3825 && ix == vec_safe_length (args)
3826 /* May be this should be sufficient_parms_p instead,
3827 depending on how exactly should user-defined literals
3828 work in presence of default arguments on the literal
3829 operator parameters. */
3830 && parmtypes == void_list_node)
3835 return error_mark_node;
3838 /* Parse a user-defined char constant. Returns a call to a user-defined
3839 literal operator taking the character as an argument. */
3842 cp_parser_userdef_char_literal (cp_parser *parser)
3844 cp_token *token = cp_lexer_consume_token (parser->lexer);
3845 tree literal = token->u.value;
3846 tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3847 tree value = USERDEF_LITERAL_VALUE (literal);
3848 tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3851 /* Build up a call to the user-defined operator */
3852 /* Lookup the name we got back from the id-expression. */
3853 vec<tree, va_gc> *args = make_tree_vector ();
3854 vec_safe_push (args, value);
3855 decl = lookup_literal_operator (name, args);
3856 if (!decl || decl == error_mark_node)
3858 error ("unable to find character literal operator %qD with %qT argument",
3859 name, TREE_TYPE (value));
3860 release_tree_vector (args);
3861 return error_mark_node;
3863 result = finish_call_expr (decl, &args, false, true, tf_warning_or_error);
3864 release_tree_vector (args);
3868 /* A subroutine of cp_parser_userdef_numeric_literal to
3869 create a char... template parameter pack from a string node. */
3872 make_char_string_pack (tree value)
3875 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
3876 const char *str = TREE_STRING_POINTER (value);
3877 int i, len = TREE_STRING_LENGTH (value) - 1;
3878 tree argvec = make_tree_vec (1);
3880 /* Fill in CHARVEC with all of the parameters. */
3881 charvec = make_tree_vec (len);
3882 for (i = 0; i < len; ++i)
3883 TREE_VEC_ELT (charvec, i) = build_int_cst (char_type_node, str[i]);
3885 /* Build the argument packs. */
3886 SET_ARGUMENT_PACK_ARGS (argpack, charvec);
3887 TREE_TYPE (argpack) = char_type_node;
3889 TREE_VEC_ELT (argvec, 0) = argpack;
3894 /* A subroutine of cp_parser_userdef_numeric_literal to
3895 create a char... template parameter pack from a string node. */
3898 make_string_pack (tree value)
3901 tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
3902 const unsigned char *str
3903 = (const unsigned char *) TREE_STRING_POINTER (value);
3904 int sz = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value))));
3905 int len = TREE_STRING_LENGTH (value) / sz - 1;
3906 tree argvec = make_tree_vec (2);
3908 tree str_char_type_node = TREE_TYPE (TREE_TYPE (value));
3909 str_char_type_node = TYPE_MAIN_VARIANT (str_char_type_node);
3911 /* First template parm is character type. */
3912 TREE_VEC_ELT (argvec, 0) = str_char_type_node;
3914 /* Fill in CHARVEC with all of the parameters. */
3915 charvec = make_tree_vec (len);
3916 for (int i = 0; i < len; ++i)
3917 TREE_VEC_ELT (charvec, i)
3918 = double_int_to_tree (str_char_type_node,
3919 double_int::from_buffer (str + i * sz, sz));
3921 /* Build the argument packs. */
3922 SET_ARGUMENT_PACK_ARGS (argpack, charvec);
3923 TREE_TYPE (argpack) = str_char_type_node;
3925 TREE_VEC_ELT (argvec, 1) = argpack;
3930 /* Parse a user-defined numeric constant. returns a call to a user-defined
3931 literal operator. */
3934 cp_parser_userdef_numeric_literal (cp_parser *parser)
3936 cp_token *token = cp_lexer_consume_token (parser->lexer);
3937 tree literal = token->u.value;
3938 tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
3939 tree value = USERDEF_LITERAL_VALUE (literal);
3940 int overflow = USERDEF_LITERAL_OVERFLOW (literal);
3941 tree num_string = USERDEF_LITERAL_NUM_STRING (literal);
3942 tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
3944 vec<tree, va_gc> *args;
3946 /* Look for a literal operator taking the exact type of numeric argument
3947 as the literal value. */
3948 args = make_tree_vector ();
3949 vec_safe_push (args, value);
3950 decl = lookup_literal_operator (name, args);
3951 if (decl && decl != error_mark_node)
3953 result = finish_call_expr (decl, &args, false, true,
3954 tf_warning_or_error);
3956 if (TREE_CODE (TREE_TYPE (value)) == INTEGER_TYPE && overflow > 0)
3958 warning_at (token->location, OPT_Woverflow,
3959 "integer literal exceeds range of %qT type",
3960 long_long_unsigned_type_node);
3965 warning_at (token->location, OPT_Woverflow,
3966 "floating literal exceeds range of %qT type",
3967 long_double_type_node);
3968 else if (overflow < 0)
3969 warning_at (token->location, OPT_Woverflow,
3970 "floating literal truncated to zero");
3973 release_tree_vector (args);
3976 release_tree_vector (args);
3978 /* If the numeric argument didn't work, look for a raw literal
3979 operator taking a const char* argument consisting of the number
3980 in string format. */
3981 args = make_tree_vector ();
3982 vec_safe_push (args, num_string);
3983 decl = lookup_literal_operator (name, args);
3984 if (decl && decl != error_mark_node)
3986 result = finish_call_expr (decl, &args, false, true,
3987 tf_warning_or_error);
3988 release_tree_vector (args);
3991 release_tree_vector (args);
3993 /* If the raw literal didn't work, look for a non-type template
3994 function with parameter pack char.... Call the function with
3995 template parameter characters representing the number. */
3996 args = make_tree_vector ();
3997 decl = lookup_literal_operator (name, args);
3998 if (decl && decl != error_mark_node)
4000 tree tmpl_args = make_char_string_pack (num_string);
4001 decl = lookup_template_function (decl, tmpl_args);
4002 result = finish_call_expr (decl, &args, false, true,
4003 tf_warning_or_error);
4004 release_tree_vector (args);
4008 release_tree_vector (args);
4010 error ("unable to find numeric literal operator %qD", name);
4011 if (!cpp_get_options (parse_in)->ext_numeric_literals)
4012 inform (token->location, "use -std=gnu++11 or -fext-numeric-literals "
4013 "to enable more built-in suffixes");
4014 return error_mark_node;
4017 /* Parse a user-defined string constant. Returns a call to a user-defined
4018 literal operator taking a character pointer and the length of the string
4022 cp_parser_userdef_string_literal (tree literal)
4024 tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal);
4025 tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id));
4026 tree value = USERDEF_LITERAL_VALUE (literal);
4027 int len = TREE_STRING_LENGTH (value)
4028 / TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value)))) - 1;
4030 vec<tree, va_gc> *args;
4032 /* Build up a call to the user-defined operator. */
4033 /* Lookup the name we got back from the id-expression. */
4034 args = make_tree_vector ();
4035 vec_safe_push (args, value);
4036 vec_safe_push (args, build_int_cst (size_type_node, len));
4037 decl = lookup_literal_operator (name, args);
4039 if (decl && decl != error_mark_node)
4041 result = finish_call_expr (decl, &args, false, true,
4042 tf_warning_or_error);
4043 release_tree_vector (args);
4046 release_tree_vector (args);
4048 /* Look for a template function with typename parameter CharT
4049 and parameter pack CharT... Call the function with
4050 template parameter characters representing the string. */
4051 args = make_tree_vector ();
4052 decl = lookup_literal_operator (name, args);
4053 if (decl && decl != error_mark_node)
4055 tree tmpl_args = make_string_pack (value);
4056 decl = lookup_template_function (decl, tmpl_args);
4057 result = finish_call_expr (decl, &args, false, true,
4058 tf_warning_or_error);
4059 release_tree_vector (args);
4062 release_tree_vector (args);
4064 error ("unable to find string literal operator %qD with %qT, %qT arguments",
4065 name, TREE_TYPE (value), size_type_node);
4066 return error_mark_node;
4070 /* Basic concepts [gram.basic] */
4072 /* Parse a translation-unit.
4075 declaration-seq [opt]
4077 Returns TRUE if all went well. */
4080 cp_parser_translation_unit (cp_parser* parser)
4082 /* The address of the first non-permanent object on the declarator
4084 static void *declarator_obstack_base;
4088 /* Create the declarator obstack, if necessary. */
4089 if (!cp_error_declarator)
4091 gcc_obstack_init (&declarator_obstack);
4092 /* Create the error declarator. */
4093 cp_error_declarator = make_declarator (cdk_error);
4094 /* Create the empty parameter list. */
4095 no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE);
4096 /* Remember where the base of the declarator obstack lies. */
4097 declarator_obstack_base = obstack_next_free (&declarator_obstack);
4100 cp_parser_declaration_seq_opt (parser);
4102 /* If there are no tokens left then all went well. */
4103 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
4105 /* Get rid of the token array; we don't need it any more. */
4106 cp_lexer_destroy (parser->lexer);
4107 parser->lexer = NULL;
4109 /* This file might have been a context that's implicitly extern
4110 "C". If so, pop the lang context. (Only relevant for PCH.) */
4111 if (parser->implicit_extern_c)
4113 pop_lang_context ();
4114 parser->implicit_extern_c = false;
4118 finish_translation_unit ();
4124 cp_parser_error (parser, "expected declaration");
4128 /* Make sure the declarator obstack was fully cleaned up. */
4129 gcc_assert (obstack_next_free (&declarator_obstack)
4130 == declarator_obstack_base);
4132 /* All went well. */
4136 /* Return the appropriate tsubst flags for parsing, possibly in N3276
4137 decltype context. */
4139 static inline tsubst_flags_t
4140 complain_flags (bool decltype_p)
4142 tsubst_flags_t complain = tf_warning_or_error;
4144 complain |= tf_decltype;
4148 /* We're about to parse a collection of statements. If we're currently
4149 parsing tentatively, set up a firewall so that any nested
4150 cp_parser_commit_to_tentative_parse won't affect the current context. */
4152 static cp_token_position
4153 cp_parser_start_tentative_firewall (cp_parser *parser)
4155 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
4158 cp_parser_parse_tentatively (parser);
4159 cp_parser_commit_to_topmost_tentative_parse (parser);
4160 return cp_lexer_token_position (parser->lexer, false);
4163 /* We've finished parsing the collection of statements. Wrap up the
4164 firewall and replace the relevant tokens with the parsed form. */
4167 cp_parser_end_tentative_firewall (cp_parser *parser, cp_token_position start,
4173 /* Finish the firewall level. */
4174 cp_parser_parse_definitely (parser);
4175 /* And remember the result of the parse for when we try again. */
4176 cp_token *token = cp_lexer_token_at (parser->lexer, start);
4177 token->type = CPP_PREPARSED_EXPR;
4178 token->u.value = expr;
4179 token->keyword = RID_MAX;
4180 cp_lexer_purge_tokens_after (parser->lexer, start);
4183 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
4184 enclosing parentheses. */
4187 cp_parser_statement_expr (cp_parser *parser)
4189 cp_token_position start = cp_parser_start_tentative_firewall (parser);
4191 /* Consume the '('. */
4192 cp_lexer_consume_token (parser->lexer);
4193 /* Start the statement-expression. */
4194 tree expr = begin_stmt_expr ();
4195 /* Parse the compound-statement. */
4196 cp_parser_compound_statement (parser, expr, false, false);
4198 expr = finish_stmt_expr (expr, false);
4199 /* Consume the ')'. */
4200 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
4201 cp_parser_skip_to_end_of_statement (parser);
4203 cp_parser_end_tentative_firewall (parser, start, expr);
4207 /* Expressions [gram.expr] */
4209 /* Parse a primary-expression.
4216 lambda-expression (C++11)
4221 ( compound-statement )
4222 __builtin_va_arg ( assignment-expression , type-id )
4223 __builtin_offsetof ( type-id , offsetof-expression )
4226 __has_nothrow_assign ( type-id )
4227 __has_nothrow_constructor ( type-id )
4228 __has_nothrow_copy ( type-id )
4229 __has_trivial_assign ( type-id )
4230 __has_trivial_constructor ( type-id )
4231 __has_trivial_copy ( type-id )
4232 __has_trivial_destructor ( type-id )
4233 __has_virtual_destructor ( type-id )
4234 __is_abstract ( type-id )
4235 __is_base_of ( type-id , type-id )
4236 __is_class ( type-id )
4237 __is_empty ( type-id )
4238 __is_enum ( type-id )
4239 __is_final ( type-id )
4240 __is_literal_type ( type-id )
4241 __is_pod ( type-id )
4242 __is_polymorphic ( type-id )
4243 __is_std_layout ( type-id )
4244 __is_trivial ( type-id )
4245 __is_union ( type-id )
4247 Objective-C++ Extension:
4255 ADDRESS_P is true iff this expression was immediately preceded by
4256 "&" and therefore might denote a pointer-to-member. CAST_P is true
4257 iff this expression is the target of a cast. TEMPLATE_ARG_P is
4258 true iff this expression is a template argument.
4260 Returns a representation of the expression. Upon return, *IDK
4261 indicates what kind of id-expression (if any) was present. */
4264 cp_parser_primary_expression (cp_parser *parser,
4267 bool template_arg_p,
4271 cp_token *token = NULL;
4273 /* Assume the primary expression is not an id-expression. */
4274 *idk = CP_ID_KIND_NONE;
4276 /* Peek at the next token. */
4277 token = cp_lexer_peek_token (parser->lexer);
4278 switch ((int) token->type)
4287 user-defined-literal */
4293 case CPP_PREPARSED_EXPR:
4294 if (TREE_CODE (token->u.value) == USERDEF_LITERAL)
4295 return cp_parser_userdef_numeric_literal (parser);
4296 token = cp_lexer_consume_token (parser->lexer);
4297 if (TREE_CODE (token->u.value) == FIXED_CST)
4299 error_at (token->location,
4300 "fixed-point types not supported in C++");
4301 return error_mark_node;
4303 /* Floating-point literals are only allowed in an integral
4304 constant expression if they are cast to an integral or
4305 enumeration type. */
4306 if (TREE_CODE (token->u.value) == REAL_CST
4307 && parser->integral_constant_expression_p
4310 /* CAST_P will be set even in invalid code like "int(2.7 +
4311 ...)". Therefore, we have to check that the next token
4312 is sure to end the cast. */
4315 cp_token *next_token;
4317 next_token = cp_lexer_peek_token (parser->lexer);
4318 if (/* The comma at the end of an
4319 enumerator-definition. */
4320 next_token->type != CPP_COMMA
4321 /* The curly brace at the end of an enum-specifier. */
4322 && next_token->type != CPP_CLOSE_BRACE
4323 /* The end of a statement. */
4324 && next_token->type != CPP_SEMICOLON
4325 /* The end of the cast-expression. */
4326 && next_token->type != CPP_CLOSE_PAREN
4327 /* The end of an array bound. */
4328 && next_token->type != CPP_CLOSE_SQUARE
4329 /* The closing ">" in a template-argument-list. */
4330 && (next_token->type != CPP_GREATER
4331 || parser->greater_than_is_operator_p)
4332 /* C++0x only: A ">>" treated like two ">" tokens,
4333 in a template-argument-list. */
4334 && (next_token->type != CPP_RSHIFT
4335 || (cxx_dialect == cxx98)
4336 || parser->greater_than_is_operator_p))
4340 /* If we are within a cast, then the constraint that the
4341 cast is to an integral or enumeration type will be
4342 checked at that point. If we are not within a cast, then
4343 this code is invalid. */
4345 cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
4347 return token->u.value;
4349 case CPP_CHAR_USERDEF:
4350 case CPP_CHAR16_USERDEF:
4351 case CPP_CHAR32_USERDEF:
4352 case CPP_WCHAR_USERDEF:
4353 return cp_parser_userdef_char_literal (parser);
4359 case CPP_UTF8STRING:
4360 case CPP_STRING_USERDEF:
4361 case CPP_STRING16_USERDEF:
4362 case CPP_STRING32_USERDEF:
4363 case CPP_WSTRING_USERDEF:
4364 case CPP_UTF8STRING_USERDEF:
4365 /* ??? Should wide strings be allowed when parser->translate_strings_p
4366 is false (i.e. in attributes)? If not, we can kill the third
4367 argument to cp_parser_string_literal. */
4368 return cp_parser_string_literal (parser,
4369 parser->translate_strings_p,
4372 case CPP_OPEN_PAREN:
4373 /* If we see `( { ' then we are looking at the beginning of
4374 a GNU statement-expression. */
4375 if (cp_parser_allow_gnu_extensions_p (parser)
4376 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_BRACE))
4378 /* Statement-expressions are not allowed by the standard. */
4379 pedwarn (token->location, OPT_Wpedantic,
4380 "ISO C++ forbids braced-groups within expressions");
4382 /* And they're not allowed outside of a function-body; you
4383 cannot, for example, write:
4385 int i = ({ int j = 3; j + 1; });
4387 at class or namespace scope. */
4388 if (!parser->in_function_body
4389 || parser->in_template_argument_list_p)
4391 error_at (token->location,
4392 "statement-expressions are not allowed outside "
4393 "functions nor in template-argument lists");
4394 cp_parser_skip_to_end_of_block_or_statement (parser);
4395 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
4396 cp_lexer_consume_token (parser->lexer);
4397 return error_mark_node;
4400 return cp_parser_statement_expr (parser);
4402 /* Otherwise it's a normal parenthesized expression. */
4405 bool saved_greater_than_is_operator_p;
4407 /* Consume the `('. */
4408 cp_lexer_consume_token (parser->lexer);
4409 /* Within a parenthesized expression, a `>' token is always
4410 the greater-than operator. */
4411 saved_greater_than_is_operator_p
4412 = parser->greater_than_is_operator_p;
4413 parser->greater_than_is_operator_p = true;
4415 /* Parse the parenthesized expression. */
4416 expr = cp_parser_expression (parser, idk, cast_p, decltype_p);
4417 /* Let the front end know that this expression was
4418 enclosed in parentheses. This matters in case, for
4419 example, the expression is of the form `A::B', since
4420 `&A::B' might be a pointer-to-member, but `&(A::B)' is
4422 expr = finish_parenthesized_expr (expr);
4423 /* DR 705: Wrapping an unqualified name in parentheses
4424 suppresses arg-dependent lookup. We want to pass back
4425 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
4426 (c++/37862), but none of the others. */
4427 if (*idk != CP_ID_KIND_QUALIFIED)
4428 *idk = CP_ID_KIND_NONE;
4430 /* The `>' token might be the end of a template-id or
4431 template-parameter-list now. */
4432 parser->greater_than_is_operator_p
4433 = saved_greater_than_is_operator_p;
4434 /* Consume the `)'. */
4435 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
4436 cp_parser_skip_to_end_of_statement (parser);
4441 case CPP_OPEN_SQUARE:
4443 if (c_dialect_objc ())
4445 /* We might have an Objective-C++ message. */
4446 cp_parser_parse_tentatively (parser);
4447 tree msg = cp_parser_objc_message_expression (parser);
4448 /* If that works out, we're done ... */
4449 if (cp_parser_parse_definitely (parser))
4451 /* ... else, fall though to see if it's a lambda. */
4453 tree lam = cp_parser_lambda_expression (parser);
4454 /* Don't warn about a failed tentative parse. */
4455 if (cp_parser_error_occurred (parser))
4456 return error_mark_node;
4457 maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
4461 case CPP_OBJC_STRING:
4462 if (c_dialect_objc ())
4463 /* We have an Objective-C++ string literal. */
4464 return cp_parser_objc_expression (parser);
4465 cp_parser_error (parser, "expected primary-expression");
4466 return error_mark_node;
4469 switch (token->keyword)
4471 /* These two are the boolean literals. */
4473 cp_lexer_consume_token (parser->lexer);
4474 return boolean_true_node;
4476 cp_lexer_consume_token (parser->lexer);
4477 return boolean_false_node;
4479 /* The `__null' literal. */
4481 cp_lexer_consume_token (parser->lexer);
4484 /* The `nullptr' literal. */
4486 cp_lexer_consume_token (parser->lexer);
4487 return nullptr_node;
4489 /* Recognize the `this' keyword. */
4491 cp_lexer_consume_token (parser->lexer);
4492 if (parser->local_variables_forbidden_p)
4494 error_at (token->location,
4495 "%<this%> may not be used in this context");
4496 return error_mark_node;
4498 /* Pointers cannot appear in constant-expressions. */
4499 if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
4500 return error_mark_node;
4501 return finish_this_expr ();
4503 /* The `operator' keyword can be the beginning of an
4508 case RID_FUNCTION_NAME:
4509 case RID_PRETTY_FUNCTION_NAME:
4510 case RID_C99_FUNCTION_NAME:
4512 non_integral_constant name;
4514 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
4515 __func__ are the names of variables -- but they are
4516 treated specially. Therefore, they are handled here,
4517 rather than relying on the generic id-expression logic
4518 below. Grammatically, these names are id-expressions.
4520 Consume the token. */
4521 token = cp_lexer_consume_token (parser->lexer);
4523 switch (token->keyword)
4525 case RID_FUNCTION_NAME:
4526 name = NIC_FUNC_NAME;
4528 case RID_PRETTY_FUNCTION_NAME:
4529 name = NIC_PRETTY_FUNC;
4531 case RID_C99_FUNCTION_NAME:
4532 name = NIC_C99_FUNC;
4538 if (cp_parser_non_integral_constant_expression (parser, name))
4539 return error_mark_node;
4541 /* Look up the name. */
4542 return finish_fname (token->u.value);
4549 source_location type_location;
4551 /* The `__builtin_va_arg' construct is used to handle
4552 `va_arg'. Consume the `__builtin_va_arg' token. */
4553 cp_lexer_consume_token (parser->lexer);
4554 /* Look for the opening `('. */
4555 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
4556 /* Now, parse the assignment-expression. */
4557 expression = cp_parser_assignment_expression (parser);
4558 /* Look for the `,'. */
4559 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
4560 type_location = cp_lexer_peek_token (parser->lexer)->location;
4561 /* Parse the type-id. */
4562 type = cp_parser_type_id (parser);
4563 /* Look for the closing `)'. */
4564 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
4565 /* Using `va_arg' in a constant-expression is not
4567 if (cp_parser_non_integral_constant_expression (parser,
4569 return error_mark_node;
4570 return build_x_va_arg (type_location, expression, type);
4574 return cp_parser_builtin_offsetof (parser);
4576 case RID_HAS_NOTHROW_ASSIGN:
4577 case RID_HAS_NOTHROW_CONSTRUCTOR:
4578 case RID_HAS_NOTHROW_COPY:
4579 case RID_HAS_TRIVIAL_ASSIGN:
4580 case RID_HAS_TRIVIAL_CONSTRUCTOR:
4581 case RID_HAS_TRIVIAL_COPY:
4582 case RID_HAS_TRIVIAL_DESTRUCTOR:
4583 case RID_HAS_VIRTUAL_DESTRUCTOR:
4584 case RID_IS_ABSTRACT:
4585 case RID_IS_BASE_OF:
4590 case RID_IS_LITERAL_TYPE:
4592 case RID_IS_POLYMORPHIC:
4593 case RID_IS_STD_LAYOUT:
4594 case RID_IS_TRIVIAL:
4595 case RID_IS_TRIVIALLY_ASSIGNABLE:
4596 case RID_IS_TRIVIALLY_CONSTRUCTIBLE:
4597 case RID_IS_TRIVIALLY_COPYABLE:
4599 return cp_parser_trait_expr (parser, token->keyword);
4601 /* Objective-C++ expressions. */
4603 case RID_AT_PROTOCOL:
4604 case RID_AT_SELECTOR:
4605 return cp_parser_objc_expression (parser);
4608 if (parser->in_function_body
4609 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
4612 error_at (token->location,
4613 "a template declaration cannot appear at block scope");
4614 cp_parser_skip_to_end_of_block_or_statement (parser);
4615 return error_mark_node;
4618 cp_parser_error (parser, "expected primary-expression");
4619 return error_mark_node;
4622 /* An id-expression can start with either an identifier, a
4623 `::' as the beginning of a qualified-id, or the "operator"
4627 case CPP_TEMPLATE_ID:
4628 case CPP_NESTED_NAME_SPECIFIER:
4632 const char *error_msg;
4635 cp_token *id_expr_token;
4638 /* Parse the id-expression. */
4640 = cp_parser_id_expression (parser,
4641 /*template_keyword_p=*/false,
4642 /*check_dependency_p=*/true,
4644 /*declarator_p=*/false,
4645 /*optional_p=*/false);
4646 if (id_expression == error_mark_node)
4647 return error_mark_node;
4648 id_expr_token = token;
4649 token = cp_lexer_peek_token (parser->lexer);
4650 done = (token->type != CPP_OPEN_SQUARE
4651 && token->type != CPP_OPEN_PAREN
4652 && token->type != CPP_DOT
4653 && token->type != CPP_DEREF
4654 && token->type != CPP_PLUS_PLUS
4655 && token->type != CPP_MINUS_MINUS);
4656 /* If we have a template-id, then no further lookup is
4657 required. If the template-id was for a template-class, we
4658 will sometimes have a TYPE_DECL at this point. */
4659 if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR
4660 || TREE_CODE (id_expression) == TYPE_DECL)
4661 decl = id_expression;
4662 /* Look up the name. */
4665 tree ambiguous_decls;
4667 /* If we already know that this lookup is ambiguous, then
4668 we've already issued an error message; there's no reason
4670 if (id_expr_token->type == CPP_NAME
4671 && id_expr_token->error_reported)
4673 cp_parser_simulate_error (parser);
4674 return error_mark_node;
4677 decl = cp_parser_lookup_name (parser, id_expression,
4680 /*is_namespace=*/false,
4681 /*check_dependency=*/true,
4683 id_expr_token->location);
4684 /* If the lookup was ambiguous, an error will already have
4686 if (ambiguous_decls)
4687 return error_mark_node;
4689 /* In Objective-C++, we may have an Objective-C 2.0
4690 dot-syntax for classes here. */
4691 if (c_dialect_objc ()
4692 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
4693 && TREE_CODE (decl) == TYPE_DECL
4694 && objc_is_class_name (decl))
4697 cp_lexer_consume_token (parser->lexer);
4698 component = cp_parser_identifier (parser);
4699 if (component == error_mark_node)
4700 return error_mark_node;
4702 return objc_build_class_component_ref (id_expression, component);
4705 /* In Objective-C++, an instance variable (ivar) may be preferred
4706 to whatever cp_parser_lookup_name() found. */
4707 decl = objc_lookup_ivar (decl, id_expression);
4709 /* If name lookup gives us a SCOPE_REF, then the
4710 qualifying scope was dependent. */
4711 if (TREE_CODE (decl) == SCOPE_REF)
4713 /* At this point, we do not know if DECL is a valid
4714 integral constant expression. We assume that it is
4715 in fact such an expression, so that code like:
4717 template <int N> struct A {
4721 is accepted. At template-instantiation time, we
4722 will check that B<N>::i is actually a constant. */
4725 /* Check to see if DECL is a local variable in a context
4726 where that is forbidden. */
4727 if (parser->local_variables_forbidden_p
4728 && local_variable_p (decl))
4730 /* It might be that we only found DECL because we are
4731 trying to be generous with pre-ISO scoping rules.
4732 For example, consider:
4736 for (int i = 0; i < 10; ++i) {}
4737 extern void f(int j = i);
4740 Here, name look up will originally find the out
4741 of scope `i'. We need to issue a warning message,
4742 but then use the global `i'. */
4743 decl = check_for_out_of_scope_variable (decl);
4744 if (local_variable_p (decl))
4746 error_at (id_expr_token->location,
4747 "local variable %qD may not appear in this context",
4749 return error_mark_node;
4754 decl = (finish_id_expression
4755 (id_expression, decl, parser->scope,
4757 parser->integral_constant_expression_p,
4758 parser->allow_non_integral_constant_expression_p,
4759 &parser->non_integral_constant_expression_p,
4760 template_p, done, address_p,
4763 id_expr_token->location));
4765 cp_parser_error (parser, error_msg);
4769 /* Anything else is an error. */
4771 cp_parser_error (parser, "expected primary-expression");
4772 return error_mark_node;
4777 cp_parser_primary_expression (cp_parser *parser,
4780 bool template_arg_p,
4783 return cp_parser_primary_expression (parser, address_p, cast_p, template_arg_p,
4784 /*decltype*/false, idk);
4787 /* Parse an id-expression.
4794 :: [opt] nested-name-specifier template [opt] unqualified-id
4796 :: operator-function-id
4799 Return a representation of the unqualified portion of the
4800 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
4801 a `::' or nested-name-specifier.
4803 Often, if the id-expression was a qualified-id, the caller will
4804 want to make a SCOPE_REF to represent the qualified-id. This
4805 function does not do this in order to avoid wastefully creating
4806 SCOPE_REFs when they are not required.
4808 If TEMPLATE_KEYWORD_P is true, then we have just seen the
4811 If CHECK_DEPENDENCY_P is false, then names are looked up inside
4812 uninstantiated templates.
4814 If *TEMPLATE_P is non-NULL, it is set to true iff the
4815 `template' keyword is used to explicitly indicate that the entity
4816 named is a template.
4818 If DECLARATOR_P is true, the id-expression is appearing as part of
4819 a declarator, rather than as part of an expression. */
4822 cp_parser_id_expression (cp_parser *parser,
4823 bool template_keyword_p,
4824 bool check_dependency_p,
4829 bool global_scope_p;
4830 bool nested_name_specifier_p;
4832 /* Assume the `template' keyword was not used. */
4834 *template_p = template_keyword_p;
4836 /* Look for the optional `::' operator. */
4838 = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)
4840 /* Look for the optional nested-name-specifier. */
4841 nested_name_specifier_p
4842 = (cp_parser_nested_name_specifier_opt (parser,
4843 /*typename_keyword_p=*/false,
4848 /* If there is a nested-name-specifier, then we are looking at
4849 the first qualified-id production. */
4850 if (nested_name_specifier_p)
4853 tree saved_object_scope;
4854 tree saved_qualifying_scope;
4855 tree unqualified_id;
4858 /* See if the next token is the `template' keyword. */
4860 template_p = &is_template;
4861 *template_p = cp_parser_optional_template_keyword (parser);
4862 /* Name lookup we do during the processing of the
4863 unqualified-id might obliterate SCOPE. */
4864 saved_scope = parser->scope;
4865 saved_object_scope = parser->object_scope;
4866 saved_qualifying_scope = parser->qualifying_scope;
4867 /* Process the final unqualified-id. */
4868 unqualified_id = cp_parser_unqualified_id (parser, *template_p,
4871 /*optional_p=*/false);
4872 /* Restore the SAVED_SCOPE for our caller. */
4873 parser->scope = saved_scope;
4874 parser->object_scope = saved_object_scope;
4875 parser->qualifying_scope = saved_qualifying_scope;
4877 return unqualified_id;
4879 /* Otherwise, if we are in global scope, then we are looking at one
4880 of the other qualified-id productions. */
4881 else if (global_scope_p)
4886 /* Peek at the next token. */
4887 token = cp_lexer_peek_token (parser->lexer);
4889 /* If it's an identifier, and the next token is not a "<", then
4890 we can avoid the template-id case. This is an optimization
4891 for this common case. */
4892 if (token->type == CPP_NAME
4893 && !cp_parser_nth_token_starts_template_argument_list_p
4895 return cp_parser_identifier (parser);
4897 cp_parser_parse_tentatively (parser);
4898 /* Try a template-id. */
4899 id = cp_parser_template_id (parser,
4900 /*template_keyword_p=*/false,
4901 /*check_dependency_p=*/true,
4904 /* If that worked, we're done. */
4905 if (cp_parser_parse_definitely (parser))
4908 /* Peek at the next token. (Changes in the token buffer may
4909 have invalidated the pointer obtained above.) */
4910 token = cp_lexer_peek_token (parser->lexer);
4912 switch (token->type)
4915 return cp_parser_identifier (parser);
4918 if (token->keyword == RID_OPERATOR)
4919 return cp_parser_operator_function_id (parser);
4923 cp_parser_error (parser, "expected id-expression");
4924 return error_mark_node;
4928 return cp_parser_unqualified_id (parser, template_keyword_p,
4929 /*check_dependency_p=*/true,
4934 /* Parse an unqualified-id.
4938 operator-function-id
4939 conversion-function-id
4943 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
4944 keyword, in a construct like `A::template ...'.
4946 Returns a representation of unqualified-id. For the `identifier'
4947 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
4948 production a BIT_NOT_EXPR is returned; the operand of the
4949 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
4950 other productions, see the documentation accompanying the
4951 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
4952 names are looked up in uninstantiated templates. If DECLARATOR_P
4953 is true, the unqualified-id is appearing as part of a declarator,
4954 rather than as part of an expression. */
4957 cp_parser_unqualified_id (cp_parser* parser,
4958 bool template_keyword_p,
4959 bool check_dependency_p,
4965 /* Peek at the next token. */
4966 token = cp_lexer_peek_token (parser->lexer);
4968 switch ((int) token->type)
4974 /* We don't know yet whether or not this will be a
4976 cp_parser_parse_tentatively (parser);
4977 /* Try a template-id. */
4978 id = cp_parser_template_id (parser, template_keyword_p,
4982 /* If it worked, we're done. */
4983 if (cp_parser_parse_definitely (parser))
4985 /* Otherwise, it's an ordinary identifier. */
4986 return cp_parser_identifier (parser);
4989 case CPP_TEMPLATE_ID:
4990 return cp_parser_template_id (parser, template_keyword_p,
4998 tree qualifying_scope;
5003 /* Consume the `~' token. */
5004 cp_lexer_consume_token (parser->lexer);
5005 /* Parse the class-name. The standard, as written, seems to
5008 template <typename T> struct S { ~S (); };
5009 template <typename T> S<T>::~S() {}
5011 is invalid, since `~' must be followed by a class-name, but
5012 `S<T>' is dependent, and so not known to be a class.
5013 That's not right; we need to look in uninstantiated
5014 templates. A further complication arises from:
5016 template <typename T> void f(T t) {
5020 Here, it is not possible to look up `T' in the scope of `T'
5021 itself. We must look in both the current scope, and the
5022 scope of the containing complete expression.
5024 Yet another issue is:
5033 The standard does not seem to say that the `S' in `~S'
5034 should refer to the type `S' and not the data member
5037 /* DR 244 says that we look up the name after the "~" in the
5038 same scope as we looked up the qualifying name. That idea
5039 isn't fully worked out; it's more complicated than that. */
5040 scope = parser->scope;
5041 object_scope = parser->object_scope;
5042 qualifying_scope = parser->qualifying_scope;
5044 /* Check for invalid scopes. */
5045 if (scope == error_mark_node)
5047 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
5048 cp_lexer_consume_token (parser->lexer);
5049 return error_mark_node;
5051 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
5053 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
5054 error_at (token->location,
5055 "scope %qT before %<~%> is not a class-name",
5057 cp_parser_simulate_error (parser);
5058 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
5059 cp_lexer_consume_token (parser->lexer);
5060 return error_mark_node;
5062 gcc_assert (!scope || TYPE_P (scope));
5064 /* If the name is of the form "X::~X" it's OK even if X is a
5066 token = cp_lexer_peek_token (parser->lexer);
5068 && token->type == CPP_NAME
5069 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
5071 && (token->u.value == TYPE_IDENTIFIER (scope)
5072 || (CLASS_TYPE_P (scope)
5073 && constructor_name_p (token->u.value, scope))))
5075 cp_lexer_consume_token (parser->lexer);
5076 return build_nt (BIT_NOT_EXPR, scope);
5079 /* ~auto means the destructor of whatever the object is. */
5080 if (cp_parser_is_keyword (token, RID_AUTO))
5082 if (cxx_dialect < cxx14)
5083 pedwarn (input_location, 0,
5084 "%<~auto%> only available with "
5085 "-std=c++14 or -std=gnu++14");
5086 cp_lexer_consume_token (parser->lexer);
5087 return build_nt (BIT_NOT_EXPR, make_auto ());
5090 /* If there was an explicit qualification (S::~T), first look
5091 in the scope given by the qualification (i.e., S).
5093 Note: in the calls to cp_parser_class_name below we pass
5094 typename_type so that lookup finds the injected-class-name
5095 rather than the constructor. */
5097 type_decl = NULL_TREE;
5100 cp_parser_parse_tentatively (parser);
5101 type_decl = cp_parser_class_name (parser,
5102 /*typename_keyword_p=*/false,
5103 /*template_keyword_p=*/false,
5105 /*check_dependency=*/false,
5106 /*class_head_p=*/false,
5108 if (cp_parser_parse_definitely (parser))
5111 /* In "N::S::~S", look in "N" as well. */
5112 if (!done && scope && qualifying_scope)
5114 cp_parser_parse_tentatively (parser);
5115 parser->scope = qualifying_scope;
5116 parser->object_scope = NULL_TREE;
5117 parser->qualifying_scope = NULL_TREE;
5119 = cp_parser_class_name (parser,
5120 /*typename_keyword_p=*/false,
5121 /*template_keyword_p=*/false,
5123 /*check_dependency=*/false,
5124 /*class_head_p=*/false,
5126 if (cp_parser_parse_definitely (parser))
5129 /* In "p->S::~T", look in the scope given by "*p" as well. */
5130 else if (!done && object_scope)
5132 cp_parser_parse_tentatively (parser);
5133 parser->scope = object_scope;
5134 parser->object_scope = NULL_TREE;
5135 parser->qualifying_scope = NULL_TREE;
5137 = cp_parser_class_name (parser,
5138 /*typename_keyword_p=*/false,
5139 /*template_keyword_p=*/false,
5141 /*check_dependency=*/false,
5142 /*class_head_p=*/false,
5144 if (cp_parser_parse_definitely (parser))
5147 /* Look in the surrounding context. */
5150 parser->scope = NULL_TREE;
5151 parser->object_scope = NULL_TREE;
5152 parser->qualifying_scope = NULL_TREE;
5153 if (processing_template_decl)
5154 cp_parser_parse_tentatively (parser);
5156 = cp_parser_class_name (parser,
5157 /*typename_keyword_p=*/false,
5158 /*template_keyword_p=*/false,
5160 /*check_dependency=*/false,
5161 /*class_head_p=*/false,
5163 if (processing_template_decl
5164 && ! cp_parser_parse_definitely (parser))
5166 /* We couldn't find a type with this name, so just accept
5167 it and check for a match at instantiation time. */
5168 type_decl = cp_parser_identifier (parser);
5169 if (type_decl != error_mark_node)
5170 type_decl = build_nt (BIT_NOT_EXPR, type_decl);
5174 /* If an error occurred, assume that the name of the
5175 destructor is the same as the name of the qualifying
5176 class. That allows us to keep parsing after running
5177 into ill-formed destructor names. */
5178 if (type_decl == error_mark_node && scope)
5179 return build_nt (BIT_NOT_EXPR, scope);
5180 else if (type_decl == error_mark_node)
5181 return error_mark_node;
5183 /* Check that destructor name and scope match. */
5184 if (declarator_p && scope && !check_dtor_name (scope, type_decl))
5186 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
5187 error_at (token->location,
5188 "declaration of %<~%T%> as member of %qT",
5190 cp_parser_simulate_error (parser);
5191 return error_mark_node;
5196 A typedef-name that names a class shall not be used as the
5197 identifier in the declarator for a destructor declaration. */
5199 && !DECL_IMPLICIT_TYPEDEF_P (type_decl)
5200 && !DECL_SELF_REFERENCE_P (type_decl)
5201 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
5202 error_at (token->location,
5203 "typedef-name %qD used as destructor declarator",
5206 return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl));
5210 if (token->keyword == RID_OPERATOR)
5214 /* This could be a template-id, so we try that first. */
5215 cp_parser_parse_tentatively (parser);
5216 /* Try a template-id. */
5217 id = cp_parser_template_id (parser, template_keyword_p,
5218 /*check_dependency_p=*/true,
5221 /* If that worked, we're done. */
5222 if (cp_parser_parse_definitely (parser))
5224 /* We still don't know whether we're looking at an
5225 operator-function-id or a conversion-function-id. */
5226 cp_parser_parse_tentatively (parser);
5227 /* Try an operator-function-id. */
5228 id = cp_parser_operator_function_id (parser);
5229 /* If that didn't work, try a conversion-function-id. */
5230 if (!cp_parser_parse_definitely (parser))
5231 id = cp_parser_conversion_function_id (parser);
5232 else if (UDLIT_OPER_P (id))
5235 const char *name = UDLIT_OP_SUFFIX (id);
5236 if (name[0] != '_' && !in_system_header_at (input_location)
5238 warning (0, "literal operator suffixes not preceded by %<_%>"
5239 " are reserved for future standardization");
5249 cp_parser_error (parser, "expected unqualified-id");
5250 return error_mark_node;
5254 /* Parse an (optional) nested-name-specifier.
5256 nested-name-specifier: [C++98]
5257 class-or-namespace-name :: nested-name-specifier [opt]
5258 class-or-namespace-name :: template nested-name-specifier [opt]
5260 nested-name-specifier: [C++0x]
5263 nested-name-specifier identifier ::
5264 nested-name-specifier template [opt] simple-template-id ::
5266 PARSER->SCOPE should be set appropriately before this function is
5267 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
5268 effect. TYPE_P is TRUE if we non-type bindings should be ignored
5271 Sets PARSER->SCOPE to the class (TYPE) or namespace
5272 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
5273 it unchanged if there is no nested-name-specifier. Returns the new
5274 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
5276 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
5277 part of a declaration and/or decl-specifier. */
5280 cp_parser_nested_name_specifier_opt (cp_parser *parser,
5281 bool typename_keyword_p,
5282 bool check_dependency_p,
5284 bool is_declaration)
5286 bool success = false;
5287 cp_token_position start = 0;
5290 /* Remember where the nested-name-specifier starts. */
5291 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
5293 start = cp_lexer_token_position (parser->lexer, false);
5294 push_deferring_access_checks (dk_deferred);
5301 tree saved_qualifying_scope;
5302 bool template_keyword_p;
5304 /* Spot cases that cannot be the beginning of a
5305 nested-name-specifier. */
5306 token = cp_lexer_peek_token (parser->lexer);
5308 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
5309 the already parsed nested-name-specifier. */
5310 if (token->type == CPP_NESTED_NAME_SPECIFIER)
5312 /* Grab the nested-name-specifier and continue the loop. */
5313 cp_parser_pre_parsed_nested_name_specifier (parser);
5314 /* If we originally encountered this nested-name-specifier
5315 with IS_DECLARATION set to false, we will not have
5316 resolved TYPENAME_TYPEs, so we must do so here. */
5318 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
5320 new_scope = resolve_typename_type (parser->scope,
5321 /*only_current_p=*/false);
5322 if (TREE_CODE (new_scope) != TYPENAME_TYPE)
5323 parser->scope = new_scope;
5329 /* Spot cases that cannot be the beginning of a
5330 nested-name-specifier. On the second and subsequent times
5331 through the loop, we look for the `template' keyword. */
5332 if (success && token->keyword == RID_TEMPLATE)
5334 /* A template-id can start a nested-name-specifier. */
5335 else if (token->type == CPP_TEMPLATE_ID)
5337 /* DR 743: decltype can be used in a nested-name-specifier. */
5338 else if (token_is_decltype (token))
5342 /* If the next token is not an identifier, then it is
5343 definitely not a type-name or namespace-name. */
5344 if (token->type != CPP_NAME)
5346 /* If the following token is neither a `<' (to begin a
5347 template-id), nor a `::', then we are not looking at a
5348 nested-name-specifier. */
5349 token = cp_lexer_peek_nth_token (parser->lexer, 2);
5351 if (token->type == CPP_COLON
5352 && parser->colon_corrects_to_scope_p
5353 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME)
5355 error_at (token->location,
5356 "found %<:%> in nested-name-specifier, expected %<::%>");
5357 token->type = CPP_SCOPE;
5360 if (token->type != CPP_SCOPE
5361 && !cp_parser_nth_token_starts_template_argument_list_p
5366 /* The nested-name-specifier is optional, so we parse
5368 cp_parser_parse_tentatively (parser);
5370 /* Look for the optional `template' keyword, if this isn't the
5371 first time through the loop. */
5373 template_keyword_p = cp_parser_optional_template_keyword (parser);
5375 template_keyword_p = false;
5377 /* Save the old scope since the name lookup we are about to do
5378 might destroy it. */
5379 old_scope = parser->scope;
5380 saved_qualifying_scope = parser->qualifying_scope;
5381 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
5382 look up names in "X<T>::I" in order to determine that "Y" is
5383 a template. So, if we have a typename at this point, we make
5384 an effort to look through it. */
5386 && !typename_keyword_p
5388 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
5389 parser->scope = resolve_typename_type (parser->scope,
5390 /*only_current_p=*/false);
5391 /* Parse the qualifying entity. */
5393 = cp_parser_qualifying_entity (parser,
5399 /* Look for the `::' token. */
5400 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
5402 /* If we found what we wanted, we keep going; otherwise, we're
5404 if (!cp_parser_parse_definitely (parser))
5406 bool error_p = false;
5408 /* Restore the OLD_SCOPE since it was valid before the
5409 failed attempt at finding the last
5410 class-or-namespace-name. */
5411 parser->scope = old_scope;
5412 parser->qualifying_scope = saved_qualifying_scope;
5414 /* If the next token is a decltype, and the one after that is a
5415 `::', then the decltype has failed to resolve to a class or
5416 enumeration type. Give this error even when parsing
5417 tentatively since it can't possibly be valid--and we're going
5418 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
5419 won't get another chance.*/
5420 if (cp_lexer_next_token_is (parser->lexer, CPP_DECLTYPE)
5421 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
5424 token = cp_lexer_consume_token (parser->lexer);
5425 error_at (token->location, "decltype evaluates to %qT, "
5426 "which is not a class or enumeration type",
5428 parser->scope = error_mark_node;
5432 cp_lexer_consume_token (parser->lexer);
5435 if (cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID)
5436 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
5438 /* If we have a non-type template-id followed by ::, it can't
5439 possibly be valid. */
5440 token = cp_lexer_peek_token (parser->lexer);
5441 tree tid = token->u.tree_check_value->value;
5442 if (TREE_CODE (tid) == TEMPLATE_ID_EXPR
5443 && TREE_CODE (TREE_OPERAND (tid, 0)) != IDENTIFIER_NODE)
5445 tree tmpl = NULL_TREE;
5446 if (is_overloaded_fn (tid))
5448 tree fns = get_fns (tid);
5449 if (!OVL_CHAIN (fns))
5450 tmpl = OVL_CURRENT (fns);
5451 error_at (token->location, "function template-id %qD "
5452 "in nested-name-specifier", tid);
5456 /* Variable template. */
5457 tmpl = TREE_OPERAND (tid, 0);
5458 gcc_assert (variable_template_p (tmpl));
5459 error_at (token->location, "variable template-id %qD "
5460 "in nested-name-specifier", tid);
5463 inform (DECL_SOURCE_LOCATION (tmpl),
5464 "%qD declared here", tmpl);
5466 parser->scope = error_mark_node;
5470 cp_lexer_consume_token (parser->lexer);
5471 cp_lexer_consume_token (parser->lexer);
5475 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
5477 /* If the next token is an identifier, and the one after
5478 that is a `::', then any valid interpretation would have
5479 found a class-or-namespace-name. */
5480 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
5481 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
5483 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
5486 token = cp_lexer_consume_token (parser->lexer);
5489 if (!token->error_reported)
5492 tree ambiguous_decls;
5494 decl = cp_parser_lookup_name (parser, token->u.value,
5496 /*is_template=*/false,
5497 /*is_namespace=*/false,
5498 /*check_dependency=*/true,
5501 if (TREE_CODE (decl) == TEMPLATE_DECL)
5502 error_at (token->location,
5503 "%qD used without template parameters",
5505 else if (ambiguous_decls)
5507 // cp_parser_lookup_name has the same diagnostic,
5508 // thus make sure to emit it at most once.
5509 if (cp_parser_uncommitted_to_tentative_parse_p
5512 error_at (token->location,
5513 "reference to %qD is ambiguous",
5515 print_candidates (ambiguous_decls);
5517 decl = error_mark_node;
5521 if (cxx_dialect != cxx98)
5522 cp_parser_name_lookup_error
5523 (parser, token->u.value, decl, NLE_NOT_CXX98,
5526 cp_parser_name_lookup_error
5527 (parser, token->u.value, decl, NLE_CXX98,
5531 parser->scope = error_mark_node;
5533 /* Treat this as a successful nested-name-specifier
5538 If the name found is not a class-name (clause
5539 _class_) or namespace-name (_namespace.def_), the
5540 program is ill-formed. */
5543 cp_lexer_consume_token (parser->lexer);
5547 /* We've found one valid nested-name-specifier. */
5549 /* Name lookup always gives us a DECL. */
5550 if (TREE_CODE (new_scope) == TYPE_DECL)
5551 new_scope = TREE_TYPE (new_scope);
5552 /* Uses of "template" must be followed by actual templates. */
5553 if (template_keyword_p
5554 && !(CLASS_TYPE_P (new_scope)
5555 && ((CLASSTYPE_USE_TEMPLATE (new_scope)
5556 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope)))
5557 || CLASSTYPE_IS_TEMPLATE (new_scope)))
5558 && !(TREE_CODE (new_scope) == TYPENAME_TYPE
5559 && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope))
5560 == TEMPLATE_ID_EXPR)))
5561 permerror (input_location, TYPE_P (new_scope)
5562 ? G_("%qT is not a template")
5563 : G_("%qD is not a template"),
5565 /* If it is a class scope, try to complete it; we are about to
5566 be looking up names inside the class. */
5567 if (TYPE_P (new_scope)
5568 /* Since checking types for dependency can be expensive,
5569 avoid doing it if the type is already complete. */
5570 && !COMPLETE_TYPE_P (new_scope)
5571 /* Do not try to complete dependent types. */
5572 && !dependent_type_p (new_scope))
5574 new_scope = complete_type (new_scope);
5575 /* If it is a typedef to current class, use the current
5576 class instead, as the typedef won't have any names inside
5578 if (!COMPLETE_TYPE_P (new_scope)
5579 && currently_open_class (new_scope))
5580 new_scope = TYPE_MAIN_VARIANT (new_scope);
5582 /* Make sure we look in the right scope the next time through
5584 parser->scope = new_scope;
5587 /* If parsing tentatively, replace the sequence of tokens that makes
5588 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
5589 token. That way, should we re-parse the token stream, we will
5590 not have to repeat the effort required to do the parse, nor will
5591 we issue duplicate error messages. */
5592 if (success && start)
5596 token = cp_lexer_token_at (parser->lexer, start);
5597 /* Reset the contents of the START token. */
5598 token->type = CPP_NESTED_NAME_SPECIFIER;
5599 /* Retrieve any deferred checks. Do not pop this access checks yet
5600 so the memory will not be reclaimed during token replacing below. */
5601 token->u.tree_check_value = ggc_cleared_alloc<struct tree_check> ();
5602 token->u.tree_check_value->value = parser->scope;
5603 token->u.tree_check_value->checks = get_deferred_access_checks ();
5604 token->u.tree_check_value->qualifying_scope =
5605 parser->qualifying_scope;
5606 token->keyword = RID_MAX;
5608 /* Purge all subsequent tokens. */
5609 cp_lexer_purge_tokens_after (parser->lexer, start);
5613 pop_to_parent_deferring_access_checks ();
5615 return success ? parser->scope : NULL_TREE;
5618 /* Parse a nested-name-specifier. See
5619 cp_parser_nested_name_specifier_opt for details. This function
5620 behaves identically, except that it will an issue an error if no
5621 nested-name-specifier is present. */
5624 cp_parser_nested_name_specifier (cp_parser *parser,
5625 bool typename_keyword_p,
5626 bool check_dependency_p,
5628 bool is_declaration)
5632 /* Look for the nested-name-specifier. */
5633 scope = cp_parser_nested_name_specifier_opt (parser,
5638 /* If it was not present, issue an error message. */
5641 cp_parser_error (parser, "expected nested-name-specifier");
5642 parser->scope = NULL_TREE;
5648 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
5649 this is either a class-name or a namespace-name (which corresponds
5650 to the class-or-namespace-name production in the grammar). For
5651 C++0x, it can also be a type-name that refers to an enumeration
5652 type or a simple-template-id.
5654 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
5655 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
5656 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
5657 TYPE_P is TRUE iff the next name should be taken as a class-name,
5658 even the same name is declared to be another entity in the same
5661 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
5662 specified by the class-or-namespace-name. If neither is found the
5663 ERROR_MARK_NODE is returned. */
5666 cp_parser_qualifying_entity (cp_parser *parser,
5667 bool typename_keyword_p,
5668 bool template_keyword_p,
5669 bool check_dependency_p,
5671 bool is_declaration)
5674 tree saved_qualifying_scope;
5675 tree saved_object_scope;
5678 bool successful_parse_p;
5680 /* DR 743: decltype can appear in a nested-name-specifier. */
5681 if (cp_lexer_next_token_is_decltype (parser->lexer))
5683 scope = cp_parser_decltype (parser);
5684 if (TREE_CODE (scope) != ENUMERAL_TYPE
5685 && !MAYBE_CLASS_TYPE_P (scope))
5687 cp_parser_simulate_error (parser);
5688 return error_mark_node;
5690 if (TYPE_NAME (scope))
5691 scope = TYPE_NAME (scope);
5695 /* Before we try to parse the class-name, we must save away the
5696 current PARSER->SCOPE since cp_parser_class_name will destroy
5698 saved_scope = parser->scope;
5699 saved_qualifying_scope = parser->qualifying_scope;
5700 saved_object_scope = parser->object_scope;
5701 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
5702 there is no need to look for a namespace-name. */
5703 only_class_p = template_keyword_p
5704 || (saved_scope && TYPE_P (saved_scope) && cxx_dialect == cxx98);
5706 cp_parser_parse_tentatively (parser);
5707 scope = cp_parser_class_name (parser,
5710 type_p ? class_type : none_type,
5712 /*class_head_p=*/false,
5714 successful_parse_p = only_class_p || cp_parser_parse_definitely (parser);
5715 /* If that didn't work and we're in C++0x mode, try for a type-name. */
5717 && cxx_dialect != cxx98
5718 && !successful_parse_p)
5720 /* Restore the saved scope. */
5721 parser->scope = saved_scope;
5722 parser->qualifying_scope = saved_qualifying_scope;
5723 parser->object_scope = saved_object_scope;
5725 /* Parse tentatively. */
5726 cp_parser_parse_tentatively (parser);
5728 /* Parse a type-name */
5729 scope = cp_parser_type_name (parser);
5731 /* "If the name found does not designate a namespace or a class,
5732 enumeration, or dependent type, the program is ill-formed."
5734 We cover classes and dependent types above and namespaces below,
5735 so this code is only looking for enums. */
5736 if (!scope || TREE_CODE (scope) != TYPE_DECL
5737 || TREE_CODE (TREE_TYPE (scope)) != ENUMERAL_TYPE)
5738 cp_parser_simulate_error (parser);
5740 successful_parse_p = cp_parser_parse_definitely (parser);
5742 /* If that didn't work, try for a namespace-name. */
5743 if (!only_class_p && !successful_parse_p)
5745 /* Restore the saved scope. */
5746 parser->scope = saved_scope;
5747 parser->qualifying_scope = saved_qualifying_scope;
5748 parser->object_scope = saved_object_scope;
5749 /* If we are not looking at an identifier followed by the scope
5750 resolution operator, then this is not part of a
5751 nested-name-specifier. (Note that this function is only used
5752 to parse the components of a nested-name-specifier.) */
5753 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
5754 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
5755 return error_mark_node;
5756 scope = cp_parser_namespace_name (parser);
5762 /* Return true if we are looking at a compound-literal, false otherwise. */
5765 cp_parser_compound_literal_p (cp_parser *parser)
5767 /* Consume the `('. */
5768 cp_lexer_consume_token (parser->lexer);
5770 cp_lexer_save_tokens (parser->lexer);
5772 /* Skip tokens until the next token is a closing parenthesis.
5773 If we find the closing `)', and the next token is a `{', then
5774 we are looking at a compound-literal. */
5775 bool compound_literal_p
5776 = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
5777 /*consume_paren=*/true)
5778 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
5780 /* Roll back the tokens we skipped. */
5781 cp_lexer_rollback_tokens (parser->lexer);
5783 return compound_literal_p;
5786 /* Parse a postfix-expression.
5790 postfix-expression [ expression ]
5791 postfix-expression ( expression-list [opt] )
5792 simple-type-specifier ( expression-list [opt] )
5793 typename :: [opt] nested-name-specifier identifier
5794 ( expression-list [opt] )
5795 typename :: [opt] nested-name-specifier template [opt] template-id
5796 ( expression-list [opt] )
5797 postfix-expression . template [opt] id-expression
5798 postfix-expression -> template [opt] id-expression
5799 postfix-expression . pseudo-destructor-name
5800 postfix-expression -> pseudo-destructor-name
5801 postfix-expression ++
5802 postfix-expression --
5803 dynamic_cast < type-id > ( expression )
5804 static_cast < type-id > ( expression )
5805 reinterpret_cast < type-id > ( expression )
5806 const_cast < type-id > ( expression )
5807 typeid ( expression )
5813 ( type-id ) { initializer-list , [opt] }
5815 This extension is a GNU version of the C99 compound-literal
5816 construct. (The C99 grammar uses `type-name' instead of `type-id',
5817 but they are essentially the same concept.)
5819 If ADDRESS_P is true, the postfix expression is the operand of the
5820 `&' operator. CAST_P is true if this expression is the target of a
5823 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
5824 class member access expressions [expr.ref].
5826 Returns a representation of the expression. */
5829 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
5830 bool member_access_only_p, bool decltype_p,
5831 cp_id_kind * pidk_return)
5836 cp_id_kind idk = CP_ID_KIND_NONE;
5837 tree postfix_expression = NULL_TREE;
5838 bool is_member_access = false;
5839 int saved_in_statement = -1;
5841 /* Peek at the next token. */
5842 token = cp_lexer_peek_token (parser->lexer);
5843 loc = token->location;
5844 /* Some of the productions are determined by keywords. */
5845 keyword = token->keyword;
5855 const char *saved_message;
5856 bool saved_in_type_id_in_expr_p;
5858 /* All of these can be handled in the same way from the point
5859 of view of parsing. Begin by consuming the token
5860 identifying the cast. */
5861 cp_lexer_consume_token (parser->lexer);
5863 /* New types cannot be defined in the cast. */
5864 saved_message = parser->type_definition_forbidden_message;
5865 parser->type_definition_forbidden_message
5866 = G_("types may not be defined in casts");
5868 /* Look for the opening `<'. */
5869 cp_parser_require (parser, CPP_LESS, RT_LESS);
5870 /* Parse the type to which we are casting. */
5871 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
5872 parser->in_type_id_in_expr_p = true;
5873 type = cp_parser_type_id (parser);
5874 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
5875 /* Look for the closing `>'. */
5876 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
5877 /* Restore the old message. */
5878 parser->type_definition_forbidden_message = saved_message;
5880 bool saved_greater_than_is_operator_p
5881 = parser->greater_than_is_operator_p;
5882 parser->greater_than_is_operator_p = true;
5884 /* And the expression which is being cast. */
5885 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
5886 expression = cp_parser_expression (parser, & idk, /*cast_p=*/true);
5887 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
5889 parser->greater_than_is_operator_p
5890 = saved_greater_than_is_operator_p;
5892 /* Only type conversions to integral or enumeration types
5893 can be used in constant-expressions. */
5894 if (!cast_valid_in_integral_constant_expression_p (type)
5895 && cp_parser_non_integral_constant_expression (parser, NIC_CAST))
5896 return error_mark_node;
5902 = build_dynamic_cast (type, expression, tf_warning_or_error);
5906 = build_static_cast (type, expression, tf_warning_or_error);
5910 = build_reinterpret_cast (type, expression,
5911 tf_warning_or_error);
5915 = build_const_cast (type, expression, tf_warning_or_error);
5926 const char *saved_message;
5927 bool saved_in_type_id_in_expr_p;
5929 /* Consume the `typeid' token. */
5930 cp_lexer_consume_token (parser->lexer);
5931 /* Look for the `(' token. */
5932 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
5933 /* Types cannot be defined in a `typeid' expression. */
5934 saved_message = parser->type_definition_forbidden_message;
5935 parser->type_definition_forbidden_message
5936 = G_("types may not be defined in a %<typeid%> expression");
5937 /* We can't be sure yet whether we're looking at a type-id or an
5939 cp_parser_parse_tentatively (parser);
5940 /* Try a type-id first. */
5941 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
5942 parser->in_type_id_in_expr_p = true;
5943 type = cp_parser_type_id (parser);
5944 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
5945 /* Look for the `)' token. Otherwise, we can't be sure that
5946 we're not looking at an expression: consider `typeid (int
5947 (3))', for example. */
5948 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
5949 /* If all went well, simply lookup the type-id. */
5950 if (cp_parser_parse_definitely (parser))
5951 postfix_expression = get_typeid (type, tf_warning_or_error);
5952 /* Otherwise, fall back to the expression variant. */
5957 /* Look for an expression. */
5958 expression = cp_parser_expression (parser, & idk);
5959 /* Compute its typeid. */
5960 postfix_expression = build_typeid (expression, tf_warning_or_error);
5961 /* Look for the `)' token. */
5962 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
5964 /* Restore the saved message. */
5965 parser->type_definition_forbidden_message = saved_message;
5966 /* `typeid' may not appear in an integral constant expression. */
5967 if (cp_parser_non_integral_constant_expression (parser, NIC_TYPEID))
5968 return error_mark_node;
5975 /* The syntax permitted here is the same permitted for an
5976 elaborated-type-specifier. */
5977 type = cp_parser_elaborated_type_specifier (parser,
5978 /*is_friend=*/false,
5979 /*is_declaration=*/false);
5980 postfix_expression = cp_parser_functional_cast (parser, type);
5984 case RID_CILK_SPAWN:
5986 cp_lexer_consume_token (parser->lexer);
5987 token = cp_lexer_peek_token (parser->lexer);
5988 if (token->type == CPP_SEMICOLON)
5990 error_at (token->location, "%<_Cilk_spawn%> must be followed by "
5992 postfix_expression = error_mark_node;
5995 else if (!current_function_decl)
5997 error_at (token->location, "%<_Cilk_spawn%> may only be used "
5998 "inside a function");
5999 postfix_expression = error_mark_node;
6004 /* Consecutive _Cilk_spawns are not allowed in a statement. */
6005 saved_in_statement = parser->in_statement;
6006 parser->in_statement |= IN_CILK_SPAWN;
6008 cfun->calls_cilk_spawn = 1;
6009 postfix_expression =
6010 cp_parser_postfix_expression (parser, false, false,
6011 false, false, &idk);
6014 error_at (token->location, "-fcilkplus must be enabled to use"
6015 " %<_Cilk_spawn%>");
6016 cfun->calls_cilk_spawn = 0;
6018 else if (saved_in_statement & IN_CILK_SPAWN)
6020 error_at (token->location, "consecutive %<_Cilk_spawn%> keywords "
6021 "are not permitted");
6022 postfix_expression = error_mark_node;
6023 cfun->calls_cilk_spawn = 0;
6027 postfix_expression = build_cilk_spawn (token->location,
6028 postfix_expression);
6029 if (postfix_expression != error_mark_node)
6030 SET_EXPR_LOCATION (postfix_expression, input_location);
6031 parser->in_statement = parser->in_statement & ~IN_CILK_SPAWN;
6036 case RID_BUILTIN_SHUFFLE:
6038 vec<tree, va_gc> *vec;
6042 cp_lexer_consume_token (parser->lexer);
6043 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
6044 /*cast_p=*/false, /*allow_expansion_p=*/true,
6045 /*non_constant_p=*/NULL);
6047 return error_mark_node;
6049 FOR_EACH_VEC_ELT (*vec, i, p)
6052 if (vec->length () == 2)
6053 return build_x_vec_perm_expr (loc, (*vec)[0], NULL_TREE, (*vec)[1],
6054 tf_warning_or_error);
6055 else if (vec->length () == 3)
6056 return build_x_vec_perm_expr (loc, (*vec)[0], (*vec)[1], (*vec)[2],
6057 tf_warning_or_error);
6060 error_at (loc, "wrong number of arguments to "
6061 "%<__builtin_shuffle%>");
6062 return error_mark_node;
6071 /* If the next thing is a simple-type-specifier, we may be
6072 looking at a functional cast. We could also be looking at
6073 an id-expression. So, we try the functional cast, and if
6074 that doesn't work we fall back to the primary-expression. */
6075 cp_parser_parse_tentatively (parser);
6076 /* Look for the simple-type-specifier. */
6077 type = cp_parser_simple_type_specifier (parser,
6078 /*decl_specs=*/NULL,
6079 CP_PARSER_FLAGS_NONE);
6080 /* Parse the cast itself. */
6081 if (!cp_parser_error_occurred (parser))
6083 = cp_parser_functional_cast (parser, type);
6084 /* If that worked, we're done. */
6085 if (cp_parser_parse_definitely (parser))
6088 /* If the functional-cast didn't work out, try a
6089 compound-literal. */
6090 if (cp_parser_allow_gnu_extensions_p (parser)
6091 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
6093 tree initializer = NULL_TREE;
6095 cp_parser_parse_tentatively (parser);
6097 /* Avoid calling cp_parser_type_id pointlessly, see comment
6098 in cp_parser_cast_expression about c++/29234. */
6099 if (!cp_parser_compound_literal_p (parser))
6100 cp_parser_simulate_error (parser);
6103 /* Parse the type. */
6104 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
6105 parser->in_type_id_in_expr_p = true;
6106 type = cp_parser_type_id (parser);
6107 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
6108 /* Look for the `)'. */
6109 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
6112 /* If things aren't going well, there's no need to
6114 if (!cp_parser_error_occurred (parser))
6116 bool non_constant_p;
6117 /* Parse the brace-enclosed initializer list. */
6118 initializer = cp_parser_braced_list (parser,
6121 /* If that worked, we're definitely looking at a
6122 compound-literal expression. */
6123 if (cp_parser_parse_definitely (parser))
6125 /* Warn the user that a compound literal is not
6126 allowed in standard C++. */
6127 pedwarn (input_location, OPT_Wpedantic,
6128 "ISO C++ forbids compound-literals");
6129 /* For simplicity, we disallow compound literals in
6130 constant-expressions. We could
6131 allow compound literals of integer type, whose
6132 initializer was a constant, in constant
6133 expressions. Permitting that usage, as a further
6134 extension, would not change the meaning of any
6135 currently accepted programs. (Of course, as
6136 compound literals are not part of ISO C++, the
6137 standard has nothing to say.) */
6138 if (cp_parser_non_integral_constant_expression (parser,
6141 postfix_expression = error_mark_node;
6144 /* Form the representation of the compound-literal. */
6146 = finish_compound_literal (type, initializer,
6147 tf_warning_or_error);
6152 /* It must be a primary-expression. */
6154 = cp_parser_primary_expression (parser, address_p, cast_p,
6155 /*template_arg_p=*/false,
6162 /* Note that we don't need to worry about calling build_cplus_new on a
6163 class-valued CALL_EXPR in decltype when it isn't the end of the
6164 postfix-expression; unary_complex_lvalue will take care of that for
6167 /* Keep looping until the postfix-expression is complete. */
6170 if (idk == CP_ID_KIND_UNQUALIFIED
6171 && identifier_p (postfix_expression)
6172 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
6173 /* It is not a Koenig lookup function call. */
6175 = unqualified_name_lookup_error (postfix_expression);
6177 /* Peek at the next token. */
6178 token = cp_lexer_peek_token (parser->lexer);
6180 switch (token->type)
6182 case CPP_OPEN_SQUARE:
6183 if (cp_next_tokens_can_be_std_attribute_p (parser))
6185 cp_parser_error (parser,
6186 "two consecutive %<[%> shall "
6187 "only introduce an attribute");
6188 return error_mark_node;
6191 = cp_parser_postfix_open_square_expression (parser,
6195 idk = CP_ID_KIND_NONE;
6196 is_member_access = false;
6199 case CPP_OPEN_PAREN:
6200 /* postfix-expression ( expression-list [opt] ) */
6203 bool is_builtin_constant_p;
6204 bool saved_integral_constant_expression_p = false;
6205 bool saved_non_integral_constant_expression_p = false;
6206 tsubst_flags_t complain = complain_flags (decltype_p);
6207 vec<tree, va_gc> *args;
6209 is_member_access = false;
6211 is_builtin_constant_p
6212 = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression);
6213 if (is_builtin_constant_p)
6215 /* The whole point of __builtin_constant_p is to allow
6216 non-constant expressions to appear as arguments. */
6217 saved_integral_constant_expression_p
6218 = parser->integral_constant_expression_p;
6219 saved_non_integral_constant_expression_p
6220 = parser->non_integral_constant_expression_p;
6221 parser->integral_constant_expression_p = false;
6223 args = (cp_parser_parenthesized_expression_list
6225 /*cast_p=*/false, /*allow_expansion_p=*/true,
6226 /*non_constant_p=*/NULL,
6227 /*want_literal_zero_p=*/warn_memset_transposed_args));
6228 if (is_builtin_constant_p)
6230 parser->integral_constant_expression_p
6231 = saved_integral_constant_expression_p;
6232 parser->non_integral_constant_expression_p
6233 = saved_non_integral_constant_expression_p;
6238 postfix_expression = error_mark_node;
6242 /* Function calls are not permitted in
6243 constant-expressions. */
6244 if (! builtin_valid_in_constant_expr_p (postfix_expression)
6245 && cp_parser_non_integral_constant_expression (parser,
6248 postfix_expression = error_mark_node;
6249 release_tree_vector (args);
6254 if (idk == CP_ID_KIND_UNQUALIFIED
6255 || idk == CP_ID_KIND_TEMPLATE_ID)
6257 if (identifier_p (postfix_expression))
6259 if (!args->is_empty ())
6262 if (!any_type_dependent_arguments_p (args))
6264 = perform_koenig_lookup (postfix_expression, args,
6269 = unqualified_fn_lookup_error (postfix_expression);
6271 /* We do not perform argument-dependent lookup if
6272 normal lookup finds a non-function, in accordance
6273 with the expected resolution of DR 218. */
6274 else if (!args->is_empty ()
6275 && is_overloaded_fn (postfix_expression))
6277 tree fn = get_first_fn (postfix_expression);
6278 fn = STRIP_TEMPLATE (fn);
6280 /* Do not do argument dependent lookup if regular
6281 lookup finds a member function or a block-scope
6282 function declaration. [basic.lookup.argdep]/3 */
6283 if (!DECL_FUNCTION_MEMBER_P (fn)
6284 && !DECL_LOCAL_FUNCTION_P (fn))
6287 if (!any_type_dependent_arguments_p (args))
6289 = perform_koenig_lookup (postfix_expression, args,
6295 if (warn_memset_transposed_args)
6297 if (TREE_CODE (postfix_expression) == FUNCTION_DECL
6298 && DECL_BUILT_IN_CLASS (postfix_expression) == BUILT_IN_NORMAL
6299 && DECL_FUNCTION_CODE (postfix_expression) == BUILT_IN_MEMSET
6300 && vec_safe_length (args) == 3
6301 && integer_zerop ((*args)[2])
6302 && LITERAL_ZERO_P ((*args)[2])
6303 && !(integer_zerop ((*args)[1])
6304 && LITERAL_ZERO_P ((*args)[1])))
6305 warning (OPT_Wmemset_transposed_args,
6306 "%<memset%> used with constant zero length "
6307 "parameter; this could be due to transposed "
6310 /* Replace LITERAL_ZERO_P INTEGER_CSTs with normal ones
6311 to avoid leaking those into folder and middle-end. */
6314 FOR_EACH_VEC_SAFE_ELT (args, i, arg)
6315 if (TREE_CODE (arg) == INTEGER_CST && LITERAL_ZERO_P (arg))
6316 (*args)[i] = build_int_cst (TREE_TYPE (arg), 0);
6319 if (TREE_CODE (postfix_expression) == COMPONENT_REF)
6321 tree instance = TREE_OPERAND (postfix_expression, 0);
6322 tree fn = TREE_OPERAND (postfix_expression, 1);
6324 if (processing_template_decl
6325 && (type_dependent_expression_p (instance)
6326 || (!BASELINK_P (fn)
6327 && TREE_CODE (fn) != FIELD_DECL)
6328 || type_dependent_expression_p (fn)
6329 || any_type_dependent_arguments_p (args)))
6332 = build_nt_call_vec (postfix_expression, args);
6333 release_tree_vector (args);
6337 if (BASELINK_P (fn))
6340 = (build_new_method_call
6341 (instance, fn, &args, NULL_TREE,
6342 (idk == CP_ID_KIND_QUALIFIED
6343 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
6350 = finish_call_expr (postfix_expression, &args,
6351 /*disallow_virtual=*/false,
6355 else if (TREE_CODE (postfix_expression) == OFFSET_REF
6356 || TREE_CODE (postfix_expression) == MEMBER_REF
6357 || TREE_CODE (postfix_expression) == DOTSTAR_EXPR)
6358 postfix_expression = (build_offset_ref_call_from_tree
6359 (postfix_expression, &args,
6361 else if (idk == CP_ID_KIND_QUALIFIED)
6362 /* A call to a static class member, or a namespace-scope
6365 = finish_call_expr (postfix_expression, &args,
6366 /*disallow_virtual=*/true,
6370 /* All other function calls. */
6372 = finish_call_expr (postfix_expression, &args,
6373 /*disallow_virtual=*/false,
6377 protected_set_expr_location (postfix_expression, token->location);
6379 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
6380 idk = CP_ID_KIND_NONE;
6382 release_tree_vector (args);
6388 /* postfix-expression . template [opt] id-expression
6389 postfix-expression . pseudo-destructor-name
6390 postfix-expression -> template [opt] id-expression
6391 postfix-expression -> pseudo-destructor-name */
6393 /* Consume the `.' or `->' operator. */
6394 cp_lexer_consume_token (parser->lexer);
6397 = cp_parser_postfix_dot_deref_expression (parser, token->type,
6401 is_member_access = true;
6405 /* postfix-expression ++ */
6406 /* Consume the `++' token. */
6407 cp_lexer_consume_token (parser->lexer);
6408 /* Generate a representation for the complete expression. */
6410 = finish_increment_expr (postfix_expression,
6411 POSTINCREMENT_EXPR);
6412 /* Increments may not appear in constant-expressions. */
6413 if (cp_parser_non_integral_constant_expression (parser, NIC_INC))
6414 postfix_expression = error_mark_node;
6415 idk = CP_ID_KIND_NONE;
6416 is_member_access = false;
6419 case CPP_MINUS_MINUS:
6420 /* postfix-expression -- */
6421 /* Consume the `--' token. */
6422 cp_lexer_consume_token (parser->lexer);
6423 /* Generate a representation for the complete expression. */
6425 = finish_increment_expr (postfix_expression,
6426 POSTDECREMENT_EXPR);
6427 /* Decrements may not appear in constant-expressions. */
6428 if (cp_parser_non_integral_constant_expression (parser, NIC_DEC))
6429 postfix_expression = error_mark_node;
6430 idk = CP_ID_KIND_NONE;
6431 is_member_access = false;
6435 if (pidk_return != NULL)
6436 * pidk_return = idk;
6437 if (member_access_only_p)
6438 return is_member_access? postfix_expression : error_mark_node;
6440 return postfix_expression;
6444 /* We should never get here. */
6446 return error_mark_node;
6449 /* This function parses Cilk Plus array notations. If a normal array expr. is
6450 parsed then the array index is passed back to the caller through *INIT_INDEX
6451 and the function returns a NULL_TREE. If array notation expr. is parsed,
6452 then *INIT_INDEX is ignored by the caller and the function returns
6453 a tree of type ARRAY_NOTATION_REF. If some error occurred it returns
6457 cp_parser_array_notation (location_t loc, cp_parser *parser, tree *init_index,
6460 cp_token *token = NULL;
6461 tree length_index, stride = NULL_TREE, value_tree, array_type;
6462 if (!array_value || array_value == error_mark_node)
6464 cp_parser_skip_to_end_of_statement (parser);
6465 return error_mark_node;
6468 array_type = TREE_TYPE (array_value);
6470 bool saved_colon_corrects = parser->colon_corrects_to_scope_p;
6471 parser->colon_corrects_to_scope_p = false;
6472 token = cp_lexer_peek_token (parser->lexer);
6476 cp_parser_error (parser, "expected %<:%> or numeral");
6477 return error_mark_node;
6479 else if (token->type == CPP_COLON)
6481 /* Consume the ':'. */
6482 cp_lexer_consume_token (parser->lexer);
6484 /* If we are here, then we have a case like this A[:]. */
6485 if (cp_lexer_peek_token (parser->lexer)->type != CPP_CLOSE_SQUARE)
6487 cp_parser_error (parser, "expected %<]%>");
6488 cp_parser_skip_to_end_of_statement (parser);
6489 return error_mark_node;
6491 *init_index = NULL_TREE;
6493 length_index = NULL_TREE;
6497 /* If we are here, then there are three valid possibilities:
6499 2. ARRAY [ EXP : EXP ]
6500 3. ARRAY [ EXP : EXP : EXP ] */
6502 *init_index = cp_parser_expression (parser);
6503 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
6505 /* This indicates that we have a normal array expression. */
6506 parser->colon_corrects_to_scope_p = saved_colon_corrects;
6510 /* Consume the ':'. */
6511 cp_lexer_consume_token (parser->lexer);
6512 length_index = cp_parser_expression (parser);
6513 if (cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
6515 cp_lexer_consume_token (parser->lexer);
6516 stride = cp_parser_expression (parser);
6519 parser->colon_corrects_to_scope_p = saved_colon_corrects;
6521 if (*init_index == error_mark_node || length_index == error_mark_node
6522 || stride == error_mark_node || array_type == error_mark_node)
6524 if (cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_SQUARE)
6525 cp_lexer_consume_token (parser->lexer);
6526 return error_mark_node;
6528 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
6530 value_tree = build_array_notation_ref (loc, array_value, *init_index,
6531 length_index, stride, array_type);
6535 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6536 by cp_parser_builtin_offsetof. We're looking for
6538 postfix-expression [ expression ]
6539 postfix-expression [ braced-init-list ] (C++11)
6541 FOR_OFFSETOF is set if we're being called in that context, which
6542 changes how we deal with integer constant expressions. */
6545 cp_parser_postfix_open_square_expression (cp_parser *parser,
6546 tree postfix_expression,
6550 tree index = NULL_TREE;
6551 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
6552 bool saved_greater_than_is_operator_p;
6554 /* Consume the `[' token. */
6555 cp_lexer_consume_token (parser->lexer);
6557 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
6558 parser->greater_than_is_operator_p = true;
6560 /* Parse the index expression. */
6561 /* ??? For offsetof, there is a question of what to allow here. If
6562 offsetof is not being used in an integral constant expression context,
6563 then we *could* get the right answer by computing the value at runtime.
6564 If we are in an integral constant expression context, then we might
6565 could accept any constant expression; hard to say without analysis.
6566 Rather than open the barn door too wide right away, allow only integer
6567 constant expressions here. */
6569 index = cp_parser_constant_expression (parser);
6572 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
6574 bool expr_nonconst_p;
6575 cp_lexer_set_source_position (parser->lexer);
6576 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6577 index = cp_parser_braced_list (parser, &expr_nonconst_p);
6579 && cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
6581 error_at (cp_lexer_peek_token (parser->lexer)->location,
6582 "braced list index is not allowed with array "
6584 cp_parser_skip_to_end_of_statement (parser);
6585 return error_mark_node;
6588 else if (flag_cilkplus)
6590 /* Here are have these two options:
6591 ARRAY[EXP : EXP] - Array notation expr with default
6593 ARRAY[EXP : EXP : EXP] - Array Notation with user-defined
6595 tree an_exp = cp_parser_array_notation (loc, parser, &index,
6596 postfix_expression);
6601 index = cp_parser_expression (parser);
6604 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
6606 /* Look for the closing `]'. */
6607 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
6609 /* Build the ARRAY_REF. */
6610 postfix_expression = grok_array_decl (loc, postfix_expression,
6613 /* When not doing offsetof, array references are not permitted in
6614 constant-expressions. */
6616 && (cp_parser_non_integral_constant_expression (parser, NIC_ARRAY_REF)))
6617 postfix_expression = error_mark_node;
6619 return postfix_expression;
6622 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
6623 by cp_parser_builtin_offsetof. We're looking for
6625 postfix-expression . template [opt] id-expression
6626 postfix-expression . pseudo-destructor-name
6627 postfix-expression -> template [opt] id-expression
6628 postfix-expression -> pseudo-destructor-name
6630 FOR_OFFSETOF is set if we're being called in that context. That sorta
6631 limits what of the above we'll actually accept, but nevermind.
6632 TOKEN_TYPE is the "." or "->" token, which will already have been
6633 removed from the stream. */
6636 cp_parser_postfix_dot_deref_expression (cp_parser *parser,
6637 enum cpp_ttype token_type,
6638 tree postfix_expression,
6639 bool for_offsetof, cp_id_kind *idk,
6640 location_t location)
6644 bool pseudo_destructor_p;
6645 tree scope = NULL_TREE;
6647 /* If this is a `->' operator, dereference the pointer. */
6648 if (token_type == CPP_DEREF)
6649 postfix_expression = build_x_arrow (location, postfix_expression,
6650 tf_warning_or_error);
6651 /* Check to see whether or not the expression is type-dependent. */
6652 dependent_p = type_dependent_expression_p (postfix_expression);
6653 /* The identifier following the `->' or `.' is not qualified. */
6654 parser->scope = NULL_TREE;
6655 parser->qualifying_scope = NULL_TREE;
6656 parser->object_scope = NULL_TREE;
6657 *idk = CP_ID_KIND_NONE;
6659 /* Enter the scope corresponding to the type of the object
6660 given by the POSTFIX_EXPRESSION. */
6661 if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE)
6663 scope = TREE_TYPE (postfix_expression);
6664 /* According to the standard, no expression should ever have
6665 reference type. Unfortunately, we do not currently match
6666 the standard in this respect in that our internal representation
6667 of an expression may have reference type even when the standard
6668 says it does not. Therefore, we have to manually obtain the
6669 underlying type here. */
6670 scope = non_reference (scope);
6671 /* The type of the POSTFIX_EXPRESSION must be complete. */
6672 if (scope == unknown_type_node)
6674 error_at (location, "%qE does not have class type",
6675 postfix_expression);
6678 /* Unlike the object expression in other contexts, *this is not
6679 required to be of complete type for purposes of class member
6680 access (5.2.5) outside the member function body. */
6681 else if (postfix_expression != current_class_ref
6682 && !(processing_template_decl && scope == current_class_type))
6683 scope = complete_type_or_else (scope, NULL_TREE);
6684 /* Let the name lookup machinery know that we are processing a
6685 class member access expression. */
6686 parser->context->object_type = scope;
6687 /* If something went wrong, we want to be able to discern that case,
6688 as opposed to the case where there was no SCOPE due to the type
6689 of expression being dependent. */
6691 scope = error_mark_node;
6692 /* If the SCOPE was erroneous, make the various semantic analysis
6693 functions exit quickly -- and without issuing additional error
6695 if (scope == error_mark_node)
6696 postfix_expression = error_mark_node;
6699 /* Assume this expression is not a pseudo-destructor access. */
6700 pseudo_destructor_p = false;
6702 /* If the SCOPE is a scalar type, then, if this is a valid program,
6703 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
6704 is type dependent, it can be pseudo-destructor-name or something else.
6705 Try to parse it as pseudo-destructor-name first. */
6706 if ((scope && SCALAR_TYPE_P (scope)) || dependent_p)
6711 cp_parser_parse_tentatively (parser);
6712 /* Parse the pseudo-destructor-name. */
6714 cp_parser_pseudo_destructor_name (parser, postfix_expression,
6717 && (cp_parser_error_occurred (parser)
6718 || !SCALAR_TYPE_P (type)))
6719 cp_parser_abort_tentative_parse (parser);
6720 else if (cp_parser_parse_definitely (parser))
6722 pseudo_destructor_p = true;
6724 = finish_pseudo_destructor_expr (postfix_expression,
6729 if (!pseudo_destructor_p)
6731 /* If the SCOPE is not a scalar type, we are looking at an
6732 ordinary class member access expression, rather than a
6733 pseudo-destructor-name. */
6735 cp_token *token = cp_lexer_peek_token (parser->lexer);
6736 /* Parse the id-expression. */
6737 name = (cp_parser_id_expression
6739 cp_parser_optional_template_keyword (parser),
6740 /*check_dependency_p=*/true,
6742 /*declarator_p=*/false,
6743 /*optional_p=*/false));
6744 /* In general, build a SCOPE_REF if the member name is qualified.
6745 However, if the name was not dependent and has already been
6746 resolved; there is no need to build the SCOPE_REF. For example;
6748 struct X { void f(); };
6749 template <typename T> void f(T* t) { t->X::f(); }
6751 Even though "t" is dependent, "X::f" is not and has been resolved
6752 to a BASELINK; there is no need to include scope information. */
6754 /* But we do need to remember that there was an explicit scope for
6755 virtual function calls. */
6757 *idk = CP_ID_KIND_QUALIFIED;
6759 /* If the name is a template-id that names a type, we will get a
6760 TYPE_DECL here. That is invalid code. */
6761 if (TREE_CODE (name) == TYPE_DECL)
6763 error_at (token->location, "invalid use of %qD", name);
6764 postfix_expression = error_mark_node;
6768 if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
6770 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
6772 error_at (token->location, "%<%D::%D%> is not a class member",
6773 parser->scope, name);
6774 postfix_expression = error_mark_node;
6777 name = build_qualified_name (/*type=*/NULL_TREE,
6781 parser->scope = NULL_TREE;
6782 parser->qualifying_scope = NULL_TREE;
6783 parser->object_scope = NULL_TREE;
6785 if (parser->scope && name && BASELINK_P (name))
6786 adjust_result_of_qualified_name_lookup
6787 (name, parser->scope, scope);
6789 = finish_class_member_access_expr (postfix_expression, name,
6791 tf_warning_or_error);
6795 /* We no longer need to look up names in the scope of the object on
6796 the left-hand side of the `.' or `->' operator. */
6797 parser->context->object_type = NULL_TREE;
6799 /* Outside of offsetof, these operators may not appear in
6800 constant-expressions. */
6802 && (cp_parser_non_integral_constant_expression
6803 (parser, token_type == CPP_DEREF ? NIC_ARROW : NIC_POINT)))
6804 postfix_expression = error_mark_node;
6806 return postfix_expression;
6809 /* Cache of LITERAL_ZERO_P constants. */
6811 static GTY(()) tree literal_zeros[itk_none];
6813 /* Parse a parenthesized expression-list.
6816 assignment-expression
6817 expression-list, assignment-expression
6822 identifier, expression-list
6824 CAST_P is true if this expression is the target of a cast.
6826 ALLOW_EXPANSION_P is true if this expression allows expansion of an
6829 Returns a vector of trees. Each element is a representation of an
6830 assignment-expression. NULL is returned if the ( and or ) are
6831 missing. An empty, but allocated, vector is returned on no
6832 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
6833 if we are parsing an attribute list for an attribute that wants a
6834 plain identifier argument, normal_attr for an attribute that wants
6835 an expression, or non_attr if we aren't parsing an attribute list. If
6836 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
6837 not all of the expressions in the list were constant.
6838 WANT_LITERAL_ZERO_P is true if the caller is interested in
6839 LITERAL_ZERO_P INTEGER_CSTs. FIXME: once we don't fold everything
6840 immediately, this can be removed. */
6842 static vec<tree, va_gc> *
6843 cp_parser_parenthesized_expression_list (cp_parser* parser,
6844 int is_attribute_list,
6846 bool allow_expansion_p,
6847 bool *non_constant_p,
6848 bool want_literal_zero_p)
6850 vec<tree, va_gc> *expression_list;
6851 bool fold_expr_p = is_attribute_list != non_attr;
6852 tree identifier = NULL_TREE;
6853 bool saved_greater_than_is_operator_p;
6855 /* Assume all the expressions will be constant. */
6857 *non_constant_p = false;
6859 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
6862 expression_list = make_tree_vector ();
6864 /* Within a parenthesized expression, a `>' token is always
6865 the greater-than operator. */
6866 saved_greater_than_is_operator_p
6867 = parser->greater_than_is_operator_p;
6868 parser->greater_than_is_operator_p = true;
6870 /* Consume expressions until there are no more. */
6871 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
6876 /* At the beginning of attribute lists, check to see if the
6877 next token is an identifier. */
6878 if (is_attribute_list == id_attr
6879 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
6883 /* Consume the identifier. */
6884 token = cp_lexer_consume_token (parser->lexer);
6885 /* Save the identifier. */
6886 identifier = token->u.value;
6890 bool expr_non_constant_p;
6892 /* Parse the next assignment-expression. */
6893 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
6895 /* A braced-init-list. */
6896 cp_lexer_set_source_position (parser->lexer);
6897 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
6898 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
6899 if (non_constant_p && expr_non_constant_p)
6900 *non_constant_p = true;
6902 else if (non_constant_p)
6904 expr = (cp_parser_constant_expression
6905 (parser, /*allow_non_constant_p=*/true,
6906 &expr_non_constant_p));
6907 if (expr_non_constant_p)
6908 *non_constant_p = true;
6913 cp_token *tok = cp_lexer_peek_token (parser->lexer);
6921 /* If a parameter is literal zero alone, remember it
6922 for -Wmemset-transposed-args warning. */
6923 if (integer_zerop (tok->u.value)
6924 && !TREE_OVERFLOW (tok->u.value)
6925 && want_literal_zero_p
6926 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6928 || cp_lexer_peek_nth_token (parser->lexer, 2)->type
6929 == CPP_CLOSE_PAREN))
6932 for (i = 0; i < itk_none; ++i)
6933 if (TREE_TYPE (tok->u.value) == integer_types[i])
6935 if (i < itk_none && literal_zeros[i])
6936 expr = literal_zeros[i];
6939 expr = copy_node (tok->u.value);
6940 LITERAL_ZERO_P (expr) = 1;
6942 literal_zeros[i] = expr;
6944 /* Consume the 0 token (or '\0', 0LL etc.). */
6945 cp_lexer_consume_token (parser->lexer);
6951 if (expr == NULL_TREE)
6952 expr = cp_parser_assignment_expression (parser, /*pidk=*/NULL,
6957 expr = instantiate_non_dependent_expr (expr);
6959 /* If we have an ellipsis, then this is an expression
6961 if (allow_expansion_p
6962 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
6964 /* Consume the `...'. */
6965 cp_lexer_consume_token (parser->lexer);
6967 /* Build the argument pack. */
6968 expr = make_pack_expansion (expr);
6971 /* Add it to the list. We add error_mark_node
6972 expressions to the list, so that we can still tell if
6973 the correct form for a parenthesized expression-list
6974 is found. That gives better errors. */
6975 vec_safe_push (expression_list, expr);
6977 if (expr == error_mark_node)
6981 /* After the first item, attribute lists look the same as
6982 expression lists. */
6983 is_attribute_list = non_attr;
6986 /* If the next token isn't a `,', then we are done. */
6987 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
6990 /* Otherwise, consume the `,' and keep going. */
6991 cp_lexer_consume_token (parser->lexer);
6994 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
6999 /* We try and resync to an unnested comma, as that will give the
7000 user better diagnostics. */
7001 ending = cp_parser_skip_to_closing_parenthesis (parser,
7002 /*recovering=*/true,
7004 /*consume_paren=*/true);
7009 parser->greater_than_is_operator_p
7010 = saved_greater_than_is_operator_p;
7015 parser->greater_than_is_operator_p
7016 = saved_greater_than_is_operator_p;
7019 vec_safe_insert (expression_list, 0, identifier);
7021 return expression_list;
7024 /* Parse a pseudo-destructor-name.
7026 pseudo-destructor-name:
7027 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
7028 :: [opt] nested-name-specifier template template-id :: ~ type-name
7029 :: [opt] nested-name-specifier [opt] ~ type-name
7031 If either of the first two productions is used, sets *SCOPE to the
7032 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
7033 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
7034 or ERROR_MARK_NODE if the parse fails. */
7037 cp_parser_pseudo_destructor_name (cp_parser* parser,
7042 bool nested_name_specifier_p;
7045 if (cp_lexer_next_token_is (parser->lexer, CPP_COMPL)
7046 && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_AUTO)
7047 && !type_dependent_expression_p (object))
7049 if (cxx_dialect < cxx14)
7050 pedwarn (input_location, 0,
7051 "%<~auto%> only available with "
7052 "-std=c++14 or -std=gnu++14");
7053 cp_lexer_consume_token (parser->lexer);
7054 cp_lexer_consume_token (parser->lexer);
7056 *type = TREE_TYPE (object);
7060 /* Assume that things will not work out. */
7061 *type = error_mark_node;
7063 /* Look for the optional `::' operator. */
7064 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
7065 /* Look for the optional nested-name-specifier. */
7066 nested_name_specifier_p
7067 = (cp_parser_nested_name_specifier_opt (parser,
7068 /*typename_keyword_p=*/false,
7069 /*check_dependency_p=*/true,
7071 /*is_declaration=*/false)
7073 /* Now, if we saw a nested-name-specifier, we might be doing the
7074 second production. */
7075 if (nested_name_specifier_p
7076 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
7078 /* Consume the `template' keyword. */
7079 cp_lexer_consume_token (parser->lexer);
7080 /* Parse the template-id. */
7081 cp_parser_template_id (parser,
7082 /*template_keyword_p=*/true,
7083 /*check_dependency_p=*/false,
7085 /*is_declaration=*/true);
7086 /* Look for the `::' token. */
7087 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
7089 /* If the next token is not a `~', then there might be some
7090 additional qualification. */
7091 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
7093 /* At this point, we're looking for "type-name :: ~". The type-name
7094 must not be a class-name, since this is a pseudo-destructor. So,
7095 it must be either an enum-name, or a typedef-name -- both of which
7096 are just identifiers. So, we peek ahead to check that the "::"
7097 and "~" tokens are present; if they are not, then we can avoid
7098 calling type_name. */
7099 if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
7100 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
7101 || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
7103 cp_parser_error (parser, "non-scalar type");
7107 /* Look for the type-name. */
7108 *scope = TREE_TYPE (cp_parser_nonclass_name (parser));
7109 if (*scope == error_mark_node)
7112 /* Look for the `::' token. */
7113 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
7118 /* Look for the `~'. */
7119 cp_parser_require (parser, CPP_COMPL, RT_COMPL);
7121 /* Once we see the ~, this has to be a pseudo-destructor. */
7122 if (!processing_template_decl && !cp_parser_error_occurred (parser))
7123 cp_parser_commit_to_topmost_tentative_parse (parser);
7125 /* Look for the type-name again. We are not responsible for
7126 checking that it matches the first type-name. */
7127 *type = TREE_TYPE (cp_parser_nonclass_name (parser));
7130 /* Parse a unary-expression.
7136 unary-operator cast-expression
7137 sizeof unary-expression
7139 alignof ( type-id ) [C++0x]
7146 __extension__ cast-expression
7147 __alignof__ unary-expression
7148 __alignof__ ( type-id )
7149 alignof unary-expression [C++0x]
7150 __real__ cast-expression
7151 __imag__ cast-expression
7153 sizeof ( type-id ) { initializer-list , [opt] }
7154 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
7155 __alignof__ ( type-id ) { initializer-list , [opt] }
7157 ADDRESS_P is true iff the unary-expression is appearing as the
7158 operand of the `&' operator. CAST_P is true if this expression is
7159 the target of a cast.
7161 Returns a representation of the expression. */
7164 cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
7165 bool address_p, bool cast_p, bool decltype_p)
7168 enum tree_code unary_operator;
7170 /* Peek at the next token. */
7171 token = cp_lexer_peek_token (parser->lexer);
7172 /* Some keywords give away the kind of expression. */
7173 if (token->type == CPP_KEYWORD)
7175 enum rid keyword = token->keyword;
7184 location_t first_loc;
7186 op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR;
7187 /* Consume the token. */
7188 cp_lexer_consume_token (parser->lexer);
7189 first_loc = cp_lexer_peek_token (parser->lexer)->location;
7190 /* Parse the operand. */
7191 operand = cp_parser_sizeof_operand (parser, keyword);
7193 if (TYPE_P (operand))
7194 ret = cxx_sizeof_or_alignof_type (operand, op, true);
7197 /* ISO C++ defines alignof only with types, not with
7198 expressions. So pedwarn if alignof is used with a non-
7199 type expression. However, __alignof__ is ok. */
7200 if (!strcmp (IDENTIFIER_POINTER (token->u.value), "alignof"))
7201 pedwarn (token->location, OPT_Wpedantic,
7202 "ISO C++ does not allow %<alignof%> "
7205 ret = cxx_sizeof_or_alignof_expr (operand, op, true);
7207 /* For SIZEOF_EXPR, just issue diagnostics, but keep
7208 SIZEOF_EXPR with the original operand. */
7209 if (op == SIZEOF_EXPR && ret != error_mark_node)
7211 if (TREE_CODE (ret) != SIZEOF_EXPR || TYPE_P (operand))
7213 if (!processing_template_decl && TYPE_P (operand))
7215 ret = build_min (SIZEOF_EXPR, size_type_node,
7216 build1 (NOP_EXPR, operand,
7218 SIZEOF_EXPR_TYPE_P (ret) = 1;
7221 ret = build_min (SIZEOF_EXPR, size_type_node, operand);
7222 TREE_SIDE_EFFECTS (ret) = 0;
7223 TREE_READONLY (ret) = 1;
7225 SET_EXPR_LOCATION (ret, first_loc);
7231 return cp_parser_new_expression (parser);
7234 return cp_parser_delete_expression (parser);
7238 /* The saved value of the PEDANTIC flag. */
7242 /* Save away the PEDANTIC flag. */
7243 cp_parser_extension_opt (parser, &saved_pedantic);
7244 /* Parse the cast-expression. */
7245 expr = cp_parser_simple_cast_expression (parser);
7246 /* Restore the PEDANTIC flag. */
7247 pedantic = saved_pedantic;
7257 /* Consume the `__real__' or `__imag__' token. */
7258 cp_lexer_consume_token (parser->lexer);
7259 /* Parse the cast-expression. */
7260 expression = cp_parser_simple_cast_expression (parser);
7261 /* Create the complete representation. */
7262 return build_x_unary_op (token->location,
7263 (keyword == RID_REALPART
7264 ? REALPART_EXPR : IMAGPART_EXPR),
7266 tf_warning_or_error);
7270 case RID_TRANSACTION_ATOMIC:
7271 case RID_TRANSACTION_RELAXED:
7272 return cp_parser_transaction_expression (parser, keyword);
7277 const char *saved_message;
7278 bool saved_integral_constant_expression_p;
7279 bool saved_non_integral_constant_expression_p;
7280 bool saved_greater_than_is_operator_p;
7282 cp_lexer_consume_token (parser->lexer);
7283 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
7285 saved_message = parser->type_definition_forbidden_message;
7286 parser->type_definition_forbidden_message
7287 = G_("types may not be defined in %<noexcept%> expressions");
7289 saved_integral_constant_expression_p
7290 = parser->integral_constant_expression_p;
7291 saved_non_integral_constant_expression_p
7292 = parser->non_integral_constant_expression_p;
7293 parser->integral_constant_expression_p = false;
7295 saved_greater_than_is_operator_p
7296 = parser->greater_than_is_operator_p;
7297 parser->greater_than_is_operator_p = true;
7299 ++cp_unevaluated_operand;
7300 ++c_inhibit_evaluation_warnings;
7301 ++cp_noexcept_operand;
7302 expr = cp_parser_expression (parser);
7303 --cp_noexcept_operand;
7304 --c_inhibit_evaluation_warnings;
7305 --cp_unevaluated_operand;
7307 parser->greater_than_is_operator_p
7308 = saved_greater_than_is_operator_p;
7310 parser->integral_constant_expression_p
7311 = saved_integral_constant_expression_p;
7312 parser->non_integral_constant_expression_p
7313 = saved_non_integral_constant_expression_p;
7315 parser->type_definition_forbidden_message = saved_message;
7317 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7318 return finish_noexcept_expr (expr, tf_warning_or_error);
7326 /* Look for the `:: new' and `:: delete', which also signal the
7327 beginning of a new-expression, or delete-expression,
7328 respectively. If the next token is `::', then it might be one of
7330 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
7334 /* See if the token after the `::' is one of the keywords in
7335 which we're interested. */
7336 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
7337 /* If it's `new', we have a new-expression. */
7338 if (keyword == RID_NEW)
7339 return cp_parser_new_expression (parser);
7340 /* Similarly, for `delete'. */
7341 else if (keyword == RID_DELETE)
7342 return cp_parser_delete_expression (parser);
7345 /* Look for a unary operator. */
7346 unary_operator = cp_parser_unary_operator (token);
7347 /* The `++' and `--' operators can be handled similarly, even though
7348 they are not technically unary-operators in the grammar. */
7349 if (unary_operator == ERROR_MARK)
7351 if (token->type == CPP_PLUS_PLUS)
7352 unary_operator = PREINCREMENT_EXPR;
7353 else if (token->type == CPP_MINUS_MINUS)
7354 unary_operator = PREDECREMENT_EXPR;
7355 /* Handle the GNU address-of-label extension. */
7356 else if (cp_parser_allow_gnu_extensions_p (parser)
7357 && token->type == CPP_AND_AND)
7361 location_t loc = token->location;
7363 /* Consume the '&&' token. */
7364 cp_lexer_consume_token (parser->lexer);
7365 /* Look for the identifier. */
7366 identifier = cp_parser_identifier (parser);
7367 /* Create an expression representing the address. */
7368 expression = finish_label_address_expr (identifier, loc);
7369 if (cp_parser_non_integral_constant_expression (parser,
7371 expression = error_mark_node;
7375 if (unary_operator != ERROR_MARK)
7377 tree cast_expression;
7378 tree expression = error_mark_node;
7379 non_integral_constant non_constant_p = NIC_NONE;
7380 location_t loc = token->location;
7381 tsubst_flags_t complain = complain_flags (decltype_p);
7383 /* Consume the operator token. */
7384 token = cp_lexer_consume_token (parser->lexer);
7385 /* Parse the cast-expression. */
7387 = cp_parser_cast_expression (parser,
7388 unary_operator == ADDR_EXPR,
7392 /* Now, build an appropriate representation. */
7393 switch (unary_operator)
7396 non_constant_p = NIC_STAR;
7397 expression = build_x_indirect_ref (loc, cast_expression,
7403 non_constant_p = NIC_ADDR;
7406 expression = build_x_unary_op (loc, unary_operator,
7411 case PREINCREMENT_EXPR:
7412 case PREDECREMENT_EXPR:
7413 non_constant_p = unary_operator == PREINCREMENT_EXPR
7414 ? NIC_PREINCREMENT : NIC_PREDECREMENT;
7416 case UNARY_PLUS_EXPR:
7418 case TRUTH_NOT_EXPR:
7419 expression = finish_unary_op_expr (loc, unary_operator,
7420 cast_expression, complain);
7427 if (non_constant_p != NIC_NONE
7428 && cp_parser_non_integral_constant_expression (parser,
7430 expression = error_mark_node;
7435 return cp_parser_postfix_expression (parser, address_p, cast_p,
7436 /*member_access_only_p=*/false,
7441 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
7442 unary-operator, the corresponding tree code is returned. */
7444 static enum tree_code
7445 cp_parser_unary_operator (cp_token* token)
7447 switch (token->type)
7450 return INDIRECT_REF;
7456 return UNARY_PLUS_EXPR;
7462 return TRUTH_NOT_EXPR;
7465 return BIT_NOT_EXPR;
7472 /* Parse a new-expression.
7475 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
7476 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
7478 Returns a representation of the expression. */
7481 cp_parser_new_expression (cp_parser* parser)
7483 bool global_scope_p;
7484 vec<tree, va_gc> *placement;
7486 vec<tree, va_gc> *initializer;
7487 tree nelts = NULL_TREE;
7490 /* Look for the optional `::' operator. */
7492 = (cp_parser_global_scope_opt (parser,
7493 /*current_scope_valid_p=*/false)
7495 /* Look for the `new' operator. */
7496 cp_parser_require_keyword (parser, RID_NEW, RT_NEW);
7497 /* There's no easy way to tell a new-placement from the
7498 `( type-id )' construct. */
7499 cp_parser_parse_tentatively (parser);
7500 /* Look for a new-placement. */
7501 placement = cp_parser_new_placement (parser);
7502 /* If that didn't work out, there's no new-placement. */
7503 if (!cp_parser_parse_definitely (parser))
7505 if (placement != NULL)
7506 release_tree_vector (placement);
7510 /* If the next token is a `(', then we have a parenthesized
7512 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
7515 const char *saved_message = parser->type_definition_forbidden_message;
7517 /* Consume the `('. */
7518 cp_lexer_consume_token (parser->lexer);
7520 /* Parse the type-id. */
7521 parser->type_definition_forbidden_message
7522 = G_("types may not be defined in a new-expression");
7523 type = cp_parser_type_id (parser);
7524 parser->type_definition_forbidden_message = saved_message;
7526 /* Look for the closing `)'. */
7527 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
7528 token = cp_lexer_peek_token (parser->lexer);
7529 /* There should not be a direct-new-declarator in this production,
7530 but GCC used to allowed this, so we check and emit a sensible error
7531 message for this case. */
7532 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
7534 error_at (token->location,
7535 "array bound forbidden after parenthesized type-id");
7536 inform (token->location,
7537 "try removing the parentheses around the type-id");
7538 cp_parser_direct_new_declarator (parser);
7541 /* Otherwise, there must be a new-type-id. */
7543 type = cp_parser_new_type_id (parser, &nelts);
7545 /* If the next token is a `(' or '{', then we have a new-initializer. */
7546 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
7547 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7548 initializer = cp_parser_new_initializer (parser);
7552 /* A new-expression may not appear in an integral constant
7554 if (cp_parser_non_integral_constant_expression (parser, NIC_NEW))
7555 ret = error_mark_node;
7558 /* Create a representation of the new-expression. */
7559 ret = build_new (&placement, type, nelts, &initializer, global_scope_p,
7560 tf_warning_or_error);
7563 if (placement != NULL)
7564 release_tree_vector (placement);
7565 if (initializer != NULL)
7566 release_tree_vector (initializer);
7571 /* Parse a new-placement.
7576 Returns the same representation as for an expression-list. */
7578 static vec<tree, va_gc> *
7579 cp_parser_new_placement (cp_parser* parser)
7581 vec<tree, va_gc> *expression_list;
7583 /* Parse the expression-list. */
7584 expression_list = (cp_parser_parenthesized_expression_list
7585 (parser, non_attr, /*cast_p=*/false,
7586 /*allow_expansion_p=*/true,
7587 /*non_constant_p=*/NULL));
7589 return expression_list;
7592 /* Parse a new-type-id.
7595 type-specifier-seq new-declarator [opt]
7597 Returns the TYPE allocated. If the new-type-id indicates an array
7598 type, *NELTS is set to the number of elements in the last array
7599 bound; the TYPE will not include the last array bound. */
7602 cp_parser_new_type_id (cp_parser* parser, tree *nelts)
7604 cp_decl_specifier_seq type_specifier_seq;
7605 cp_declarator *new_declarator;
7606 cp_declarator *declarator;
7607 cp_declarator *outer_declarator;
7608 const char *saved_message;
7610 /* The type-specifier sequence must not contain type definitions.
7611 (It cannot contain declarations of new types either, but if they
7612 are not definitions we will catch that because they are not
7614 saved_message = parser->type_definition_forbidden_message;
7615 parser->type_definition_forbidden_message
7616 = G_("types may not be defined in a new-type-id");
7617 /* Parse the type-specifier-seq. */
7618 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
7619 /*is_trailing_return=*/false,
7620 &type_specifier_seq);
7621 /* Restore the old message. */
7622 parser->type_definition_forbidden_message = saved_message;
7624 if (type_specifier_seq.type == error_mark_node)
7625 return error_mark_node;
7627 /* Parse the new-declarator. */
7628 new_declarator = cp_parser_new_declarator_opt (parser);
7630 /* Determine the number of elements in the last array dimension, if
7633 /* Skip down to the last array dimension. */
7634 declarator = new_declarator;
7635 outer_declarator = NULL;
7636 while (declarator && (declarator->kind == cdk_pointer
7637 || declarator->kind == cdk_ptrmem))
7639 outer_declarator = declarator;
7640 declarator = declarator->declarator;
7643 && declarator->kind == cdk_array
7644 && declarator->declarator
7645 && declarator->declarator->kind == cdk_array)
7647 outer_declarator = declarator;
7648 declarator = declarator->declarator;
7651 if (declarator && declarator->kind == cdk_array)
7653 *nelts = declarator->u.array.bounds;
7654 if (*nelts == error_mark_node)
7655 *nelts = integer_one_node;
7657 if (outer_declarator)
7658 outer_declarator->declarator = declarator->declarator;
7660 new_declarator = NULL;
7663 return groktypename (&type_specifier_seq, new_declarator, false);
7666 /* Parse an (optional) new-declarator.
7669 ptr-operator new-declarator [opt]
7670 direct-new-declarator
7672 Returns the declarator. */
7674 static cp_declarator *
7675 cp_parser_new_declarator_opt (cp_parser* parser)
7677 enum tree_code code;
7678 tree type, std_attributes = NULL_TREE;
7679 cp_cv_quals cv_quals;
7681 /* We don't know if there's a ptr-operator next, or not. */
7682 cp_parser_parse_tentatively (parser);
7683 /* Look for a ptr-operator. */
7684 code = cp_parser_ptr_operator (parser, &type, &cv_quals, &std_attributes);
7685 /* If that worked, look for more new-declarators. */
7686 if (cp_parser_parse_definitely (parser))
7688 cp_declarator *declarator;
7690 /* Parse another optional declarator. */
7691 declarator = cp_parser_new_declarator_opt (parser);
7693 declarator = cp_parser_make_indirect_declarator
7694 (code, type, cv_quals, declarator, std_attributes);
7699 /* If the next token is a `[', there is a direct-new-declarator. */
7700 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
7701 return cp_parser_direct_new_declarator (parser);
7706 /* Parse a direct-new-declarator.
7708 direct-new-declarator:
7710 direct-new-declarator [constant-expression]
7714 static cp_declarator *
7715 cp_parser_direct_new_declarator (cp_parser* parser)
7717 cp_declarator *declarator = NULL;
7724 /* Look for the opening `['. */
7725 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
7727 token = cp_lexer_peek_token (parser->lexer);
7728 expression = cp_parser_expression (parser);
7729 /* The standard requires that the expression have integral
7730 type. DR 74 adds enumeration types. We believe that the
7731 real intent is that these expressions be handled like the
7732 expression in a `switch' condition, which also allows
7733 classes with a single conversion to integral or
7734 enumeration type. */
7735 if (!processing_template_decl)
7738 = build_expr_type_conversion (WANT_INT | WANT_ENUM,
7743 error_at (token->location,
7744 "expression in new-declarator must have integral "
7745 "or enumeration type");
7746 expression = error_mark_node;
7750 /* Look for the closing `]'. */
7751 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
7753 /* Add this bound to the declarator. */
7754 declarator = make_array_declarator (declarator, expression);
7756 /* If the next token is not a `[', then there are no more
7758 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
7765 /* Parse a new-initializer.
7768 ( expression-list [opt] )
7771 Returns a representation of the expression-list. */
7773 static vec<tree, va_gc> *
7774 cp_parser_new_initializer (cp_parser* parser)
7776 vec<tree, va_gc> *expression_list;
7778 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7781 bool expr_non_constant_p;
7782 cp_lexer_set_source_position (parser->lexer);
7783 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
7784 t = cp_parser_braced_list (parser, &expr_non_constant_p);
7785 CONSTRUCTOR_IS_DIRECT_INIT (t) = 1;
7786 expression_list = make_tree_vector_single (t);
7789 expression_list = (cp_parser_parenthesized_expression_list
7790 (parser, non_attr, /*cast_p=*/false,
7791 /*allow_expansion_p=*/true,
7792 /*non_constant_p=*/NULL));
7794 return expression_list;
7797 /* Parse a delete-expression.
7800 :: [opt] delete cast-expression
7801 :: [opt] delete [ ] cast-expression
7803 Returns a representation of the expression. */
7806 cp_parser_delete_expression (cp_parser* parser)
7808 bool global_scope_p;
7812 /* Look for the optional `::' operator. */
7814 = (cp_parser_global_scope_opt (parser,
7815 /*current_scope_valid_p=*/false)
7817 /* Look for the `delete' keyword. */
7818 cp_parser_require_keyword (parser, RID_DELETE, RT_DELETE);
7819 /* See if the array syntax is in use. */
7820 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
7822 /* Consume the `[' token. */
7823 cp_lexer_consume_token (parser->lexer);
7824 /* Look for the `]' token. */
7825 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
7826 /* Remember that this is the `[]' construct. */
7832 /* Parse the cast-expression. */
7833 expression = cp_parser_simple_cast_expression (parser);
7835 /* A delete-expression may not appear in an integral constant
7837 if (cp_parser_non_integral_constant_expression (parser, NIC_DEL))
7838 return error_mark_node;
7840 return delete_sanity (expression, NULL_TREE, array_p, global_scope_p,
7841 tf_warning_or_error);
7844 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
7845 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
7849 cp_parser_tokens_start_cast_expression (cp_parser *parser)
7851 cp_token *token = cp_lexer_peek_token (parser->lexer);
7852 switch (token->type)
7858 case CPP_CLOSE_SQUARE:
7859 case CPP_CLOSE_PAREN:
7860 case CPP_CLOSE_BRACE:
7861 case CPP_OPEN_BRACE:
7865 case CPP_DEREF_STAR:
7873 case CPP_GREATER_EQ:
7894 case CPP_OPEN_PAREN:
7895 /* In ((type ()) () the last () isn't a valid cast-expression,
7896 so the whole must be parsed as postfix-expression. */
7897 return cp_lexer_peek_nth_token (parser->lexer, 2)->type
7900 case CPP_OPEN_SQUARE:
7901 /* '[' may start a primary-expression in obj-c++ and in C++11,
7902 as a lambda-expression, eg, '(void)[]{}'. */
7903 if (cxx_dialect >= cxx11)
7905 return c_dialect_objc ();
7908 case CPP_MINUS_MINUS:
7909 /* '++' and '--' may or may not start a cast-expression:
7911 struct T { void operator++(int); };
7912 void f() { (T())++; }
7925 /* Parse a cast-expression.
7929 ( type-id ) cast-expression
7931 ADDRESS_P is true iff the unary-expression is appearing as the
7932 operand of the `&' operator. CAST_P is true if this expression is
7933 the target of a cast.
7935 Returns a representation of the expression. */
7938 cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
7939 bool decltype_p, cp_id_kind * pidk)
7941 /* If it's a `(', then we might be looking at a cast. */
7942 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
7944 tree type = NULL_TREE;
7945 tree expr = NULL_TREE;
7946 int cast_expression = 0;
7947 const char *saved_message;
7949 /* There's no way to know yet whether or not this is a cast.
7950 For example, `(int (3))' is a unary-expression, while `(int)
7951 3' is a cast. So, we resort to parsing tentatively. */
7952 cp_parser_parse_tentatively (parser);
7953 /* Types may not be defined in a cast. */
7954 saved_message = parser->type_definition_forbidden_message;
7955 parser->type_definition_forbidden_message
7956 = G_("types may not be defined in casts");
7957 /* Consume the `('. */
7958 cp_lexer_consume_token (parser->lexer);
7959 /* A very tricky bit is that `(struct S) { 3 }' is a
7960 compound-literal (which we permit in C++ as an extension).
7961 But, that construct is not a cast-expression -- it is a
7962 postfix-expression. (The reason is that `(struct S) { 3 }.i'
7963 is legal; if the compound-literal were a cast-expression,
7964 you'd need an extra set of parentheses.) But, if we parse
7965 the type-id, and it happens to be a class-specifier, then we
7966 will commit to the parse at that point, because we cannot
7967 undo the action that is done when creating a new class. So,
7968 then we cannot back up and do a postfix-expression.
7970 Another tricky case is the following (c++/29234):
7972 struct S { void operator () (); };
7979 As a type-id we parse the parenthesized S()() as a function
7980 returning a function, groktypename complains and we cannot
7981 back up in this case either.
7983 Therefore, we scan ahead to the closing `)', and check to see
7984 if the tokens after the `)' can start a cast-expression. Otherwise
7985 we are dealing with an unary-expression, a postfix-expression
7988 Yet another tricky case, in C++11, is the following (c++/54891):
7992 The issue is that usually, besides the case of lambda-expressions,
7993 the parenthesized type-id cannot be followed by '[', and, eg, we
7994 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
7995 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
7996 we don't commit, we try a cast-expression, then an unary-expression.
7998 Save tokens so that we can put them back. */
7999 cp_lexer_save_tokens (parser->lexer);
8001 /* We may be looking at a cast-expression. */
8002 if (cp_parser_skip_to_closing_parenthesis (parser, false, false,
8003 /*consume_paren=*/true))
8005 = cp_parser_tokens_start_cast_expression (parser);
8007 /* Roll back the tokens we skipped. */
8008 cp_lexer_rollback_tokens (parser->lexer);
8009 /* If we aren't looking at a cast-expression, simulate an error so
8010 that the call to cp_parser_error_occurred below returns true. */
8011 if (!cast_expression)
8012 cp_parser_simulate_error (parser);
8015 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
8016 parser->in_type_id_in_expr_p = true;
8017 /* Look for the type-id. */
8018 type = cp_parser_type_id (parser);
8019 /* Look for the closing `)'. */
8020 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8021 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
8024 /* Restore the saved message. */
8025 parser->type_definition_forbidden_message = saved_message;
8027 /* At this point this can only be either a cast or a
8028 parenthesized ctor such as `(T ())' that looks like a cast to
8029 function returning T. */
8030 if (!cp_parser_error_occurred (parser))
8032 /* Only commit if the cast-expression doesn't start with
8033 '++', '--', or '[' in C++11. */
8034 if (cast_expression > 0)
8035 cp_parser_commit_to_topmost_tentative_parse (parser);
8037 expr = cp_parser_cast_expression (parser,
8038 /*address_p=*/false,
8040 /*decltype_p=*/false,
8043 if (cp_parser_parse_definitely (parser))
8045 /* Warn about old-style casts, if so requested. */
8046 if (warn_old_style_cast
8047 && !in_system_header_at (input_location)
8048 && !VOID_TYPE_P (type)
8049 && current_lang_name != lang_name_c)
8050 warning (OPT_Wold_style_cast, "use of old-style cast");
8052 /* Only type conversions to integral or enumeration types
8053 can be used in constant-expressions. */
8054 if (!cast_valid_in_integral_constant_expression_p (type)
8055 && cp_parser_non_integral_constant_expression (parser,
8057 return error_mark_node;
8059 /* Perform the cast. */
8060 expr = build_c_cast (input_location, type, expr);
8065 cp_parser_abort_tentative_parse (parser);
8068 /* If we get here, then it's not a cast, so it must be a
8069 unary-expression. */
8070 return cp_parser_unary_expression (parser, pidk, address_p,
8071 cast_p, decltype_p);
8074 /* Parse a binary expression of the general form:
8078 pm-expression .* cast-expression
8079 pm-expression ->* cast-expression
8081 multiplicative-expression:
8083 multiplicative-expression * pm-expression
8084 multiplicative-expression / pm-expression
8085 multiplicative-expression % pm-expression
8087 additive-expression:
8088 multiplicative-expression
8089 additive-expression + multiplicative-expression
8090 additive-expression - multiplicative-expression
8094 shift-expression << additive-expression
8095 shift-expression >> additive-expression
8097 relational-expression:
8099 relational-expression < shift-expression
8100 relational-expression > shift-expression
8101 relational-expression <= shift-expression
8102 relational-expression >= shift-expression
8106 relational-expression:
8107 relational-expression <? shift-expression
8108 relational-expression >? shift-expression
8110 equality-expression:
8111 relational-expression
8112 equality-expression == relational-expression
8113 equality-expression != relational-expression
8117 and-expression & equality-expression
8119 exclusive-or-expression:
8121 exclusive-or-expression ^ and-expression
8123 inclusive-or-expression:
8124 exclusive-or-expression
8125 inclusive-or-expression | exclusive-or-expression
8127 logical-and-expression:
8128 inclusive-or-expression
8129 logical-and-expression && inclusive-or-expression
8131 logical-or-expression:
8132 logical-and-expression
8133 logical-or-expression || logical-and-expression
8135 All these are implemented with a single function like:
8138 simple-cast-expression
8139 binary-expression <token> binary-expression
8141 CAST_P is true if this expression is the target of a cast.
8143 The binops_by_token map is used to get the tree codes for each <token> type.
8144 binary-expressions are associated according to a precedence table. */
8146 #define TOKEN_PRECEDENCE(token) \
8147 (((token->type == CPP_GREATER \
8148 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
8149 && !parser->greater_than_is_operator_p) \
8150 ? PREC_NOT_OPERATOR \
8151 : binops_by_token[token->type].prec)
8154 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
8155 bool no_toplevel_fold_p,
8157 enum cp_parser_prec prec,
8160 cp_parser_expression_stack stack;
8161 cp_parser_expression_stack_entry *sp = &stack[0];
8162 cp_parser_expression_stack_entry current;
8165 enum tree_code rhs_type;
8166 enum cp_parser_prec new_prec, lookahead_prec;
8169 /* Parse the first expression. */
8170 current.lhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
8171 ? TRUTH_NOT_EXPR : ERROR_MARK);
8172 current.lhs = cp_parser_cast_expression (parser, /*address_p=*/false,
8173 cast_p, decltype_p, pidk);
8174 current.prec = prec;
8176 if (cp_parser_error_occurred (parser))
8177 return error_mark_node;
8181 /* Get an operator token. */
8182 token = cp_lexer_peek_token (parser->lexer);
8184 if (warn_cxx0x_compat
8185 && token->type == CPP_RSHIFT
8186 && !parser->greater_than_is_operator_p)
8188 if (warning_at (token->location, OPT_Wc__0x_compat,
8189 "%<>>%> operator is treated"
8190 " as two right angle brackets in C++11"))
8191 inform (token->location,
8192 "suggest parentheses around %<>>%> expression");
8195 new_prec = TOKEN_PRECEDENCE (token);
8197 /* Popping an entry off the stack means we completed a subexpression:
8198 - either we found a token which is not an operator (`>' where it is not
8199 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
8200 will happen repeatedly;
8201 - or, we found an operator which has lower priority. This is the case
8202 where the recursive descent *ascends*, as in `3 * 4 + 5' after
8204 if (new_prec <= current.prec)
8213 current.tree_type = binops_by_token[token->type].tree_type;
8214 current.loc = token->location;
8216 /* We used the operator token. */
8217 cp_lexer_consume_token (parser->lexer);
8219 /* For "false && x" or "true || x", x will never be executed;
8220 disable warnings while evaluating it. */
8221 if (current.tree_type == TRUTH_ANDIF_EXPR)
8222 c_inhibit_evaluation_warnings += current.lhs == truthvalue_false_node;
8223 else if (current.tree_type == TRUTH_ORIF_EXPR)
8224 c_inhibit_evaluation_warnings += current.lhs == truthvalue_true_node;
8226 /* Extract another operand. It may be the RHS of this expression
8227 or the LHS of a new, higher priority expression. */
8228 rhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
8229 ? TRUTH_NOT_EXPR : ERROR_MARK);
8230 rhs = cp_parser_simple_cast_expression (parser);
8232 /* Get another operator token. Look up its precedence to avoid
8233 building a useless (immediately popped) stack entry for common
8234 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
8235 token = cp_lexer_peek_token (parser->lexer);
8236 lookahead_prec = TOKEN_PRECEDENCE (token);
8237 if (lookahead_prec > new_prec)
8239 /* ... and prepare to parse the RHS of the new, higher priority
8240 expression. Since precedence levels on the stack are
8241 monotonically increasing, we do not have to care about
8246 current.lhs_type = rhs_type;
8247 current.prec = new_prec;
8248 new_prec = lookahead_prec;
8252 lookahead_prec = new_prec;
8253 /* If the stack is not empty, we have parsed into LHS the right side
8254 (`4' in the example above) of an expression we had suspended.
8255 We can use the information on the stack to recover the LHS (`3')
8256 from the stack together with the tree code (`MULT_EXPR'), and
8257 the precedence of the higher level subexpression
8258 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
8259 which will be used to actually build the additive expression. */
8261 rhs_type = current.lhs_type;
8266 /* Undo the disabling of warnings done above. */
8267 if (current.tree_type == TRUTH_ANDIF_EXPR)
8268 c_inhibit_evaluation_warnings -= current.lhs == truthvalue_false_node;
8269 else if (current.tree_type == TRUTH_ORIF_EXPR)
8270 c_inhibit_evaluation_warnings -= current.lhs == truthvalue_true_node;
8272 if (warn_logical_not_paren
8273 && TREE_CODE_CLASS (current.tree_type) == tcc_comparison
8274 && current.lhs_type == TRUTH_NOT_EXPR
8275 /* Avoid warning for !!x == y. */
8276 && (TREE_CODE (current.lhs) != NE_EXPR
8277 || !integer_zerop (TREE_OPERAND (current.lhs, 1)))
8278 && (TREE_CODE (current.lhs) != TRUTH_NOT_EXPR
8279 || (TREE_CODE (TREE_OPERAND (current.lhs, 0)) != TRUTH_NOT_EXPR
8280 /* Avoid warning for !b == y where b is boolean. */
8281 && (TREE_TYPE (TREE_OPERAND (current.lhs, 0)) == NULL_TREE
8282 || (TREE_CODE (TREE_TYPE (TREE_OPERAND (current.lhs, 0)))
8284 /* Avoid warning for !!b == y where b is boolean. */
8285 && (!DECL_P (current.lhs)
8286 || TREE_TYPE (current.lhs) == NULL_TREE
8287 || TREE_CODE (TREE_TYPE (current.lhs)) != BOOLEAN_TYPE))
8288 warn_logical_not_parentheses (current.loc, current.tree_type,
8289 maybe_constant_value (rhs));
8292 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
8293 ERROR_MARK for everything that is not a binary expression.
8294 This makes warn_about_parentheses miss some warnings that
8295 involve unary operators. For unary expressions we should
8296 pass the correct tree_code unless the unary expression was
8297 surrounded by parentheses.
8299 if (no_toplevel_fold_p
8300 && lookahead_prec <= current.prec
8302 current.lhs = build2 (current.tree_type,
8303 TREE_CODE_CLASS (current.tree_type)
8305 ? boolean_type_node : TREE_TYPE (current.lhs),
8308 current.lhs = build_x_binary_op (current.loc, current.tree_type,
8309 current.lhs, current.lhs_type,
8310 rhs, rhs_type, &overload,
8311 complain_flags (decltype_p));
8312 current.lhs_type = current.tree_type;
8313 if (EXPR_P (current.lhs))
8314 SET_EXPR_LOCATION (current.lhs, current.loc);
8316 /* If the binary operator required the use of an overloaded operator,
8317 then this expression cannot be an integral constant-expression.
8318 An overloaded operator can be used even if both operands are
8319 otherwise permissible in an integral constant-expression if at
8320 least one of the operands is of enumeration type. */
8323 && cp_parser_non_integral_constant_expression (parser,
8325 return error_mark_node;
8332 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
8333 bool no_toplevel_fold_p,
8334 enum cp_parser_prec prec,
8337 return cp_parser_binary_expression (parser, cast_p, no_toplevel_fold_p,
8338 /*decltype*/false, prec, pidk);
8341 /* Parse the `? expression : assignment-expression' part of a
8342 conditional-expression. The LOGICAL_OR_EXPR is the
8343 logical-or-expression that started the conditional-expression.
8344 Returns a representation of the entire conditional-expression.
8346 This routine is used by cp_parser_assignment_expression.
8348 ? expression : assignment-expression
8352 ? : assignment-expression */
8355 cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr)
8358 tree assignment_expr;
8359 struct cp_token *token;
8360 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8362 /* Consume the `?' token. */
8363 cp_lexer_consume_token (parser->lexer);
8364 token = cp_lexer_peek_token (parser->lexer);
8365 if (cp_parser_allow_gnu_extensions_p (parser)
8366 && token->type == CPP_COLON)
8368 pedwarn (token->location, OPT_Wpedantic,
8369 "ISO C++ does not allow ?: with omitted middle operand");
8370 /* Implicit true clause. */
8372 c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_true_node;
8373 warn_for_omitted_condop (token->location, logical_or_expr);
8377 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
8378 parser->colon_corrects_to_scope_p = false;
8379 /* Parse the expression. */
8380 c_inhibit_evaluation_warnings += logical_or_expr == truthvalue_false_node;
8381 expr = cp_parser_expression (parser);
8382 c_inhibit_evaluation_warnings +=
8383 ((logical_or_expr == truthvalue_true_node)
8384 - (logical_or_expr == truthvalue_false_node));
8385 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
8388 /* The next token should be a `:'. */
8389 cp_parser_require (parser, CPP_COLON, RT_COLON);
8390 /* Parse the assignment-expression. */
8391 assignment_expr = cp_parser_assignment_expression (parser);
8392 c_inhibit_evaluation_warnings -= logical_or_expr == truthvalue_true_node;
8394 /* Build the conditional-expression. */
8395 return build_x_conditional_expr (loc, logical_or_expr,
8398 tf_warning_or_error);
8401 /* Parse an assignment-expression.
8403 assignment-expression:
8404 conditional-expression
8405 logical-or-expression assignment-operator assignment_expression
8408 CAST_P is true if this expression is the target of a cast.
8409 DECLTYPE_P is true if this expression is the operand of decltype.
8411 Returns a representation for the expression. */
8414 cp_parser_assignment_expression (cp_parser* parser, cp_id_kind * pidk,
8415 bool cast_p, bool decltype_p)
8419 /* If the next token is the `throw' keyword, then we're looking at
8420 a throw-expression. */
8421 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
8422 expr = cp_parser_throw_expression (parser);
8423 /* Otherwise, it must be that we are looking at a
8424 logical-or-expression. */
8427 /* Parse the binary expressions (logical-or-expression). */
8428 expr = cp_parser_binary_expression (parser, cast_p, false,
8430 PREC_NOT_OPERATOR, pidk);
8431 /* If the next token is a `?' then we're actually looking at a
8432 conditional-expression. */
8433 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
8434 return cp_parser_question_colon_clause (parser, expr);
8437 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8439 /* If it's an assignment-operator, we're using the second
8441 enum tree_code assignment_operator
8442 = cp_parser_assignment_operator_opt (parser);
8443 if (assignment_operator != ERROR_MARK)
8445 bool non_constant_p;
8446 location_t saved_input_location;
8448 /* Parse the right-hand side of the assignment. */
8449 tree rhs = cp_parser_initializer_clause (parser, &non_constant_p);
8451 if (BRACE_ENCLOSED_INITIALIZER_P (rhs))
8452 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
8454 /* An assignment may not appear in a
8455 constant-expression. */
8456 if (cp_parser_non_integral_constant_expression (parser,
8458 return error_mark_node;
8459 /* Build the assignment expression. Its default
8460 location is the location of the '=' token. */
8461 saved_input_location = input_location;
8462 input_location = loc;
8463 expr = build_x_modify_expr (loc, expr,
8464 assignment_operator,
8466 complain_flags (decltype_p));
8467 input_location = saved_input_location;
8475 /* Parse an (optional) assignment-operator.
8477 assignment-operator: one of
8478 = *= /= %= += -= >>= <<= &= ^= |=
8482 assignment-operator: one of
8485 If the next token is an assignment operator, the corresponding tree
8486 code is returned, and the token is consumed. For example, for
8487 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
8488 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
8489 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
8490 operator, ERROR_MARK is returned. */
8492 static enum tree_code
8493 cp_parser_assignment_operator_opt (cp_parser* parser)
8498 /* Peek at the next token. */
8499 token = cp_lexer_peek_token (parser->lexer);
8501 switch (token->type)
8512 op = TRUNC_DIV_EXPR;
8516 op = TRUNC_MOD_EXPR;
8548 /* Nothing else is an assignment operator. */
8552 /* If it was an assignment operator, consume it. */
8553 if (op != ERROR_MARK)
8554 cp_lexer_consume_token (parser->lexer);
8559 /* Parse an expression.
8562 assignment-expression
8563 expression , assignment-expression
8565 CAST_P is true if this expression is the target of a cast.
8566 DECLTYPE_P is true if this expression is the immediate operand of decltype,
8567 except possibly parenthesized or on the RHS of a comma (N3276).
8569 Returns a representation of the expression. */
8572 cp_parser_expression (cp_parser* parser, cp_id_kind * pidk,
8573 bool cast_p, bool decltype_p)
8575 tree expression = NULL_TREE;
8576 location_t loc = UNKNOWN_LOCATION;
8580 tree assignment_expression;
8582 /* Parse the next assignment-expression. */
8583 assignment_expression
8584 = cp_parser_assignment_expression (parser, pidk, cast_p, decltype_p);
8586 /* We don't create a temporary for a call that is the immediate operand
8587 of decltype or on the RHS of a comma. But when we see a comma, we
8588 need to create a temporary for a call on the LHS. */
8589 if (decltype_p && !processing_template_decl
8590 && TREE_CODE (assignment_expression) == CALL_EXPR
8591 && CLASS_TYPE_P (TREE_TYPE (assignment_expression))
8592 && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
8593 assignment_expression
8594 = build_cplus_new (TREE_TYPE (assignment_expression),
8595 assignment_expression, tf_warning_or_error);
8597 /* If this is the first assignment-expression, we can just
8600 expression = assignment_expression;
8602 expression = build_x_compound_expr (loc, expression,
8603 assignment_expression,
8604 complain_flags (decltype_p));
8605 /* If the next token is not a comma, then we are done with the
8607 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8609 /* Consume the `,'. */
8610 loc = cp_lexer_peek_token (parser->lexer)->location;
8611 cp_lexer_consume_token (parser->lexer);
8612 /* A comma operator cannot appear in a constant-expression. */
8613 if (cp_parser_non_integral_constant_expression (parser, NIC_COMMA))
8614 expression = error_mark_node;
8620 /* Parse a constant-expression.
8622 constant-expression:
8623 conditional-expression
8625 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
8626 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
8627 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
8628 is false, NON_CONSTANT_P should be NULL. */
8631 cp_parser_constant_expression (cp_parser* parser,
8632 bool allow_non_constant_p,
8633 bool *non_constant_p)
8635 bool saved_integral_constant_expression_p;
8636 bool saved_allow_non_integral_constant_expression_p;
8637 bool saved_non_integral_constant_expression_p;
8640 /* It might seem that we could simply parse the
8641 conditional-expression, and then check to see if it were
8642 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
8643 one that the compiler can figure out is constant, possibly after
8644 doing some simplifications or optimizations. The standard has a
8645 precise definition of constant-expression, and we must honor
8646 that, even though it is somewhat more restrictive.
8652 is not a legal declaration, because `(2, 3)' is not a
8653 constant-expression. The `,' operator is forbidden in a
8654 constant-expression. However, GCC's constant-folding machinery
8655 will fold this operation to an INTEGER_CST for `3'. */
8657 /* Save the old settings. */
8658 saved_integral_constant_expression_p = parser->integral_constant_expression_p;
8659 saved_allow_non_integral_constant_expression_p
8660 = parser->allow_non_integral_constant_expression_p;
8661 saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
8662 /* We are now parsing a constant-expression. */
8663 parser->integral_constant_expression_p = true;
8664 parser->allow_non_integral_constant_expression_p
8665 = (allow_non_constant_p || cxx_dialect >= cxx11);
8666 parser->non_integral_constant_expression_p = false;
8667 /* Although the grammar says "conditional-expression", we parse an
8668 "assignment-expression", which also permits "throw-expression"
8669 and the use of assignment operators. In the case that
8670 ALLOW_NON_CONSTANT_P is false, we get better errors than we would
8671 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
8672 actually essential that we look for an assignment-expression.
8673 For example, cp_parser_initializer_clauses uses this function to
8674 determine whether a particular assignment-expression is in fact
8676 expression = cp_parser_assignment_expression (parser);
8677 /* Restore the old settings. */
8678 parser->integral_constant_expression_p
8679 = saved_integral_constant_expression_p;
8680 parser->allow_non_integral_constant_expression_p
8681 = saved_allow_non_integral_constant_expression_p;
8682 if (cxx_dialect >= cxx11)
8684 /* Require an rvalue constant expression here; that's what our
8685 callers expect. Reference constant expressions are handled
8686 separately in e.g. cp_parser_template_argument. */
8687 bool is_const = potential_rvalue_constant_expression (expression);
8688 parser->non_integral_constant_expression_p = !is_const;
8689 if (!is_const && !allow_non_constant_p)
8690 require_potential_rvalue_constant_expression (expression);
8692 if (allow_non_constant_p)
8693 *non_constant_p = parser->non_integral_constant_expression_p;
8694 parser->non_integral_constant_expression_p
8695 = saved_non_integral_constant_expression_p;
8700 /* Parse __builtin_offsetof.
8702 offsetof-expression:
8703 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
8705 offsetof-member-designator:
8707 | offsetof-member-designator "." id-expression
8708 | offsetof-member-designator "[" expression "]"
8709 | offsetof-member-designator "->" id-expression */
8712 cp_parser_builtin_offsetof (cp_parser *parser)
8714 int save_ice_p, save_non_ice_p;
8719 /* We're about to accept non-integral-constant things, but will
8720 definitely yield an integral constant expression. Save and
8721 restore these values around our local parsing. */
8722 save_ice_p = parser->integral_constant_expression_p;
8723 save_non_ice_p = parser->non_integral_constant_expression_p;
8725 /* Consume the "__builtin_offsetof" token. */
8726 cp_lexer_consume_token (parser->lexer);
8727 /* Consume the opening `('. */
8728 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8729 /* Parse the type-id. */
8730 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
8731 type = cp_parser_type_id (parser);
8732 /* Look for the `,'. */
8733 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
8734 token = cp_lexer_peek_token (parser->lexer);
8736 /* Build the (type *)null that begins the traditional offsetof macro. */
8737 expr = build_static_cast (build_pointer_type (type), null_pointer_node,
8738 tf_warning_or_error);
8740 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
8741 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr,
8742 true, &dummy, token->location);
8745 token = cp_lexer_peek_token (parser->lexer);
8746 switch (token->type)
8748 case CPP_OPEN_SQUARE:
8749 /* offsetof-member-designator "[" expression "]" */
8750 expr = cp_parser_postfix_open_square_expression (parser, expr,
8755 /* offsetof-member-designator "->" identifier */
8756 expr = grok_array_decl (token->location, expr,
8757 integer_zero_node, false);
8761 /* offsetof-member-designator "." identifier */
8762 cp_lexer_consume_token (parser->lexer);
8763 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT,
8768 case CPP_CLOSE_PAREN:
8769 /* Consume the ")" token. */
8770 cp_lexer_consume_token (parser->lexer);
8774 /* Error. We know the following require will fail, but
8775 that gives the proper error message. */
8776 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8777 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
8778 expr = error_mark_node;
8784 expr = finish_offsetof (expr, loc);
8787 parser->integral_constant_expression_p = save_ice_p;
8788 parser->non_integral_constant_expression_p = save_non_ice_p;
8793 /* Parse a trait expression.
8795 Returns a representation of the expression, the underlying type
8796 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
8799 cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
8802 tree type1, type2 = NULL_TREE;
8803 bool binary = false;
8804 bool variadic = false;
8808 case RID_HAS_NOTHROW_ASSIGN:
8809 kind = CPTK_HAS_NOTHROW_ASSIGN;
8811 case RID_HAS_NOTHROW_CONSTRUCTOR:
8812 kind = CPTK_HAS_NOTHROW_CONSTRUCTOR;
8814 case RID_HAS_NOTHROW_COPY:
8815 kind = CPTK_HAS_NOTHROW_COPY;
8817 case RID_HAS_TRIVIAL_ASSIGN:
8818 kind = CPTK_HAS_TRIVIAL_ASSIGN;
8820 case RID_HAS_TRIVIAL_CONSTRUCTOR:
8821 kind = CPTK_HAS_TRIVIAL_CONSTRUCTOR;
8823 case RID_HAS_TRIVIAL_COPY:
8824 kind = CPTK_HAS_TRIVIAL_COPY;
8826 case RID_HAS_TRIVIAL_DESTRUCTOR:
8827 kind = CPTK_HAS_TRIVIAL_DESTRUCTOR;
8829 case RID_HAS_VIRTUAL_DESTRUCTOR:
8830 kind = CPTK_HAS_VIRTUAL_DESTRUCTOR;
8832 case RID_IS_ABSTRACT:
8833 kind = CPTK_IS_ABSTRACT;
8835 case RID_IS_BASE_OF:
8836 kind = CPTK_IS_BASE_OF;
8840 kind = CPTK_IS_CLASS;
8843 kind = CPTK_IS_EMPTY;
8846 kind = CPTK_IS_ENUM;
8849 kind = CPTK_IS_FINAL;
8851 case RID_IS_LITERAL_TYPE:
8852 kind = CPTK_IS_LITERAL_TYPE;
8857 case RID_IS_POLYMORPHIC:
8858 kind = CPTK_IS_POLYMORPHIC;
8860 case RID_IS_STD_LAYOUT:
8861 kind = CPTK_IS_STD_LAYOUT;
8863 case RID_IS_TRIVIAL:
8864 kind = CPTK_IS_TRIVIAL;
8866 case RID_IS_TRIVIALLY_ASSIGNABLE:
8867 kind = CPTK_IS_TRIVIALLY_ASSIGNABLE;
8870 case RID_IS_TRIVIALLY_CONSTRUCTIBLE:
8871 kind = CPTK_IS_TRIVIALLY_CONSTRUCTIBLE;
8874 case RID_IS_TRIVIALLY_COPYABLE:
8875 kind = CPTK_IS_TRIVIALLY_COPYABLE;
8878 kind = CPTK_IS_UNION;
8880 case RID_UNDERLYING_TYPE:
8881 kind = CPTK_UNDERLYING_TYPE;
8886 case RID_DIRECT_BASES:
8887 kind = CPTK_DIRECT_BASES;
8893 /* Consume the token. */
8894 cp_lexer_consume_token (parser->lexer);
8896 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
8898 type1 = cp_parser_type_id (parser);
8900 if (type1 == error_mark_node)
8901 return error_mark_node;
8905 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
8907 type2 = cp_parser_type_id (parser);
8909 if (type2 == error_mark_node)
8910 return error_mark_node;
8914 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
8916 cp_lexer_consume_token (parser->lexer);
8917 tree elt = cp_parser_type_id (parser);
8918 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
8920 cp_lexer_consume_token (parser->lexer);
8921 elt = make_pack_expansion (elt);
8923 if (elt == error_mark_node)
8924 return error_mark_node;
8925 type2 = tree_cons (NULL_TREE, elt, type2);
8929 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
8931 /* Complete the trait expression, which may mean either processing
8932 the trait expr now or saving it for template instantiation. */
8935 case CPTK_UNDERLYING_TYPE:
8936 return finish_underlying_type (type1);
8938 return finish_bases (type1, false);
8939 case CPTK_DIRECT_BASES:
8940 return finish_bases (type1, true);
8942 return finish_trait_expr (kind, type1, type2);
8946 /* Lambdas that appear in variable initializer or default argument scope
8947 get that in their mangling, so we need to record it. We might as well
8948 use the count for function and namespace scopes as well. */
8949 static GTY(()) tree lambda_scope;
8950 static GTY(()) int lambda_count;
8951 typedef struct GTY(()) tree_int
8956 static GTY(()) vec<tree_int, va_gc> *lambda_scope_stack;
8959 start_lambda_scope (tree decl)
8963 /* Once we're inside a function, we ignore other scopes and just push
8964 the function again so that popping works properly. */
8965 if (current_function_decl && TREE_CODE (decl) != FUNCTION_DECL)
8966 decl = current_function_decl;
8967 ti.t = lambda_scope;
8968 ti.i = lambda_count;
8969 vec_safe_push (lambda_scope_stack, ti);
8970 if (lambda_scope != decl)
8972 /* Don't reset the count if we're still in the same function. */
8973 lambda_scope = decl;
8979 record_lambda_scope (tree lambda)
8981 LAMBDA_EXPR_EXTRA_SCOPE (lambda) = lambda_scope;
8982 LAMBDA_EXPR_DISCRIMINATOR (lambda) = lambda_count++;
8986 finish_lambda_scope (void)
8988 tree_int *p = &lambda_scope_stack->last ();
8989 if (lambda_scope != p->t)
8991 lambda_scope = p->t;
8992 lambda_count = p->i;
8994 lambda_scope_stack->pop ();
8997 /* Parse a lambda expression.
9000 lambda-introducer lambda-declarator [opt] compound-statement
9002 Returns a representation of the expression. */
9005 cp_parser_lambda_expression (cp_parser* parser)
9007 tree lambda_expr = build_lambda_expr ();
9010 cp_token *token = cp_lexer_peek_token (parser->lexer);
9011 cp_token_position start = 0;
9013 LAMBDA_EXPR_LOCATION (lambda_expr) = token->location;
9015 if (cp_unevaluated_operand)
9017 if (!token->error_reported)
9019 error_at (LAMBDA_EXPR_LOCATION (lambda_expr),
9020 "lambda-expression in unevaluated context");
9021 token->error_reported = true;
9025 else if (parser->in_template_argument_list_p)
9027 if (!token->error_reported)
9029 error_at (token->location, "lambda-expression in template-argument");
9030 token->error_reported = true;
9035 /* We may be in the middle of deferred access check. Disable
9037 push_deferring_access_checks (dk_no_deferred);
9039 cp_parser_lambda_introducer (parser, lambda_expr);
9041 type = begin_lambda_type (lambda_expr);
9042 if (type == error_mark_node)
9043 return error_mark_node;
9045 record_lambda_scope (lambda_expr);
9047 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
9048 determine_visibility (TYPE_NAME (type));
9050 /* Now that we've started the type, add the capture fields for any
9051 explicit captures. */
9052 register_capture_members (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr));
9055 /* Inside the class, surrounding template-parameter-lists do not apply. */
9056 unsigned int saved_num_template_parameter_lists
9057 = parser->num_template_parameter_lists;
9058 unsigned char in_statement = parser->in_statement;
9059 bool in_switch_statement_p = parser->in_switch_statement_p;
9060 bool fully_implicit_function_template_p
9061 = parser->fully_implicit_function_template_p;
9062 tree implicit_template_parms = parser->implicit_template_parms;
9063 cp_binding_level* implicit_template_scope = parser->implicit_template_scope;
9064 bool auto_is_implicit_function_template_parm_p
9065 = parser->auto_is_implicit_function_template_parm_p;
9067 parser->num_template_parameter_lists = 0;
9068 parser->in_statement = 0;
9069 parser->in_switch_statement_p = false;
9070 parser->fully_implicit_function_template_p = false;
9071 parser->implicit_template_parms = 0;
9072 parser->implicit_template_scope = 0;
9073 parser->auto_is_implicit_function_template_parm_p = false;
9075 /* By virtue of defining a local class, a lambda expression has access to
9076 the private variables of enclosing classes. */
9078 ok &= cp_parser_lambda_declarator_opt (parser, lambda_expr);
9082 if (!cp_parser_error_occurred (parser)
9083 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
9084 && cp_parser_start_tentative_firewall (parser))
9086 cp_parser_lambda_body (parser, lambda_expr);
9088 else if (cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
9090 if (cp_parser_skip_to_closing_brace (parser))
9091 cp_lexer_consume_token (parser->lexer);
9094 /* The capture list was built up in reverse order; fix that now. */
9095 LAMBDA_EXPR_CAPTURE_LIST (lambda_expr)
9096 = nreverse (LAMBDA_EXPR_CAPTURE_LIST (lambda_expr));
9099 maybe_add_lambda_conv_op (type);
9101 type = finish_struct (type, /*attributes=*/NULL_TREE);
9103 parser->num_template_parameter_lists = saved_num_template_parameter_lists;
9104 parser->in_statement = in_statement;
9105 parser->in_switch_statement_p = in_switch_statement_p;
9106 parser->fully_implicit_function_template_p
9107 = fully_implicit_function_template_p;
9108 parser->implicit_template_parms = implicit_template_parms;
9109 parser->implicit_template_scope = implicit_template_scope;
9110 parser->auto_is_implicit_function_template_parm_p
9111 = auto_is_implicit_function_template_parm_p;
9114 pop_deferring_access_checks ();
9116 /* This field is only used during parsing of the lambda. */
9117 LAMBDA_EXPR_THIS_CAPTURE (lambda_expr) = NULL_TREE;
9119 /* This lambda shouldn't have any proxies left at this point. */
9120 gcc_assert (LAMBDA_EXPR_PENDING_PROXIES (lambda_expr) == NULL);
9121 /* And now that we're done, push proxies for an enclosing lambda. */
9122 insert_pending_capture_proxies ();
9125 lambda_expr = build_lambda_object (lambda_expr);
9127 lambda_expr = error_mark_node;
9129 cp_parser_end_tentative_firewall (parser, start, lambda_expr);
9134 /* Parse the beginning of a lambda expression.
9137 [ lambda-capture [opt] ]
9139 LAMBDA_EXPR is the current representation of the lambda expression. */
9142 cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
9144 /* Need commas after the first capture. */
9147 /* Eat the leading `['. */
9148 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
9150 /* Record default capture mode. "[&" "[=" "[&," "[=," */
9151 if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
9152 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_NAME)
9153 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_REFERENCE;
9154 else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
9155 LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) = CPLD_COPY;
9157 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE)
9159 cp_lexer_consume_token (parser->lexer);
9163 while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
9165 cp_token* capture_token;
9167 tree capture_init_expr;
9168 cp_id_kind idk = CP_ID_KIND_NONE;
9169 bool explicit_init_p = false;
9171 enum capture_kind_type
9176 enum capture_kind_type capture_kind = BY_COPY;
9178 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
9180 error ("expected end of capture-list");
9187 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
9189 /* Possibly capture `this'. */
9190 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THIS))
9192 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
9193 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_COPY)
9194 pedwarn (loc, 0, "explicit by-copy capture of %<this%> redundant "
9195 "with by-copy capture default");
9196 cp_lexer_consume_token (parser->lexer);
9197 add_capture (lambda_expr,
9198 /*id=*/this_identifier,
9199 /*initializer=*/finish_this_expr(),
9200 /*by_reference_p=*/false,
9205 /* Remember whether we want to capture as a reference or not. */
9206 if (cp_lexer_next_token_is (parser->lexer, CPP_AND))
9208 capture_kind = BY_REFERENCE;
9209 cp_lexer_consume_token (parser->lexer);
9212 /* Get the identifier. */
9213 capture_token = cp_lexer_peek_token (parser->lexer);
9214 capture_id = cp_parser_identifier (parser);
9216 if (capture_id == error_mark_node)
9217 /* Would be nice to have a cp_parser_skip_to_closing_x for general
9218 delimiters, but I modified this to stop on unnested ']' as well. It
9219 was already changed to stop on unnested '}', so the
9220 "closing_parenthesis" name is no more misleading with my change. */
9222 cp_parser_skip_to_closing_parenthesis (parser,
9223 /*recovering=*/true,
9225 /*consume_paren=*/true);
9229 /* Find the initializer for this capture. */
9230 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
9231 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
9232 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9234 bool direct, non_constant;
9235 /* An explicit initializer exists. */
9236 if (cxx_dialect < cxx14)
9237 pedwarn (input_location, 0,
9238 "lambda capture initializers "
9239 "only available with -std=c++14 or -std=gnu++14");
9240 capture_init_expr = cp_parser_initializer (parser, &direct,
9242 explicit_init_p = true;
9243 if (capture_init_expr == NULL_TREE)
9245 error ("empty initializer for lambda init-capture");
9246 capture_init_expr = error_mark_node;
9251 const char* error_msg;
9253 /* Turn the identifier into an id-expression. */
9255 = cp_parser_lookup_name_simple (parser, capture_id,
9256 capture_token->location);
9258 if (capture_init_expr == error_mark_node)
9260 unqualified_name_lookup_error (capture_id);
9263 else if (DECL_P (capture_init_expr)
9264 && (!VAR_P (capture_init_expr)
9265 && TREE_CODE (capture_init_expr) != PARM_DECL))
9267 error_at (capture_token->location,
9268 "capture of non-variable %qD ",
9270 inform (0, "%q+#D declared here", capture_init_expr);
9273 if (VAR_P (capture_init_expr)
9274 && decl_storage_duration (capture_init_expr) != dk_auto)
9276 if (pedwarn (capture_token->location, 0, "capture of variable "
9277 "%qD with non-automatic storage duration",
9279 inform (0, "%q+#D declared here", capture_init_expr);
9284 = finish_id_expression
9289 /*integral_constant_expression_p=*/false,
9290 /*allow_non_integral_constant_expression_p=*/false,
9291 /*non_integral_constant_expression_p=*/NULL,
9292 /*template_p=*/false,
9294 /*address_p=*/false,
9295 /*template_arg_p=*/false,
9297 capture_token->location);
9299 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
9301 cp_lexer_consume_token (parser->lexer);
9302 capture_init_expr = make_pack_expansion (capture_init_expr);
9305 check_for_bare_parameter_packs (capture_init_expr);
9308 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) != CPLD_NONE
9309 && !explicit_init_p)
9311 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_COPY
9312 && capture_kind == BY_COPY)
9313 pedwarn (capture_token->location, 0, "explicit by-copy capture "
9314 "of %qD redundant with by-copy capture default",
9316 if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda_expr) == CPLD_REFERENCE
9317 && capture_kind == BY_REFERENCE)
9318 pedwarn (capture_token->location, 0, "explicit by-reference "
9319 "capture of %qD redundant with by-reference capture "
9320 "default", capture_id);
9323 add_capture (lambda_expr,
9326 /*by_reference_p=*/capture_kind == BY_REFERENCE,
9330 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
9333 /* Parse the (optional) middle of a lambda expression.
9336 < template-parameter-list [opt] >
9337 ( parameter-declaration-clause [opt] )
9338 attribute-specifier [opt]
9340 exception-specification [opt]
9341 lambda-return-type-clause [opt]
9343 LAMBDA_EXPR is the current representation of the lambda expression. */
9346 cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr)
9348 /* 5.1.1.4 of the standard says:
9349 If a lambda-expression does not include a lambda-declarator, it is as if
9350 the lambda-declarator were ().
9351 This means an empty parameter list, no attributes, and no exception
9353 tree param_list = void_list_node;
9354 tree attributes = NULL_TREE;
9355 tree exception_spec = NULL_TREE;
9356 tree template_param_list = NULL_TREE;
9358 /* The template-parameter-list is optional, but must begin with
9359 an opening angle if present. */
9360 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
9362 if (cxx_dialect < cxx14)
9363 pedwarn (parser->lexer->next_token->location, 0,
9364 "lambda templates are only available with "
9365 "-std=c++14 or -std=gnu++14");
9367 cp_lexer_consume_token (parser->lexer);
9369 template_param_list = cp_parser_template_parameter_list (parser);
9371 cp_parser_skip_to_end_of_template_parameter_list (parser);
9373 /* We just processed one more parameter list. */
9374 ++parser->num_template_parameter_lists;
9377 /* The parameter-declaration-clause is optional (unless
9378 template-parameter-list was given), but must begin with an
9379 opening parenthesis if present. */
9380 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
9382 cp_lexer_consume_token (parser->lexer);
9384 begin_scope (sk_function_parms, /*entity=*/NULL_TREE);
9386 /* Parse parameters. */
9387 param_list = cp_parser_parameter_declaration_clause (parser);
9389 /* Default arguments shall not be specified in the
9390 parameter-declaration-clause of a lambda-declarator. */
9391 for (tree t = param_list; t; t = TREE_CHAIN (t))
9392 if (TREE_PURPOSE (t) && cxx_dialect < cxx14)
9393 pedwarn (DECL_SOURCE_LOCATION (TREE_VALUE (t)), OPT_Wpedantic,
9394 "default argument specified for lambda parameter");
9396 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
9398 attributes = cp_parser_attributes_opt (parser);
9400 /* Parse optional `mutable' keyword. */
9401 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_MUTABLE))
9403 cp_lexer_consume_token (parser->lexer);
9404 LAMBDA_EXPR_MUTABLE_P (lambda_expr) = 1;
9407 /* Parse optional exception specification. */
9408 exception_spec = cp_parser_exception_specification_opt (parser);
9410 /* Parse optional trailing return type. */
9411 if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
9413 cp_lexer_consume_token (parser->lexer);
9414 LAMBDA_EXPR_RETURN_TYPE (lambda_expr)
9415 = cp_parser_trailing_type_id (parser);
9418 /* The function parameters must be in scope all the way until after the
9419 trailing-return-type in case of decltype. */
9420 pop_bindings_and_leave_scope ();
9422 else if (template_param_list != NULL_TREE) // generate diagnostic
9423 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
9425 /* Create the function call operator.
9427 Messing with declarators like this is no uglier than building up the
9428 FUNCTION_DECL by hand, and this is less likely to get out of sync with
9431 cp_decl_specifier_seq return_type_specs;
9432 cp_declarator* declarator;
9437 clear_decl_specs (&return_type_specs);
9438 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
9439 return_type_specs.type = LAMBDA_EXPR_RETURN_TYPE (lambda_expr);
9441 /* Maybe we will deduce the return type later. */
9442 return_type_specs.type = make_auto ();
9444 p = obstack_alloc (&declarator_obstack, 0);
9446 declarator = make_id_declarator (NULL_TREE, ansi_opname (CALL_EXPR),
9449 quals = (LAMBDA_EXPR_MUTABLE_P (lambda_expr)
9450 ? TYPE_UNQUALIFIED : TYPE_QUAL_CONST);
9451 declarator = make_call_declarator (declarator, param_list, quals,
9452 VIRT_SPEC_UNSPECIFIED,
9455 /*late_return_type=*/NULL_TREE);
9456 declarator->id_loc = LAMBDA_EXPR_LOCATION (lambda_expr);
9458 fco = grokmethod (&return_type_specs,
9461 if (fco != error_mark_node)
9463 DECL_INITIALIZED_IN_CLASS_P (fco) = 1;
9464 DECL_ARTIFICIAL (fco) = 1;
9465 /* Give the object parameter a different name. */
9466 DECL_NAME (DECL_ARGUMENTS (fco)) = get_identifier ("__closure");
9467 if (LAMBDA_EXPR_RETURN_TYPE (lambda_expr))
9468 TYPE_HAS_LATE_RETURN_TYPE (TREE_TYPE (fco)) = 1;
9470 if (template_param_list)
9472 fco = finish_member_template_decl (fco);
9473 finish_template_decl (template_param_list);
9474 --parser->num_template_parameter_lists;
9476 else if (parser->fully_implicit_function_template_p)
9477 fco = finish_fully_implicit_template (parser, fco);
9479 finish_member_declaration (fco);
9481 obstack_free (&declarator_obstack, p);
9483 return (fco != error_mark_node);
9487 /* Parse the body of a lambda expression, which is simply
9491 but which requires special handling.
9492 LAMBDA_EXPR is the current representation of the lambda expression. */
9495 cp_parser_lambda_body (cp_parser* parser, tree lambda_expr)
9497 bool nested = (current_function_decl != NULL_TREE);
9498 bool local_variables_forbidden_p = parser->local_variables_forbidden_p;
9500 push_function_context ();
9502 /* Still increment function_depth so that we don't GC in the
9503 middle of an expression. */
9505 /* Clear this in case we're in the middle of a default argument. */
9506 parser->local_variables_forbidden_p = false;
9508 /* Finish the function call operator
9510 + late_parsing_for_member
9511 + function_definition_after_declarator
9512 + ctor_initializer_opt_and_function_body */
9514 tree fco = lambda_function (lambda_expr);
9520 /* Let the front end know that we are going to be defining this
9522 start_preparsed_function (fco,
9524 SF_PRE_PARSED | SF_INCLASS_INLINE);
9526 start_lambda_scope (fco);
9527 body = begin_function_body ();
9529 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
9532 /* Push the proxies for any explicit captures. */
9533 for (cap = LAMBDA_EXPR_CAPTURE_LIST (lambda_expr); cap;
9534 cap = TREE_CHAIN (cap))
9535 build_capture_proxy (TREE_PURPOSE (cap));
9537 compound_stmt = begin_compound_stmt (0);
9539 /* 5.1.1.4 of the standard says:
9540 If a lambda-expression does not include a trailing-return-type, it
9541 is as if the trailing-return-type denotes the following type:
9542 * if the compound-statement is of the form
9543 { return attribute-specifier [opt] expression ; }
9544 the type of the returned expression after lvalue-to-rvalue
9545 conversion (_conv.lval_ 4.1), array-to-pointer conversion
9546 (_conv.array_ 4.2), and function-to-pointer conversion
9548 * otherwise, void. */
9550 /* In a lambda that has neither a lambda-return-type-clause
9551 nor a deducible form, errors should be reported for return statements
9552 in the body. Since we used void as the placeholder return type, parsing
9553 the body as usual will give such desired behavior. */
9554 if (!LAMBDA_EXPR_RETURN_TYPE (lambda_expr)
9555 && cp_lexer_peek_nth_token (parser->lexer, 1)->keyword == RID_RETURN
9556 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SEMICOLON)
9558 tree expr = NULL_TREE;
9559 cp_id_kind idk = CP_ID_KIND_NONE;
9561 /* Parse tentatively in case there's more after the initial return
9563 cp_parser_parse_tentatively (parser);
9565 cp_parser_require_keyword (parser, RID_RETURN, RT_RETURN);
9567 expr = cp_parser_expression (parser, &idk);
9569 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9570 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
9572 if (cp_parser_parse_definitely (parser))
9574 if (!processing_template_decl)
9575 apply_deduced_return_type (fco, lambda_return_type (expr));
9577 /* Will get error here if type not deduced yet. */
9578 finish_return_stmt (expr);
9586 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
9587 cp_parser_label_declaration (parser);
9588 cp_parser_statement_seq_opt (parser, NULL_TREE);
9589 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
9592 finish_compound_stmt (compound_stmt);
9595 finish_function_body (body);
9596 finish_lambda_scope ();
9598 /* Finish the function and generate code for it if necessary. */
9599 tree fn = finish_function (/*inline*/2);
9601 /* Only expand if the call op is not a template. */
9602 if (!DECL_TEMPLATE_INFO (fco))
9603 expand_or_defer_fn (fn);
9606 parser->local_variables_forbidden_p = local_variables_forbidden_p;
9608 pop_function_context();
9613 /* Statements [gram.stmt.stmt] */
9615 /* Parse a statement.
9619 expression-statement
9624 declaration-statement
9631 attribute-specifier-seq (opt) expression-statement
9632 attribute-specifier-seq (opt) compound-statement
9633 attribute-specifier-seq (opt) selection-statement
9634 attribute-specifier-seq (opt) iteration-statement
9635 attribute-specifier-seq (opt) jump-statement
9636 declaration-statement
9637 attribute-specifier-seq (opt) try-block
9644 IN_COMPOUND is true when the statement is nested inside a
9645 cp_parser_compound_statement; this matters for certain pragmas.
9647 If IF_P is not NULL, *IF_P is set to indicate whether the statement
9648 is a (possibly labeled) if statement which is not enclosed in braces
9649 and has an else clause. This is used to implement -Wparentheses. */
9652 cp_parser_statement (cp_parser* parser, tree in_statement_expr,
9653 bool in_compound, bool *if_p)
9655 tree statement, std_attrs = NULL_TREE;
9657 location_t statement_location, attrs_location;
9662 /* There is no statement yet. */
9663 statement = NULL_TREE;
9665 saved_token_sentinel saved_tokens (parser->lexer);
9666 attrs_location = cp_lexer_peek_token (parser->lexer)->location;
9667 if (c_dialect_objc ())
9668 /* In obj-c++, seeing '[[' might be the either the beginning of
9669 c++11 attributes, or a nested objc-message-expression. So
9670 let's parse the c++11 attributes tentatively. */
9671 cp_parser_parse_tentatively (parser);
9672 std_attrs = cp_parser_std_attribute_spec_seq (parser);
9673 if (c_dialect_objc ())
9675 if (!cp_parser_parse_definitely (parser))
9676 std_attrs = NULL_TREE;
9679 /* Peek at the next token. */
9680 token = cp_lexer_peek_token (parser->lexer);
9681 /* Remember the location of the first token in the statement. */
9682 statement_location = token->location;
9683 /* If this is a keyword, then that will often determine what kind of
9684 statement we have. */
9685 if (token->type == CPP_KEYWORD)
9687 enum rid keyword = token->keyword;
9693 /* Looks like a labeled-statement with a case label.
9694 Parse the label, and then use tail recursion to parse
9696 cp_parser_label_for_labeled_statement (parser, std_attrs);
9701 statement = cp_parser_selection_statement (parser, if_p);
9707 statement = cp_parser_iteration_statement (parser, false);
9713 error_at (cp_lexer_peek_token (parser->lexer)->location,
9714 "-fcilkplus must be enabled to use %<_Cilk_for%>");
9715 cp_lexer_consume_token (parser->lexer);
9716 statement = error_mark_node;
9719 statement = cp_parser_cilk_for (parser, integer_zero_node);
9726 statement = cp_parser_jump_statement (parser);
9730 cp_lexer_consume_token (parser->lexer);
9733 tree sync_expr = build_cilk_sync ();
9734 SET_EXPR_LOCATION (sync_expr,
9736 statement = finish_expr_stmt (sync_expr);
9740 error_at (token->location, "-fcilkplus must be enabled to use"
9742 statement = error_mark_node;
9744 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
9747 /* Objective-C++ exception-handling constructs. */
9750 case RID_AT_FINALLY:
9751 case RID_AT_SYNCHRONIZED:
9753 statement = cp_parser_objc_statement (parser);
9757 statement = cp_parser_try_block (parser);
9761 /* This must be a namespace alias definition. */
9762 cp_parser_declaration_statement (parser);
9765 case RID_TRANSACTION_ATOMIC:
9766 case RID_TRANSACTION_RELAXED:
9767 statement = cp_parser_transaction (parser, keyword);
9769 case RID_TRANSACTION_CANCEL:
9770 statement = cp_parser_transaction_cancel (parser);
9774 /* It might be a keyword like `int' that can start a
9775 declaration-statement. */
9779 else if (token->type == CPP_NAME)
9781 /* If the next token is a `:', then we are looking at a
9782 labeled-statement. */
9783 token = cp_lexer_peek_nth_token (parser->lexer, 2);
9784 if (token->type == CPP_COLON)
9786 /* Looks like a labeled-statement with an ordinary label.
9787 Parse the label, and then use tail recursion to parse
9790 cp_parser_label_for_labeled_statement (parser, std_attrs);
9794 /* Anything that starts with a `{' must be a compound-statement. */
9795 else if (token->type == CPP_OPEN_BRACE)
9796 statement = cp_parser_compound_statement (parser, NULL, false, false);
9797 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
9798 a statement all its own. */
9799 else if (token->type == CPP_PRAGMA)
9801 /* Only certain OpenMP pragmas are attached to statements, and thus
9802 are considered statements themselves. All others are not. In
9803 the context of a compound, accept the pragma as a "statement" and
9804 return so that we can check for a close brace. Otherwise we
9805 require a real statement and must go back and read one. */
9807 cp_parser_pragma (parser, pragma_compound);
9808 else if (!cp_parser_pragma (parser, pragma_stmt))
9812 else if (token->type == CPP_EOF)
9814 cp_parser_error (parser, "expected statement");
9818 /* Everything else must be a declaration-statement or an
9819 expression-statement. Try for the declaration-statement
9820 first, unless we are looking at a `;', in which case we know that
9821 we have an expression-statement. */
9824 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
9826 if (std_attrs != NULL_TREE)
9828 /* Attributes should be parsed as part of the the
9829 declaration, so let's un-parse them. */
9830 saved_tokens.rollback();
9831 std_attrs = NULL_TREE;
9834 cp_parser_parse_tentatively (parser);
9835 /* Try to parse the declaration-statement. */
9836 cp_parser_declaration_statement (parser);
9837 /* If that worked, we're done. */
9838 if (cp_parser_parse_definitely (parser))
9841 /* Look for an expression-statement instead. */
9842 statement = cp_parser_expression_statement (parser, in_statement_expr);
9845 /* Set the line number for the statement. */
9846 if (statement && STATEMENT_CODE_P (TREE_CODE (statement)))
9847 SET_EXPR_LOCATION (statement, statement_location);
9849 /* Note that for now, we don't do anything with c++11 statements
9850 parsed at this level. */
9851 if (std_attrs != NULL_TREE)
9852 warning_at (attrs_location,
9854 "attributes at the beginning of statement are ignored");
9857 /* Parse the label for a labeled-statement, i.e.
9860 case constant-expression :
9864 case constant-expression ... constant-expression : statement
9866 When a label is parsed without errors, the label is added to the
9867 parse tree by the finish_* functions, so this function doesn't
9868 have to return the label. */
9871 cp_parser_label_for_labeled_statement (cp_parser* parser, tree attributes)
9874 tree label = NULL_TREE;
9875 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
9877 /* The next token should be an identifier. */
9878 token = cp_lexer_peek_token (parser->lexer);
9879 if (token->type != CPP_NAME
9880 && token->type != CPP_KEYWORD)
9882 cp_parser_error (parser, "expected labeled-statement");
9886 parser->colon_corrects_to_scope_p = false;
9887 switch (token->keyword)
9894 /* Consume the `case' token. */
9895 cp_lexer_consume_token (parser->lexer);
9896 /* Parse the constant-expression. */
9897 expr = cp_parser_constant_expression (parser);
9898 if (check_for_bare_parameter_packs (expr))
9899 expr = error_mark_node;
9901 ellipsis = cp_lexer_peek_token (parser->lexer);
9902 if (ellipsis->type == CPP_ELLIPSIS)
9904 /* Consume the `...' token. */
9905 cp_lexer_consume_token (parser->lexer);
9906 expr_hi = cp_parser_constant_expression (parser);
9907 if (check_for_bare_parameter_packs (expr_hi))
9908 expr_hi = error_mark_node;
9910 /* We don't need to emit warnings here, as the common code
9911 will do this for us. */
9914 expr_hi = NULL_TREE;
9916 if (parser->in_switch_statement_p)
9917 finish_case_label (token->location, expr, expr_hi);
9919 error_at (token->location,
9920 "case label %qE not within a switch statement",
9926 /* Consume the `default' token. */
9927 cp_lexer_consume_token (parser->lexer);
9929 if (parser->in_switch_statement_p)
9930 finish_case_label (token->location, NULL_TREE, NULL_TREE);
9932 error_at (token->location, "case label not within a switch statement");
9936 /* Anything else must be an ordinary label. */
9937 label = finish_label_stmt (cp_parser_identifier (parser));
9941 /* Require the `:' token. */
9942 cp_parser_require (parser, CPP_COLON, RT_COLON);
9944 /* An ordinary label may optionally be followed by attributes.
9945 However, this is only permitted if the attributes are then
9946 followed by a semicolon. This is because, for backward
9947 compatibility, when parsing
9948 lab: __attribute__ ((unused)) int i;
9949 we want the attribute to attach to "i", not "lab". */
9950 if (label != NULL_TREE
9951 && cp_next_tokens_can_be_gnu_attribute_p (parser))
9954 cp_parser_parse_tentatively (parser);
9955 attrs = cp_parser_gnu_attributes_opt (parser);
9956 if (attrs == NULL_TREE
9957 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
9958 cp_parser_abort_tentative_parse (parser);
9959 else if (!cp_parser_parse_definitely (parser))
9962 attributes = chainon (attributes, attrs);
9965 if (attributes != NULL_TREE)
9966 cplus_decl_attributes (&label, attributes, 0);
9968 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
9971 /* Parse an expression-statement.
9973 expression-statement:
9976 Returns the new EXPR_STMT -- or NULL_TREE if the expression
9977 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
9978 indicates whether this expression-statement is part of an
9979 expression statement. */
9982 cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
9984 tree statement = NULL_TREE;
9985 cp_token *token = cp_lexer_peek_token (parser->lexer);
9987 /* If the next token is a ';', then there is no expression
9989 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
9991 statement = cp_parser_expression (parser);
9992 if (statement == error_mark_node
9993 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
9995 cp_parser_skip_to_end_of_block_or_statement (parser);
9996 return error_mark_node;
10000 /* Give a helpful message for "A<T>::type t;" and the like. */
10001 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
10002 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
10004 if (TREE_CODE (statement) == SCOPE_REF)
10005 error_at (token->location, "need %<typename%> before %qE because "
10006 "%qT is a dependent scope",
10007 statement, TREE_OPERAND (statement, 0));
10008 else if (is_overloaded_fn (statement)
10009 && DECL_CONSTRUCTOR_P (get_first_fn (statement)))
10012 tree fn = get_first_fn (statement);
10013 error_at (token->location,
10014 "%<%T::%D%> names the constructor, not the type",
10015 DECL_CONTEXT (fn), DECL_NAME (fn));
10019 /* Consume the final `;'. */
10020 cp_parser_consume_semicolon_at_end_of_statement (parser);
10022 if (in_statement_expr
10023 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
10024 /* This is the final expression statement of a statement
10026 statement = finish_stmt_expr_expr (statement, in_statement_expr);
10027 else if (statement)
10028 statement = finish_expr_stmt (statement);
10033 /* Parse a compound-statement.
10035 compound-statement:
10036 { statement-seq [opt] }
10040 compound-statement:
10041 { label-declaration-seq [opt] statement-seq [opt] }
10043 label-declaration-seq:
10045 label-declaration-seq label-declaration
10047 Returns a tree representing the statement. */
10050 cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
10051 bool in_try, bool function_body)
10053 tree compound_stmt;
10055 /* Consume the `{'. */
10056 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
10057 return error_mark_node;
10058 if (DECL_DECLARED_CONSTEXPR_P (current_function_decl)
10059 && !function_body && cxx_dialect < cxx14)
10060 pedwarn (input_location, OPT_Wpedantic,
10061 "compound-statement in constexpr function");
10062 /* Begin the compound-statement. */
10063 compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0);
10064 /* If the next keyword is `__label__' we have a label declaration. */
10065 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
10066 cp_parser_label_declaration (parser);
10067 /* Parse an (optional) statement-seq. */
10068 cp_parser_statement_seq_opt (parser, in_statement_expr);
10069 /* Finish the compound-statement. */
10070 finish_compound_stmt (compound_stmt);
10071 /* Consume the `}'. */
10072 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
10074 return compound_stmt;
10077 /* Parse an (optional) statement-seq.
10081 statement-seq [opt] statement */
10084 cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
10086 /* Scan statements until there aren't any more. */
10089 cp_token *token = cp_lexer_peek_token (parser->lexer);
10091 /* If we are looking at a `}', then we have run out of
10092 statements; the same is true if we have reached the end
10093 of file, or have stumbled upon a stray '@end'. */
10094 if (token->type == CPP_CLOSE_BRACE
10095 || token->type == CPP_EOF
10096 || token->type == CPP_PRAGMA_EOL
10097 || (token->type == CPP_KEYWORD && token->keyword == RID_AT_END))
10100 /* If we are in a compound statement and find 'else' then
10101 something went wrong. */
10102 else if (token->type == CPP_KEYWORD && token->keyword == RID_ELSE)
10104 if (parser->in_statement & IN_IF_STMT)
10108 token = cp_lexer_consume_token (parser->lexer);
10109 error_at (token->location, "%<else%> without a previous %<if%>");
10113 /* Parse the statement. */
10114 cp_parser_statement (parser, in_statement_expr, true, NULL);
10118 /* Parse a selection-statement.
10120 selection-statement:
10121 if ( condition ) statement
10122 if ( condition ) statement else statement
10123 switch ( condition ) statement
10125 Returns the new IF_STMT or SWITCH_STMT.
10127 If IF_P is not NULL, *IF_P is set to indicate whether the statement
10128 is a (possibly labeled) if statement which is not enclosed in
10129 braces and has an else clause. This is used to implement
10133 cp_parser_selection_statement (cp_parser* parser, bool *if_p)
10141 /* Peek at the next token. */
10142 token = cp_parser_require (parser, CPP_KEYWORD, RT_SELECT);
10144 /* See what kind of keyword it is. */
10145 keyword = token->keyword;
10154 /* Look for the `('. */
10155 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
10157 cp_parser_skip_to_end_of_statement (parser);
10158 return error_mark_node;
10161 /* Begin the selection-statement. */
10162 if (keyword == RID_IF)
10163 statement = begin_if_stmt ();
10165 statement = begin_switch_stmt ();
10167 /* Parse the condition. */
10168 condition = cp_parser_condition (parser);
10169 /* Look for the `)'. */
10170 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
10171 cp_parser_skip_to_closing_parenthesis (parser, true, false,
10172 /*consume_paren=*/true);
10174 if (keyword == RID_IF)
10177 unsigned char in_statement;
10179 /* Add the condition. */
10180 finish_if_stmt_cond (condition, statement);
10182 /* Parse the then-clause. */
10183 in_statement = parser->in_statement;
10184 parser->in_statement |= IN_IF_STMT;
10185 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
10187 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10188 add_stmt (build_empty_stmt (loc));
10189 cp_lexer_consume_token (parser->lexer);
10190 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
10191 warning_at (loc, OPT_Wempty_body, "suggest braces around "
10192 "empty body in an %<if%> statement");
10196 cp_parser_implicitly_scoped_statement (parser, &nested_if);
10197 parser->in_statement = in_statement;
10199 finish_then_clause (statement);
10201 /* If the next token is `else', parse the else-clause. */
10202 if (cp_lexer_next_token_is_keyword (parser->lexer,
10205 /* Consume the `else' keyword. */
10206 cp_lexer_consume_token (parser->lexer);
10207 begin_else_clause (statement);
10208 /* Parse the else-clause. */
10209 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
10212 loc = cp_lexer_peek_token (parser->lexer)->location;
10214 OPT_Wempty_body, "suggest braces around "
10215 "empty body in an %<else%> statement");
10216 add_stmt (build_empty_stmt (loc));
10217 cp_lexer_consume_token (parser->lexer);
10220 cp_parser_implicitly_scoped_statement (parser, NULL);
10222 finish_else_clause (statement);
10224 /* If we are currently parsing a then-clause, then
10225 IF_P will not be NULL. We set it to true to
10226 indicate that this if statement has an else clause.
10227 This may trigger the Wparentheses warning below
10228 when we get back up to the parent if statement. */
10234 /* This if statement does not have an else clause. If
10235 NESTED_IF is true, then the then-clause is an if
10236 statement which does have an else clause. We warn
10237 about the potential ambiguity. */
10239 warning_at (EXPR_LOCATION (statement), OPT_Wparentheses,
10240 "suggest explicit braces to avoid ambiguous"
10244 /* Now we're all done with the if-statement. */
10245 finish_if_stmt (statement);
10249 bool in_switch_statement_p;
10250 unsigned char in_statement;
10252 /* Add the condition. */
10253 finish_switch_cond (condition, statement);
10255 /* Parse the body of the switch-statement. */
10256 in_switch_statement_p = parser->in_switch_statement_p;
10257 in_statement = parser->in_statement;
10258 parser->in_switch_statement_p = true;
10259 parser->in_statement |= IN_SWITCH_STMT;
10260 cp_parser_implicitly_scoped_statement (parser, NULL);
10261 parser->in_switch_statement_p = in_switch_statement_p;
10262 parser->in_statement = in_statement;
10264 /* Now we're all done with the switch-statement. */
10265 finish_switch_stmt (statement);
10273 cp_parser_error (parser, "expected selection-statement");
10274 return error_mark_node;
10278 /* Parse a condition.
10282 type-specifier-seq declarator = initializer-clause
10283 type-specifier-seq declarator braced-init-list
10288 type-specifier-seq declarator asm-specification [opt]
10289 attributes [opt] = assignment-expression
10291 Returns the expression that should be tested. */
10294 cp_parser_condition (cp_parser* parser)
10296 cp_decl_specifier_seq type_specifiers;
10297 const char *saved_message;
10298 int declares_class_or_enum;
10300 /* Try the declaration first. */
10301 cp_parser_parse_tentatively (parser);
10302 /* New types are not allowed in the type-specifier-seq for a
10304 saved_message = parser->type_definition_forbidden_message;
10305 parser->type_definition_forbidden_message
10306 = G_("types may not be defined in conditions");
10307 /* Parse the type-specifier-seq. */
10308 cp_parser_decl_specifier_seq (parser,
10309 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
10311 &declares_class_or_enum);
10312 /* Restore the saved message. */
10313 parser->type_definition_forbidden_message = saved_message;
10314 /* If all is well, we might be looking at a declaration. */
10315 if (!cp_parser_error_occurred (parser))
10318 tree asm_specification;
10320 cp_declarator *declarator;
10321 tree initializer = NULL_TREE;
10323 /* Parse the declarator. */
10324 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
10325 /*ctor_dtor_or_conv_p=*/NULL,
10326 /*parenthesized_p=*/NULL,
10327 /*member_p=*/false,
10328 /*friend_p=*/false);
10329 /* Parse the attributes. */
10330 attributes = cp_parser_attributes_opt (parser);
10331 /* Parse the asm-specification. */
10332 asm_specification = cp_parser_asm_specification_opt (parser);
10333 /* If the next token is not an `=' or '{', then we might still be
10334 looking at an expression. For example:
10338 looks like a decl-specifier-seq and a declarator -- but then
10339 there is no `=', so this is an expression. */
10340 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
10341 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
10342 cp_parser_simulate_error (parser);
10344 /* If we did see an `=' or '{', then we are looking at a declaration
10346 if (cp_parser_parse_definitely (parser))
10349 bool non_constant_p;
10350 bool flags = LOOKUP_ONLYCONVERTING;
10352 /* Create the declaration. */
10353 decl = start_decl (declarator, &type_specifiers,
10354 /*initialized_p=*/true,
10355 attributes, /*prefix_attributes=*/NULL_TREE,
10358 /* Parse the initializer. */
10359 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10361 initializer = cp_parser_braced_list (parser, &non_constant_p);
10362 CONSTRUCTOR_IS_DIRECT_INIT (initializer) = 1;
10367 /* Consume the `='. */
10368 cp_parser_require (parser, CPP_EQ, RT_EQ);
10369 initializer = cp_parser_initializer_clause (parser, &non_constant_p);
10371 if (BRACE_ENCLOSED_INITIALIZER_P (initializer))
10372 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
10374 /* Process the initializer. */
10375 cp_finish_decl (decl,
10376 initializer, !non_constant_p,
10381 pop_scope (pushed_scope);
10383 return convert_from_reference (decl);
10386 /* If we didn't even get past the declarator successfully, we are
10387 definitely not looking at a declaration. */
10389 cp_parser_abort_tentative_parse (parser);
10391 /* Otherwise, we are looking at an expression. */
10392 return cp_parser_expression (parser);
10395 /* Parses a for-statement or range-for-statement until the closing ')',
10399 cp_parser_for (cp_parser *parser, bool ivdep)
10401 tree init, scope, decl;
10404 /* Begin the for-statement. */
10405 scope = begin_for_scope (&init);
10407 /* Parse the initialization. */
10408 is_range_for = cp_parser_for_init_statement (parser, &decl);
10411 return cp_parser_range_for (parser, scope, init, decl, ivdep);
10413 return cp_parser_c_for (parser, scope, init, ivdep);
10417 cp_parser_c_for (cp_parser *parser, tree scope, tree init, bool ivdep)
10419 /* Normal for loop */
10420 tree condition = NULL_TREE;
10421 tree expression = NULL_TREE;
10424 stmt = begin_for_stmt (scope, init);
10425 /* The for-init-statement has already been parsed in
10426 cp_parser_for_init_statement, so no work is needed here. */
10427 finish_for_init_stmt (stmt);
10429 /* If there's a condition, process it. */
10430 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
10431 condition = cp_parser_condition (parser);
10434 cp_parser_error (parser, "missing loop condition in loop with "
10435 "%<GCC ivdep%> pragma");
10436 condition = error_mark_node;
10438 finish_for_cond (condition, stmt, ivdep);
10439 /* Look for the `;'. */
10440 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
10442 /* If there's an expression, process it. */
10443 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
10444 expression = cp_parser_expression (parser);
10445 finish_for_expr (expression, stmt);
10450 /* Tries to parse a range-based for-statement:
10453 decl-specifier-seq declarator : expression
10455 The decl-specifier-seq declarator and the `:' are already parsed by
10456 cp_parser_for_init_statement. If processing_template_decl it returns a
10457 newly created RANGE_FOR_STMT; if not, it is converted to a
10458 regular FOR_STMT. */
10461 cp_parser_range_for (cp_parser *parser, tree scope, tree init, tree range_decl,
10464 tree stmt, range_expr;
10466 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10468 bool expr_non_constant_p;
10469 range_expr = cp_parser_braced_list (parser, &expr_non_constant_p);
10472 range_expr = cp_parser_expression (parser);
10474 /* If in template, STMT is converted to a normal for-statement
10475 at instantiation. If not, it is done just ahead. */
10476 if (processing_template_decl)
10478 if (check_for_bare_parameter_packs (range_expr))
10479 range_expr = error_mark_node;
10480 stmt = begin_range_for_stmt (scope, init);
10482 RANGE_FOR_IVDEP (stmt) = 1;
10483 finish_range_for_decl (stmt, range_decl, range_expr);
10484 if (!type_dependent_expression_p (range_expr)
10485 /* do_auto_deduction doesn't mess with template init-lists. */
10486 && !BRACE_ENCLOSED_INITIALIZER_P (range_expr))
10487 do_range_for_auto_deduction (range_decl, range_expr);
10491 stmt = begin_for_stmt (scope, init);
10492 stmt = cp_convert_range_for (stmt, range_decl, range_expr, ivdep);
10497 /* Subroutine of cp_convert_range_for: given the initializer expression,
10498 builds up the range temporary. */
10501 build_range_temp (tree range_expr)
10503 tree range_type, range_temp;
10505 /* Find out the type deduced by the declaration
10506 `auto &&__range = range_expr'. */
10507 range_type = cp_build_reference_type (make_auto (), true);
10508 range_type = do_auto_deduction (range_type, range_expr,
10509 type_uses_auto (range_type));
10511 /* Create the __range variable. */
10512 range_temp = build_decl (input_location, VAR_DECL,
10513 get_identifier ("__for_range"), range_type);
10514 TREE_USED (range_temp) = 1;
10515 DECL_ARTIFICIAL (range_temp) = 1;
10520 /* Used by cp_parser_range_for in template context: we aren't going to
10521 do a full conversion yet, but we still need to resolve auto in the
10522 type of the for-range-declaration if present. This is basically
10523 a shortcut version of cp_convert_range_for. */
10526 do_range_for_auto_deduction (tree decl, tree range_expr)
10528 tree auto_node = type_uses_auto (TREE_TYPE (decl));
10531 tree begin_dummy, end_dummy, range_temp, iter_type, iter_decl;
10532 range_temp = convert_from_reference (build_range_temp (range_expr));
10533 iter_type = (cp_parser_perform_range_for_lookup
10534 (range_temp, &begin_dummy, &end_dummy));
10537 iter_decl = build_decl (input_location, VAR_DECL, NULL_TREE,
10539 iter_decl = build_x_indirect_ref (input_location, iter_decl, RO_NULL,
10540 tf_warning_or_error);
10541 TREE_TYPE (decl) = do_auto_deduction (TREE_TYPE (decl),
10542 iter_decl, auto_node);
10547 /* Converts a range-based for-statement into a normal
10548 for-statement, as per the definition.
10550 for (RANGE_DECL : RANGE_EXPR)
10553 should be equivalent to:
10556 auto &&__range = RANGE_EXPR;
10557 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
10561 RANGE_DECL = *__begin;
10566 If RANGE_EXPR is an array:
10567 BEGIN_EXPR = __range
10568 END_EXPR = __range + ARRAY_SIZE(__range)
10569 Else if RANGE_EXPR has a member 'begin' or 'end':
10570 BEGIN_EXPR = __range.begin()
10571 END_EXPR = __range.end()
10573 BEGIN_EXPR = begin(__range)
10574 END_EXPR = end(__range);
10576 If __range has a member 'begin' but not 'end', or vice versa, we must
10577 still use the second alternative (it will surely fail, however).
10578 When calling begin()/end() in the third alternative we must use
10579 argument dependent lookup, but always considering 'std' as an associated
10583 cp_convert_range_for (tree statement, tree range_decl, tree range_expr,
10587 tree iter_type, begin_expr, end_expr;
10588 tree condition, expression;
10590 if (range_decl == error_mark_node || range_expr == error_mark_node)
10591 /* If an error happened previously do nothing or else a lot of
10592 unhelpful errors would be issued. */
10593 begin_expr = end_expr = iter_type = error_mark_node;
10598 if (TREE_CODE (range_expr) == VAR_DECL
10599 && array_of_runtime_bound_p (TREE_TYPE (range_expr)))
10600 /* Can't bind a reference to an array of runtime bound. */
10601 range_temp = range_expr;
10604 range_temp = build_range_temp (range_expr);
10605 pushdecl (range_temp);
10606 cp_finish_decl (range_temp, range_expr,
10607 /*is_constant_init*/false, NULL_TREE,
10608 LOOKUP_ONLYCONVERTING);
10609 range_temp = convert_from_reference (range_temp);
10611 iter_type = cp_parser_perform_range_for_lookup (range_temp,
10612 &begin_expr, &end_expr);
10615 /* The new for initialization statement. */
10616 begin = build_decl (input_location, VAR_DECL,
10617 get_identifier ("__for_begin"), iter_type);
10618 TREE_USED (begin) = 1;
10619 DECL_ARTIFICIAL (begin) = 1;
10621 cp_finish_decl (begin, begin_expr,
10622 /*is_constant_init*/false, NULL_TREE,
10623 LOOKUP_ONLYCONVERTING);
10625 end = build_decl (input_location, VAR_DECL,
10626 get_identifier ("__for_end"), iter_type);
10627 TREE_USED (end) = 1;
10628 DECL_ARTIFICIAL (end) = 1;
10630 cp_finish_decl (end, end_expr,
10631 /*is_constant_init*/false, NULL_TREE,
10632 LOOKUP_ONLYCONVERTING);
10634 finish_for_init_stmt (statement);
10636 /* The new for condition. */
10637 condition = build_x_binary_op (input_location, NE_EXPR,
10640 NULL, tf_warning_or_error);
10641 finish_for_cond (condition, statement, ivdep);
10643 /* The new increment expression. */
10644 expression = finish_unary_op_expr (input_location,
10645 PREINCREMENT_EXPR, begin,
10646 tf_warning_or_error);
10647 finish_for_expr (expression, statement);
10649 /* The declaration is initialized with *__begin inside the loop body. */
10650 cp_finish_decl (range_decl,
10651 build_x_indirect_ref (input_location, begin, RO_NULL,
10652 tf_warning_or_error),
10653 /*is_constant_init*/false, NULL_TREE,
10654 LOOKUP_ONLYCONVERTING);
10659 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
10660 We need to solve both at the same time because the method used
10661 depends on the existence of members begin or end.
10662 Returns the type deduced for the iterator expression. */
10665 cp_parser_perform_range_for_lookup (tree range, tree *begin, tree *end)
10667 if (error_operand_p (range))
10669 *begin = *end = error_mark_node;
10670 return error_mark_node;
10673 if (!COMPLETE_TYPE_P (complete_type (TREE_TYPE (range))))
10675 error ("range-based %<for%> expression of type %qT "
10676 "has incomplete type", TREE_TYPE (range));
10677 *begin = *end = error_mark_node;
10678 return error_mark_node;
10680 if (TREE_CODE (TREE_TYPE (range)) == ARRAY_TYPE)
10682 /* If RANGE is an array, we will use pointer arithmetic. */
10684 *end = build_binary_op (input_location, PLUS_EXPR,
10686 array_type_nelts_top (TREE_TYPE (range)),
10688 return build_pointer_type (TREE_TYPE (TREE_TYPE (range)));
10692 /* If it is not an array, we must do a bit of magic. */
10693 tree id_begin, id_end;
10694 tree member_begin, member_end;
10696 *begin = *end = error_mark_node;
10698 id_begin = get_identifier ("begin");
10699 id_end = get_identifier ("end");
10700 member_begin = lookup_member (TREE_TYPE (range), id_begin,
10701 /*protect=*/2, /*want_type=*/false,
10702 tf_warning_or_error);
10703 member_end = lookup_member (TREE_TYPE (range), id_end,
10704 /*protect=*/2, /*want_type=*/false,
10705 tf_warning_or_error);
10707 if (member_begin != NULL_TREE || member_end != NULL_TREE)
10709 /* Use the member functions. */
10710 if (member_begin != NULL_TREE)
10711 *begin = cp_parser_range_for_member_function (range, id_begin);
10713 error ("range-based %<for%> expression of type %qT has an "
10714 "%<end%> member but not a %<begin%>", TREE_TYPE (range));
10716 if (member_end != NULL_TREE)
10717 *end = cp_parser_range_for_member_function (range, id_end);
10719 error ("range-based %<for%> expression of type %qT has a "
10720 "%<begin%> member but not an %<end%>", TREE_TYPE (range));
10724 /* Use global functions with ADL. */
10725 vec<tree, va_gc> *vec;
10726 vec = make_tree_vector ();
10728 vec_safe_push (vec, range);
10730 member_begin = perform_koenig_lookup (id_begin, vec,
10731 tf_warning_or_error);
10732 *begin = finish_call_expr (member_begin, &vec, false, true,
10733 tf_warning_or_error);
10734 member_end = perform_koenig_lookup (id_end, vec,
10735 tf_warning_or_error);
10736 *end = finish_call_expr (member_end, &vec, false, true,
10737 tf_warning_or_error);
10739 release_tree_vector (vec);
10742 /* Last common checks. */
10743 if (*begin == error_mark_node || *end == error_mark_node)
10745 /* If one of the expressions is an error do no more checks. */
10746 *begin = *end = error_mark_node;
10747 return error_mark_node;
10749 else if (type_dependent_expression_p (*begin)
10750 || type_dependent_expression_p (*end))
10751 /* Can happen, when, eg, in a template context, Koenig lookup
10752 can't resolve begin/end (c++/58503). */
10756 tree iter_type = cv_unqualified (TREE_TYPE (*begin));
10757 /* The unqualified type of the __begin and __end temporaries should
10758 be the same, as required by the multiple auto declaration. */
10759 if (!same_type_p (iter_type, cv_unqualified (TREE_TYPE (*end))))
10760 error ("inconsistent begin/end types in range-based %<for%> "
10761 "statement: %qT and %qT",
10762 TREE_TYPE (*begin), TREE_TYPE (*end));
10768 /* Helper function for cp_parser_perform_range_for_lookup.
10769 Builds a tree for RANGE.IDENTIFIER(). */
10772 cp_parser_range_for_member_function (tree range, tree identifier)
10775 vec<tree, va_gc> *vec;
10777 member = finish_class_member_access_expr (range, identifier,
10778 false, tf_warning_or_error);
10779 if (member == error_mark_node)
10780 return error_mark_node;
10782 vec = make_tree_vector ();
10783 res = finish_call_expr (member, &vec,
10784 /*disallow_virtual=*/false,
10785 /*koenig_p=*/false,
10786 tf_warning_or_error);
10787 release_tree_vector (vec);
10791 /* Parse an iteration-statement.
10793 iteration-statement:
10794 while ( condition ) statement
10795 do statement while ( expression ) ;
10796 for ( for-init-statement condition [opt] ; expression [opt] )
10799 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
10802 cp_parser_iteration_statement (cp_parser* parser, bool ivdep)
10807 unsigned char in_statement;
10809 /* Peek at the next token. */
10810 token = cp_parser_require (parser, CPP_KEYWORD, RT_INTERATION);
10812 return error_mark_node;
10814 /* Remember whether or not we are already within an iteration
10816 in_statement = parser->in_statement;
10818 /* See what kind of keyword it is. */
10819 keyword = token->keyword;
10826 /* Begin the while-statement. */
10827 statement = begin_while_stmt ();
10828 /* Look for the `('. */
10829 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
10830 /* Parse the condition. */
10831 condition = cp_parser_condition (parser);
10832 finish_while_stmt_cond (condition, statement, ivdep);
10833 /* Look for the `)'. */
10834 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
10835 /* Parse the dependent statement. */
10836 parser->in_statement = IN_ITERATION_STMT;
10837 cp_parser_already_scoped_statement (parser);
10838 parser->in_statement = in_statement;
10839 /* We're done with the while-statement. */
10840 finish_while_stmt (statement);
10848 /* Begin the do-statement. */
10849 statement = begin_do_stmt ();
10850 /* Parse the body of the do-statement. */
10851 parser->in_statement = IN_ITERATION_STMT;
10852 cp_parser_implicitly_scoped_statement (parser, NULL);
10853 parser->in_statement = in_statement;
10854 finish_do_body (statement);
10855 /* Look for the `while' keyword. */
10856 cp_parser_require_keyword (parser, RID_WHILE, RT_WHILE);
10857 /* Look for the `('. */
10858 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
10859 /* Parse the expression. */
10860 expression = cp_parser_expression (parser);
10861 /* We're done with the do-statement. */
10862 finish_do_stmt (expression, statement, ivdep);
10863 /* Look for the `)'. */
10864 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
10865 /* Look for the `;'. */
10866 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
10872 /* Look for the `('. */
10873 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
10875 statement = cp_parser_for (parser, ivdep);
10877 /* Look for the `)'. */
10878 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
10880 /* Parse the body of the for-statement. */
10881 parser->in_statement = IN_ITERATION_STMT;
10882 cp_parser_already_scoped_statement (parser);
10883 parser->in_statement = in_statement;
10885 /* We're done with the for-statement. */
10886 finish_for_stmt (statement);
10891 cp_parser_error (parser, "expected iteration-statement");
10892 statement = error_mark_node;
10899 /* Parse a for-init-statement or the declarator of a range-based-for.
10900 Returns true if a range-based-for declaration is seen.
10902 for-init-statement:
10903 expression-statement
10904 simple-declaration */
10907 cp_parser_for_init_statement (cp_parser* parser, tree *decl)
10909 /* If the next token is a `;', then we have an empty
10910 expression-statement. Grammatically, this is also a
10911 simple-declaration, but an invalid one, because it does not
10912 declare anything. Therefore, if we did not handle this case
10913 specially, we would issue an error message about an invalid
10915 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
10917 bool is_range_for = false;
10918 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
10920 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
10921 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
10923 /* N3994 -- for (id : init) ... */
10924 if (cxx_dialect < cxx1z)
10925 pedwarn (input_location, 0, "range-based for loop without a "
10926 "type-specifier only available with "
10927 "-std=c++1z or -std=gnu++1z");
10928 tree name = cp_parser_identifier (parser);
10929 tree type = cp_build_reference_type (make_auto (), /*rval*/true);
10930 *decl = build_decl (input_location, VAR_DECL, name, type);
10932 cp_lexer_consume_token (parser->lexer);
10936 /* A colon is used in range-based for. */
10937 parser->colon_corrects_to_scope_p = false;
10939 /* We're going to speculatively look for a declaration, falling back
10940 to an expression, if necessary. */
10941 cp_parser_parse_tentatively (parser);
10942 /* Parse the declaration. */
10943 cp_parser_simple_declaration (parser,
10944 /*function_definition_allowed_p=*/false,
10946 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
10947 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
10949 /* It is a range-for, consume the ':' */
10950 cp_lexer_consume_token (parser->lexer);
10951 is_range_for = true;
10952 if (cxx_dialect < cxx11)
10954 pedwarn (cp_lexer_peek_token (parser->lexer)->location, 0,
10955 "range-based %<for%> loops only available with "
10956 "-std=c++11 or -std=gnu++11");
10957 *decl = error_mark_node;
10961 /* The ';' is not consumed yet because we told
10962 cp_parser_simple_declaration not to. */
10963 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
10965 if (cp_parser_parse_definitely (parser))
10966 return is_range_for;
10967 /* If the tentative parse failed, then we shall need to look for an
10968 expression-statement. */
10970 /* If we are here, it is an expression-statement. */
10971 cp_parser_expression_statement (parser, NULL_TREE);
10975 /* Parse a jump-statement.
10980 return expression [opt] ;
10981 return braced-init-list ;
10987 goto * expression ;
10989 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
10992 cp_parser_jump_statement (cp_parser* parser)
10994 tree statement = error_mark_node;
10997 unsigned char in_statement;
10999 /* Peek at the next token. */
11000 token = cp_parser_require (parser, CPP_KEYWORD, RT_JUMP);
11002 return error_mark_node;
11004 /* See what kind of keyword it is. */
11005 keyword = token->keyword;
11009 in_statement = parser->in_statement & ~IN_IF_STMT;
11010 switch (in_statement)
11013 error_at (token->location, "break statement not within loop or switch");
11016 gcc_assert ((in_statement & IN_SWITCH_STMT)
11017 || in_statement == IN_ITERATION_STMT);
11018 statement = finish_break_stmt ();
11019 if (in_statement == IN_ITERATION_STMT)
11020 break_maybe_infinite_loop ();
11023 error_at (token->location, "invalid exit from OpenMP structured block");
11026 error_at (token->location, "break statement used with OpenMP for loop");
11028 case IN_CILK_SIMD_FOR:
11029 error_at (token->location, "break statement used with Cilk Plus for loop");
11032 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
11036 switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
11039 error_at (token->location, "continue statement not within a loop");
11041 case IN_CILK_SIMD_FOR:
11042 error_at (token->location,
11043 "continue statement within %<#pragma simd%> loop body");
11044 /* Fall through. */
11045 case IN_ITERATION_STMT:
11047 statement = finish_continue_stmt ();
11050 error_at (token->location, "invalid exit from OpenMP structured block");
11053 gcc_unreachable ();
11055 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
11061 bool expr_non_constant_p;
11063 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11065 cp_lexer_set_source_position (parser->lexer);
11066 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
11067 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
11069 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
11070 expr = cp_parser_expression (parser);
11072 /* If the next token is a `;', then there is no
11075 /* Build the return-statement. */
11076 statement = finish_return_stmt (expr);
11077 /* Look for the final `;'. */
11078 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
11083 if (parser->in_function_body
11084 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
11086 error ("%<goto%> in %<constexpr%> function");
11087 cp_function_chain->invalid_constexpr = true;
11090 /* Create the goto-statement. */
11091 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
11093 /* Issue a warning about this use of a GNU extension. */
11094 pedwarn (token->location, OPT_Wpedantic, "ISO C++ forbids computed gotos");
11095 /* Consume the '*' token. */
11096 cp_lexer_consume_token (parser->lexer);
11097 /* Parse the dependent expression. */
11098 finish_goto_stmt (cp_parser_expression (parser));
11101 finish_goto_stmt (cp_parser_identifier (parser));
11102 /* Look for the final `;'. */
11103 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
11107 cp_parser_error (parser, "expected jump-statement");
11114 /* Parse a declaration-statement.
11116 declaration-statement:
11117 block-declaration */
11120 cp_parser_declaration_statement (cp_parser* parser)
11124 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11125 p = obstack_alloc (&declarator_obstack, 0);
11127 /* Parse the block-declaration. */
11128 cp_parser_block_declaration (parser, /*statement_p=*/true);
11130 /* Free any declarators allocated. */
11131 obstack_free (&declarator_obstack, p);
11134 /* Some dependent statements (like `if (cond) statement'), are
11135 implicitly in their own scope. In other words, if the statement is
11136 a single statement (as opposed to a compound-statement), it is
11137 none-the-less treated as if it were enclosed in braces. Any
11138 declarations appearing in the dependent statement are out of scope
11139 after control passes that point. This function parses a statement,
11140 but ensures that is in its own scope, even if it is not a
11141 compound-statement.
11143 If IF_P is not NULL, *IF_P is set to indicate whether the statement
11144 is a (possibly labeled) if statement which is not enclosed in
11145 braces and has an else clause. This is used to implement
11148 Returns the new statement. */
11151 cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p)
11158 /* Mark if () ; with a special NOP_EXPR. */
11159 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
11161 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
11162 cp_lexer_consume_token (parser->lexer);
11163 statement = add_stmt (build_empty_stmt (loc));
11165 /* if a compound is opened, we simply parse the statement directly. */
11166 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
11167 statement = cp_parser_compound_statement (parser, NULL, false, false);
11168 /* If the token is not a `{', then we must take special action. */
11171 /* Create a compound-statement. */
11172 statement = begin_compound_stmt (0);
11173 /* Parse the dependent-statement. */
11174 cp_parser_statement (parser, NULL_TREE, false, if_p);
11175 /* Finish the dummy compound-statement. */
11176 finish_compound_stmt (statement);
11179 /* Return the statement. */
11183 /* For some dependent statements (like `while (cond) statement'), we
11184 have already created a scope. Therefore, even if the dependent
11185 statement is a compound-statement, we do not want to create another
11189 cp_parser_already_scoped_statement (cp_parser* parser)
11191 /* If the token is a `{', then we must take special action. */
11192 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
11193 cp_parser_statement (parser, NULL_TREE, false, NULL);
11196 /* Avoid calling cp_parser_compound_statement, so that we
11197 don't create a new scope. Do everything else by hand. */
11198 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
11199 /* If the next keyword is `__label__' we have a label declaration. */
11200 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
11201 cp_parser_label_declaration (parser);
11202 /* Parse an (optional) statement-seq. */
11203 cp_parser_statement_seq_opt (parser, NULL_TREE);
11204 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
11208 /* Declarations [gram.dcl.dcl] */
11210 /* Parse an optional declaration-sequence.
11214 declaration-seq declaration */
11217 cp_parser_declaration_seq_opt (cp_parser* parser)
11223 token = cp_lexer_peek_token (parser->lexer);
11225 if (token->type == CPP_CLOSE_BRACE
11226 || token->type == CPP_EOF
11227 || token->type == CPP_PRAGMA_EOL)
11230 if (token->type == CPP_SEMICOLON)
11232 /* A declaration consisting of a single semicolon is
11233 invalid. Allow it unless we're being pedantic. */
11234 cp_lexer_consume_token (parser->lexer);
11235 if (!in_system_header_at (input_location))
11236 pedwarn (input_location, OPT_Wpedantic, "extra %<;%>");
11240 /* If we're entering or exiting a region that's implicitly
11241 extern "C", modify the lang context appropriately. */
11242 if (!parser->implicit_extern_c && token->implicit_extern_c)
11244 push_lang_context (lang_name_c);
11245 parser->implicit_extern_c = true;
11247 else if (parser->implicit_extern_c && !token->implicit_extern_c)
11249 pop_lang_context ();
11250 parser->implicit_extern_c = false;
11253 if (token->type == CPP_PRAGMA)
11255 /* A top-level declaration can consist solely of a #pragma.
11256 A nested declaration cannot, so this is done here and not
11257 in cp_parser_declaration. (A #pragma at block scope is
11258 handled in cp_parser_statement.) */
11259 cp_parser_pragma (parser, pragma_external);
11263 /* Parse the declaration itself. */
11264 cp_parser_declaration (parser);
11268 /* Parse a declaration.
11272 function-definition
11273 template-declaration
11274 explicit-instantiation
11275 explicit-specialization
11276 linkage-specification
11277 namespace-definition
11282 __extension__ declaration */
11285 cp_parser_declaration (cp_parser* parser)
11289 int saved_pedantic;
11291 tree attributes = NULL_TREE;
11293 /* Check for the `__extension__' keyword. */
11294 if (cp_parser_extension_opt (parser, &saved_pedantic))
11296 /* Parse the qualified declaration. */
11297 cp_parser_declaration (parser);
11298 /* Restore the PEDANTIC flag. */
11299 pedantic = saved_pedantic;
11304 /* Try to figure out what kind of declaration is present. */
11305 token1 = *cp_lexer_peek_token (parser->lexer);
11307 if (token1.type != CPP_EOF)
11308 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
11311 token2.type = CPP_EOF;
11312 token2.keyword = RID_MAX;
11315 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
11316 p = obstack_alloc (&declarator_obstack, 0);
11318 /* If the next token is `extern' and the following token is a string
11319 literal, then we have a linkage specification. */
11320 if (token1.keyword == RID_EXTERN
11321 && cp_parser_is_pure_string_literal (&token2))
11322 cp_parser_linkage_specification (parser);
11323 /* If the next token is `template', then we have either a template
11324 declaration, an explicit instantiation, or an explicit
11326 else if (token1.keyword == RID_TEMPLATE)
11328 /* `template <>' indicates a template specialization. */
11329 if (token2.type == CPP_LESS
11330 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
11331 cp_parser_explicit_specialization (parser);
11332 /* `template <' indicates a template declaration. */
11333 else if (token2.type == CPP_LESS)
11334 cp_parser_template_declaration (parser, /*member_p=*/false);
11335 /* Anything else must be an explicit instantiation. */
11337 cp_parser_explicit_instantiation (parser);
11339 /* If the next token is `export', then we have a template
11341 else if (token1.keyword == RID_EXPORT)
11342 cp_parser_template_declaration (parser, /*member_p=*/false);
11343 /* If the next token is `extern', 'static' or 'inline' and the one
11344 after that is `template', we have a GNU extended explicit
11345 instantiation directive. */
11346 else if (cp_parser_allow_gnu_extensions_p (parser)
11347 && (token1.keyword == RID_EXTERN
11348 || token1.keyword == RID_STATIC
11349 || token1.keyword == RID_INLINE)
11350 && token2.keyword == RID_TEMPLATE)
11351 cp_parser_explicit_instantiation (parser);
11352 /* If the next token is `namespace', check for a named or unnamed
11353 namespace definition. */
11354 else if (token1.keyword == RID_NAMESPACE
11355 && (/* A named namespace definition. */
11356 (token2.type == CPP_NAME
11357 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
11359 /* An unnamed namespace definition. */
11360 || token2.type == CPP_OPEN_BRACE
11361 || token2.keyword == RID_ATTRIBUTE))
11362 cp_parser_namespace_definition (parser);
11363 /* An inline (associated) namespace definition. */
11364 else if (token1.keyword == RID_INLINE
11365 && token2.keyword == RID_NAMESPACE)
11366 cp_parser_namespace_definition (parser);
11367 /* Objective-C++ declaration/definition. */
11368 else if (c_dialect_objc () && OBJC_IS_AT_KEYWORD (token1.keyword))
11369 cp_parser_objc_declaration (parser, NULL_TREE);
11370 else if (c_dialect_objc ()
11371 && token1.keyword == RID_ATTRIBUTE
11372 && cp_parser_objc_valid_prefix_attributes (parser, &attributes))
11373 cp_parser_objc_declaration (parser, attributes);
11374 /* We must have either a block declaration or a function
11377 /* Try to parse a block-declaration, or a function-definition. */
11378 cp_parser_block_declaration (parser, /*statement_p=*/false);
11380 /* Free any declarators allocated. */
11381 obstack_free (&declarator_obstack, p);
11384 /* Parse a block-declaration.
11389 namespace-alias-definition
11396 __extension__ block-declaration
11401 static_assert-declaration
11403 If STATEMENT_P is TRUE, then this block-declaration is occurring as
11404 part of a declaration-statement. */
11407 cp_parser_block_declaration (cp_parser *parser,
11411 int saved_pedantic;
11413 /* Check for the `__extension__' keyword. */
11414 if (cp_parser_extension_opt (parser, &saved_pedantic))
11416 /* Parse the qualified declaration. */
11417 cp_parser_block_declaration (parser, statement_p);
11418 /* Restore the PEDANTIC flag. */
11419 pedantic = saved_pedantic;
11424 /* Peek at the next token to figure out which kind of declaration is
11426 token1 = cp_lexer_peek_token (parser->lexer);
11428 /* If the next keyword is `asm', we have an asm-definition. */
11429 if (token1->keyword == RID_ASM)
11432 cp_parser_commit_to_tentative_parse (parser);
11433 cp_parser_asm_definition (parser);
11435 /* If the next keyword is `namespace', we have a
11436 namespace-alias-definition. */
11437 else if (token1->keyword == RID_NAMESPACE)
11438 cp_parser_namespace_alias_definition (parser);
11439 /* If the next keyword is `using', we have a
11440 using-declaration, a using-directive, or an alias-declaration. */
11441 else if (token1->keyword == RID_USING)
11446 cp_parser_commit_to_tentative_parse (parser);
11447 /* If the token after `using' is `namespace', then we have a
11448 using-directive. */
11449 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
11450 if (token2->keyword == RID_NAMESPACE)
11451 cp_parser_using_directive (parser);
11452 /* If the second token after 'using' is '=', then we have an
11453 alias-declaration. */
11454 else if (cxx_dialect >= cxx11
11455 && token2->type == CPP_NAME
11456 && ((cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
11457 || (cp_nth_tokens_can_be_attribute_p (parser, 3))))
11458 cp_parser_alias_declaration (parser);
11459 /* Otherwise, it's a using-declaration. */
11461 cp_parser_using_declaration (parser,
11462 /*access_declaration_p=*/false);
11464 /* If the next keyword is `__label__' we have a misplaced label
11466 else if (token1->keyword == RID_LABEL)
11468 cp_lexer_consume_token (parser->lexer);
11469 error_at (token1->location, "%<__label__%> not at the beginning of a block");
11470 cp_parser_skip_to_end_of_statement (parser);
11471 /* If the next token is now a `;', consume it. */
11472 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
11473 cp_lexer_consume_token (parser->lexer);
11475 /* If the next token is `static_assert' we have a static assertion. */
11476 else if (token1->keyword == RID_STATIC_ASSERT)
11477 cp_parser_static_assert (parser, /*member_p=*/false);
11478 /* Anything else must be a simple-declaration. */
11480 cp_parser_simple_declaration (parser, !statement_p,
11481 /*maybe_range_for_decl*/NULL);
11484 /* Parse a simple-declaration.
11486 simple-declaration:
11487 decl-specifier-seq [opt] init-declarator-list [opt] ;
11489 init-declarator-list:
11491 init-declarator-list , init-declarator
11493 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
11494 function-definition as a simple-declaration.
11496 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
11497 parsed declaration if it is an uninitialized single declarator not followed
11498 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
11499 if present, will not be consumed. */
11502 cp_parser_simple_declaration (cp_parser* parser,
11503 bool function_definition_allowed_p,
11504 tree *maybe_range_for_decl)
11506 cp_decl_specifier_seq decl_specifiers;
11507 int declares_class_or_enum;
11508 bool saw_declarator;
11509 location_t comma_loc = UNKNOWN_LOCATION;
11510 location_t init_loc = UNKNOWN_LOCATION;
11512 if (maybe_range_for_decl)
11513 *maybe_range_for_decl = NULL_TREE;
11515 /* Defer access checks until we know what is being declared; the
11516 checks for names appearing in the decl-specifier-seq should be
11517 done as if we were in the scope of the thing being declared. */
11518 push_deferring_access_checks (dk_deferred);
11520 /* Parse the decl-specifier-seq. We have to keep track of whether
11521 or not the decl-specifier-seq declares a named class or
11522 enumeration type, since that is the only case in which the
11523 init-declarator-list is allowed to be empty.
11527 In a simple-declaration, the optional init-declarator-list can be
11528 omitted only when declaring a class or enumeration, that is when
11529 the decl-specifier-seq contains either a class-specifier, an
11530 elaborated-type-specifier, or an enum-specifier. */
11531 cp_parser_decl_specifier_seq (parser,
11532 CP_PARSER_FLAGS_OPTIONAL,
11534 &declares_class_or_enum);
11535 /* We no longer need to defer access checks. */
11536 stop_deferring_access_checks ();
11538 /* In a block scope, a valid declaration must always have a
11539 decl-specifier-seq. By not trying to parse declarators, we can
11540 resolve the declaration/expression ambiguity more quickly. */
11541 if (!function_definition_allowed_p
11542 && !decl_specifiers.any_specifiers_p)
11544 cp_parser_error (parser, "expected declaration");
11548 /* If the next two tokens are both identifiers, the code is
11549 erroneous. The usual cause of this situation is code like:
11553 where "T" should name a type -- but does not. */
11554 if (!decl_specifiers.any_type_specifiers_p
11555 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
11557 /* If parsing tentatively, we should commit; we really are
11558 looking at a declaration. */
11559 cp_parser_commit_to_tentative_parse (parser);
11564 /* If we have seen at least one decl-specifier, and the next token
11565 is not a parenthesis, then we must be looking at a declaration.
11566 (After "int (" we might be looking at a functional cast.) */
11567 if (decl_specifiers.any_specifiers_p
11568 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)
11569 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
11570 && !cp_parser_error_occurred (parser))
11571 cp_parser_commit_to_tentative_parse (parser);
11573 /* Keep going until we hit the `;' at the end of the simple
11575 saw_declarator = false;
11576 while (cp_lexer_next_token_is_not (parser->lexer,
11580 bool function_definition_p;
11583 if (saw_declarator)
11585 /* If we are processing next declarator, comma is expected */
11586 token = cp_lexer_peek_token (parser->lexer);
11587 gcc_assert (token->type == CPP_COMMA);
11588 cp_lexer_consume_token (parser->lexer);
11589 if (maybe_range_for_decl)
11591 *maybe_range_for_decl = error_mark_node;
11592 if (comma_loc == UNKNOWN_LOCATION)
11593 comma_loc = token->location;
11597 saw_declarator = true;
11599 /* Parse the init-declarator. */
11600 decl = cp_parser_init_declarator (parser, &decl_specifiers,
11602 function_definition_allowed_p,
11603 /*member_p=*/false,
11604 declares_class_or_enum,
11605 &function_definition_p,
11606 maybe_range_for_decl,
11608 /* If an error occurred while parsing tentatively, exit quickly.
11609 (That usually happens when in the body of a function; each
11610 statement is treated as a declaration-statement until proven
11612 if (cp_parser_error_occurred (parser))
11614 /* Handle function definitions specially. */
11615 if (function_definition_p)
11617 /* If the next token is a `,', then we are probably
11618 processing something like:
11622 which is erroneous. */
11623 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
11625 cp_token *token = cp_lexer_peek_token (parser->lexer);
11626 error_at (token->location,
11628 " declarations and function-definitions is forbidden");
11630 /* Otherwise, we're done with the list of declarators. */
11633 pop_deferring_access_checks ();
11637 if (maybe_range_for_decl && *maybe_range_for_decl == NULL_TREE)
11638 *maybe_range_for_decl = decl;
11639 /* The next token should be either a `,' or a `;'. */
11640 token = cp_lexer_peek_token (parser->lexer);
11641 /* If it's a `,', there are more declarators to come. */
11642 if (token->type == CPP_COMMA)
11643 /* will be consumed next time around */;
11644 /* If it's a `;', we are done. */
11645 else if (token->type == CPP_SEMICOLON || maybe_range_for_decl)
11647 /* Anything else is an error. */
11650 /* If we have already issued an error message we don't need
11651 to issue another one. */
11652 if (decl != error_mark_node
11653 || cp_parser_uncommitted_to_tentative_parse_p (parser))
11654 cp_parser_error (parser, "expected %<,%> or %<;%>");
11655 /* Skip tokens until we reach the end of the statement. */
11656 cp_parser_skip_to_end_of_statement (parser);
11657 /* If the next token is now a `;', consume it. */
11658 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
11659 cp_lexer_consume_token (parser->lexer);
11662 /* After the first time around, a function-definition is not
11663 allowed -- even if it was OK at first. For example:
11668 function_definition_allowed_p = false;
11671 /* Issue an error message if no declarators are present, and the
11672 decl-specifier-seq does not itself declare a class or
11673 enumeration: [dcl.dcl]/3. */
11674 if (!saw_declarator)
11676 if (cp_parser_declares_only_class_p (parser))
11678 if (!declares_class_or_enum
11679 && decl_specifiers.type
11680 && OVERLOAD_TYPE_P (decl_specifiers.type))
11681 /* Ensure an error is issued anyway when finish_decltype_type,
11682 called via cp_parser_decl_specifier_seq, returns a class or
11683 an enumeration (c++/51786). */
11684 decl_specifiers.type = NULL_TREE;
11685 shadow_tag (&decl_specifiers);
11687 /* Perform any deferred access checks. */
11688 perform_deferred_access_checks (tf_warning_or_error);
11691 /* Consume the `;'. */
11692 if (!maybe_range_for_decl)
11693 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
11694 else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
11696 if (init_loc != UNKNOWN_LOCATION)
11697 error_at (init_loc, "initializer in range-based %<for%> loop");
11698 if (comma_loc != UNKNOWN_LOCATION)
11699 error_at (comma_loc,
11700 "multiple declarations in range-based %<for%> loop");
11704 pop_deferring_access_checks ();
11707 /* Parse a decl-specifier-seq.
11709 decl-specifier-seq:
11710 decl-specifier-seq [opt] decl-specifier
11711 decl-specifier attribute-specifier-seq [opt] (C++11)
11714 storage-class-specifier
11725 Set *DECL_SPECS to a representation of the decl-specifier-seq.
11727 The parser flags FLAGS is used to control type-specifier parsing.
11729 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
11732 1: one of the decl-specifiers is an elaborated-type-specifier
11733 (i.e., a type declaration)
11734 2: one of the decl-specifiers is an enum-specifier or a
11735 class-specifier (i.e., a type definition)
11740 cp_parser_decl_specifier_seq (cp_parser* parser,
11741 cp_parser_flags flags,
11742 cp_decl_specifier_seq *decl_specs,
11743 int* declares_class_or_enum)
11745 bool constructor_possible_p = !parser->in_declarator_p;
11746 bool found_decl_spec = false;
11747 cp_token *start_token = NULL;
11750 /* Clear DECL_SPECS. */
11751 clear_decl_specs (decl_specs);
11753 /* Assume no class or enumeration type is declared. */
11754 *declares_class_or_enum = 0;
11756 /* Keep reading specifiers until there are no more to read. */
11759 bool constructor_p;
11763 /* Peek at the next token. */
11764 token = cp_lexer_peek_token (parser->lexer);
11766 /* Save the first token of the decl spec list for error
11769 start_token = token;
11770 /* Handle attributes. */
11771 if (cp_next_tokens_can_be_attribute_p (parser))
11773 /* Parse the attributes. */
11774 tree attrs = cp_parser_attributes_opt (parser);
11776 /* In a sequence of declaration specifiers, c++11 attributes
11777 appertain to the type that precede them. In that case
11780 The attribute-specifier-seq affects the type only for
11781 the declaration it appears in, not other declarations
11782 involving the same type.
11784 But for now let's force the user to position the
11785 attribute either at the beginning of the declaration or
11786 after the declarator-id, which would clearly mean that it
11787 applies to the declarator. */
11788 if (cxx11_attribute_p (attrs))
11790 if (!found_decl_spec)
11791 /* The c++11 attribute is at the beginning of the
11792 declaration. It appertains to the entity being
11796 if (decl_specs->type && CLASS_TYPE_P (decl_specs->type))
11798 /* This is an attribute following a
11799 class-specifier. */
11800 if (decl_specs->type_definition_p)
11801 warn_misplaced_attr_for_class_type (token->location,
11807 decl_specs->std_attributes
11808 = chainon (decl_specs->std_attributes,
11810 if (decl_specs->locations[ds_std_attribute] == 0)
11811 decl_specs->locations[ds_std_attribute] = token->location;
11817 decl_specs->attributes
11818 = chainon (decl_specs->attributes,
11820 if (decl_specs->locations[ds_attribute] == 0)
11821 decl_specs->locations[ds_attribute] = token->location;
11824 /* Assume we will find a decl-specifier keyword. */
11825 found_decl_spec = true;
11826 /* If the next token is an appropriate keyword, we can simply
11827 add it to the list. */
11828 switch (token->keyword)
11834 if (!at_class_scope_p ())
11836 error_at (token->location, "%<friend%> used outside of class");
11837 cp_lexer_purge_token (parser->lexer);
11842 /* Consume the token. */
11843 cp_lexer_consume_token (parser->lexer);
11847 case RID_CONSTEXPR:
11849 cp_lexer_consume_token (parser->lexer);
11852 /* function-specifier:
11859 cp_parser_function_specifier_opt (parser, decl_specs);
11866 /* Consume the token. */
11867 cp_lexer_consume_token (parser->lexer);
11868 /* A constructor declarator cannot appear in a typedef. */
11869 constructor_possible_p = false;
11870 /* The "typedef" keyword can only occur in a declaration; we
11871 may as well commit at this point. */
11872 cp_parser_commit_to_tentative_parse (parser);
11874 if (decl_specs->storage_class != sc_none)
11875 decl_specs->conflicting_specifiers_p = true;
11878 /* storage-class-specifier:
11888 if (cxx_dialect == cxx98)
11890 /* Consume the token. */
11891 cp_lexer_consume_token (parser->lexer);
11893 /* Complain about `auto' as a storage specifier, if
11894 we're complaining about C++0x compatibility. */
11895 warning_at (token->location, OPT_Wc__0x_compat, "%<auto%>"
11896 " changes meaning in C++11; please remove it");
11898 /* Set the storage class anyway. */
11899 cp_parser_set_storage_class (parser, decl_specs, RID_AUTO,
11903 /* C++0x auto type-specifier. */
11904 found_decl_spec = false;
11911 /* Consume the token. */
11912 cp_lexer_consume_token (parser->lexer);
11913 cp_parser_set_storage_class (parser, decl_specs, token->keyword,
11917 /* Consume the token. */
11919 cp_lexer_consume_token (parser->lexer);
11923 /* We did not yet find a decl-specifier yet. */
11924 found_decl_spec = false;
11928 if (found_decl_spec
11929 && (flags & CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR)
11930 && token->keyword != RID_CONSTEXPR)
11931 error ("decl-specifier invalid in condition");
11934 set_and_check_decl_spec_loc (decl_specs, ds, token);
11936 /* Constructors are a special case. The `S' in `S()' is not a
11937 decl-specifier; it is the beginning of the declarator. */
11939 = (!found_decl_spec
11940 && constructor_possible_p
11941 && (cp_parser_constructor_declarator_p
11942 (parser, decl_spec_seq_has_spec_p (decl_specs, ds_friend))));
11944 /* If we don't have a DECL_SPEC yet, then we must be looking at
11945 a type-specifier. */
11946 if (!found_decl_spec && !constructor_p)
11948 int decl_spec_declares_class_or_enum;
11949 bool is_cv_qualifier;
11953 = cp_parser_type_specifier (parser, flags,
11955 /*is_declaration=*/true,
11956 &decl_spec_declares_class_or_enum,
11958 *declares_class_or_enum |= decl_spec_declares_class_or_enum;
11960 /* If this type-specifier referenced a user-defined type
11961 (a typedef, class-name, etc.), then we can't allow any
11962 more such type-specifiers henceforth.
11966 The longest sequence of decl-specifiers that could
11967 possibly be a type name is taken as the
11968 decl-specifier-seq of a declaration. The sequence shall
11969 be self-consistent as described below.
11973 As a general rule, at most one type-specifier is allowed
11974 in the complete decl-specifier-seq of a declaration. The
11975 only exceptions are the following:
11977 -- const or volatile can be combined with any other
11980 -- signed or unsigned can be combined with char, long,
11988 void g (const int Pc);
11990 Here, Pc is *not* part of the decl-specifier seq; it's
11991 the declarator. Therefore, once we see a type-specifier
11992 (other than a cv-qualifier), we forbid any additional
11993 user-defined types. We *do* still allow things like `int
11994 int' to be considered a decl-specifier-seq, and issue the
11995 error message later. */
11996 if (type_spec && !is_cv_qualifier)
11997 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
11998 /* A constructor declarator cannot follow a type-specifier. */
12001 constructor_possible_p = false;
12002 found_decl_spec = true;
12003 if (!is_cv_qualifier)
12004 decl_specs->any_type_specifiers_p = true;
12008 /* If we still do not have a DECL_SPEC, then there are no more
12009 decl-specifiers. */
12010 if (!found_decl_spec)
12013 decl_specs->any_specifiers_p = true;
12014 /* After we see one decl-specifier, further decl-specifiers are
12015 always optional. */
12016 flags |= CP_PARSER_FLAGS_OPTIONAL;
12019 /* Don't allow a friend specifier with a class definition. */
12020 if (decl_spec_seq_has_spec_p (decl_specs, ds_friend)
12021 && (*declares_class_or_enum & 2))
12022 error_at (decl_specs->locations[ds_friend],
12023 "class definition may not be declared a friend");
12026 /* Parse an (optional) storage-class-specifier.
12028 storage-class-specifier:
12037 storage-class-specifier:
12040 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
12043 cp_parser_storage_class_specifier_opt (cp_parser* parser)
12045 switch (cp_lexer_peek_token (parser->lexer)->keyword)
12048 if (cxx_dialect != cxx98)
12050 /* Fall through for C++98. */
12057 /* Consume the token. */
12058 return cp_lexer_consume_token (parser->lexer)->u.value;
12065 /* Parse an (optional) function-specifier.
12067 function-specifier:
12072 Returns an IDENTIFIER_NODE corresponding to the keyword used.
12073 Updates DECL_SPECS, if it is non-NULL. */
12076 cp_parser_function_specifier_opt (cp_parser* parser,
12077 cp_decl_specifier_seq *decl_specs)
12079 cp_token *token = cp_lexer_peek_token (parser->lexer);
12080 switch (token->keyword)
12083 set_and_check_decl_spec_loc (decl_specs, ds_inline, token);
12087 /* 14.5.2.3 [temp.mem]
12089 A member function template shall not be virtual. */
12090 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
12091 error_at (token->location, "templates may not be %<virtual%>");
12093 set_and_check_decl_spec_loc (decl_specs, ds_virtual, token);
12097 set_and_check_decl_spec_loc (decl_specs, ds_explicit, token);
12104 /* Consume the token. */
12105 return cp_lexer_consume_token (parser->lexer)->u.value;
12108 /* Parse a linkage-specification.
12110 linkage-specification:
12111 extern string-literal { declaration-seq [opt] }
12112 extern string-literal declaration */
12115 cp_parser_linkage_specification (cp_parser* parser)
12119 /* Look for the `extern' keyword. */
12120 cp_parser_require_keyword (parser, RID_EXTERN, RT_EXTERN);
12122 /* Look for the string-literal. */
12123 linkage = cp_parser_string_literal (parser, false, false);
12125 /* Transform the literal into an identifier. If the literal is a
12126 wide-character string, or contains embedded NULs, then we can't
12127 handle it as the user wants. */
12128 if (strlen (TREE_STRING_POINTER (linkage))
12129 != (size_t) (TREE_STRING_LENGTH (linkage) - 1))
12131 cp_parser_error (parser, "invalid linkage-specification");
12132 /* Assume C++ linkage. */
12133 linkage = lang_name_cplusplus;
12136 linkage = get_identifier (TREE_STRING_POINTER (linkage));
12138 /* We're now using the new linkage. */
12139 push_lang_context (linkage);
12141 /* If the next token is a `{', then we're using the first
12143 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
12145 cp_ensure_no_omp_declare_simd (parser);
12147 /* Consume the `{' token. */
12148 cp_lexer_consume_token (parser->lexer);
12149 /* Parse the declarations. */
12150 cp_parser_declaration_seq_opt (parser);
12151 /* Look for the closing `}'. */
12152 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
12154 /* Otherwise, there's just one declaration. */
12157 bool saved_in_unbraced_linkage_specification_p;
12159 saved_in_unbraced_linkage_specification_p
12160 = parser->in_unbraced_linkage_specification_p;
12161 parser->in_unbraced_linkage_specification_p = true;
12162 cp_parser_declaration (parser);
12163 parser->in_unbraced_linkage_specification_p
12164 = saved_in_unbraced_linkage_specification_p;
12167 /* We're done with the linkage-specification. */
12168 pop_lang_context ();
12171 /* Parse a static_assert-declaration.
12173 static_assert-declaration:
12174 static_assert ( constant-expression , string-literal ) ;
12176 If MEMBER_P, this static_assert is a class member. */
12179 cp_parser_static_assert(cp_parser *parser, bool member_p)
12184 location_t saved_loc;
12187 /* Peek at the `static_assert' token so we can keep track of exactly
12188 where the static assertion started. */
12189 token = cp_lexer_peek_token (parser->lexer);
12190 saved_loc = token->location;
12192 /* Look for the `static_assert' keyword. */
12193 if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
12197 /* We know we are in a static assertion; commit to any tentative
12199 if (cp_parser_parsing_tentatively (parser))
12200 cp_parser_commit_to_tentative_parse (parser);
12202 /* Parse the `(' starting the static assertion condition. */
12203 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
12205 /* Parse the constant-expression. Allow a non-constant expression
12206 here in order to give better diagnostics in finish_static_assert. */
12208 cp_parser_constant_expression (parser,
12209 /*allow_non_constant_p=*/true,
12210 /*non_constant_p=*/&dummy);
12212 /* Parse the separating `,'. */
12213 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
12215 /* Parse the string-literal message. */
12216 message = cp_parser_string_literal (parser,
12217 /*translate=*/false,
12220 /* A `)' completes the static assertion. */
12221 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
12222 cp_parser_skip_to_closing_parenthesis (parser,
12223 /*recovering=*/true,
12224 /*or_comma=*/false,
12225 /*consume_paren=*/true);
12227 /* A semicolon terminates the declaration. */
12228 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
12230 /* Complete the static assertion, which may mean either processing
12231 the static assert now or saving it for template instantiation. */
12232 finish_static_assert (condition, message, saved_loc, member_p);
12235 /* Parse the expression in decltype ( expression ). */
12238 cp_parser_decltype_expr (cp_parser *parser,
12239 bool &id_expression_or_member_access_p)
12241 cp_token *id_expr_start_token;
12244 /* First, try parsing an id-expression. */
12245 id_expr_start_token = cp_lexer_peek_token (parser->lexer);
12246 cp_parser_parse_tentatively (parser);
12247 expr = cp_parser_id_expression (parser,
12248 /*template_keyword_p=*/false,
12249 /*check_dependency_p=*/true,
12250 /*template_p=*/NULL,
12251 /*declarator_p=*/false,
12252 /*optional_p=*/false);
12254 if (!cp_parser_error_occurred (parser) && expr != error_mark_node)
12256 bool non_integral_constant_expression_p = false;
12257 tree id_expression = expr;
12259 const char *error_msg;
12261 if (identifier_p (expr))
12262 /* Lookup the name we got back from the id-expression. */
12263 expr = cp_parser_lookup_name_simple (parser, expr,
12264 id_expr_start_token->location);
12267 && expr != error_mark_node
12268 && TREE_CODE (expr) != TYPE_DECL
12269 && (TREE_CODE (expr) != BIT_NOT_EXPR
12270 || !TYPE_P (TREE_OPERAND (expr, 0)))
12271 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
12273 /* Complete lookup of the id-expression. */
12274 expr = (finish_id_expression
12275 (id_expression, expr, parser->scope, &idk,
12276 /*integral_constant_expression_p=*/false,
12277 /*allow_non_integral_constant_expression_p=*/true,
12278 &non_integral_constant_expression_p,
12279 /*template_p=*/false,
12281 /*address_p=*/false,
12282 /*template_arg_p=*/false,
12284 id_expr_start_token->location));
12286 if (expr == error_mark_node)
12287 /* We found an id-expression, but it was something that we
12288 should not have found. This is an error, not something
12289 we can recover from, so note that we found an
12290 id-expression and we'll recover as gracefully as
12292 id_expression_or_member_access_p = true;
12296 && expr != error_mark_node
12297 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
12298 /* We have an id-expression. */
12299 id_expression_or_member_access_p = true;
12302 if (!id_expression_or_member_access_p)
12304 /* Abort the id-expression parse. */
12305 cp_parser_abort_tentative_parse (parser);
12307 /* Parsing tentatively, again. */
12308 cp_parser_parse_tentatively (parser);
12310 /* Parse a class member access. */
12311 expr = cp_parser_postfix_expression (parser, /*address_p=*/false,
12312 /*cast_p=*/false, /*decltype*/true,
12313 /*member_access_only_p=*/true, NULL);
12316 && expr != error_mark_node
12317 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
12318 /* We have an id-expression. */
12319 id_expression_or_member_access_p = true;
12322 if (id_expression_or_member_access_p)
12323 /* We have parsed the complete id-expression or member access. */
12324 cp_parser_parse_definitely (parser);
12327 /* Abort our attempt to parse an id-expression or member access
12329 cp_parser_abort_tentative_parse (parser);
12331 /* Parse a full expression. */
12332 expr = cp_parser_expression (parser, /*pidk=*/NULL, /*cast_p=*/false,
12333 /*decltype_p=*/true);
12339 /* Parse a `decltype' type. Returns the type.
12341 simple-type-specifier:
12342 decltype ( expression )
12344 decltype ( auto ) */
12347 cp_parser_decltype (cp_parser *parser)
12350 bool id_expression_or_member_access_p = false;
12351 const char *saved_message;
12352 bool saved_integral_constant_expression_p;
12353 bool saved_non_integral_constant_expression_p;
12354 bool saved_greater_than_is_operator_p;
12355 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
12357 if (start_token->type == CPP_DECLTYPE)
12359 /* Already parsed. */
12360 cp_lexer_consume_token (parser->lexer);
12361 return start_token->u.value;
12364 /* Look for the `decltype' token. */
12365 if (!cp_parser_require_keyword (parser, RID_DECLTYPE, RT_DECLTYPE))
12366 return error_mark_node;
12368 /* Parse the opening `('. */
12369 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
12370 return error_mark_node;
12372 /* decltype (auto) */
12373 if (cxx_dialect >= cxx14
12374 && cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
12376 cp_lexer_consume_token (parser->lexer);
12377 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
12378 return error_mark_node;
12379 expr = make_decltype_auto ();
12380 AUTO_IS_DECLTYPE (expr) = true;
12384 /* Types cannot be defined in a `decltype' expression. Save away the
12386 saved_message = parser->type_definition_forbidden_message;
12388 /* And create the new one. */
12389 parser->type_definition_forbidden_message
12390 = G_("types may not be defined in %<decltype%> expressions");
12392 /* The restrictions on constant-expressions do not apply inside
12393 decltype expressions. */
12394 saved_integral_constant_expression_p
12395 = parser->integral_constant_expression_p;
12396 saved_non_integral_constant_expression_p
12397 = parser->non_integral_constant_expression_p;
12398 parser->integral_constant_expression_p = false;
12400 /* Within a parenthesized expression, a `>' token is always
12401 the greater-than operator. */
12402 saved_greater_than_is_operator_p
12403 = parser->greater_than_is_operator_p;
12404 parser->greater_than_is_operator_p = true;
12406 /* Do not actually evaluate the expression. */
12407 ++cp_unevaluated_operand;
12409 /* Do not warn about problems with the expression. */
12410 ++c_inhibit_evaluation_warnings;
12412 expr = cp_parser_decltype_expr (parser, id_expression_or_member_access_p);
12414 /* Go back to evaluating expressions. */
12415 --cp_unevaluated_operand;
12416 --c_inhibit_evaluation_warnings;
12418 /* The `>' token might be the end of a template-id or
12419 template-parameter-list now. */
12420 parser->greater_than_is_operator_p
12421 = saved_greater_than_is_operator_p;
12423 /* Restore the old message and the integral constant expression
12425 parser->type_definition_forbidden_message = saved_message;
12426 parser->integral_constant_expression_p
12427 = saved_integral_constant_expression_p;
12428 parser->non_integral_constant_expression_p
12429 = saved_non_integral_constant_expression_p;
12431 /* Parse to the closing `)'. */
12432 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
12434 cp_parser_skip_to_closing_parenthesis (parser, true, false,
12435 /*consume_paren=*/true);
12436 return error_mark_node;
12439 expr = finish_decltype_type (expr, id_expression_or_member_access_p,
12440 tf_warning_or_error);
12443 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
12445 start_token->type = CPP_DECLTYPE;
12446 start_token->u.value = expr;
12447 start_token->keyword = RID_MAX;
12448 cp_lexer_purge_tokens_after (parser->lexer, start_token);
12453 /* Special member functions [gram.special] */
12455 /* Parse a conversion-function-id.
12457 conversion-function-id:
12458 operator conversion-type-id
12460 Returns an IDENTIFIER_NODE representing the operator. */
12463 cp_parser_conversion_function_id (cp_parser* parser)
12467 tree saved_qualifying_scope;
12468 tree saved_object_scope;
12469 tree pushed_scope = NULL_TREE;
12471 /* Look for the `operator' token. */
12472 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
12473 return error_mark_node;
12474 /* When we parse the conversion-type-id, the current scope will be
12475 reset. However, we need that information in able to look up the
12476 conversion function later, so we save it here. */
12477 saved_scope = parser->scope;
12478 saved_qualifying_scope = parser->qualifying_scope;
12479 saved_object_scope = parser->object_scope;
12480 /* We must enter the scope of the class so that the names of
12481 entities declared within the class are available in the
12482 conversion-type-id. For example, consider:
12489 S::operator I() { ... }
12491 In order to see that `I' is a type-name in the definition, we
12492 must be in the scope of `S'. */
12494 pushed_scope = push_scope (saved_scope);
12495 /* Parse the conversion-type-id. */
12496 type = cp_parser_conversion_type_id (parser);
12497 /* Leave the scope of the class, if any. */
12499 pop_scope (pushed_scope);
12500 /* Restore the saved scope. */
12501 parser->scope = saved_scope;
12502 parser->qualifying_scope = saved_qualifying_scope;
12503 parser->object_scope = saved_object_scope;
12504 /* If the TYPE is invalid, indicate failure. */
12505 if (type == error_mark_node)
12506 return error_mark_node;
12507 return mangle_conv_op_name_for_type (type);
12510 /* Parse a conversion-type-id:
12512 conversion-type-id:
12513 type-specifier-seq conversion-declarator [opt]
12515 Returns the TYPE specified. */
12518 cp_parser_conversion_type_id (cp_parser* parser)
12521 cp_decl_specifier_seq type_specifiers;
12522 cp_declarator *declarator;
12523 tree type_specified;
12524 const char *saved_message;
12526 /* Parse the attributes. */
12527 attributes = cp_parser_attributes_opt (parser);
12529 saved_message = parser->type_definition_forbidden_message;
12530 parser->type_definition_forbidden_message
12531 = G_("types may not be defined in a conversion-type-id");
12533 /* Parse the type-specifiers. */
12534 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
12535 /*is_trailing_return=*/false,
12538 parser->type_definition_forbidden_message = saved_message;
12540 /* If that didn't work, stop. */
12541 if (type_specifiers.type == error_mark_node)
12542 return error_mark_node;
12543 /* Parse the conversion-declarator. */
12544 declarator = cp_parser_conversion_declarator_opt (parser);
12546 type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME,
12547 /*initialized=*/0, &attributes);
12549 cplus_decl_attributes (&type_specified, attributes, /*flags=*/0);
12551 /* Don't give this error when parsing tentatively. This happens to
12552 work because we always parse this definitively once. */
12553 if (! cp_parser_uncommitted_to_tentative_parse_p (parser)
12554 && type_uses_auto (type_specified))
12556 if (cxx_dialect < cxx14)
12558 error ("invalid use of %<auto%> in conversion operator");
12559 return error_mark_node;
12561 else if (template_parm_scope_p ())
12562 warning (0, "use of %<auto%> in member template "
12563 "conversion operator can never be deduced");
12566 return type_specified;
12569 /* Parse an (optional) conversion-declarator.
12571 conversion-declarator:
12572 ptr-operator conversion-declarator [opt]
12576 static cp_declarator *
12577 cp_parser_conversion_declarator_opt (cp_parser* parser)
12579 enum tree_code code;
12580 tree class_type, std_attributes = NULL_TREE;
12581 cp_cv_quals cv_quals;
12583 /* We don't know if there's a ptr-operator next, or not. */
12584 cp_parser_parse_tentatively (parser);
12585 /* Try the ptr-operator. */
12586 code = cp_parser_ptr_operator (parser, &class_type, &cv_quals,
12588 /* If it worked, look for more conversion-declarators. */
12589 if (cp_parser_parse_definitely (parser))
12591 cp_declarator *declarator;
12593 /* Parse another optional declarator. */
12594 declarator = cp_parser_conversion_declarator_opt (parser);
12596 declarator = cp_parser_make_indirect_declarator
12597 (code, class_type, cv_quals, declarator, std_attributes);
12605 /* Parse an (optional) ctor-initializer.
12608 : mem-initializer-list
12610 Returns TRUE iff the ctor-initializer was actually present. */
12613 cp_parser_ctor_initializer_opt (cp_parser* parser)
12615 /* If the next token is not a `:', then there is no
12616 ctor-initializer. */
12617 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
12619 /* Do default initialization of any bases and members. */
12620 if (DECL_CONSTRUCTOR_P (current_function_decl))
12621 finish_mem_initializers (NULL_TREE);
12626 /* Consume the `:' token. */
12627 cp_lexer_consume_token (parser->lexer);
12628 /* And the mem-initializer-list. */
12629 cp_parser_mem_initializer_list (parser);
12634 /* Parse a mem-initializer-list.
12636 mem-initializer-list:
12637 mem-initializer ... [opt]
12638 mem-initializer ... [opt] , mem-initializer-list */
12641 cp_parser_mem_initializer_list (cp_parser* parser)
12643 tree mem_initializer_list = NULL_TREE;
12644 tree target_ctor = error_mark_node;
12645 cp_token *token = cp_lexer_peek_token (parser->lexer);
12647 /* Let the semantic analysis code know that we are starting the
12648 mem-initializer-list. */
12649 if (!DECL_CONSTRUCTOR_P (current_function_decl))
12650 error_at (token->location,
12651 "only constructors take member initializers");
12653 /* Loop through the list. */
12656 tree mem_initializer;
12658 token = cp_lexer_peek_token (parser->lexer);
12659 /* Parse the mem-initializer. */
12660 mem_initializer = cp_parser_mem_initializer (parser);
12661 /* If the next token is a `...', we're expanding member initializers. */
12662 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
12664 /* Consume the `...'. */
12665 cp_lexer_consume_token (parser->lexer);
12667 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
12668 can be expanded but members cannot. */
12669 if (mem_initializer != error_mark_node
12670 && !TYPE_P (TREE_PURPOSE (mem_initializer)))
12672 error_at (token->location,
12673 "cannot expand initializer for member %<%D%>",
12674 TREE_PURPOSE (mem_initializer));
12675 mem_initializer = error_mark_node;
12678 /* Construct the pack expansion type. */
12679 if (mem_initializer != error_mark_node)
12680 mem_initializer = make_pack_expansion (mem_initializer);
12682 if (target_ctor != error_mark_node
12683 && mem_initializer != error_mark_node)
12685 error ("mem-initializer for %qD follows constructor delegation",
12686 TREE_PURPOSE (mem_initializer));
12687 mem_initializer = error_mark_node;
12689 /* Look for a target constructor. */
12690 if (mem_initializer != error_mark_node
12691 && CLASS_TYPE_P (TREE_PURPOSE (mem_initializer))
12692 && same_type_p (TREE_PURPOSE (mem_initializer), current_class_type))
12694 maybe_warn_cpp0x (CPP0X_DELEGATING_CTORS);
12695 if (mem_initializer_list)
12697 error ("constructor delegation follows mem-initializer for %qD",
12698 TREE_PURPOSE (mem_initializer_list));
12699 mem_initializer = error_mark_node;
12701 target_ctor = mem_initializer;
12703 /* Add it to the list, unless it was erroneous. */
12704 if (mem_initializer != error_mark_node)
12706 TREE_CHAIN (mem_initializer) = mem_initializer_list;
12707 mem_initializer_list = mem_initializer;
12709 /* If the next token is not a `,', we're done. */
12710 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
12712 /* Consume the `,' token. */
12713 cp_lexer_consume_token (parser->lexer);
12716 /* Perform semantic analysis. */
12717 if (DECL_CONSTRUCTOR_P (current_function_decl))
12718 finish_mem_initializers (mem_initializer_list);
12721 /* Parse a mem-initializer.
12724 mem-initializer-id ( expression-list [opt] )
12725 mem-initializer-id braced-init-list
12730 ( expression-list [opt] )
12732 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
12733 class) or FIELD_DECL (for a non-static data member) to initialize;
12734 the TREE_VALUE is the expression-list. An empty initialization
12735 list is represented by void_list_node. */
12738 cp_parser_mem_initializer (cp_parser* parser)
12740 tree mem_initializer_id;
12741 tree expression_list;
12743 cp_token *token = cp_lexer_peek_token (parser->lexer);
12745 /* Find out what is being initialized. */
12746 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
12748 permerror (token->location,
12749 "anachronistic old-style base class initializer");
12750 mem_initializer_id = NULL_TREE;
12754 mem_initializer_id = cp_parser_mem_initializer_id (parser);
12755 if (mem_initializer_id == error_mark_node)
12756 return mem_initializer_id;
12758 member = expand_member_init (mem_initializer_id);
12759 if (member && !DECL_P (member))
12760 in_base_initializer = 1;
12762 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
12764 bool expr_non_constant_p;
12765 cp_lexer_set_source_position (parser->lexer);
12766 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
12767 expression_list = cp_parser_braced_list (parser, &expr_non_constant_p);
12768 CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
12769 expression_list = build_tree_list (NULL_TREE, expression_list);
12773 vec<tree, va_gc> *vec;
12774 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
12776 /*allow_expansion_p=*/true,
12777 /*non_constant_p=*/NULL);
12779 return error_mark_node;
12780 expression_list = build_tree_list_vec (vec);
12781 release_tree_vector (vec);
12784 if (expression_list == error_mark_node)
12785 return error_mark_node;
12786 if (!expression_list)
12787 expression_list = void_type_node;
12789 in_base_initializer = 0;
12791 return member ? build_tree_list (member, expression_list) : error_mark_node;
12794 /* Parse a mem-initializer-id.
12796 mem-initializer-id:
12797 :: [opt] nested-name-specifier [opt] class-name
12800 Returns a TYPE indicating the class to be initializer for the first
12801 production. Returns an IDENTIFIER_NODE indicating the data member
12802 to be initialized for the second production. */
12805 cp_parser_mem_initializer_id (cp_parser* parser)
12807 bool global_scope_p;
12808 bool nested_name_specifier_p;
12809 bool template_p = false;
12812 cp_token *token = cp_lexer_peek_token (parser->lexer);
12814 /* `typename' is not allowed in this context ([temp.res]). */
12815 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
12817 error_at (token->location,
12818 "keyword %<typename%> not allowed in this context (a qualified "
12819 "member initializer is implicitly a type)");
12820 cp_lexer_consume_token (parser->lexer);
12822 /* Look for the optional `::' operator. */
12824 = (cp_parser_global_scope_opt (parser,
12825 /*current_scope_valid_p=*/false)
12827 /* Look for the optional nested-name-specifier. The simplest way to
12832 The keyword `typename' is not permitted in a base-specifier or
12833 mem-initializer; in these contexts a qualified name that
12834 depends on a template-parameter is implicitly assumed to be a
12837 is to assume that we have seen the `typename' keyword at this
12839 nested_name_specifier_p
12840 = (cp_parser_nested_name_specifier_opt (parser,
12841 /*typename_keyword_p=*/true,
12842 /*check_dependency_p=*/true,
12844 /*is_declaration=*/true)
12846 if (nested_name_specifier_p)
12847 template_p = cp_parser_optional_template_keyword (parser);
12848 /* If there is a `::' operator or a nested-name-specifier, then we
12849 are definitely looking for a class-name. */
12850 if (global_scope_p || nested_name_specifier_p)
12851 return cp_parser_class_name (parser,
12852 /*typename_keyword_p=*/true,
12853 /*template_keyword_p=*/template_p,
12855 /*check_dependency_p=*/true,
12856 /*class_head_p=*/false,
12857 /*is_declaration=*/true);
12858 /* Otherwise, we could also be looking for an ordinary identifier. */
12859 cp_parser_parse_tentatively (parser);
12860 /* Try a class-name. */
12861 id = cp_parser_class_name (parser,
12862 /*typename_keyword_p=*/true,
12863 /*template_keyword_p=*/false,
12865 /*check_dependency_p=*/true,
12866 /*class_head_p=*/false,
12867 /*is_declaration=*/true);
12868 /* If we found one, we're done. */
12869 if (cp_parser_parse_definitely (parser))
12871 /* Otherwise, look for an ordinary identifier. */
12872 return cp_parser_identifier (parser);
12875 /* Overloading [gram.over] */
12877 /* Parse an operator-function-id.
12879 operator-function-id:
12882 Returns an IDENTIFIER_NODE for the operator which is a
12883 human-readable spelling of the identifier, e.g., `operator +'. */
12886 cp_parser_operator_function_id (cp_parser* parser)
12888 /* Look for the `operator' keyword. */
12889 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
12890 return error_mark_node;
12891 /* And then the name of the operator itself. */
12892 return cp_parser_operator (parser);
12895 /* Return an identifier node for a user-defined literal operator.
12896 The suffix identifier is chained to the operator name identifier. */
12899 cp_literal_operator_id (const char* name)
12902 char *buffer = XNEWVEC (char, strlen (UDLIT_OP_ANSI_PREFIX)
12903 + strlen (name) + 10);
12904 sprintf (buffer, UDLIT_OP_ANSI_FORMAT, name);
12905 identifier = get_identifier (buffer);
12910 /* Parse an operator.
12913 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
12914 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
12915 || ++ -- , ->* -> () []
12922 Returns an IDENTIFIER_NODE for the operator which is a
12923 human-readable spelling of the identifier, e.g., `operator +'. */
12926 cp_parser_operator (cp_parser* parser)
12928 tree id = NULL_TREE;
12932 /* Peek at the next token. */
12933 token = cp_lexer_peek_token (parser->lexer);
12934 /* Figure out which operator we have. */
12935 switch (token->type)
12941 /* The keyword should be either `new' or `delete'. */
12942 if (token->keyword == RID_NEW)
12944 else if (token->keyword == RID_DELETE)
12949 /* Consume the `new' or `delete' token. */
12950 cp_lexer_consume_token (parser->lexer);
12952 /* Peek at the next token. */
12953 token = cp_lexer_peek_token (parser->lexer);
12954 /* If it's a `[' token then this is the array variant of the
12956 if (token->type == CPP_OPEN_SQUARE)
12958 /* Consume the `[' token. */
12959 cp_lexer_consume_token (parser->lexer);
12960 /* Look for the `]' token. */
12961 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
12962 id = ansi_opname (op == NEW_EXPR
12963 ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
12965 /* Otherwise, we have the non-array variant. */
12967 id = ansi_opname (op);
12973 id = ansi_opname (PLUS_EXPR);
12977 id = ansi_opname (MINUS_EXPR);
12981 id = ansi_opname (MULT_EXPR);
12985 id = ansi_opname (TRUNC_DIV_EXPR);
12989 id = ansi_opname (TRUNC_MOD_EXPR);
12993 id = ansi_opname (BIT_XOR_EXPR);
12997 id = ansi_opname (BIT_AND_EXPR);
13001 id = ansi_opname (BIT_IOR_EXPR);
13005 id = ansi_opname (BIT_NOT_EXPR);
13009 id = ansi_opname (TRUTH_NOT_EXPR);
13013 id = ansi_assopname (NOP_EXPR);
13017 id = ansi_opname (LT_EXPR);
13021 id = ansi_opname (GT_EXPR);
13025 id = ansi_assopname (PLUS_EXPR);
13029 id = ansi_assopname (MINUS_EXPR);
13033 id = ansi_assopname (MULT_EXPR);
13037 id = ansi_assopname (TRUNC_DIV_EXPR);
13041 id = ansi_assopname (TRUNC_MOD_EXPR);
13045 id = ansi_assopname (BIT_XOR_EXPR);
13049 id = ansi_assopname (BIT_AND_EXPR);
13053 id = ansi_assopname (BIT_IOR_EXPR);
13057 id = ansi_opname (LSHIFT_EXPR);
13061 id = ansi_opname (RSHIFT_EXPR);
13064 case CPP_LSHIFT_EQ:
13065 id = ansi_assopname (LSHIFT_EXPR);
13068 case CPP_RSHIFT_EQ:
13069 id = ansi_assopname (RSHIFT_EXPR);
13073 id = ansi_opname (EQ_EXPR);
13077 id = ansi_opname (NE_EXPR);
13081 id = ansi_opname (LE_EXPR);
13084 case CPP_GREATER_EQ:
13085 id = ansi_opname (GE_EXPR);
13089 id = ansi_opname (TRUTH_ANDIF_EXPR);
13093 id = ansi_opname (TRUTH_ORIF_EXPR);
13096 case CPP_PLUS_PLUS:
13097 id = ansi_opname (POSTINCREMENT_EXPR);
13100 case CPP_MINUS_MINUS:
13101 id = ansi_opname (PREDECREMENT_EXPR);
13105 id = ansi_opname (COMPOUND_EXPR);
13108 case CPP_DEREF_STAR:
13109 id = ansi_opname (MEMBER_REF);
13113 id = ansi_opname (COMPONENT_REF);
13116 case CPP_OPEN_PAREN:
13117 /* Consume the `('. */
13118 cp_lexer_consume_token (parser->lexer);
13119 /* Look for the matching `)'. */
13120 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
13121 return ansi_opname (CALL_EXPR);
13123 case CPP_OPEN_SQUARE:
13124 /* Consume the `['. */
13125 cp_lexer_consume_token (parser->lexer);
13126 /* Look for the matching `]'. */
13127 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
13128 return ansi_opname (ARRAY_REF);
13130 case CPP_UTF8STRING:
13131 case CPP_UTF8STRING_USERDEF:
13137 case CPP_STRING_USERDEF:
13138 case CPP_WSTRING_USERDEF:
13139 case CPP_STRING16_USERDEF:
13140 case CPP_STRING32_USERDEF:
13142 tree str, string_tree;
13145 if (cxx_dialect == cxx98)
13146 maybe_warn_cpp0x (CPP0X_USER_DEFINED_LITERALS);
13148 /* Consume the string. */
13149 str = cp_parser_string_literal (parser, /*translate=*/true,
13150 /*wide_ok=*/true, /*lookup_udlit=*/false);
13151 if (str == error_mark_node)
13152 return error_mark_node;
13153 else if (TREE_CODE (str) == USERDEF_LITERAL)
13155 string_tree = USERDEF_LITERAL_VALUE (str);
13156 id = USERDEF_LITERAL_SUFFIX_ID (str);
13161 /* Look for the suffix identifier. */
13162 token = cp_lexer_peek_token (parser->lexer);
13163 if (token->type == CPP_NAME)
13164 id = cp_parser_identifier (parser);
13165 else if (token->type == CPP_KEYWORD)
13167 error ("unexpected keyword;"
13168 " remove space between quotes and suffix identifier");
13169 return error_mark_node;
13173 error ("expected suffix identifier");
13174 return error_mark_node;
13177 sz = TREE_INT_CST_LOW (TYPE_SIZE_UNIT
13178 (TREE_TYPE (TREE_TYPE (string_tree))));
13179 len = TREE_STRING_LENGTH (string_tree) / sz - 1;
13182 error ("expected empty string after %<operator%> keyword");
13183 return error_mark_node;
13185 if (utf8 || TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (string_tree)))
13188 error ("invalid encoding prefix in literal operator");
13189 return error_mark_node;
13191 if (id != error_mark_node)
13193 const char *name = IDENTIFIER_POINTER (id);
13194 id = cp_literal_operator_id (name);
13200 /* Anything else is an error. */
13204 /* If we have selected an identifier, we need to consume the
13207 cp_lexer_consume_token (parser->lexer);
13208 /* Otherwise, no valid operator name was present. */
13211 cp_parser_error (parser, "expected operator");
13212 id = error_mark_node;
13218 /* Parse a template-declaration.
13220 template-declaration:
13221 export [opt] template < template-parameter-list > declaration
13223 If MEMBER_P is TRUE, this template-declaration occurs within a
13226 The grammar rule given by the standard isn't correct. What
13227 is really meant is:
13229 template-declaration:
13230 export [opt] template-parameter-list-seq
13231 decl-specifier-seq [opt] init-declarator [opt] ;
13232 export [opt] template-parameter-list-seq
13233 function-definition
13235 template-parameter-list-seq:
13236 template-parameter-list-seq [opt]
13237 template < template-parameter-list > */
13240 cp_parser_template_declaration (cp_parser* parser, bool member_p)
13242 /* Check for `export'. */
13243 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
13245 /* Consume the `export' token. */
13246 cp_lexer_consume_token (parser->lexer);
13247 /* Warn that we do not support `export'. */
13248 warning (0, "keyword %<export%> not implemented, and will be ignored");
13251 cp_parser_template_declaration_after_export (parser, member_p);
13254 /* Parse a template-parameter-list.
13256 template-parameter-list:
13258 template-parameter-list , template-parameter
13260 Returns a TREE_LIST. Each node represents a template parameter.
13261 The nodes are connected via their TREE_CHAINs. */
13264 cp_parser_template_parameter_list (cp_parser* parser)
13266 tree parameter_list = NULL_TREE;
13268 begin_template_parm_list ();
13270 /* The loop below parses the template parms. We first need to know
13271 the total number of template parms to be able to compute proper
13272 canonical types of each dependent type. So after the loop, when
13273 we know the total number of template parms,
13274 end_template_parm_list computes the proper canonical types and
13275 fixes up the dependent types accordingly. */
13280 bool is_parameter_pack;
13281 location_t parm_loc;
13283 /* Parse the template-parameter. */
13284 parm_loc = cp_lexer_peek_token (parser->lexer)->location;
13285 parameter = cp_parser_template_parameter (parser,
13287 &is_parameter_pack);
13288 /* Add it to the list. */
13289 if (parameter != error_mark_node)
13290 parameter_list = process_template_parm (parameter_list,
13294 is_parameter_pack);
13297 tree err_parm = build_tree_list (parameter, parameter);
13298 parameter_list = chainon (parameter_list, err_parm);
13301 /* If the next token is not a `,', we're done. */
13302 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
13304 /* Otherwise, consume the `,' token. */
13305 cp_lexer_consume_token (parser->lexer);
13308 return end_template_parm_list (parameter_list);
13311 /* Parse a template-parameter.
13313 template-parameter:
13315 parameter-declaration
13317 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
13318 the parameter. The TREE_PURPOSE is the default value, if any.
13319 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
13320 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
13321 set to true iff this parameter is a parameter pack. */
13324 cp_parser_template_parameter (cp_parser* parser, bool *is_non_type,
13325 bool *is_parameter_pack)
13328 cp_parameter_declarator *parameter_declarator;
13329 cp_declarator *id_declarator;
13332 /* Assume it is a type parameter or a template parameter. */
13333 *is_non_type = false;
13334 /* Assume it not a parameter pack. */
13335 *is_parameter_pack = false;
13336 /* Peek at the next token. */
13337 token = cp_lexer_peek_token (parser->lexer);
13338 /* If it is `class' or `template', we have a type-parameter. */
13339 if (token->keyword == RID_TEMPLATE)
13340 return cp_parser_type_parameter (parser, is_parameter_pack);
13341 /* If it is `class' or `typename' we do not know yet whether it is a
13342 type parameter or a non-type parameter. Consider:
13344 template <typename T, typename T::X X> ...
13348 template <class C, class D*> ...
13350 Here, the first parameter is a type parameter, and the second is
13351 a non-type parameter. We can tell by looking at the token after
13352 the identifier -- if it is a `,', `=', or `>' then we have a type
13354 if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS)
13356 /* Peek at the token after `class' or `typename'. */
13357 token = cp_lexer_peek_nth_token (parser->lexer, 2);
13358 /* If it's an ellipsis, we have a template type parameter
13360 if (token->type == CPP_ELLIPSIS)
13361 return cp_parser_type_parameter (parser, is_parameter_pack);
13362 /* If it's an identifier, skip it. */
13363 if (token->type == CPP_NAME)
13364 token = cp_lexer_peek_nth_token (parser->lexer, 3);
13365 /* Now, see if the token looks like the end of a template
13367 if (token->type == CPP_COMMA
13368 || token->type == CPP_EQ
13369 || token->type == CPP_GREATER)
13370 return cp_parser_type_parameter (parser, is_parameter_pack);
13373 /* Otherwise, it is a non-type parameter.
13377 When parsing a default template-argument for a non-type
13378 template-parameter, the first non-nested `>' is taken as the end
13379 of the template parameter-list rather than a greater-than
13381 *is_non_type = true;
13382 parameter_declarator
13383 = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true,
13384 /*parenthesized_p=*/NULL);
13386 if (!parameter_declarator)
13387 return error_mark_node;
13389 /* If the parameter declaration is marked as a parameter pack, set
13390 *IS_PARAMETER_PACK to notify the caller. Also, unmark the
13391 declarator's PACK_EXPANSION_P, otherwise we'll get errors from
13393 if (parameter_declarator->declarator
13394 && parameter_declarator->declarator->parameter_pack_p)
13396 *is_parameter_pack = true;
13397 parameter_declarator->declarator->parameter_pack_p = false;
13400 if (parameter_declarator->default_argument)
13402 /* Can happen in some cases of erroneous input (c++/34892). */
13403 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
13404 /* Consume the `...' for better error recovery. */
13405 cp_lexer_consume_token (parser->lexer);
13407 /* If the next token is an ellipsis, and we don't already have it
13408 marked as a parameter pack, then we have a parameter pack (that
13409 has no declarator). */
13410 else if (!*is_parameter_pack
13411 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
13412 && (declarator_can_be_parameter_pack
13413 (parameter_declarator->declarator)))
13415 /* Consume the `...'. */
13416 cp_lexer_consume_token (parser->lexer);
13417 maybe_warn_variadic_templates ();
13419 *is_parameter_pack = true;
13421 /* We might end up with a pack expansion as the type of the non-type
13422 template parameter, in which case this is a non-type template
13424 else if (parameter_declarator->decl_specifiers.type
13425 && PACK_EXPANSION_P (parameter_declarator->decl_specifiers.type))
13427 *is_parameter_pack = true;
13428 parameter_declarator->decl_specifiers.type =
13429 PACK_EXPANSION_PATTERN (parameter_declarator->decl_specifiers.type);
13432 if (*is_parameter_pack && cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13434 /* Parameter packs cannot have default arguments. However, a
13435 user may try to do so, so we'll parse them and give an
13436 appropriate diagnostic here. */
13438 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
13440 /* Find the name of the parameter pack. */
13441 id_declarator = parameter_declarator->declarator;
13442 while (id_declarator && id_declarator->kind != cdk_id)
13443 id_declarator = id_declarator->declarator;
13445 if (id_declarator && id_declarator->kind == cdk_id)
13446 error_at (start_token->location,
13447 "template parameter pack %qD cannot have a default argument",
13448 id_declarator->u.id.unqualified_name);
13450 error_at (start_token->location,
13451 "template parameter pack cannot have a default argument");
13453 /* Parse the default argument, but throw away the result. */
13454 cp_parser_default_argument (parser, /*template_parm_p=*/true);
13457 parm = grokdeclarator (parameter_declarator->declarator,
13458 ¶meter_declarator->decl_specifiers,
13459 TPARM, /*initialized=*/0,
13460 /*attrlist=*/NULL);
13461 if (parm == error_mark_node)
13462 return error_mark_node;
13464 return build_tree_list (parameter_declarator->default_argument, parm);
13467 /* Parse a type-parameter.
13470 class identifier [opt]
13471 class identifier [opt] = type-id
13472 typename identifier [opt]
13473 typename identifier [opt] = type-id
13474 template < template-parameter-list > class identifier [opt]
13475 template < template-parameter-list > class identifier [opt]
13478 GNU Extension (variadic templates):
13481 class ... identifier [opt]
13482 typename ... identifier [opt]
13484 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
13485 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
13486 the declaration of the parameter.
13488 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
13491 cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack)
13496 /* Look for a keyword to tell us what kind of parameter this is. */
13497 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_TYPENAME_TEMPLATE);
13499 return error_mark_node;
13501 switch (token->keyword)
13507 tree default_argument;
13509 /* If the next token is an ellipsis, we have a template
13511 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
13513 /* Consume the `...' token. */
13514 cp_lexer_consume_token (parser->lexer);
13515 maybe_warn_variadic_templates ();
13517 *is_parameter_pack = true;
13520 /* If the next token is an identifier, then it names the
13522 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
13523 identifier = cp_parser_identifier (parser);
13525 identifier = NULL_TREE;
13527 /* Create the parameter. */
13528 parameter = finish_template_type_parm (class_type_node, identifier);
13530 /* If the next token is an `=', we have a default argument. */
13531 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13533 /* Consume the `=' token. */
13534 cp_lexer_consume_token (parser->lexer);
13535 /* Parse the default-argument. */
13536 push_deferring_access_checks (dk_no_deferred);
13537 default_argument = cp_parser_type_id (parser);
13539 /* Template parameter packs cannot have default
13541 if (*is_parameter_pack)
13544 error_at (token->location,
13545 "template parameter pack %qD cannot have a "
13546 "default argument", identifier);
13548 error_at (token->location,
13549 "template parameter packs cannot have "
13550 "default arguments");
13551 default_argument = NULL_TREE;
13553 else if (check_for_bare_parameter_packs (default_argument))
13554 default_argument = error_mark_node;
13555 pop_deferring_access_checks ();
13558 default_argument = NULL_TREE;
13560 /* Create the combined representation of the parameter and the
13561 default argument. */
13562 parameter = build_tree_list (default_argument, parameter);
13569 tree default_argument;
13571 /* Look for the `<'. */
13572 cp_parser_require (parser, CPP_LESS, RT_LESS);
13573 /* Parse the template-parameter-list. */
13574 cp_parser_template_parameter_list (parser);
13575 /* Look for the `>'. */
13576 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
13577 /* Look for the `class' or 'typename' keywords. */
13578 cp_parser_type_parameter_key (parser);
13579 /* If the next token is an ellipsis, we have a template
13581 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
13583 /* Consume the `...' token. */
13584 cp_lexer_consume_token (parser->lexer);
13585 maybe_warn_variadic_templates ();
13587 *is_parameter_pack = true;
13589 /* If the next token is an `=', then there is a
13590 default-argument. If the next token is a `>', we are at
13591 the end of the parameter-list. If the next token is a `,',
13592 then we are at the end of this parameter. */
13593 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
13594 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
13595 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
13597 identifier = cp_parser_identifier (parser);
13598 /* Treat invalid names as if the parameter were nameless. */
13599 if (identifier == error_mark_node)
13600 identifier = NULL_TREE;
13603 identifier = NULL_TREE;
13605 /* Create the template parameter. */
13606 parameter = finish_template_template_parm (class_type_node,
13609 /* If the next token is an `=', then there is a
13610 default-argument. */
13611 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
13615 /* Consume the `='. */
13616 cp_lexer_consume_token (parser->lexer);
13617 /* Parse the id-expression. */
13618 push_deferring_access_checks (dk_no_deferred);
13619 /* save token before parsing the id-expression, for error
13621 token = cp_lexer_peek_token (parser->lexer);
13623 = cp_parser_id_expression (parser,
13624 /*template_keyword_p=*/false,
13625 /*check_dependency_p=*/true,
13626 /*template_p=*/&is_template,
13627 /*declarator_p=*/false,
13628 /*optional_p=*/false);
13629 if (TREE_CODE (default_argument) == TYPE_DECL)
13630 /* If the id-expression was a template-id that refers to
13631 a template-class, we already have the declaration here,
13632 so no further lookup is needed. */
13635 /* Look up the name. */
13637 = cp_parser_lookup_name (parser, default_argument,
13639 /*is_template=*/is_template,
13640 /*is_namespace=*/false,
13641 /*check_dependency=*/true,
13642 /*ambiguous_decls=*/NULL,
13644 /* See if the default argument is valid. */
13646 = check_template_template_default_arg (default_argument);
13648 /* Template parameter packs cannot have default
13650 if (*is_parameter_pack)
13653 error_at (token->location,
13654 "template parameter pack %qD cannot "
13655 "have a default argument",
13658 error_at (token->location, "template parameter packs cannot "
13659 "have default arguments");
13660 default_argument = NULL_TREE;
13662 pop_deferring_access_checks ();
13665 default_argument = NULL_TREE;
13667 /* Create the combined representation of the parameter and the
13668 default argument. */
13669 parameter = build_tree_list (default_argument, parameter);
13674 gcc_unreachable ();
13681 /* Parse a template-id.
13684 template-name < template-argument-list [opt] >
13686 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
13687 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
13688 returned. Otherwise, if the template-name names a function, or set
13689 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
13690 names a class, returns a TYPE_DECL for the specialization.
13692 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
13693 uninstantiated templates. */
13696 cp_parser_template_id (cp_parser *parser,
13697 bool template_keyword_p,
13698 bool check_dependency_p,
13699 enum tag_types tag_type,
13700 bool is_declaration)
13706 cp_token_position start_of_id = 0;
13707 deferred_access_check *chk;
13708 vec<deferred_access_check, va_gc> *access_check;
13709 cp_token *next_token = NULL, *next_token_2 = NULL;
13710 bool is_identifier;
13712 /* If the next token corresponds to a template-id, there is no need
13714 next_token = cp_lexer_peek_token (parser->lexer);
13715 if (next_token->type == CPP_TEMPLATE_ID)
13717 struct tree_check *check_value;
13719 /* Get the stored value. */
13720 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
13721 /* Perform any access checks that were deferred. */
13722 access_check = check_value->checks;
13725 FOR_EACH_VEC_ELT (*access_check, i, chk)
13726 perform_or_defer_access_check (chk->binfo,
13729 tf_warning_or_error);
13731 /* Return the stored value. */
13732 return check_value->value;
13735 /* Avoid performing name lookup if there is no possibility of
13736 finding a template-id. */
13737 if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR)
13738 || (next_token->type == CPP_NAME
13739 && !cp_parser_nth_token_starts_template_argument_list_p
13742 cp_parser_error (parser, "expected template-id");
13743 return error_mark_node;
13746 /* Remember where the template-id starts. */
13747 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
13748 start_of_id = cp_lexer_token_position (parser->lexer, false);
13750 push_deferring_access_checks (dk_deferred);
13752 /* Parse the template-name. */
13753 is_identifier = false;
13754 templ = cp_parser_template_name (parser, template_keyword_p,
13755 check_dependency_p,
13759 if (templ == error_mark_node || is_identifier)
13761 pop_deferring_access_checks ();
13765 /* If we find the sequence `[:' after a template-name, it's probably
13766 a digraph-typo for `< ::'. Substitute the tokens and check if we can
13767 parse correctly the argument list. */
13768 next_token = cp_lexer_peek_token (parser->lexer);
13769 next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2);
13770 if (next_token->type == CPP_OPEN_SQUARE
13771 && next_token->flags & DIGRAPH
13772 && next_token_2->type == CPP_COLON
13773 && !(next_token_2->flags & PREV_WHITE))
13775 cp_parser_parse_tentatively (parser);
13776 /* Change `:' into `::'. */
13777 next_token_2->type = CPP_SCOPE;
13778 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
13780 cp_lexer_consume_token (parser->lexer);
13782 /* Parse the arguments. */
13783 arguments = cp_parser_enclosed_template_argument_list (parser);
13784 if (!cp_parser_parse_definitely (parser))
13786 /* If we couldn't parse an argument list, then we revert our changes
13787 and return simply an error. Maybe this is not a template-id
13789 next_token_2->type = CPP_COLON;
13790 cp_parser_error (parser, "expected %<<%>");
13791 pop_deferring_access_checks ();
13792 return error_mark_node;
13794 /* Otherwise, emit an error about the invalid digraph, but continue
13795 parsing because we got our argument list. */
13796 if (permerror (next_token->location,
13797 "%<<::%> cannot begin a template-argument list"))
13799 static bool hint = false;
13800 inform (next_token->location,
13801 "%<<:%> is an alternate spelling for %<[%>."
13802 " Insert whitespace between %<<%> and %<::%>");
13803 if (!hint && !flag_permissive)
13805 inform (next_token->location, "(if you use %<-fpermissive%> "
13806 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
13807 "accept your code)");
13814 /* Look for the `<' that starts the template-argument-list. */
13815 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
13817 pop_deferring_access_checks ();
13818 return error_mark_node;
13820 /* Parse the arguments. */
13821 arguments = cp_parser_enclosed_template_argument_list (parser);
13824 /* Build a representation of the specialization. */
13825 if (identifier_p (templ))
13826 template_id = build_min_nt_loc (next_token->location,
13829 else if (DECL_TYPE_TEMPLATE_P (templ)
13830 || DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
13832 bool entering_scope;
13833 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
13834 template (rather than some instantiation thereof) only if
13835 is not nested within some other construct. For example, in
13836 "template <typename T> void f(T) { A<T>::", A<T> is just an
13837 instantiation of A. */
13838 entering_scope = (template_parm_scope_p ()
13839 && cp_lexer_next_token_is (parser->lexer,
13842 = finish_template_type (templ, arguments, entering_scope);
13844 else if (variable_template_p (templ))
13846 template_id = lookup_template_variable (templ, arguments);
13850 /* If it's not a class-template or a template-template, it should be
13851 a function-template. */
13852 gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
13853 || TREE_CODE (templ) == OVERLOAD
13854 || BASELINK_P (templ)));
13856 template_id = lookup_template_function (templ, arguments);
13859 /* If parsing tentatively, replace the sequence of tokens that makes
13860 up the template-id with a CPP_TEMPLATE_ID token. That way,
13861 should we re-parse the token stream, we will not have to repeat
13862 the effort required to do the parse, nor will we issue duplicate
13863 error messages about problems during instantiation of the
13866 /* Don't do this if we had a parse error in a declarator; re-parsing
13867 might succeed if a name changes meaning (60361). */
13868 && !(cp_parser_error_occurred (parser)
13869 && cp_parser_parsing_tentatively (parser)
13870 && parser->in_declarator_p))
13872 cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id);
13874 /* Reset the contents of the START_OF_ID token. */
13875 token->type = CPP_TEMPLATE_ID;
13876 /* Retrieve any deferred checks. Do not pop this access checks yet
13877 so the memory will not be reclaimed during token replacing below. */
13878 token->u.tree_check_value = ggc_cleared_alloc<struct tree_check> ();
13879 token->u.tree_check_value->value = template_id;
13880 token->u.tree_check_value->checks = get_deferred_access_checks ();
13881 token->keyword = RID_MAX;
13883 /* Purge all subsequent tokens. */
13884 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
13886 /* ??? Can we actually assume that, if template_id ==
13887 error_mark_node, we will have issued a diagnostic to the
13888 user, as opposed to simply marking the tentative parse as
13890 if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
13891 error_at (token->location, "parse error in template argument list");
13894 pop_to_parent_deferring_access_checks ();
13895 return template_id;
13898 /* Parse a template-name.
13903 The standard should actually say:
13907 operator-function-id
13909 A defect report has been filed about this issue.
13911 A conversion-function-id cannot be a template name because they cannot
13912 be part of a template-id. In fact, looking at this code:
13914 a.operator K<int>()
13916 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
13917 It is impossible to call a templated conversion-function-id with an
13918 explicit argument list, since the only allowed template parameter is
13919 the type to which it is converting.
13921 If TEMPLATE_KEYWORD_P is true, then we have just seen the
13922 `template' keyword, in a construction like:
13926 In that case `f' is taken to be a template-name, even though there
13927 is no way of knowing for sure.
13929 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
13930 name refers to a set of overloaded functions, at least one of which
13931 is a template, or an IDENTIFIER_NODE with the name of the template,
13932 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
13933 names are looked up inside uninstantiated templates. */
13936 cp_parser_template_name (cp_parser* parser,
13937 bool template_keyword_p,
13938 bool check_dependency_p,
13939 bool is_declaration,
13940 enum tag_types tag_type,
13941 bool *is_identifier)
13946 cp_token *token = cp_lexer_peek_token (parser->lexer);
13948 /* If the next token is `operator', then we have either an
13949 operator-function-id or a conversion-function-id. */
13950 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
13952 /* We don't know whether we're looking at an
13953 operator-function-id or a conversion-function-id. */
13954 cp_parser_parse_tentatively (parser);
13955 /* Try an operator-function-id. */
13956 identifier = cp_parser_operator_function_id (parser);
13957 /* If that didn't work, try a conversion-function-id. */
13958 if (!cp_parser_parse_definitely (parser))
13960 cp_parser_error (parser, "expected template-name");
13961 return error_mark_node;
13964 /* Look for the identifier. */
13966 identifier = cp_parser_identifier (parser);
13968 /* If we didn't find an identifier, we don't have a template-id. */
13969 if (identifier == error_mark_node)
13970 return error_mark_node;
13972 /* If the name immediately followed the `template' keyword, then it
13973 is a template-name. However, if the next token is not `<', then
13974 we do not treat it as a template-name, since it is not being used
13975 as part of a template-id. This enables us to handle constructs
13978 template <typename T> struct S { S(); };
13979 template <typename T> S<T>::S();
13981 correctly. We would treat `S' as a template -- if it were `S<T>'
13982 -- but we do not if there is no `<'. */
13984 if (processing_template_decl
13985 && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
13987 /* In a declaration, in a dependent context, we pretend that the
13988 "template" keyword was present in order to improve error
13989 recovery. For example, given:
13991 template <typename T> void f(T::X<int>);
13993 we want to treat "X<int>" as a template-id. */
13995 && !template_keyword_p
13996 && parser->scope && TYPE_P (parser->scope)
13997 && check_dependency_p
13998 && dependent_scope_p (parser->scope)
13999 /* Do not do this for dtors (or ctors), since they never
14000 need the template keyword before their name. */
14001 && !constructor_name_p (identifier, parser->scope))
14003 cp_token_position start = 0;
14005 /* Explain what went wrong. */
14006 error_at (token->location, "non-template %qD used as template",
14008 inform (token->location, "use %<%T::template %D%> to indicate that it is a template",
14009 parser->scope, identifier);
14010 /* If parsing tentatively, find the location of the "<" token. */
14011 if (cp_parser_simulate_error (parser))
14012 start = cp_lexer_token_position (parser->lexer, true);
14013 /* Parse the template arguments so that we can issue error
14014 messages about them. */
14015 cp_lexer_consume_token (parser->lexer);
14016 cp_parser_enclosed_template_argument_list (parser);
14017 /* Skip tokens until we find a good place from which to
14018 continue parsing. */
14019 cp_parser_skip_to_closing_parenthesis (parser,
14020 /*recovering=*/true,
14022 /*consume_paren=*/false);
14023 /* If parsing tentatively, permanently remove the
14024 template argument list. That will prevent duplicate
14025 error messages from being issued about the missing
14026 "template" keyword. */
14028 cp_lexer_purge_tokens_after (parser->lexer, start);
14030 *is_identifier = true;
14034 /* If the "template" keyword is present, then there is generally
14035 no point in doing name-lookup, so we just return IDENTIFIER.
14036 But, if the qualifying scope is non-dependent then we can
14037 (and must) do name-lookup normally. */
14038 if (template_keyword_p
14040 || (TYPE_P (parser->scope)
14041 && dependent_type_p (parser->scope))))
14045 /* Look up the name. */
14046 decl = cp_parser_lookup_name (parser, identifier,
14048 /*is_template=*/true,
14049 /*is_namespace=*/false,
14050 check_dependency_p,
14051 /*ambiguous_decls=*/NULL,
14054 /* If DECL is a template, then the name was a template-name. */
14055 if (TREE_CODE (decl) == TEMPLATE_DECL)
14057 if (TREE_DEPRECATED (decl)
14058 && deprecated_state != DEPRECATED_SUPPRESS)
14059 warn_deprecated_use (decl, NULL_TREE);
14063 tree fn = NULL_TREE;
14065 /* The standard does not explicitly indicate whether a name that
14066 names a set of overloaded declarations, some of which are
14067 templates, is a template-name. However, such a name should
14068 be a template-name; otherwise, there is no way to form a
14069 template-id for the overloaded templates. */
14070 fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl;
14071 if (TREE_CODE (fns) == OVERLOAD)
14072 for (fn = fns; fn; fn = OVL_NEXT (fn))
14073 if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL)
14078 /* The name does not name a template. */
14079 cp_parser_error (parser, "expected template-name");
14080 return error_mark_node;
14084 /* If DECL is dependent, and refers to a function, then just return
14085 its name; we will look it up again during template instantiation. */
14086 if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl))
14088 tree scope = ovl_scope (decl);
14089 if (TYPE_P (scope) && dependent_type_p (scope))
14096 /* Parse a template-argument-list.
14098 template-argument-list:
14099 template-argument ... [opt]
14100 template-argument-list , template-argument ... [opt]
14102 Returns a TREE_VEC containing the arguments. */
14105 cp_parser_template_argument_list (cp_parser* parser)
14107 tree fixed_args[10];
14108 unsigned n_args = 0;
14109 unsigned alloced = 10;
14110 tree *arg_ary = fixed_args;
14112 bool saved_in_template_argument_list_p;
14114 bool saved_non_ice_p;
14116 saved_in_template_argument_list_p = parser->in_template_argument_list_p;
14117 parser->in_template_argument_list_p = true;
14118 /* Even if the template-id appears in an integral
14119 constant-expression, the contents of the argument list do
14121 saved_ice_p = parser->integral_constant_expression_p;
14122 parser->integral_constant_expression_p = false;
14123 saved_non_ice_p = parser->non_integral_constant_expression_p;
14124 parser->non_integral_constant_expression_p = false;
14126 /* Parse the arguments. */
14132 /* Consume the comma. */
14133 cp_lexer_consume_token (parser->lexer);
14135 /* Parse the template-argument. */
14136 argument = cp_parser_template_argument (parser);
14138 /* If the next token is an ellipsis, we're expanding a template
14140 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
14142 if (argument == error_mark_node)
14144 cp_token *token = cp_lexer_peek_token (parser->lexer);
14145 error_at (token->location,
14146 "expected parameter pack before %<...%>");
14148 /* Consume the `...' token. */
14149 cp_lexer_consume_token (parser->lexer);
14151 /* Make the argument into a TYPE_PACK_EXPANSION or
14152 EXPR_PACK_EXPANSION. */
14153 argument = make_pack_expansion (argument);
14156 if (n_args == alloced)
14160 if (arg_ary == fixed_args)
14162 arg_ary = XNEWVEC (tree, alloced);
14163 memcpy (arg_ary, fixed_args, sizeof (tree) * n_args);
14166 arg_ary = XRESIZEVEC (tree, arg_ary, alloced);
14168 arg_ary[n_args++] = argument;
14170 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
14172 vec = make_tree_vec (n_args);
14175 TREE_VEC_ELT (vec, n_args) = arg_ary[n_args];
14177 if (arg_ary != fixed_args)
14179 parser->non_integral_constant_expression_p = saved_non_ice_p;
14180 parser->integral_constant_expression_p = saved_ice_p;
14181 parser->in_template_argument_list_p = saved_in_template_argument_list_p;
14182 #ifdef ENABLE_CHECKING
14183 SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
14188 /* Parse a template-argument.
14191 assignment-expression
14195 The representation is that of an assignment-expression, type-id, or
14196 id-expression -- except that the qualified id-expression is
14197 evaluated, so that the value returned is either a DECL or an
14200 Although the standard says "assignment-expression", it forbids
14201 throw-expressions or assignments in the template argument.
14202 Therefore, we use "conditional-expression" instead. */
14205 cp_parser_template_argument (cp_parser* parser)
14210 bool maybe_type_id = false;
14211 cp_token *token = NULL, *argument_start_token = NULL;
14212 location_t loc = 0;
14215 /* There's really no way to know what we're looking at, so we just
14216 try each alternative in order.
14220 In a template-argument, an ambiguity between a type-id and an
14221 expression is resolved to a type-id, regardless of the form of
14222 the corresponding template-parameter.
14224 Therefore, we try a type-id first. */
14225 cp_parser_parse_tentatively (parser);
14226 argument = cp_parser_template_type_arg (parser);
14227 /* If there was no error parsing the type-id but the next token is a
14228 '>>', our behavior depends on which dialect of C++ we're
14229 parsing. In C++98, we probably found a typo for '> >'. But there
14230 are type-id which are also valid expressions. For instance:
14232 struct X { int operator >> (int); };
14233 template <int V> struct Foo {};
14236 Here 'X()' is a valid type-id of a function type, but the user just
14237 wanted to write the expression "X() >> 5". Thus, we remember that we
14238 found a valid type-id, but we still try to parse the argument as an
14239 expression to see what happens.
14241 In C++0x, the '>>' will be considered two separate '>'
14243 if (!cp_parser_error_occurred (parser)
14244 && cxx_dialect == cxx98
14245 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
14247 maybe_type_id = true;
14248 cp_parser_abort_tentative_parse (parser);
14252 /* If the next token isn't a `,' or a `>', then this argument wasn't
14253 really finished. This means that the argument is not a valid
14255 if (!cp_parser_next_token_ends_template_argument_p (parser))
14256 cp_parser_error (parser, "expected template-argument");
14257 /* If that worked, we're done. */
14258 if (cp_parser_parse_definitely (parser))
14261 /* We're still not sure what the argument will be. */
14262 cp_parser_parse_tentatively (parser);
14263 /* Try a template. */
14264 argument_start_token = cp_lexer_peek_token (parser->lexer);
14265 argument = cp_parser_id_expression (parser,
14266 /*template_keyword_p=*/false,
14267 /*check_dependency_p=*/true,
14269 /*declarator_p=*/false,
14270 /*optional_p=*/false);
14271 /* If the next token isn't a `,' or a `>', then this argument wasn't
14272 really finished. */
14273 if (!cp_parser_next_token_ends_template_argument_p (parser))
14274 cp_parser_error (parser, "expected template-argument");
14275 if (!cp_parser_error_occurred (parser))
14277 /* Figure out what is being referred to. If the id-expression
14278 was for a class template specialization, then we will have a
14279 TYPE_DECL at this point. There is no need to do name lookup
14280 at this point in that case. */
14281 if (TREE_CODE (argument) != TYPE_DECL)
14282 argument = cp_parser_lookup_name (parser, argument,
14284 /*is_template=*/template_p,
14285 /*is_namespace=*/false,
14286 /*check_dependency=*/true,
14287 /*ambiguous_decls=*/NULL,
14288 argument_start_token->location);
14289 if (TREE_CODE (argument) != TEMPLATE_DECL
14290 && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
14291 cp_parser_error (parser, "expected template-name");
14293 if (cp_parser_parse_definitely (parser))
14295 if (TREE_DEPRECATED (argument))
14296 warn_deprecated_use (argument, NULL_TREE);
14299 /* It must be a non-type argument. There permitted cases are given
14300 in [temp.arg.nontype]:
14302 -- an integral constant-expression of integral or enumeration
14305 -- the name of a non-type template-parameter; or
14307 -- the name of an object or function with external linkage...
14309 -- the address of an object or function with external linkage...
14311 -- a pointer to member... */
14312 /* Look for a non-type template parameter. */
14313 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
14315 cp_parser_parse_tentatively (parser);
14316 argument = cp_parser_primary_expression (parser,
14317 /*address_p=*/false,
14319 /*template_arg_p=*/true,
14321 if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX
14322 || !cp_parser_next_token_ends_template_argument_p (parser))
14323 cp_parser_simulate_error (parser);
14324 if (cp_parser_parse_definitely (parser))
14328 /* If the next token is "&", the argument must be the address of an
14329 object or function with external linkage. */
14330 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
14333 loc = cp_lexer_peek_token (parser->lexer)->location;
14334 cp_lexer_consume_token (parser->lexer);
14336 /* See if we might have an id-expression. */
14337 token = cp_lexer_peek_token (parser->lexer);
14338 if (token->type == CPP_NAME
14339 || token->keyword == RID_OPERATOR
14340 || token->type == CPP_SCOPE
14341 || token->type == CPP_TEMPLATE_ID
14342 || token->type == CPP_NESTED_NAME_SPECIFIER)
14344 cp_parser_parse_tentatively (parser);
14345 argument = cp_parser_primary_expression (parser,
14348 /*template_arg_p=*/true,
14350 if (cp_parser_error_occurred (parser)
14351 || !cp_parser_next_token_ends_template_argument_p (parser))
14352 cp_parser_abort_tentative_parse (parser);
14357 if (INDIRECT_REF_P (argument))
14359 /* Strip the dereference temporarily. */
14360 gcc_assert (REFERENCE_REF_P (argument));
14361 argument = TREE_OPERAND (argument, 0);
14364 /* If we're in a template, we represent a qualified-id referring
14365 to a static data member as a SCOPE_REF even if the scope isn't
14366 dependent so that we can check access control later. */
14368 if (TREE_CODE (probe) == SCOPE_REF)
14369 probe = TREE_OPERAND (probe, 1);
14372 /* A variable without external linkage might still be a
14373 valid constant-expression, so no error is issued here
14374 if the external-linkage check fails. */
14375 if (!address_p && !DECL_EXTERNAL_LINKAGE_P (probe))
14376 cp_parser_simulate_error (parser);
14378 else if (is_overloaded_fn (argument))
14379 /* All overloaded functions are allowed; if the external
14380 linkage test does not pass, an error will be issued
14384 && (TREE_CODE (argument) == OFFSET_REF
14385 || TREE_CODE (argument) == SCOPE_REF))
14386 /* A pointer-to-member. */
14388 else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX)
14391 cp_parser_simulate_error (parser);
14393 if (cp_parser_parse_definitely (parser))
14396 argument = build_x_unary_op (loc, ADDR_EXPR, argument,
14397 tf_warning_or_error);
14399 argument = convert_from_reference (argument);
14404 /* If the argument started with "&", there are no other valid
14405 alternatives at this point. */
14408 cp_parser_error (parser, "invalid non-type template argument");
14409 return error_mark_node;
14412 /* If the argument wasn't successfully parsed as a type-id followed
14413 by '>>', the argument can only be a constant expression now.
14414 Otherwise, we try parsing the constant-expression tentatively,
14415 because the argument could really be a type-id. */
14417 cp_parser_parse_tentatively (parser);
14418 argument = cp_parser_constant_expression (parser);
14420 if (!maybe_type_id)
14422 if (!cp_parser_next_token_ends_template_argument_p (parser))
14423 cp_parser_error (parser, "expected template-argument");
14424 if (cp_parser_parse_definitely (parser))
14426 /* We did our best to parse the argument as a non type-id, but that
14427 was the only alternative that matched (albeit with a '>' after
14428 it). We can assume it's just a typo from the user, and a
14429 diagnostic will then be issued. */
14430 return cp_parser_template_type_arg (parser);
14433 /* Parse an explicit-instantiation.
14435 explicit-instantiation:
14436 template declaration
14438 Although the standard says `declaration', what it really means is:
14440 explicit-instantiation:
14441 template decl-specifier-seq [opt] declarator [opt] ;
14443 Things like `template int S<int>::i = 5, int S<double>::j;' are not
14444 supposed to be allowed. A defect report has been filed about this
14449 explicit-instantiation:
14450 storage-class-specifier template
14451 decl-specifier-seq [opt] declarator [opt] ;
14452 function-specifier template
14453 decl-specifier-seq [opt] declarator [opt] ; */
14456 cp_parser_explicit_instantiation (cp_parser* parser)
14458 int declares_class_or_enum;
14459 cp_decl_specifier_seq decl_specifiers;
14460 tree extension_specifier = NULL_TREE;
14462 timevar_push (TV_TEMPLATE_INST);
14464 /* Look for an (optional) storage-class-specifier or
14465 function-specifier. */
14466 if (cp_parser_allow_gnu_extensions_p (parser))
14468 extension_specifier
14469 = cp_parser_storage_class_specifier_opt (parser);
14470 if (!extension_specifier)
14471 extension_specifier
14472 = cp_parser_function_specifier_opt (parser,
14473 /*decl_specs=*/NULL);
14476 /* Look for the `template' keyword. */
14477 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
14478 /* Let the front end know that we are processing an explicit
14480 begin_explicit_instantiation ();
14481 /* [temp.explicit] says that we are supposed to ignore access
14482 control while processing explicit instantiation directives. */
14483 push_deferring_access_checks (dk_no_check);
14484 /* Parse a decl-specifier-seq. */
14485 cp_parser_decl_specifier_seq (parser,
14486 CP_PARSER_FLAGS_OPTIONAL,
14488 &declares_class_or_enum);
14489 /* If there was exactly one decl-specifier, and it declared a class,
14490 and there's no declarator, then we have an explicit type
14492 if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
14496 type = check_tag_decl (&decl_specifiers,
14497 /*explicit_type_instantiation_p=*/true);
14498 /* Turn access control back on for names used during
14499 template instantiation. */
14500 pop_deferring_access_checks ();
14502 do_type_instantiation (type, extension_specifier,
14503 /*complain=*/tf_error);
14507 cp_declarator *declarator;
14510 /* Parse the declarator. */
14512 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
14513 /*ctor_dtor_or_conv_p=*/NULL,
14514 /*parenthesized_p=*/NULL,
14515 /*member_p=*/false,
14516 /*friend_p=*/false);
14517 if (declares_class_or_enum & 2)
14518 cp_parser_check_for_definition_in_return_type (declarator,
14519 decl_specifiers.type,
14520 decl_specifiers.locations[ds_type_spec]);
14521 if (declarator != cp_error_declarator)
14523 if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_inline))
14524 permerror (decl_specifiers.locations[ds_inline],
14525 "explicit instantiation shall not use"
14526 " %<inline%> specifier");
14527 if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_constexpr))
14528 permerror (decl_specifiers.locations[ds_constexpr],
14529 "explicit instantiation shall not use"
14530 " %<constexpr%> specifier");
14532 decl = grokdeclarator (declarator, &decl_specifiers,
14533 NORMAL, 0, &decl_specifiers.attributes);
14534 /* Turn access control back on for names used during
14535 template instantiation. */
14536 pop_deferring_access_checks ();
14537 /* Do the explicit instantiation. */
14538 do_decl_instantiation (decl, extension_specifier);
14542 pop_deferring_access_checks ();
14543 /* Skip the body of the explicit instantiation. */
14544 cp_parser_skip_to_end_of_statement (parser);
14547 /* We're done with the instantiation. */
14548 end_explicit_instantiation ();
14550 cp_parser_consume_semicolon_at_end_of_statement (parser);
14552 timevar_pop (TV_TEMPLATE_INST);
14555 /* Parse an explicit-specialization.
14557 explicit-specialization:
14558 template < > declaration
14560 Although the standard says `declaration', what it really means is:
14562 explicit-specialization:
14563 template <> decl-specifier [opt] init-declarator [opt] ;
14564 template <> function-definition
14565 template <> explicit-specialization
14566 template <> template-declaration */
14569 cp_parser_explicit_specialization (cp_parser* parser)
14571 bool need_lang_pop;
14572 cp_token *token = cp_lexer_peek_token (parser->lexer);
14574 /* Look for the `template' keyword. */
14575 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
14576 /* Look for the `<'. */
14577 cp_parser_require (parser, CPP_LESS, RT_LESS);
14578 /* Look for the `>'. */
14579 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
14580 /* We have processed another parameter list. */
14581 ++parser->num_template_parameter_lists;
14584 A template ... explicit specialization ... shall not have C
14586 if (current_lang_name == lang_name_c)
14588 error_at (token->location, "template specialization with C linkage");
14589 /* Give it C++ linkage to avoid confusing other parts of the
14591 push_lang_context (lang_name_cplusplus);
14592 need_lang_pop = true;
14595 need_lang_pop = false;
14596 /* Let the front end know that we are beginning a specialization. */
14597 if (!begin_specialization ())
14599 end_specialization ();
14603 /* If the next keyword is `template', we need to figure out whether
14604 or not we're looking a template-declaration. */
14605 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
14607 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
14608 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
14609 cp_parser_template_declaration_after_export (parser,
14610 /*member_p=*/false);
14612 cp_parser_explicit_specialization (parser);
14615 /* Parse the dependent declaration. */
14616 cp_parser_single_declaration (parser,
14618 /*member_p=*/false,
14619 /*explicit_specialization_p=*/true,
14620 /*friend_p=*/NULL);
14621 /* We're done with the specialization. */
14622 end_specialization ();
14623 /* For the erroneous case of a template with C linkage, we pushed an
14624 implicit C++ linkage scope; exit that scope now. */
14626 pop_lang_context ();
14627 /* We're done with this parameter list. */
14628 --parser->num_template_parameter_lists;
14631 /* Parse a type-specifier.
14634 simple-type-specifier
14637 elaborated-type-specifier
14645 Returns a representation of the type-specifier. For a
14646 class-specifier, enum-specifier, or elaborated-type-specifier, a
14647 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
14649 The parser flags FLAGS is used to control type-specifier parsing.
14651 If IS_DECLARATION is TRUE, then this type-specifier is appearing
14652 in a decl-specifier-seq.
14654 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
14655 class-specifier, enum-specifier, or elaborated-type-specifier, then
14656 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
14657 if a type is declared; 2 if it is defined. Otherwise, it is set to
14660 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
14661 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
14662 is set to FALSE. */
14665 cp_parser_type_specifier (cp_parser* parser,
14666 cp_parser_flags flags,
14667 cp_decl_specifier_seq *decl_specs,
14668 bool is_declaration,
14669 int* declares_class_or_enum,
14670 bool* is_cv_qualifier)
14672 tree type_spec = NULL_TREE;
14675 cp_decl_spec ds = ds_last;
14677 /* Assume this type-specifier does not declare a new type. */
14678 if (declares_class_or_enum)
14679 *declares_class_or_enum = 0;
14680 /* And that it does not specify a cv-qualifier. */
14681 if (is_cv_qualifier)
14682 *is_cv_qualifier = false;
14683 /* Peek at the next token. */
14684 token = cp_lexer_peek_token (parser->lexer);
14686 /* If we're looking at a keyword, we can use that to guide the
14687 production we choose. */
14688 keyword = token->keyword;
14692 if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
14693 goto elaborated_type_specifier;
14695 /* Look for the enum-specifier. */
14696 type_spec = cp_parser_enum_specifier (parser);
14697 /* If that worked, we're done. */
14700 if (declares_class_or_enum)
14701 *declares_class_or_enum = 2;
14703 cp_parser_set_decl_spec_type (decl_specs,
14706 /*type_definition_p=*/true);
14710 goto elaborated_type_specifier;
14712 /* Any of these indicate either a class-specifier, or an
14713 elaborated-type-specifier. */
14717 if ((flags & CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS))
14718 goto elaborated_type_specifier;
14720 /* Parse tentatively so that we can back up if we don't find a
14721 class-specifier. */
14722 cp_parser_parse_tentatively (parser);
14723 /* Look for the class-specifier. */
14724 type_spec = cp_parser_class_specifier (parser);
14725 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, type_spec);
14726 /* If that worked, we're done. */
14727 if (cp_parser_parse_definitely (parser))
14729 if (declares_class_or_enum)
14730 *declares_class_or_enum = 2;
14732 cp_parser_set_decl_spec_type (decl_specs,
14735 /*type_definition_p=*/true);
14739 /* Fall through. */
14740 elaborated_type_specifier:
14741 /* We're declaring (not defining) a class or enum. */
14742 if (declares_class_or_enum)
14743 *declares_class_or_enum = 1;
14745 /* Fall through. */
14747 /* Look for an elaborated-type-specifier. */
14749 = (cp_parser_elaborated_type_specifier
14751 decl_spec_seq_has_spec_p (decl_specs, ds_friend),
14754 cp_parser_set_decl_spec_type (decl_specs,
14757 /*type_definition_p=*/false);
14762 if (is_cv_qualifier)
14763 *is_cv_qualifier = true;
14768 if (is_cv_qualifier)
14769 *is_cv_qualifier = true;
14774 if (is_cv_qualifier)
14775 *is_cv_qualifier = true;
14779 /* The `__complex__' keyword is a GNU extension. */
14787 /* Handle simple keywords. */
14792 set_and_check_decl_spec_loc (decl_specs, ds, token);
14793 decl_specs->any_specifiers_p = true;
14795 return cp_lexer_consume_token (parser->lexer)->u.value;
14798 /* If we do not already have a type-specifier, assume we are looking
14799 at a simple-type-specifier. */
14800 type_spec = cp_parser_simple_type_specifier (parser,
14804 /* If we didn't find a type-specifier, and a type-specifier was not
14805 optional in this context, issue an error message. */
14806 if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL))
14808 cp_parser_error (parser, "expected type specifier");
14809 return error_mark_node;
14815 /* Parse a simple-type-specifier.
14817 simple-type-specifier:
14818 :: [opt] nested-name-specifier [opt] type-name
14819 :: [opt] nested-name-specifier template template-id
14834 simple-type-specifier:
14836 decltype ( expression )
14839 __underlying_type ( type-id )
14843 simple-type-specifier:
14845 __typeof__ unary-expression
14846 __typeof__ ( type-id )
14847 __typeof__ ( type-id ) { initializer-list , [opt] }
14849 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
14850 appropriately updated. */
14853 cp_parser_simple_type_specifier (cp_parser* parser,
14854 cp_decl_specifier_seq *decl_specs,
14855 cp_parser_flags flags)
14857 tree type = NULL_TREE;
14861 /* Peek at the next token. */
14862 token = cp_lexer_peek_token (parser->lexer);
14864 /* If we're looking at a keyword, things are easy. */
14865 switch (token->keyword)
14869 decl_specs->explicit_char_p = true;
14870 type = char_type_node;
14873 type = char16_type_node;
14876 type = char32_type_node;
14879 type = wchar_type_node;
14882 type = boolean_type_node;
14885 set_and_check_decl_spec_loc (decl_specs, ds_short, token);
14886 type = short_integer_type_node;
14890 decl_specs->explicit_int_p = true;
14891 type = integer_type_node;
14897 idx = token->keyword - RID_INT_N_0;
14898 if (! int_n_enabled_p [idx])
14902 decl_specs->explicit_intN_p = true;
14903 decl_specs->int_n_idx = idx;
14905 type = int_n_trees [idx].signed_type;
14909 set_and_check_decl_spec_loc (decl_specs, ds_long, token);
14910 type = long_integer_type_node;
14913 set_and_check_decl_spec_loc (decl_specs, ds_signed, token);
14914 type = integer_type_node;
14917 set_and_check_decl_spec_loc (decl_specs, ds_unsigned, token);
14918 type = unsigned_type_node;
14921 type = float_type_node;
14924 type = double_type_node;
14927 type = void_type_node;
14931 maybe_warn_cpp0x (CPP0X_AUTO);
14932 if (parser->auto_is_implicit_function_template_parm_p)
14934 if (cxx_dialect >= cxx14)
14935 type = synthesize_implicit_template_parm (parser);
14937 type = error_mark_node;
14939 if (current_class_type && LAMBDA_TYPE_P (current_class_type))
14941 if (cxx_dialect < cxx14)
14942 error_at (token->location,
14943 "use of %<auto%> in lambda parameter declaration "
14944 "only available with "
14945 "-std=c++14 or -std=gnu++14");
14947 else if (cxx_dialect < cxx14)
14948 error_at (token->location,
14949 "use of %<auto%> in parameter declaration "
14950 "only available with "
14951 "-std=c++14 or -std=gnu++14");
14953 pedwarn (token->location, OPT_Wpedantic,
14954 "ISO C++ forbids use of %<auto%> in parameter "
14958 type = make_auto ();
14962 /* Since DR 743, decltype can either be a simple-type-specifier by
14963 itself or begin a nested-name-specifier. Parsing it will replace
14964 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
14965 handling below decide what to do. */
14966 cp_parser_decltype (parser);
14967 cp_lexer_set_token_position (parser->lexer, token);
14971 /* Consume the `typeof' token. */
14972 cp_lexer_consume_token (parser->lexer);
14973 /* Parse the operand to `typeof'. */
14974 type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
14975 /* If it is not already a TYPE, take its type. */
14976 if (!TYPE_P (type))
14977 type = finish_typeof (type);
14980 cp_parser_set_decl_spec_type (decl_specs, type,
14982 /*type_definition_p=*/false);
14986 case RID_UNDERLYING_TYPE:
14987 type = cp_parser_trait_expr (parser, RID_UNDERLYING_TYPE);
14989 cp_parser_set_decl_spec_type (decl_specs, type,
14991 /*type_definition_p=*/false);
14996 case RID_DIRECT_BASES:
14997 type = cp_parser_trait_expr (parser, token->keyword);
14999 cp_parser_set_decl_spec_type (decl_specs, type,
15001 /*type_definition_p=*/false);
15007 /* If token is an already-parsed decltype not followed by ::,
15008 it's a simple-type-specifier. */
15009 if (token->type == CPP_DECLTYPE
15010 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
15012 type = token->u.value;
15015 cp_parser_set_decl_spec_type (decl_specs, type,
15017 /*type_definition_p=*/false);
15018 /* Remember that we are handling a decltype in order to
15019 implement the resolution of DR 1510 when the argument
15020 isn't instantiation dependent. */
15021 decl_specs->decltype_p = true;
15023 cp_lexer_consume_token (parser->lexer);
15027 /* If the type-specifier was for a built-in type, we're done. */
15030 /* Record the type. */
15032 && (token->keyword != RID_SIGNED
15033 && token->keyword != RID_UNSIGNED
15034 && token->keyword != RID_SHORT
15035 && token->keyword != RID_LONG))
15036 cp_parser_set_decl_spec_type (decl_specs,
15039 /*type_definition_p=*/false);
15041 decl_specs->any_specifiers_p = true;
15043 /* Consume the token. */
15044 cp_lexer_consume_token (parser->lexer);
15046 if (type == error_mark_node)
15047 return error_mark_node;
15049 /* There is no valid C++ program where a non-template type is
15050 followed by a "<". That usually indicates that the user thought
15051 that the type was a template. */
15052 cp_parser_check_for_invalid_template_id (parser, type, none_type,
15055 return TYPE_NAME (type);
15058 /* The type-specifier must be a user-defined type. */
15059 if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES))
15064 /* Don't gobble tokens or issue error messages if this is an
15065 optional type-specifier. */
15066 if (flags & CP_PARSER_FLAGS_OPTIONAL)
15067 cp_parser_parse_tentatively (parser);
15069 /* Look for the optional `::' operator. */
15071 = (cp_parser_global_scope_opt (parser,
15072 /*current_scope_valid_p=*/false)
15074 /* Look for the nested-name specifier. */
15076 = (cp_parser_nested_name_specifier_opt (parser,
15077 /*typename_keyword_p=*/false,
15078 /*check_dependency_p=*/true,
15080 /*is_declaration=*/false)
15082 token = cp_lexer_peek_token (parser->lexer);
15083 /* If we have seen a nested-name-specifier, and the next token
15084 is `template', then we are using the template-id production. */
15086 && cp_parser_optional_template_keyword (parser))
15088 /* Look for the template-id. */
15089 type = cp_parser_template_id (parser,
15090 /*template_keyword_p=*/true,
15091 /*check_dependency_p=*/true,
15093 /*is_declaration=*/false);
15094 /* If the template-id did not name a type, we are out of
15096 if (TREE_CODE (type) != TYPE_DECL)
15098 cp_parser_error (parser, "expected template-id for type");
15102 /* Otherwise, look for a type-name. */
15104 type = cp_parser_type_name (parser);
15105 /* Keep track of all name-lookups performed in class scopes. */
15109 && TREE_CODE (type) == TYPE_DECL
15110 && identifier_p (DECL_NAME (type)))
15111 maybe_note_name_used_in_class (DECL_NAME (type), type);
15112 /* If it didn't work out, we don't have a TYPE. */
15113 if ((flags & CP_PARSER_FLAGS_OPTIONAL)
15114 && !cp_parser_parse_definitely (parser))
15116 if (type && decl_specs)
15117 cp_parser_set_decl_spec_type (decl_specs, type,
15119 /*type_definition_p=*/false);
15122 /* If we didn't get a type-name, issue an error message. */
15123 if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL))
15125 cp_parser_error (parser, "expected type-name");
15126 return error_mark_node;
15129 if (type && type != error_mark_node)
15131 /* See if TYPE is an Objective-C type, and if so, parse and
15132 accept any protocol references following it. Do this before
15133 the cp_parser_check_for_invalid_template_id() call, because
15134 Objective-C types can be followed by '<...>' which would
15135 enclose protocol names rather than template arguments, and so
15136 everything is fine. */
15137 if (c_dialect_objc () && !parser->scope
15138 && (objc_is_id (type) || objc_is_class_name (type)))
15140 tree protos = cp_parser_objc_protocol_refs_opt (parser);
15141 tree qual_type = objc_get_protocol_qualified_type (type, protos);
15143 /* Clobber the "unqualified" type previously entered into
15144 DECL_SPECS with the new, improved protocol-qualified version. */
15146 decl_specs->type = qual_type;
15151 /* There is no valid C++ program where a non-template type is
15152 followed by a "<". That usually indicates that the user
15153 thought that the type was a template. */
15154 cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type),
15162 /* Parse a type-name.
15168 simple-template-id [in c++0x]
15176 Returns a TYPE_DECL for the type. */
15179 cp_parser_type_name (cp_parser* parser)
15183 /* We can't know yet whether it is a class-name or not. */
15184 cp_parser_parse_tentatively (parser);
15185 /* Try a class-name. */
15186 type_decl = cp_parser_class_name (parser,
15187 /*typename_keyword_p=*/false,
15188 /*template_keyword_p=*/false,
15190 /*check_dependency_p=*/true,
15191 /*class_head_p=*/false,
15192 /*is_declaration=*/false);
15193 /* If it's not a class-name, keep looking. */
15194 if (!cp_parser_parse_definitely (parser))
15196 if (cxx_dialect < cxx11)
15197 /* It must be a typedef-name or an enum-name. */
15198 return cp_parser_nonclass_name (parser);
15200 cp_parser_parse_tentatively (parser);
15201 /* It is either a simple-template-id representing an
15202 instantiation of an alias template... */
15203 type_decl = cp_parser_template_id (parser,
15204 /*template_keyword_p=*/false,
15205 /*check_dependency_p=*/true,
15207 /*is_declaration=*/false);
15208 /* Note that this must be an instantiation of an alias template
15209 because [temp.names]/6 says:
15211 A template-id that names an alias template specialization
15214 Whereas [temp.names]/7 says:
15216 A simple-template-id that names a class template
15217 specialization is a class-name. */
15218 if (type_decl != NULL_TREE
15219 && TREE_CODE (type_decl) == TYPE_DECL
15220 && TYPE_DECL_ALIAS_P (type_decl))
15221 gcc_assert (DECL_TEMPLATE_INSTANTIATION (type_decl));
15223 cp_parser_simulate_error (parser);
15225 if (!cp_parser_parse_definitely (parser))
15226 /* ... Or a typedef-name or an enum-name. */
15227 return cp_parser_nonclass_name (parser);
15233 /* Parse a non-class type-name, that is, either an enum-name or a typedef-name.
15241 Returns a TYPE_DECL for the type. */
15244 cp_parser_nonclass_name (cp_parser* parser)
15249 cp_token *token = cp_lexer_peek_token (parser->lexer);
15250 identifier = cp_parser_identifier (parser);
15251 if (identifier == error_mark_node)
15252 return error_mark_node;
15254 /* Look up the type-name. */
15255 type_decl = cp_parser_lookup_name_simple (parser, identifier, token->location);
15257 type_decl = strip_using_decl (type_decl);
15259 if (TREE_CODE (type_decl) != TYPE_DECL
15260 && (objc_is_id (identifier) || objc_is_class_name (identifier)))
15262 /* See if this is an Objective-C type. */
15263 tree protos = cp_parser_objc_protocol_refs_opt (parser);
15264 tree type = objc_get_protocol_qualified_type (identifier, protos);
15266 type_decl = TYPE_NAME (type);
15269 /* Issue an error if we did not find a type-name. */
15270 if (TREE_CODE (type_decl) != TYPE_DECL
15271 /* In Objective-C, we have the complication that class names are
15272 normally type names and start declarations (eg, the
15273 "NSObject" in "NSObject *object;"), but can be used in an
15274 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
15275 is an expression. So, a classname followed by a dot is not a
15276 valid type-name. */
15277 || (objc_is_class_name (TREE_TYPE (type_decl))
15278 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT))
15280 if (!cp_parser_simulate_error (parser))
15281 cp_parser_name_lookup_error (parser, identifier, type_decl,
15282 NLE_TYPE, token->location);
15283 return error_mark_node;
15285 /* Remember that the name was used in the definition of the
15286 current class so that we can check later to see if the
15287 meaning would have been different after the class was
15288 entirely defined. */
15289 else if (type_decl != error_mark_node
15291 maybe_note_name_used_in_class (identifier, type_decl);
15296 /* Parse an elaborated-type-specifier. Note that the grammar given
15297 here incorporates the resolution to DR68.
15299 elaborated-type-specifier:
15300 class-key :: [opt] nested-name-specifier [opt] identifier
15301 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
15302 enum-key :: [opt] nested-name-specifier [opt] identifier
15303 typename :: [opt] nested-name-specifier identifier
15304 typename :: [opt] nested-name-specifier template [opt]
15309 elaborated-type-specifier:
15310 class-key attributes :: [opt] nested-name-specifier [opt] identifier
15311 class-key attributes :: [opt] nested-name-specifier [opt]
15312 template [opt] template-id
15313 enum attributes :: [opt] nested-name-specifier [opt] identifier
15315 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
15316 declared `friend'. If IS_DECLARATION is TRUE, then this
15317 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
15318 something is being declared.
15320 Returns the TYPE specified. */
15323 cp_parser_elaborated_type_specifier (cp_parser* parser,
15325 bool is_declaration)
15327 enum tag_types tag_type;
15329 tree type = NULL_TREE;
15330 tree attributes = NULL_TREE;
15332 cp_token *token = NULL;
15334 /* See if we're looking at the `enum' keyword. */
15335 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
15337 /* Consume the `enum' token. */
15338 cp_lexer_consume_token (parser->lexer);
15339 /* Remember that it's an enumeration type. */
15340 tag_type = enum_type;
15341 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
15342 enums) is used here. */
15343 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
15344 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
15346 pedwarn (input_location, 0, "elaborated-type-specifier "
15347 "for a scoped enum must not use the %<%D%> keyword",
15348 cp_lexer_peek_token (parser->lexer)->u.value);
15349 /* Consume the `struct' or `class' and parse it anyway. */
15350 cp_lexer_consume_token (parser->lexer);
15352 /* Parse the attributes. */
15353 attributes = cp_parser_attributes_opt (parser);
15355 /* Or, it might be `typename'. */
15356 else if (cp_lexer_next_token_is_keyword (parser->lexer,
15359 /* Consume the `typename' token. */
15360 cp_lexer_consume_token (parser->lexer);
15361 /* Remember that it's a `typename' type. */
15362 tag_type = typename_type;
15364 /* Otherwise it must be a class-key. */
15367 tag_type = cp_parser_class_key (parser);
15368 if (tag_type == none_type)
15369 return error_mark_node;
15370 /* Parse the attributes. */
15371 attributes = cp_parser_attributes_opt (parser);
15374 /* Look for the `::' operator. */
15375 globalscope = cp_parser_global_scope_opt (parser,
15376 /*current_scope_valid_p=*/false);
15377 /* Look for the nested-name-specifier. */
15378 if (tag_type == typename_type && !globalscope)
15380 if (!cp_parser_nested_name_specifier (parser,
15381 /*typename_keyword_p=*/true,
15382 /*check_dependency_p=*/true,
15385 return error_mark_node;
15388 /* Even though `typename' is not present, the proposed resolution
15389 to Core Issue 180 says that in `class A<T>::B', `B' should be
15390 considered a type-name, even if `A<T>' is dependent. */
15391 cp_parser_nested_name_specifier_opt (parser,
15392 /*typename_keyword_p=*/true,
15393 /*check_dependency_p=*/true,
15396 /* For everything but enumeration types, consider a template-id.
15397 For an enumeration type, consider only a plain identifier. */
15398 if (tag_type != enum_type)
15400 bool template_p = false;
15403 /* Allow the `template' keyword. */
15404 template_p = cp_parser_optional_template_keyword (parser);
15405 /* If we didn't see `template', we don't know if there's a
15406 template-id or not. */
15408 cp_parser_parse_tentatively (parser);
15409 /* Parse the template-id. */
15410 token = cp_lexer_peek_token (parser->lexer);
15411 decl = cp_parser_template_id (parser, template_p,
15412 /*check_dependency_p=*/true,
15415 /* If we didn't find a template-id, look for an ordinary
15417 if (!template_p && !cp_parser_parse_definitely (parser))
15419 /* We can get here when cp_parser_template_id, called by
15420 cp_parser_class_name with tag_type == none_type, succeeds
15421 and caches a BASELINK. Then, when called again here,
15422 instead of failing and returning an error_mark_node
15423 returns it (see template/typename17.C in C++11).
15424 ??? Could we diagnose this earlier? */
15425 else if (tag_type == typename_type && BASELINK_P (decl))
15427 cp_parser_diagnose_invalid_type_name (parser, decl, token->location);
15428 type = error_mark_node;
15430 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
15431 in effect, then we must assume that, upon instantiation, the
15432 template will correspond to a class. */
15433 else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
15434 && tag_type == typename_type)
15435 type = make_typename_type (parser->scope, decl,
15437 /*complain=*/tf_error);
15438 /* If the `typename' keyword is in effect and DECL is not a type
15439 decl, then type is non existent. */
15440 else if (tag_type == typename_type && TREE_CODE (decl) != TYPE_DECL)
15442 else if (TREE_CODE (decl) == TYPE_DECL)
15443 type = check_elaborated_type_specifier (tag_type, decl,
15444 /*allow_template_p=*/true);
15445 else if (decl == error_mark_node)
15446 type = error_mark_node;
15451 token = cp_lexer_peek_token (parser->lexer);
15452 identifier = cp_parser_identifier (parser);
15454 if (identifier == error_mark_node)
15456 parser->scope = NULL_TREE;
15457 return error_mark_node;
15460 /* For a `typename', we needn't call xref_tag. */
15461 if (tag_type == typename_type
15462 && TREE_CODE (parser->scope) != NAMESPACE_DECL)
15463 return cp_parser_make_typename_type (parser, identifier,
15466 /* Template parameter lists apply only if we are not within a
15467 function parameter list. */
15468 bool template_parm_lists_apply
15469 = parser->num_template_parameter_lists;
15470 if (template_parm_lists_apply)
15471 for (cp_binding_level *s = current_binding_level;
15472 s && s->kind != sk_template_parms;
15473 s = s->level_chain)
15474 if (s->kind == sk_function_parms)
15475 template_parm_lists_apply = false;
15477 /* Look up a qualified name in the usual way. */
15481 tree ambiguous_decls;
15483 decl = cp_parser_lookup_name (parser, identifier,
15485 /*is_template=*/false,
15486 /*is_namespace=*/false,
15487 /*check_dependency=*/true,
15491 /* If the lookup was ambiguous, an error will already have been
15493 if (ambiguous_decls)
15494 return error_mark_node;
15496 /* If we are parsing friend declaration, DECL may be a
15497 TEMPLATE_DECL tree node here. However, we need to check
15498 whether this TEMPLATE_DECL results in valid code. Consider
15499 the following example:
15502 template <class T> class C {};
15505 template <class T> friend class N::C; // #1, valid code
15507 template <class T> class Y {
15508 friend class N::C; // #2, invalid code
15511 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
15512 name lookup of `N::C'. We see that friend declaration must
15513 be template for the code to be valid. Note that
15514 processing_template_decl does not work here since it is
15515 always 1 for the above two cases. */
15517 decl = (cp_parser_maybe_treat_template_as_class
15518 (decl, /*tag_name_p=*/is_friend
15519 && template_parm_lists_apply));
15521 if (TREE_CODE (decl) != TYPE_DECL)
15523 cp_parser_diagnose_invalid_type_name (parser,
15526 return error_mark_node;
15529 if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE)
15531 bool allow_template = (template_parm_lists_apply
15532 || DECL_SELF_REFERENCE_P (decl));
15533 type = check_elaborated_type_specifier (tag_type, decl,
15536 if (type == error_mark_node)
15537 return error_mark_node;
15540 /* Forward declarations of nested types, such as
15545 are invalid unless all components preceding the final '::'
15546 are complete. If all enclosing types are complete, these
15547 declarations become merely pointless.
15549 Invalid forward declarations of nested types are errors
15550 caught elsewhere in parsing. Those that are pointless arrive
15553 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
15554 && !is_friend && !processing_explicit_instantiation)
15555 warning (0, "declaration %qD does not declare anything", decl);
15557 type = TREE_TYPE (decl);
15561 /* An elaborated-type-specifier sometimes introduces a new type and
15562 sometimes names an existing type. Normally, the rule is that it
15563 introduces a new type only if there is not an existing type of
15564 the same name already in scope. For example, given:
15567 void f() { struct S s; }
15569 the `struct S' in the body of `f' is the same `struct S' as in
15570 the global scope; the existing definition is used. However, if
15571 there were no global declaration, this would introduce a new
15572 local class named `S'.
15574 An exception to this rule applies to the following code:
15576 namespace N { struct S; }
15578 Here, the elaborated-type-specifier names a new type
15579 unconditionally; even if there is already an `S' in the
15580 containing scope this declaration names a new type.
15581 This exception only applies if the elaborated-type-specifier
15582 forms the complete declaration:
15586 A declaration consisting solely of `class-key identifier ;' is
15587 either a redeclaration of the name in the current scope or a
15588 forward declaration of the identifier as a class name. It
15589 introduces the name into the current scope.
15591 We are in this situation precisely when the next token is a `;'.
15593 An exception to the exception is that a `friend' declaration does
15594 *not* name a new type; i.e., given:
15596 struct S { friend struct T; };
15598 `T' is not a new type in the scope of `S'.
15600 Also, `new struct S' or `sizeof (struct S)' never results in the
15601 definition of a new type; a new type can only be declared in a
15602 declaration context. */
15608 /* Friends have special name lookup rules. */
15609 ts = ts_within_enclosing_non_class;
15610 else if (is_declaration
15611 && cp_lexer_next_token_is (parser->lexer,
15613 /* This is a `class-key identifier ;' */
15619 (template_parm_lists_apply
15620 && (cp_parser_next_token_starts_class_definition_p (parser)
15621 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
15622 /* An unqualified name was used to reference this type, so
15623 there were no qualifying templates. */
15624 if (template_parm_lists_apply
15625 && !cp_parser_check_template_parameters (parser,
15626 /*num_templates=*/0,
15628 /*declarator=*/NULL))
15629 return error_mark_node;
15630 type = xref_tag (tag_type, identifier, ts, template_p);
15634 if (type == error_mark_node)
15635 return error_mark_node;
15637 /* Allow attributes on forward declarations of classes. */
15640 if (TREE_CODE (type) == TYPENAME_TYPE)
15641 warning (OPT_Wattributes,
15642 "attributes ignored on uninstantiated type");
15643 else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type)
15644 && ! processing_explicit_instantiation)
15645 warning (OPT_Wattributes,
15646 "attributes ignored on template instantiation");
15647 else if (is_declaration && cp_parser_declares_only_class_p (parser))
15648 cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
15650 warning (OPT_Wattributes,
15651 "attributes ignored on elaborated-type-specifier that is not a forward declaration");
15654 if (tag_type != enum_type)
15656 /* Indicate whether this class was declared as a `class' or as a
15658 if (TREE_CODE (type) == RECORD_TYPE)
15659 CLASSTYPE_DECLARED_CLASS (type) = (tag_type == class_type);
15660 cp_parser_check_class_key (tag_type, type);
15663 /* A "<" cannot follow an elaborated type specifier. If that
15664 happens, the user was probably trying to form a template-id. */
15665 cp_parser_check_for_invalid_template_id (parser, type, tag_type,
15671 /* Parse an enum-specifier.
15674 enum-head { enumerator-list [opt] }
15675 enum-head { enumerator-list , } [C++0x]
15678 enum-key identifier [opt] enum-base [opt]
15679 enum-key nested-name-specifier identifier enum-base [opt]
15684 enum struct [C++0x]
15687 : type-specifier-seq
15689 opaque-enum-specifier:
15690 enum-key identifier enum-base [opt] ;
15693 enum-key attributes[opt] identifier [opt] enum-base [opt]
15694 { enumerator-list [opt] }attributes[opt]
15695 enum-key attributes[opt] identifier [opt] enum-base [opt]
15696 { enumerator-list, }attributes[opt] [C++0x]
15698 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
15699 if the token stream isn't an enum-specifier after all. */
15702 cp_parser_enum_specifier (cp_parser* parser)
15705 tree type = NULL_TREE;
15707 tree nested_name_specifier = NULL_TREE;
15709 bool scoped_enum_p = false;
15710 bool has_underlying_type = false;
15711 bool nested_being_defined = false;
15712 bool new_value_list = false;
15713 bool is_new_type = false;
15714 bool is_anonymous = false;
15715 tree underlying_type = NULL_TREE;
15716 cp_token *type_start_token = NULL;
15717 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
15719 parser->colon_corrects_to_scope_p = false;
15721 /* Parse tentatively so that we can back up if we don't find a
15723 cp_parser_parse_tentatively (parser);
15725 /* Caller guarantees that the current token is 'enum', an identifier
15726 possibly follows, and the token after that is an opening brace.
15727 If we don't have an identifier, fabricate an anonymous name for
15728 the enumeration being defined. */
15729 cp_lexer_consume_token (parser->lexer);
15731 /* Parse the "class" or "struct", which indicates a scoped
15732 enumeration type in C++0x. */
15733 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
15734 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
15736 if (cxx_dialect < cxx11)
15737 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
15739 /* Consume the `struct' or `class' token. */
15740 cp_lexer_consume_token (parser->lexer);
15742 scoped_enum_p = true;
15745 attributes = cp_parser_attributes_opt (parser);
15747 /* Clear the qualification. */
15748 parser->scope = NULL_TREE;
15749 parser->qualifying_scope = NULL_TREE;
15750 parser->object_scope = NULL_TREE;
15752 /* Figure out in what scope the declaration is being placed. */
15753 prev_scope = current_scope ();
15755 type_start_token = cp_lexer_peek_token (parser->lexer);
15757 push_deferring_access_checks (dk_no_check);
15758 nested_name_specifier
15759 = cp_parser_nested_name_specifier_opt (parser,
15760 /*typename_keyword_p=*/true,
15761 /*check_dependency_p=*/false,
15763 /*is_declaration=*/false);
15765 if (nested_name_specifier)
15769 identifier = cp_parser_identifier (parser);
15770 name = cp_parser_lookup_name (parser, identifier,
15772 /*is_template=*/false,
15773 /*is_namespace=*/false,
15774 /*check_dependency=*/true,
15775 /*ambiguous_decls=*/NULL,
15777 if (name && name != error_mark_node)
15779 type = TREE_TYPE (name);
15780 if (TREE_CODE (type) == TYPENAME_TYPE)
15782 /* Are template enums allowed in ISO? */
15783 if (template_parm_scope_p ())
15784 pedwarn (type_start_token->location, OPT_Wpedantic,
15785 "%qD is an enumeration template", name);
15786 /* ignore a typename reference, for it will be solved by name
15791 else if (nested_name_specifier == error_mark_node)
15792 /* We already issued an error. */;
15794 error_at (type_start_token->location,
15795 "%qD is not an enumerator-name", identifier);
15799 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
15800 identifier = cp_parser_identifier (parser);
15803 identifier = make_anon_name ();
15804 is_anonymous = true;
15806 error_at (type_start_token->location,
15807 "anonymous scoped enum is not allowed");
15810 pop_deferring_access_checks ();
15812 /* Check for the `:' that denotes a specified underlying type in C++0x.
15813 Note that a ':' could also indicate a bitfield width, however. */
15814 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
15816 cp_decl_specifier_seq type_specifiers;
15818 /* Consume the `:'. */
15819 cp_lexer_consume_token (parser->lexer);
15821 /* Parse the type-specifier-seq. */
15822 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
15823 /*is_trailing_return=*/false,
15826 /* At this point this is surely not elaborated type specifier. */
15827 if (!cp_parser_parse_definitely (parser))
15830 if (cxx_dialect < cxx11)
15831 maybe_warn_cpp0x (CPP0X_SCOPED_ENUMS);
15833 has_underlying_type = true;
15835 /* If that didn't work, stop. */
15836 if (type_specifiers.type != error_mark_node)
15838 underlying_type = grokdeclarator (NULL, &type_specifiers, TYPENAME,
15839 /*initialized=*/0, NULL);
15840 if (underlying_type == error_mark_node
15841 || check_for_bare_parameter_packs (underlying_type))
15842 underlying_type = NULL_TREE;
15846 /* Look for the `{' but don't consume it yet. */
15847 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15849 if (cxx_dialect < cxx11 || (!scoped_enum_p && !underlying_type))
15851 cp_parser_error (parser, "expected %<{%>");
15852 if (has_underlying_type)
15858 /* An opaque-enum-specifier must have a ';' here. */
15859 if ((scoped_enum_p || underlying_type)
15860 && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
15862 cp_parser_error (parser, "expected %<;%> or %<{%>");
15863 if (has_underlying_type)
15871 if (!has_underlying_type && !cp_parser_parse_definitely (parser))
15874 if (nested_name_specifier)
15876 if (CLASS_TYPE_P (nested_name_specifier))
15878 nested_being_defined = TYPE_BEING_DEFINED (nested_name_specifier);
15879 TYPE_BEING_DEFINED (nested_name_specifier) = 1;
15880 push_scope (nested_name_specifier);
15882 else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
15884 push_nested_namespace (nested_name_specifier);
15888 /* Issue an error message if type-definitions are forbidden here. */
15889 if (!cp_parser_check_type_definition (parser))
15890 type = error_mark_node;
15892 /* Create the new type. We do this before consuming the opening
15893 brace so the enum will be recorded as being on the line of its
15894 tag (or the 'enum' keyword, if there is no tag). */
15895 type = start_enum (identifier, type, underlying_type,
15896 scoped_enum_p, &is_new_type);
15898 /* If the next token is not '{' it is an opaque-enum-specifier or an
15899 elaborated-type-specifier. */
15900 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15902 timevar_push (TV_PARSE_ENUM);
15903 if (nested_name_specifier
15904 && nested_name_specifier != error_mark_node)
15906 /* The following catches invalid code such as:
15907 enum class S<int>::E { A, B, C }; */
15908 if (!processing_specialization
15909 && CLASS_TYPE_P (nested_name_specifier)
15910 && CLASSTYPE_USE_TEMPLATE (nested_name_specifier))
15911 error_at (type_start_token->location, "cannot add an enumerator "
15912 "list to a template instantiation");
15914 if (TREE_CODE (nested_name_specifier) == TYPENAME_TYPE)
15916 error_at (type_start_token->location,
15917 "%<%T::%E%> has not been declared",
15918 TYPE_CONTEXT (nested_name_specifier),
15919 nested_name_specifier);
15920 type = error_mark_node;
15922 /* If that scope does not contain the scope in which the
15923 class was originally declared, the program is invalid. */
15924 else if (prev_scope && !is_ancestor (prev_scope,
15925 nested_name_specifier))
15927 if (at_namespace_scope_p ())
15928 error_at (type_start_token->location,
15929 "declaration of %qD in namespace %qD which does not "
15931 type, prev_scope, nested_name_specifier);
15933 error_at (type_start_token->location,
15934 "declaration of %qD in %qD which does not "
15936 type, prev_scope, nested_name_specifier);
15937 type = error_mark_node;
15942 begin_scope (sk_scoped_enum, type);
15944 /* Consume the opening brace. */
15945 cp_lexer_consume_token (parser->lexer);
15947 if (type == error_mark_node)
15948 ; /* Nothing to add */
15949 else if (OPAQUE_ENUM_P (type)
15950 || (cxx_dialect > cxx98 && processing_specialization))
15952 new_value_list = true;
15953 SET_OPAQUE_ENUM_P (type, false);
15954 DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
15958 error_at (type_start_token->location,
15959 "multiple definition of %q#T", type);
15960 inform (DECL_SOURCE_LOCATION (TYPE_MAIN_DECL (type)),
15961 "previous definition here");
15962 type = error_mark_node;
15965 if (type == error_mark_node)
15966 cp_parser_skip_to_end_of_block_or_statement (parser);
15967 /* If the next token is not '}', then there are some enumerators. */
15968 else if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
15970 if (is_anonymous && !scoped_enum_p)
15971 pedwarn (type_start_token->location, OPT_Wpedantic,
15972 "ISO C++ forbids empty anonymous enum");
15975 cp_parser_enumerator_list (parser, type);
15977 /* Consume the final '}'. */
15978 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
15982 timevar_pop (TV_PARSE_ENUM);
15986 /* If a ';' follows, then it is an opaque-enum-specifier
15987 and additional restrictions apply. */
15988 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
15991 error_at (type_start_token->location,
15992 "opaque-enum-specifier without name");
15993 else if (nested_name_specifier)
15994 error_at (type_start_token->location,
15995 "opaque-enum-specifier must use a simple identifier");
15999 /* Look for trailing attributes to apply to this enumeration, and
16000 apply them if appropriate. */
16001 if (cp_parser_allow_gnu_extensions_p (parser))
16003 tree trailing_attr = cp_parser_gnu_attributes_opt (parser);
16004 trailing_attr = chainon (trailing_attr, attributes);
16005 cplus_decl_attributes (&type,
16007 (int) ATTR_FLAG_TYPE_IN_PLACE);
16010 /* Finish up the enumeration. */
16011 if (type != error_mark_node)
16013 if (new_value_list)
16014 finish_enum_value_list (type);
16016 finish_enum (type);
16019 if (nested_name_specifier)
16021 if (CLASS_TYPE_P (nested_name_specifier))
16023 TYPE_BEING_DEFINED (nested_name_specifier) = nested_being_defined;
16024 pop_scope (nested_name_specifier);
16026 else if (TREE_CODE (nested_name_specifier) == NAMESPACE_DECL)
16028 pop_nested_namespace (nested_name_specifier);
16032 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
16036 /* Parse an enumerator-list. The enumerators all have the indicated
16040 enumerator-definition
16041 enumerator-list , enumerator-definition */
16044 cp_parser_enumerator_list (cp_parser* parser, tree type)
16048 /* Parse an enumerator-definition. */
16049 cp_parser_enumerator_definition (parser, type);
16051 /* If the next token is not a ',', we've reached the end of
16053 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16055 /* Otherwise, consume the `,' and keep going. */
16056 cp_lexer_consume_token (parser->lexer);
16057 /* If the next token is a `}', there is a trailing comma. */
16058 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
16060 if (cxx_dialect < cxx11 && !in_system_header_at (input_location))
16061 pedwarn (input_location, OPT_Wpedantic,
16062 "comma at end of enumerator list");
16068 /* Parse an enumerator-definition. The enumerator has the indicated
16071 enumerator-definition:
16073 enumerator = constant-expression
16079 cp_parser_enumerator_definition (cp_parser* parser, tree type)
16085 /* Save the input location because we are interested in the location
16086 of the identifier and not the location of the explicit value. */
16087 loc = cp_lexer_peek_token (parser->lexer)->location;
16089 /* Look for the identifier. */
16090 identifier = cp_parser_identifier (parser);
16091 if (identifier == error_mark_node)
16094 /* If the next token is an '=', then there is an explicit value. */
16095 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
16097 /* Consume the `=' token. */
16098 cp_lexer_consume_token (parser->lexer);
16099 /* Parse the value. */
16100 value = cp_parser_constant_expression (parser);
16105 /* If we are processing a template, make sure the initializer of the
16106 enumerator doesn't contain any bare template parameter pack. */
16107 if (check_for_bare_parameter_packs (value))
16108 value = error_mark_node;
16110 /* Create the enumerator. */
16111 build_enumerator (identifier, value, type, loc);
16114 /* Parse a namespace-name.
16117 original-namespace-name
16120 Returns the NAMESPACE_DECL for the namespace. */
16123 cp_parser_namespace_name (cp_parser* parser)
16126 tree namespace_decl;
16128 cp_token *token = cp_lexer_peek_token (parser->lexer);
16130 /* Get the name of the namespace. */
16131 identifier = cp_parser_identifier (parser);
16132 if (identifier == error_mark_node)
16133 return error_mark_node;
16135 /* Look up the identifier in the currently active scope. Look only
16136 for namespaces, due to:
16138 [basic.lookup.udir]
16140 When looking up a namespace-name in a using-directive or alias
16141 definition, only namespace names are considered.
16145 [basic.lookup.qual]
16147 During the lookup of a name preceding the :: scope resolution
16148 operator, object, function, and enumerator names are ignored.
16150 (Note that cp_parser_qualifying_entity only calls this
16151 function if the token after the name is the scope resolution
16153 namespace_decl = cp_parser_lookup_name (parser, identifier,
16155 /*is_template=*/false,
16156 /*is_namespace=*/true,
16157 /*check_dependency=*/true,
16158 /*ambiguous_decls=*/NULL,
16160 /* If it's not a namespace, issue an error. */
16161 if (namespace_decl == error_mark_node
16162 || TREE_CODE (namespace_decl) != NAMESPACE_DECL)
16164 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
16165 error_at (token->location, "%qD is not a namespace-name", identifier);
16166 cp_parser_error (parser, "expected namespace-name");
16167 namespace_decl = error_mark_node;
16170 return namespace_decl;
16173 /* Parse a namespace-definition.
16175 namespace-definition:
16176 named-namespace-definition
16177 unnamed-namespace-definition
16179 named-namespace-definition:
16180 original-namespace-definition
16181 extension-namespace-definition
16183 original-namespace-definition:
16184 namespace identifier { namespace-body }
16186 extension-namespace-definition:
16187 namespace original-namespace-name { namespace-body }
16189 unnamed-namespace-definition:
16190 namespace { namespace-body } */
16193 cp_parser_namespace_definition (cp_parser* parser)
16195 tree identifier, attribs;
16196 bool has_visibility;
16199 cp_ensure_no_omp_declare_simd (parser);
16200 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE))
16202 maybe_warn_cpp0x (CPP0X_INLINE_NAMESPACES);
16204 cp_lexer_consume_token (parser->lexer);
16209 /* Look for the `namespace' keyword. */
16210 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
16212 /* Get the name of the namespace. We do not attempt to distinguish
16213 between an original-namespace-definition and an
16214 extension-namespace-definition at this point. The semantic
16215 analysis routines are responsible for that. */
16216 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
16217 identifier = cp_parser_identifier (parser);
16219 identifier = NULL_TREE;
16221 /* Parse any specified attributes. */
16222 attribs = cp_parser_attributes_opt (parser);
16224 /* Look for the `{' to start the namespace. */
16225 cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE);
16226 /* Start the namespace. */
16227 push_namespace (identifier);
16229 /* "inline namespace" is equivalent to a stub namespace definition
16230 followed by a strong using directive. */
16233 tree name_space = current_namespace;
16234 /* Set up namespace association. */
16235 DECL_NAMESPACE_ASSOCIATIONS (name_space)
16236 = tree_cons (CP_DECL_CONTEXT (name_space), NULL_TREE,
16237 DECL_NAMESPACE_ASSOCIATIONS (name_space));
16238 /* Import the contents of the inline namespace. */
16240 do_using_directive (name_space);
16241 push_namespace (identifier);
16244 has_visibility = handle_namespace_attrs (current_namespace, attribs);
16246 /* Parse the body of the namespace. */
16247 cp_parser_namespace_body (parser);
16249 if (has_visibility)
16250 pop_visibility (1);
16252 /* Finish the namespace. */
16254 /* Look for the final `}'. */
16255 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
16258 /* Parse a namespace-body.
16261 declaration-seq [opt] */
16264 cp_parser_namespace_body (cp_parser* parser)
16266 cp_parser_declaration_seq_opt (parser);
16269 /* Parse a namespace-alias-definition.
16271 namespace-alias-definition:
16272 namespace identifier = qualified-namespace-specifier ; */
16275 cp_parser_namespace_alias_definition (cp_parser* parser)
16278 tree namespace_specifier;
16280 cp_token *token = cp_lexer_peek_token (parser->lexer);
16282 /* Look for the `namespace' keyword. */
16283 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
16284 /* Look for the identifier. */
16285 identifier = cp_parser_identifier (parser);
16286 if (identifier == error_mark_node)
16288 /* Look for the `=' token. */
16289 if (!cp_parser_uncommitted_to_tentative_parse_p (parser)
16290 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
16292 error_at (token->location, "%<namespace%> definition is not allowed here");
16293 /* Skip the definition. */
16294 cp_lexer_consume_token (parser->lexer);
16295 if (cp_parser_skip_to_closing_brace (parser))
16296 cp_lexer_consume_token (parser->lexer);
16299 cp_parser_require (parser, CPP_EQ, RT_EQ);
16300 /* Look for the qualified-namespace-specifier. */
16301 namespace_specifier
16302 = cp_parser_qualified_namespace_specifier (parser);
16303 /* Look for the `;' token. */
16304 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16306 /* Register the alias in the symbol table. */
16307 do_namespace_alias (identifier, namespace_specifier);
16310 /* Parse a qualified-namespace-specifier.
16312 qualified-namespace-specifier:
16313 :: [opt] nested-name-specifier [opt] namespace-name
16315 Returns a NAMESPACE_DECL corresponding to the specified
16319 cp_parser_qualified_namespace_specifier (cp_parser* parser)
16321 /* Look for the optional `::'. */
16322 cp_parser_global_scope_opt (parser,
16323 /*current_scope_valid_p=*/false);
16325 /* Look for the optional nested-name-specifier. */
16326 cp_parser_nested_name_specifier_opt (parser,
16327 /*typename_keyword_p=*/false,
16328 /*check_dependency_p=*/true,
16330 /*is_declaration=*/true);
16332 return cp_parser_namespace_name (parser);
16335 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
16336 access declaration.
16339 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
16340 using :: unqualified-id ;
16342 access-declaration:
16348 cp_parser_using_declaration (cp_parser* parser,
16349 bool access_declaration_p)
16352 bool typename_p = false;
16353 bool global_scope_p;
16357 int oldcount = errorcount;
16358 cp_token *diag_token = NULL;
16360 if (access_declaration_p)
16362 diag_token = cp_lexer_peek_token (parser->lexer);
16363 cp_parser_parse_tentatively (parser);
16367 /* Look for the `using' keyword. */
16368 cp_parser_require_keyword (parser, RID_USING, RT_USING);
16370 /* Peek at the next token. */
16371 token = cp_lexer_peek_token (parser->lexer);
16372 /* See if it's `typename'. */
16373 if (token->keyword == RID_TYPENAME)
16375 /* Remember that we've seen it. */
16377 /* Consume the `typename' token. */
16378 cp_lexer_consume_token (parser->lexer);
16382 /* Look for the optional global scope qualification. */
16384 = (cp_parser_global_scope_opt (parser,
16385 /*current_scope_valid_p=*/false)
16388 /* If we saw `typename', or didn't see `::', then there must be a
16389 nested-name-specifier present. */
16390 if (typename_p || !global_scope_p)
16392 qscope = cp_parser_nested_name_specifier (parser, typename_p,
16393 /*check_dependency_p=*/true,
16395 /*is_declaration=*/true);
16396 if (!qscope && !cp_parser_uncommitted_to_tentative_parse_p (parser))
16398 cp_parser_skip_to_end_of_block_or_statement (parser);
16402 /* Otherwise, we could be in either of the two productions. In that
16403 case, treat the nested-name-specifier as optional. */
16405 qscope = cp_parser_nested_name_specifier_opt (parser,
16406 /*typename_keyword_p=*/false,
16407 /*check_dependency_p=*/true,
16409 /*is_declaration=*/true);
16411 qscope = global_namespace;
16412 else if (UNSCOPED_ENUM_P (qscope))
16413 qscope = CP_TYPE_CONTEXT (qscope);
16415 if (access_declaration_p && cp_parser_error_occurred (parser))
16416 /* Something has already gone wrong; there's no need to parse
16417 further. Since an error has occurred, the return value of
16418 cp_parser_parse_definitely will be false, as required. */
16419 return cp_parser_parse_definitely (parser);
16421 token = cp_lexer_peek_token (parser->lexer);
16422 /* Parse the unqualified-id. */
16423 identifier = cp_parser_unqualified_id (parser,
16424 /*template_keyword_p=*/false,
16425 /*check_dependency_p=*/true,
16426 /*declarator_p=*/true,
16427 /*optional_p=*/false);
16429 if (access_declaration_p)
16431 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
16432 cp_parser_simulate_error (parser);
16433 if (!cp_parser_parse_definitely (parser))
16437 /* The function we call to handle a using-declaration is different
16438 depending on what scope we are in. */
16439 if (qscope == error_mark_node || identifier == error_mark_node)
16441 else if (!identifier_p (identifier)
16442 && TREE_CODE (identifier) != BIT_NOT_EXPR)
16443 /* [namespace.udecl]
16445 A using declaration shall not name a template-id. */
16446 error_at (token->location,
16447 "a template-id may not appear in a using-declaration");
16450 if (at_class_scope_p ())
16452 /* Create the USING_DECL. */
16453 decl = do_class_using_decl (parser->scope, identifier);
16455 if (decl && typename_p)
16456 USING_DECL_TYPENAME_P (decl) = 1;
16458 if (check_for_bare_parameter_packs (decl))
16460 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16464 /* Add it to the list of members in this class. */
16465 finish_member_declaration (decl);
16469 decl = cp_parser_lookup_name_simple (parser,
16472 if (decl == error_mark_node)
16473 cp_parser_name_lookup_error (parser, identifier,
16476 else if (check_for_bare_parameter_packs (decl))
16478 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16481 else if (!at_namespace_scope_p ())
16482 do_local_using_decl (decl, qscope, identifier);
16484 do_toplevel_using_decl (decl, qscope, identifier);
16488 /* Look for the final `;'. */
16489 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16491 if (access_declaration_p && errorcount == oldcount)
16492 warning_at (diag_token->location, OPT_Wdeprecated,
16493 "access declarations are deprecated "
16494 "in favour of using-declarations; "
16495 "suggestion: add the %<using%> keyword");
16500 /* Parse an alias-declaration.
16503 using identifier attribute-specifier-seq [opt] = type-id */
16506 cp_parser_alias_declaration (cp_parser* parser)
16508 tree id, type, decl, pushed_scope = NULL_TREE, attributes;
16509 location_t id_location;
16510 cp_declarator *declarator;
16511 cp_decl_specifier_seq decl_specs;
16513 const char *saved_message = NULL;
16515 /* Look for the `using' keyword. */
16516 cp_token *using_token
16517 = cp_parser_require_keyword (parser, RID_USING, RT_USING);
16518 if (using_token == NULL)
16519 return error_mark_node;
16521 id_location = cp_lexer_peek_token (parser->lexer)->location;
16522 id = cp_parser_identifier (parser);
16523 if (id == error_mark_node)
16524 return error_mark_node;
16526 cp_token *attrs_token = cp_lexer_peek_token (parser->lexer);
16527 attributes = cp_parser_attributes_opt (parser);
16528 if (attributes == error_mark_node)
16529 return error_mark_node;
16531 cp_parser_require (parser, CPP_EQ, RT_EQ);
16533 if (cp_parser_error_occurred (parser))
16534 return error_mark_node;
16536 cp_parser_commit_to_tentative_parse (parser);
16538 /* Now we are going to parse the type-id of the declaration. */
16543 "A type-specifier-seq shall not define a class or enumeration
16544 unless it appears in the type-id of an alias-declaration (7.1.3) that
16545 is not the declaration of a template-declaration."
16547 In other words, if we currently are in an alias template, the
16548 type-id should not define a type.
16550 So let's set parser->type_definition_forbidden_message in that
16551 case; cp_parser_check_type_definition (called by
16552 cp_parser_class_specifier) will then emit an error if a type is
16553 defined in the type-id. */
16554 if (parser->num_template_parameter_lists)
16556 saved_message = parser->type_definition_forbidden_message;
16557 parser->type_definition_forbidden_message =
16558 G_("types may not be defined in alias template declarations");
16561 type = cp_parser_type_id (parser);
16563 /* Restore the error message if need be. */
16564 if (parser->num_template_parameter_lists)
16565 parser->type_definition_forbidden_message = saved_message;
16567 if (type == error_mark_node
16568 || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
16570 cp_parser_skip_to_end_of_block_or_statement (parser);
16571 return error_mark_node;
16574 /* A typedef-name can also be introduced by an alias-declaration. The
16575 identifier following the using keyword becomes a typedef-name. It has
16576 the same semantics as if it were introduced by the typedef
16577 specifier. In particular, it does not define a new type and it shall
16578 not appear in the type-id. */
16580 clear_decl_specs (&decl_specs);
16581 decl_specs.type = type;
16582 if (attributes != NULL_TREE)
16584 decl_specs.attributes = attributes;
16585 set_and_check_decl_spec_loc (&decl_specs,
16589 set_and_check_decl_spec_loc (&decl_specs,
16592 set_and_check_decl_spec_loc (&decl_specs,
16596 declarator = make_id_declarator (NULL_TREE, id, sfk_none);
16597 declarator->id_loc = id_location;
16599 member_p = at_class_scope_p ();
16601 decl = grokfield (declarator, &decl_specs, NULL_TREE, false,
16602 NULL_TREE, attributes);
16604 decl = start_decl (declarator, &decl_specs, 0,
16605 attributes, NULL_TREE, &pushed_scope);
16606 if (decl == error_mark_node)
16609 cp_finish_decl (decl, NULL_TREE, 0, NULL_TREE, 0);
16612 pop_scope (pushed_scope);
16614 /* If decl is a template, return its TEMPLATE_DECL so that it gets
16615 added into the symbol table; otherwise, return the TYPE_DECL. */
16616 if (DECL_LANG_SPECIFIC (decl)
16617 && DECL_TEMPLATE_INFO (decl)
16618 && PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl)))
16620 decl = DECL_TI_TEMPLATE (decl);
16622 check_member_template (decl);
16628 /* Parse a using-directive.
16631 using namespace :: [opt] nested-name-specifier [opt]
16632 namespace-name ; */
16635 cp_parser_using_directive (cp_parser* parser)
16637 tree namespace_decl;
16640 /* Look for the `using' keyword. */
16641 cp_parser_require_keyword (parser, RID_USING, RT_USING);
16642 /* And the `namespace' keyword. */
16643 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
16644 /* Look for the optional `::' operator. */
16645 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
16646 /* And the optional nested-name-specifier. */
16647 cp_parser_nested_name_specifier_opt (parser,
16648 /*typename_keyword_p=*/false,
16649 /*check_dependency_p=*/true,
16651 /*is_declaration=*/true);
16652 /* Get the namespace being used. */
16653 namespace_decl = cp_parser_namespace_name (parser);
16654 /* And any specified attributes. */
16655 attribs = cp_parser_attributes_opt (parser);
16656 /* Update the symbol table. */
16657 parse_using_directive (namespace_decl, attribs);
16658 /* Look for the final `;'. */
16659 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16662 /* Parse an asm-definition.
16665 asm ( string-literal ) ;
16670 asm volatile [opt] ( string-literal ) ;
16671 asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ;
16672 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16673 : asm-operand-list [opt] ) ;
16674 asm volatile [opt] ( string-literal : asm-operand-list [opt]
16675 : asm-operand-list [opt]
16676 : asm-clobber-list [opt] ) ;
16677 asm volatile [opt] goto ( string-literal : : asm-operand-list [opt]
16678 : asm-clobber-list [opt]
16679 : asm-goto-list ) ; */
16682 cp_parser_asm_definition (cp_parser* parser)
16685 tree outputs = NULL_TREE;
16686 tree inputs = NULL_TREE;
16687 tree clobbers = NULL_TREE;
16688 tree labels = NULL_TREE;
16690 bool volatile_p = false;
16691 bool extended_p = false;
16692 bool invalid_inputs_p = false;
16693 bool invalid_outputs_p = false;
16694 bool goto_p = false;
16695 required_token missing = RT_NONE;
16697 /* Look for the `asm' keyword. */
16698 cp_parser_require_keyword (parser, RID_ASM, RT_ASM);
16700 if (parser->in_function_body
16701 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
16703 error ("%<asm%> in %<constexpr%> function");
16704 cp_function_chain->invalid_constexpr = true;
16707 /* See if the next token is `volatile'. */
16708 if (cp_parser_allow_gnu_extensions_p (parser)
16709 && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE))
16711 /* Remember that we saw the `volatile' keyword. */
16713 /* Consume the token. */
16714 cp_lexer_consume_token (parser->lexer);
16716 if (cp_parser_allow_gnu_extensions_p (parser)
16717 && parser->in_function_body
16718 && cp_lexer_next_token_is_keyword (parser->lexer, RID_GOTO))
16720 /* Remember that we saw the `goto' keyword. */
16722 /* Consume the token. */
16723 cp_lexer_consume_token (parser->lexer);
16725 /* Look for the opening `('. */
16726 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
16728 /* Look for the string. */
16729 string = cp_parser_string_literal (parser, false, false);
16730 if (string == error_mark_node)
16732 cp_parser_skip_to_closing_parenthesis (parser, true, false,
16733 /*consume_paren=*/true);
16737 /* If we're allowing GNU extensions, check for the extended assembly
16738 syntax. Unfortunately, the `:' tokens need not be separated by
16739 a space in C, and so, for compatibility, we tolerate that here
16740 too. Doing that means that we have to treat the `::' operator as
16742 if (cp_parser_allow_gnu_extensions_p (parser)
16743 && parser->in_function_body
16744 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
16745 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
16747 bool inputs_p = false;
16748 bool clobbers_p = false;
16749 bool labels_p = false;
16751 /* The extended syntax was used. */
16754 /* Look for outputs. */
16755 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
16757 /* Consume the `:'. */
16758 cp_lexer_consume_token (parser->lexer);
16759 /* Parse the output-operands. */
16760 if (cp_lexer_next_token_is_not (parser->lexer,
16762 && cp_lexer_next_token_is_not (parser->lexer,
16764 && cp_lexer_next_token_is_not (parser->lexer,
16767 outputs = cp_parser_asm_operand_list (parser);
16769 if (outputs == error_mark_node)
16770 invalid_outputs_p = true;
16772 /* If the next token is `::', there are no outputs, and the
16773 next token is the beginning of the inputs. */
16774 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16775 /* The inputs are coming next. */
16778 /* Look for inputs. */
16780 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
16782 /* Consume the `:' or `::'. */
16783 cp_lexer_consume_token (parser->lexer);
16784 /* Parse the output-operands. */
16785 if (cp_lexer_next_token_is_not (parser->lexer,
16787 && cp_lexer_next_token_is_not (parser->lexer,
16789 && cp_lexer_next_token_is_not (parser->lexer,
16791 inputs = cp_parser_asm_operand_list (parser);
16793 if (inputs == error_mark_node)
16794 invalid_inputs_p = true;
16796 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16797 /* The clobbers are coming next. */
16800 /* Look for clobbers. */
16802 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
16805 /* Consume the `:' or `::'. */
16806 cp_lexer_consume_token (parser->lexer);
16807 /* Parse the clobbers. */
16808 if (cp_lexer_next_token_is_not (parser->lexer,
16810 && cp_lexer_next_token_is_not (parser->lexer,
16812 clobbers = cp_parser_asm_clobber_list (parser);
16815 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
16816 /* The labels are coming next. */
16819 /* Look for labels. */
16821 || (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
16824 /* Consume the `:' or `::'. */
16825 cp_lexer_consume_token (parser->lexer);
16826 /* Parse the labels. */
16827 labels = cp_parser_asm_label_list (parser);
16830 if (goto_p && !labels_p)
16831 missing = clobbers_p ? RT_COLON : RT_COLON_SCOPE;
16834 missing = RT_COLON_SCOPE;
16836 /* Look for the closing `)'. */
16837 if (!cp_parser_require (parser, missing ? CPP_COLON : CPP_CLOSE_PAREN,
16838 missing ? missing : RT_CLOSE_PAREN))
16839 cp_parser_skip_to_closing_parenthesis (parser, true, false,
16840 /*consume_paren=*/true);
16841 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
16843 if (!invalid_inputs_p && !invalid_outputs_p)
16845 /* Create the ASM_EXPR. */
16846 if (parser->in_function_body)
16848 asm_stmt = finish_asm_stmt (volatile_p, string, outputs,
16849 inputs, clobbers, labels);
16850 /* If the extended syntax was not used, mark the ASM_EXPR. */
16853 tree temp = asm_stmt;
16854 if (TREE_CODE (temp) == CLEANUP_POINT_EXPR)
16855 temp = TREE_OPERAND (temp, 0);
16857 ASM_INPUT_P (temp) = 1;
16861 symtab->finalize_toplevel_asm (string);
16865 /* Declarators [gram.dcl.decl] */
16867 /* Parse an init-declarator.
16870 declarator initializer [opt]
16875 declarator asm-specification [opt] attributes [opt] initializer [opt]
16877 function-definition:
16878 decl-specifier-seq [opt] declarator ctor-initializer [opt]
16880 decl-specifier-seq [opt] declarator function-try-block
16884 function-definition:
16885 __extension__ function-definition
16889 function-definition:
16890 decl-specifier-seq [opt] declarator function-transaction-block
16892 The DECL_SPECIFIERS apply to this declarator. Returns a
16893 representation of the entity declared. If MEMBER_P is TRUE, then
16894 this declarator appears in a class scope. The new DECL created by
16895 this declarator is returned.
16897 The CHECKS are access checks that should be performed once we know
16898 what entity is being declared (and, therefore, what classes have
16901 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
16902 for a function-definition here as well. If the declarator is a
16903 declarator for a function-definition, *FUNCTION_DEFINITION_P will
16904 be TRUE upon return. By that point, the function-definition will
16905 have been completely parsed.
16907 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
16910 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
16911 parsed declaration if it is an uninitialized single declarator not followed
16912 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
16913 if present, will not be consumed. If returned, this declarator will be
16914 created with SD_INITIALIZED but will not call cp_finish_decl.
16916 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
16917 and there is an initializer, the pointed location_t is set to the
16918 location of the '=' or `(', or '{' in C++11 token introducing the
16922 cp_parser_init_declarator (cp_parser* parser,
16923 cp_decl_specifier_seq *decl_specifiers,
16924 vec<deferred_access_check, va_gc> *checks,
16925 bool function_definition_allowed_p,
16927 int declares_class_or_enum,
16928 bool* function_definition_p,
16929 tree* maybe_range_for_decl,
16930 location_t* init_loc)
16932 cp_token *token = NULL, *asm_spec_start_token = NULL,
16933 *attributes_start_token = NULL;
16934 cp_declarator *declarator;
16935 tree prefix_attributes;
16936 tree attributes = NULL;
16937 tree asm_specification;
16939 tree decl = NULL_TREE;
16941 int is_initialized;
16942 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
16943 initialized with "= ..", CPP_OPEN_PAREN if initialized with
16945 enum cpp_ttype initialization_kind;
16946 bool is_direct_init = false;
16947 bool is_non_constant_init;
16948 int ctor_dtor_or_conv_p;
16949 bool friend_p = cp_parser_friend_p (decl_specifiers);
16950 tree pushed_scope = NULL_TREE;
16951 bool range_for_decl_p = false;
16952 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
16953 location_t tmp_init_loc = UNKNOWN_LOCATION;
16955 /* Gather the attributes that were provided with the
16956 decl-specifiers. */
16957 prefix_attributes = decl_specifiers->attributes;
16959 /* Assume that this is not the declarator for a function
16961 if (function_definition_p)
16962 *function_definition_p = false;
16964 /* Default arguments are only permitted for function parameters. */
16965 if (decl_spec_seq_has_spec_p (decl_specifiers, ds_typedef))
16966 parser->default_arg_ok_p = false;
16968 /* Defer access checks while parsing the declarator; we cannot know
16969 what names are accessible until we know what is being
16971 resume_deferring_access_checks ();
16973 /* Parse the declarator. */
16974 token = cp_lexer_peek_token (parser->lexer);
16976 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
16977 &ctor_dtor_or_conv_p,
16978 /*parenthesized_p=*/NULL,
16979 member_p, friend_p);
16980 /* Gather up the deferred checks. */
16981 stop_deferring_access_checks ();
16983 parser->default_arg_ok_p = saved_default_arg_ok_p;
16985 /* If the DECLARATOR was erroneous, there's no need to go
16987 if (declarator == cp_error_declarator)
16988 return error_mark_node;
16990 /* Check that the number of template-parameter-lists is OK. */
16991 if (!cp_parser_check_declarator_template_parameters (parser, declarator,
16993 return error_mark_node;
16995 if (declares_class_or_enum & 2)
16996 cp_parser_check_for_definition_in_return_type (declarator,
16997 decl_specifiers->type,
16998 decl_specifiers->locations[ds_type_spec]);
17000 /* Figure out what scope the entity declared by the DECLARATOR is
17001 located in. `grokdeclarator' sometimes changes the scope, so
17002 we compute it now. */
17003 scope = get_scope_of_declarator (declarator);
17005 /* Perform any lookups in the declared type which were thought to be
17006 dependent, but are not in the scope of the declarator. */
17007 decl_specifiers->type
17008 = maybe_update_decl_type (decl_specifiers->type, scope);
17010 /* If we're allowing GNU extensions, look for an
17011 asm-specification. */
17012 if (cp_parser_allow_gnu_extensions_p (parser))
17014 /* Look for an asm-specification. */
17015 asm_spec_start_token = cp_lexer_peek_token (parser->lexer);
17016 asm_specification = cp_parser_asm_specification_opt (parser);
17019 asm_specification = NULL_TREE;
17021 /* Look for attributes. */
17022 attributes_start_token = cp_lexer_peek_token (parser->lexer);
17023 attributes = cp_parser_attributes_opt (parser);
17025 /* Peek at the next token. */
17026 token = cp_lexer_peek_token (parser->lexer);
17028 bool bogus_implicit_tmpl = false;
17030 if (function_declarator_p (declarator))
17032 /* Check to see if the token indicates the start of a
17033 function-definition. */
17034 if (cp_parser_token_starts_function_definition_p (token))
17036 if (!function_definition_allowed_p)
17038 /* If a function-definition should not appear here, issue an
17040 cp_parser_error (parser,
17041 "a function-definition is not allowed here");
17042 return error_mark_node;
17045 location_t func_brace_location
17046 = cp_lexer_peek_token (parser->lexer)->location;
17048 /* Neither attributes nor an asm-specification are allowed
17049 on a function-definition. */
17050 if (asm_specification)
17051 error_at (asm_spec_start_token->location,
17052 "an asm-specification is not allowed "
17053 "on a function-definition");
17055 error_at (attributes_start_token->location,
17056 "attributes are not allowed "
17057 "on a function-definition");
17058 /* This is a function-definition. */
17059 *function_definition_p = true;
17061 /* Parse the function definition. */
17063 decl = cp_parser_save_member_function_body (parser,
17066 prefix_attributes);
17069 (cp_parser_function_definition_from_specifiers_and_declarator
17070 (parser, decl_specifiers, prefix_attributes, declarator));
17072 if (decl != error_mark_node && DECL_STRUCT_FUNCTION (decl))
17074 /* This is where the prologue starts... */
17075 DECL_STRUCT_FUNCTION (decl)->function_start_locus
17076 = func_brace_location;
17082 else if (parser->fully_implicit_function_template_p)
17084 /* A non-template declaration involving a function parameter list
17085 containing an implicit template parameter will be made into a
17086 template. If the resulting declaration is not going to be an
17087 actual function then finish the template scope here to prevent it.
17088 An error message will be issued once we have a decl to talk about.
17090 FIXME probably we should do type deduction rather than create an
17091 implicit template, but the standard currently doesn't allow it. */
17092 bogus_implicit_tmpl = true;
17093 finish_fully_implicit_template (parser, NULL_TREE);
17098 Only in function declarations for constructors, destructors, and
17099 type conversions can the decl-specifier-seq be omitted.
17101 We explicitly postpone this check past the point where we handle
17102 function-definitions because we tolerate function-definitions
17103 that are missing their return types in some modes. */
17104 if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0)
17106 cp_parser_error (parser,
17107 "expected constructor, destructor, or type conversion");
17108 return error_mark_node;
17111 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
17112 if (token->type == CPP_EQ
17113 || token->type == CPP_OPEN_PAREN
17114 || token->type == CPP_OPEN_BRACE)
17116 is_initialized = SD_INITIALIZED;
17117 initialization_kind = token->type;
17118 if (maybe_range_for_decl)
17119 *maybe_range_for_decl = error_mark_node;
17120 tmp_init_loc = token->location;
17121 if (init_loc && *init_loc == UNKNOWN_LOCATION)
17122 *init_loc = tmp_init_loc;
17124 if (token->type == CPP_EQ
17125 && function_declarator_p (declarator))
17127 cp_token *t2 = cp_lexer_peek_nth_token (parser->lexer, 2);
17128 if (t2->keyword == RID_DEFAULT)
17129 is_initialized = SD_DEFAULTED;
17130 else if (t2->keyword == RID_DELETE)
17131 is_initialized = SD_DELETED;
17136 /* If the init-declarator isn't initialized and isn't followed by a
17137 `,' or `;', it's not a valid init-declarator. */
17138 if (token->type != CPP_COMMA
17139 && token->type != CPP_SEMICOLON)
17141 if (maybe_range_for_decl && *maybe_range_for_decl != error_mark_node)
17142 range_for_decl_p = true;
17145 if (!maybe_range_for_decl)
17146 cp_parser_error (parser, "expected initializer");
17147 return error_mark_node;
17150 is_initialized = SD_UNINITIALIZED;
17151 initialization_kind = CPP_EOF;
17154 /* Because start_decl has side-effects, we should only call it if we
17155 know we're going ahead. By this point, we know that we cannot
17156 possibly be looking at any other construct. */
17157 cp_parser_commit_to_tentative_parse (parser);
17159 /* Enter the newly declared entry in the symbol table. If we're
17160 processing a declaration in a class-specifier, we wait until
17161 after processing the initializer. */
17164 if (parser->in_unbraced_linkage_specification_p)
17165 decl_specifiers->storage_class = sc_extern;
17166 decl = start_decl (declarator, decl_specifiers,
17167 range_for_decl_p? SD_INITIALIZED : is_initialized,
17168 attributes, prefix_attributes, &pushed_scope);
17169 cp_finalize_omp_declare_simd (parser, decl);
17170 /* Adjust location of decl if declarator->id_loc is more appropriate:
17171 set, and decl wasn't merged with another decl, in which case its
17172 location would be different from input_location, and more accurate. */
17174 && declarator->id_loc != UNKNOWN_LOCATION
17175 && DECL_SOURCE_LOCATION (decl) == input_location)
17176 DECL_SOURCE_LOCATION (decl) = declarator->id_loc;
17179 /* Enter the SCOPE. That way unqualified names appearing in the
17180 initializer will be looked up in SCOPE. */
17181 pushed_scope = push_scope (scope);
17183 /* Perform deferred access control checks, now that we know in which
17184 SCOPE the declared entity resides. */
17185 if (!member_p && decl)
17187 tree saved_current_function_decl = NULL_TREE;
17189 /* If the entity being declared is a function, pretend that we
17190 are in its scope. If it is a `friend', it may have access to
17191 things that would not otherwise be accessible. */
17192 if (TREE_CODE (decl) == FUNCTION_DECL)
17194 saved_current_function_decl = current_function_decl;
17195 current_function_decl = decl;
17198 /* Perform access checks for template parameters. */
17199 cp_parser_perform_template_parameter_access_checks (checks);
17201 /* Perform the access control checks for the declarator and the
17202 decl-specifiers. */
17203 perform_deferred_access_checks (tf_warning_or_error);
17205 /* Restore the saved value. */
17206 if (TREE_CODE (decl) == FUNCTION_DECL)
17207 current_function_decl = saved_current_function_decl;
17210 /* Parse the initializer. */
17211 initializer = NULL_TREE;
17212 is_direct_init = false;
17213 is_non_constant_init = true;
17214 if (is_initialized)
17216 if (function_declarator_p (declarator))
17218 if (initialization_kind == CPP_EQ)
17219 initializer = cp_parser_pure_specifier (parser);
17222 /* If the declaration was erroneous, we don't really
17223 know what the user intended, so just silently
17224 consume the initializer. */
17225 if (decl != error_mark_node)
17226 error_at (tmp_init_loc, "initializer provided for function");
17227 cp_parser_skip_to_closing_parenthesis (parser,
17228 /*recovering=*/true,
17229 /*or_comma=*/false,
17230 /*consume_paren=*/true);
17235 /* We want to record the extra mangling scope for in-class
17236 initializers of class members and initializers of static data
17237 member templates. The former involves deferring
17238 parsing of the initializer until end of class as with default
17239 arguments. So right here we only handle the latter. */
17240 if (!member_p && processing_template_decl)
17241 start_lambda_scope (decl);
17242 initializer = cp_parser_initializer (parser,
17244 &is_non_constant_init);
17245 if (!member_p && processing_template_decl)
17246 finish_lambda_scope ();
17247 if (initializer == error_mark_node)
17248 cp_parser_skip_to_end_of_statement (parser);
17252 /* The old parser allows attributes to appear after a parenthesized
17253 initializer. Mark Mitchell proposed removing this functionality
17254 on the GCC mailing lists on 2002-08-13. This parser accepts the
17255 attributes -- but ignores them. */
17256 if (cp_parser_allow_gnu_extensions_p (parser)
17257 && initialization_kind == CPP_OPEN_PAREN)
17258 if (cp_parser_attributes_opt (parser))
17259 warning (OPT_Wattributes,
17260 "attributes after parenthesized initializer ignored");
17262 /* And now complain about a non-function implicit template. */
17263 if (bogus_implicit_tmpl)
17264 error_at (DECL_SOURCE_LOCATION (decl),
17265 "non-function %qD declared as implicit template", decl);
17267 /* For an in-class declaration, use `grokfield' to create the
17273 pop_scope (pushed_scope);
17274 pushed_scope = NULL_TREE;
17276 decl = grokfield (declarator, decl_specifiers,
17277 initializer, !is_non_constant_init,
17278 /*asmspec=*/NULL_TREE,
17279 chainon (attributes, prefix_attributes));
17280 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
17281 cp_parser_save_default_args (parser, decl);
17282 cp_finalize_omp_declare_simd (parser, decl);
17285 /* Finish processing the declaration. But, skip member
17287 if (!member_p && decl && decl != error_mark_node && !range_for_decl_p)
17289 cp_finish_decl (decl,
17290 initializer, !is_non_constant_init,
17292 /* If the initializer is in parentheses, then this is
17293 a direct-initialization, which means that an
17294 `explicit' constructor is OK. Otherwise, an
17295 `explicit' constructor cannot be used. */
17296 ((is_direct_init || !is_initialized)
17297 ? LOOKUP_NORMAL : LOOKUP_IMPLICIT));
17299 else if ((cxx_dialect != cxx98) && friend_p
17300 && decl && TREE_CODE (decl) == FUNCTION_DECL)
17301 /* Core issue #226 (C++0x only): A default template-argument
17302 shall not be specified in a friend class template
17304 check_default_tmpl_args (decl, current_template_parms, /*is_primary=*/true,
17305 /*is_partial=*/false, /*is_friend_decl=*/1);
17307 if (!friend_p && pushed_scope)
17308 pop_scope (pushed_scope);
17310 if (function_declarator_p (declarator)
17311 && parser->fully_implicit_function_template_p)
17314 decl = finish_fully_implicit_template (parser, decl);
17316 finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
17322 /* Parse a declarator.
17326 ptr-operator declarator
17328 abstract-declarator:
17329 ptr-operator abstract-declarator [opt]
17330 direct-abstract-declarator
17335 attributes [opt] direct-declarator
17336 attributes [opt] ptr-operator declarator
17338 abstract-declarator:
17339 attributes [opt] ptr-operator abstract-declarator [opt]
17340 attributes [opt] direct-abstract-declarator
17342 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
17343 detect constructor, destructor or conversion operators. It is set
17344 to -1 if the declarator is a name, and +1 if it is a
17345 function. Otherwise it is set to zero. Usually you just want to
17346 test for >0, but internally the negative value is used.
17348 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
17349 a decl-specifier-seq unless it declares a constructor, destructor,
17350 or conversion. It might seem that we could check this condition in
17351 semantic analysis, rather than parsing, but that makes it difficult
17352 to handle something like `f()'. We want to notice that there are
17353 no decl-specifiers, and therefore realize that this is an
17354 expression, not a declaration.)
17356 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
17357 the declarator is a direct-declarator of the form "(...)".
17359 MEMBER_P is true iff this declarator is a member-declarator.
17361 FRIEND_P is true iff this declarator is a friend. */
17363 static cp_declarator *
17364 cp_parser_declarator (cp_parser* parser,
17365 cp_parser_declarator_kind dcl_kind,
17366 int* ctor_dtor_or_conv_p,
17367 bool* parenthesized_p,
17368 bool member_p, bool friend_p)
17370 cp_declarator *declarator;
17371 enum tree_code code;
17372 cp_cv_quals cv_quals;
17374 tree gnu_attributes = NULL_TREE, std_attributes = NULL_TREE;
17376 /* Assume this is not a constructor, destructor, or type-conversion
17378 if (ctor_dtor_or_conv_p)
17379 *ctor_dtor_or_conv_p = 0;
17381 if (cp_parser_allow_gnu_extensions_p (parser))
17382 gnu_attributes = cp_parser_gnu_attributes_opt (parser);
17384 /* Check for the ptr-operator production. */
17385 cp_parser_parse_tentatively (parser);
17386 /* Parse the ptr-operator. */
17387 code = cp_parser_ptr_operator (parser,
17392 /* If that worked, then we have a ptr-operator. */
17393 if (cp_parser_parse_definitely (parser))
17395 /* If a ptr-operator was found, then this declarator was not
17397 if (parenthesized_p)
17398 *parenthesized_p = true;
17399 /* The dependent declarator is optional if we are parsing an
17400 abstract-declarator. */
17401 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED)
17402 cp_parser_parse_tentatively (parser);
17404 /* Parse the dependent declarator. */
17405 declarator = cp_parser_declarator (parser, dcl_kind,
17406 /*ctor_dtor_or_conv_p=*/NULL,
17407 /*parenthesized_p=*/NULL,
17408 /*member_p=*/false,
17411 /* If we are parsing an abstract-declarator, we must handle the
17412 case where the dependent declarator is absent. */
17413 if (dcl_kind != CP_PARSER_DECLARATOR_NAMED
17414 && !cp_parser_parse_definitely (parser))
17417 declarator = cp_parser_make_indirect_declarator
17418 (code, class_type, cv_quals, declarator, std_attributes);
17420 /* Everything else is a direct-declarator. */
17423 if (parenthesized_p)
17424 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
17426 declarator = cp_parser_direct_declarator (parser, dcl_kind,
17427 ctor_dtor_or_conv_p,
17428 member_p, friend_p);
17431 if (gnu_attributes && declarator && declarator != cp_error_declarator)
17432 declarator->attributes = gnu_attributes;
17436 /* Parse a direct-declarator or direct-abstract-declarator.
17440 direct-declarator ( parameter-declaration-clause )
17441 cv-qualifier-seq [opt]
17442 ref-qualifier [opt]
17443 exception-specification [opt]
17444 direct-declarator [ constant-expression [opt] ]
17447 direct-abstract-declarator:
17448 direct-abstract-declarator [opt]
17449 ( parameter-declaration-clause )
17450 cv-qualifier-seq [opt]
17451 ref-qualifier [opt]
17452 exception-specification [opt]
17453 direct-abstract-declarator [opt] [ constant-expression [opt] ]
17454 ( abstract-declarator )
17456 Returns a representation of the declarator. DCL_KIND is
17457 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
17458 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
17459 we are parsing a direct-declarator. It is
17460 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
17461 of ambiguity we prefer an abstract declarator, as per
17462 [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P, MEMBER_P, and FRIEND_P are
17463 as for cp_parser_declarator. */
17465 static cp_declarator *
17466 cp_parser_direct_declarator (cp_parser* parser,
17467 cp_parser_declarator_kind dcl_kind,
17468 int* ctor_dtor_or_conv_p,
17469 bool member_p, bool friend_p)
17472 cp_declarator *declarator = NULL;
17473 tree scope = NULL_TREE;
17474 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
17475 bool saved_in_declarator_p = parser->in_declarator_p;
17477 tree pushed_scope = NULL_TREE;
17481 /* Peek at the next token. */
17482 token = cp_lexer_peek_token (parser->lexer);
17483 if (token->type == CPP_OPEN_PAREN)
17485 /* This is either a parameter-declaration-clause, or a
17486 parenthesized declarator. When we know we are parsing a
17487 named declarator, it must be a parenthesized declarator
17488 if FIRST is true. For instance, `(int)' is a
17489 parameter-declaration-clause, with an omitted
17490 direct-abstract-declarator. But `((*))', is a
17491 parenthesized abstract declarator. Finally, when T is a
17492 template parameter `(T)' is a
17493 parameter-declaration-clause, and not a parenthesized
17496 We first try and parse a parameter-declaration-clause,
17497 and then try a nested declarator (if FIRST is true).
17499 It is not an error for it not to be a
17500 parameter-declaration-clause, even when FIRST is
17506 The first is the declaration of a function while the
17507 second is the definition of a variable, including its
17510 Having seen only the parenthesis, we cannot know which of
17511 these two alternatives should be selected. Even more
17512 complex are examples like:
17517 The former is a function-declaration; the latter is a
17518 variable initialization.
17520 Thus again, we try a parameter-declaration-clause, and if
17521 that fails, we back out and return. */
17523 if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
17526 bool is_declarator = false;
17528 /* In a member-declarator, the only valid interpretation
17529 of a parenthesis is the start of a
17530 parameter-declaration-clause. (It is invalid to
17531 initialize a static data member with a parenthesized
17532 initializer; only the "=" form of initialization is
17535 cp_parser_parse_tentatively (parser);
17537 /* Consume the `('. */
17538 cp_lexer_consume_token (parser->lexer);
17541 /* If this is going to be an abstract declarator, we're
17542 in a declarator and we can't have default args. */
17543 parser->default_arg_ok_p = false;
17544 parser->in_declarator_p = true;
17547 begin_scope (sk_function_parms, NULL_TREE);
17549 /* Parse the parameter-declaration-clause. */
17550 params = cp_parser_parameter_declaration_clause (parser);
17552 /* Consume the `)'. */
17553 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
17555 /* If all went well, parse the cv-qualifier-seq,
17556 ref-qualifier and the exception-specification. */
17557 if (member_p || cp_parser_parse_definitely (parser))
17559 cp_cv_quals cv_quals;
17560 cp_virt_specifiers virt_specifiers;
17561 cp_ref_qualifier ref_qual;
17562 tree exception_specification;
17565 bool memfn = (member_p || (pushed_scope
17566 && CLASS_TYPE_P (pushed_scope)));
17568 is_declarator = true;
17570 if (ctor_dtor_or_conv_p)
17571 *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0;
17574 /* Parse the cv-qualifier-seq. */
17575 cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
17576 /* Parse the ref-qualifier. */
17577 ref_qual = cp_parser_ref_qualifier_opt (parser);
17578 /* And the exception-specification. */
17579 exception_specification
17580 = cp_parser_exception_specification_opt (parser);
17582 attrs = cp_parser_std_attribute_spec_seq (parser);
17584 /* In here, we handle cases where attribute is used after
17585 the function declaration. For example:
17586 void func (int x) __attribute__((vector(..))); */
17588 && cp_next_tokens_can_be_gnu_attribute_p (parser))
17590 cp_parser_parse_tentatively (parser);
17591 tree attr = cp_parser_gnu_attributes_opt (parser);
17592 if (cp_lexer_next_token_is_not (parser->lexer,
17594 && cp_lexer_next_token_is_not (parser->lexer,
17596 cp_parser_abort_tentative_parse (parser);
17597 else if (!cp_parser_parse_definitely (parser))
17600 attrs = chainon (attr, attrs);
17602 late_return = (cp_parser_late_return_type_opt
17603 (parser, declarator,
17604 memfn ? cv_quals : -1));
17607 /* Parse the virt-specifier-seq. */
17608 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
17610 /* Create the function-declarator. */
17611 declarator = make_call_declarator (declarator,
17616 exception_specification,
17618 declarator->std_attributes = attrs;
17619 /* Any subsequent parameter lists are to do with
17620 return type, so are not those of the declared
17622 parser->default_arg_ok_p = false;
17625 /* Remove the function parms from scope. */
17626 pop_bindings_and_leave_scope ();
17629 /* Repeat the main loop. */
17633 /* If this is the first, we can try a parenthesized
17637 bool saved_in_type_id_in_expr_p;
17639 parser->default_arg_ok_p = saved_default_arg_ok_p;
17640 parser->in_declarator_p = saved_in_declarator_p;
17642 /* Consume the `('. */
17643 cp_lexer_consume_token (parser->lexer);
17644 /* Parse the nested declarator. */
17645 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
17646 parser->in_type_id_in_expr_p = true;
17648 = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p,
17649 /*parenthesized_p=*/NULL,
17650 member_p, friend_p);
17651 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
17653 /* Expect a `)'. */
17654 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
17655 declarator = cp_error_declarator;
17656 if (declarator == cp_error_declarator)
17659 goto handle_declarator;
17661 /* Otherwise, we must be done. */
17665 else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
17666 && token->type == CPP_OPEN_SQUARE
17667 && !cp_next_tokens_can_be_attribute_p (parser))
17669 /* Parse an array-declarator. */
17670 tree bounds, attrs;
17672 if (ctor_dtor_or_conv_p)
17673 *ctor_dtor_or_conv_p = 0;
17676 parser->default_arg_ok_p = false;
17677 parser->in_declarator_p = true;
17678 /* Consume the `['. */
17679 cp_lexer_consume_token (parser->lexer);
17680 /* Peek at the next token. */
17681 token = cp_lexer_peek_token (parser->lexer);
17682 /* If the next token is `]', then there is no
17683 constant-expression. */
17684 if (token->type != CPP_CLOSE_SQUARE)
17686 bool non_constant_p;
17688 = cp_parser_constant_expression (parser,
17689 /*allow_non_constant=*/true,
17691 if (!non_constant_p)
17693 else if (error_operand_p (bounds))
17694 /* Already gave an error. */;
17695 else if (!parser->in_function_body
17696 || current_binding_level->kind == sk_function_parms)
17698 /* Normally, the array bound must be an integral constant
17699 expression. However, as an extension, we allow VLAs
17700 in function scopes as long as they aren't part of a
17701 parameter declaration. */
17702 cp_parser_error (parser,
17703 "array bound is not an integer constant");
17704 bounds = error_mark_node;
17706 else if (processing_template_decl
17707 && !type_dependent_expression_p (bounds))
17709 /* Remember this wasn't a constant-expression. */
17710 bounds = build_nop (TREE_TYPE (bounds), bounds);
17711 TREE_SIDE_EFFECTS (bounds) = 1;
17715 bounds = NULL_TREE;
17716 /* Look for the closing `]'. */
17717 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
17719 declarator = cp_error_declarator;
17723 attrs = cp_parser_std_attribute_spec_seq (parser);
17724 declarator = make_array_declarator (declarator, bounds);
17725 declarator->std_attributes = attrs;
17727 else if (first && dcl_kind != CP_PARSER_DECLARATOR_ABSTRACT)
17730 tree qualifying_scope;
17731 tree unqualified_name;
17733 special_function_kind sfk;
17735 bool pack_expansion_p = false;
17736 cp_token *declarator_id_start_token;
17738 /* Parse a declarator-id */
17739 abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER);
17742 cp_parser_parse_tentatively (parser);
17744 /* If we see an ellipsis, we should be looking at a
17746 if (token->type == CPP_ELLIPSIS)
17748 /* Consume the `...' */
17749 cp_lexer_consume_token (parser->lexer);
17751 pack_expansion_p = true;
17755 declarator_id_start_token = cp_lexer_peek_token (parser->lexer);
17757 = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
17758 qualifying_scope = parser->scope;
17763 if (!unqualified_name && pack_expansion_p)
17765 /* Check whether an error occurred. */
17766 okay = !cp_parser_error_occurred (parser);
17768 /* We already consumed the ellipsis to mark a
17769 parameter pack, but we have no way to report it,
17770 so abort the tentative parse. We will be exiting
17771 immediately anyway. */
17772 cp_parser_abort_tentative_parse (parser);
17775 okay = cp_parser_parse_definitely (parser);
17778 unqualified_name = error_mark_node;
17779 else if (unqualified_name
17780 && (qualifying_scope
17781 || (!identifier_p (unqualified_name))))
17783 cp_parser_error (parser, "expected unqualified-id");
17784 unqualified_name = error_mark_node;
17788 if (!unqualified_name)
17790 if (unqualified_name == error_mark_node)
17792 declarator = cp_error_declarator;
17793 pack_expansion_p = false;
17794 declarator->parameter_pack_p = false;
17798 attrs = cp_parser_std_attribute_spec_seq (parser);
17800 if (qualifying_scope && at_namespace_scope_p ()
17801 && TREE_CODE (qualifying_scope) == TYPENAME_TYPE)
17803 /* In the declaration of a member of a template class
17804 outside of the class itself, the SCOPE will sometimes
17805 be a TYPENAME_TYPE. For example, given:
17807 template <typename T>
17808 int S<T>::R::i = 3;
17810 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
17811 this context, we must resolve S<T>::R to an ordinary
17812 type, rather than a typename type.
17814 The reason we normally avoid resolving TYPENAME_TYPEs
17815 is that a specialization of `S' might render
17816 `S<T>::R' not a type. However, if `S' is
17817 specialized, then this `i' will not be used, so there
17818 is no harm in resolving the types here. */
17821 /* Resolve the TYPENAME_TYPE. */
17822 type = resolve_typename_type (qualifying_scope,
17823 /*only_current_p=*/false);
17824 /* If that failed, the declarator is invalid. */
17825 if (TREE_CODE (type) == TYPENAME_TYPE)
17827 if (typedef_variant_p (type))
17828 error_at (declarator_id_start_token->location,
17829 "cannot define member of dependent typedef "
17832 error_at (declarator_id_start_token->location,
17833 "%<%T::%E%> is not a type",
17834 TYPE_CONTEXT (qualifying_scope),
17835 TYPE_IDENTIFIER (qualifying_scope));
17837 qualifying_scope = type;
17842 if (unqualified_name)
17846 if (qualifying_scope
17847 && CLASS_TYPE_P (qualifying_scope))
17848 class_type = qualifying_scope;
17850 class_type = current_class_type;
17852 if (TREE_CODE (unqualified_name) == TYPE_DECL)
17854 tree name_type = TREE_TYPE (unqualified_name);
17855 if (class_type && same_type_p (name_type, class_type))
17857 if (qualifying_scope
17858 && CLASSTYPE_USE_TEMPLATE (name_type))
17860 error_at (declarator_id_start_token->location,
17861 "invalid use of constructor as a template");
17862 inform (declarator_id_start_token->location,
17863 "use %<%T::%D%> instead of %<%T::%D%> to "
17864 "name the constructor in a qualified name",
17866 DECL_NAME (TYPE_TI_TEMPLATE (class_type)),
17867 class_type, name_type);
17868 declarator = cp_error_declarator;
17872 unqualified_name = constructor_name (class_type);
17876 /* We do not attempt to print the declarator
17877 here because we do not have enough
17878 information about its original syntactic
17880 cp_parser_error (parser, "invalid declarator");
17881 declarator = cp_error_declarator;
17888 if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR)
17889 sfk = sfk_destructor;
17890 else if (IDENTIFIER_TYPENAME_P (unqualified_name))
17891 sfk = sfk_conversion;
17892 else if (/* There's no way to declare a constructor
17893 for an anonymous type, even if the type
17894 got a name for linkage purposes. */
17895 !TYPE_WAS_ANONYMOUS (class_type)
17896 /* Handle correctly (c++/19200):
17910 friend void N::S();
17913 && class_type != qualifying_scope)
17914 && constructor_name_p (unqualified_name,
17917 unqualified_name = constructor_name (class_type);
17918 sfk = sfk_constructor;
17920 else if (is_overloaded_fn (unqualified_name)
17921 && DECL_CONSTRUCTOR_P (get_first_fn
17922 (unqualified_name)))
17923 sfk = sfk_constructor;
17925 if (ctor_dtor_or_conv_p && sfk != sfk_none)
17926 *ctor_dtor_or_conv_p = -1;
17929 declarator = make_id_declarator (qualifying_scope,
17932 declarator->std_attributes = attrs;
17933 declarator->id_loc = token->location;
17934 declarator->parameter_pack_p = pack_expansion_p;
17936 if (pack_expansion_p)
17937 maybe_warn_variadic_templates ();
17940 handle_declarator:;
17941 scope = get_scope_of_declarator (declarator);
17944 /* Any names that appear after the declarator-id for a
17945 member are looked up in the containing scope. */
17946 if (at_function_scope_p ())
17948 /* But declarations with qualified-ids can't appear in a
17950 cp_parser_error (parser, "qualified-id in declaration");
17951 declarator = cp_error_declarator;
17954 pushed_scope = push_scope (scope);
17956 parser->in_declarator_p = true;
17957 if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p)
17958 || (declarator && declarator->kind == cdk_id))
17959 /* Default args are only allowed on function
17961 parser->default_arg_ok_p = saved_default_arg_ok_p;
17963 parser->default_arg_ok_p = false;
17972 /* For an abstract declarator, we might wind up with nothing at this
17973 point. That's an error; the declarator is not optional. */
17975 cp_parser_error (parser, "expected declarator");
17977 /* If we entered a scope, we must exit it now. */
17979 pop_scope (pushed_scope);
17981 parser->default_arg_ok_p = saved_default_arg_ok_p;
17982 parser->in_declarator_p = saved_in_declarator_p;
17987 /* Parse a ptr-operator.
17990 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17991 * cv-qualifier-seq [opt]
17993 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
17994 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
17999 & cv-qualifier-seq [opt]
18001 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
18002 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
18003 an rvalue reference. In the case of a pointer-to-member, *TYPE is
18004 filled in with the TYPE containing the member. *CV_QUALS is
18005 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
18006 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
18007 Note that the tree codes returned by this function have nothing
18008 to do with the types of trees that will be eventually be created
18009 to represent the pointer or reference type being parsed. They are
18010 just constants with suggestive names. */
18011 static enum tree_code
18012 cp_parser_ptr_operator (cp_parser* parser,
18014 cp_cv_quals *cv_quals,
18017 enum tree_code code = ERROR_MARK;
18019 tree attrs = NULL_TREE;
18021 /* Assume that it's not a pointer-to-member. */
18023 /* And that there are no cv-qualifiers. */
18024 *cv_quals = TYPE_UNQUALIFIED;
18026 /* Peek at the next token. */
18027 token = cp_lexer_peek_token (parser->lexer);
18029 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
18030 if (token->type == CPP_MULT)
18031 code = INDIRECT_REF;
18032 else if (token->type == CPP_AND)
18034 else if ((cxx_dialect != cxx98) &&
18035 token->type == CPP_AND_AND) /* C++0x only */
18036 code = NON_LVALUE_EXPR;
18038 if (code != ERROR_MARK)
18040 /* Consume the `*', `&' or `&&'. */
18041 cp_lexer_consume_token (parser->lexer);
18043 /* A `*' can be followed by a cv-qualifier-seq, and so can a
18044 `&', if we are allowing GNU extensions. (The only qualifier
18045 that can legally appear after `&' is `restrict', but that is
18046 enforced during semantic analysis. */
18047 if (code == INDIRECT_REF
18048 || cp_parser_allow_gnu_extensions_p (parser))
18049 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
18051 attrs = cp_parser_std_attribute_spec_seq (parser);
18052 if (attributes != NULL)
18053 *attributes = attrs;
18057 /* Try the pointer-to-member case. */
18058 cp_parser_parse_tentatively (parser);
18059 /* Look for the optional `::' operator. */
18060 cp_parser_global_scope_opt (parser,
18061 /*current_scope_valid_p=*/false);
18062 /* Look for the nested-name specifier. */
18063 token = cp_lexer_peek_token (parser->lexer);
18064 cp_parser_nested_name_specifier (parser,
18065 /*typename_keyword_p=*/false,
18066 /*check_dependency_p=*/true,
18068 /*is_declaration=*/false);
18069 /* If we found it, and the next token is a `*', then we are
18070 indeed looking at a pointer-to-member operator. */
18071 if (!cp_parser_error_occurred (parser)
18072 && cp_parser_require (parser, CPP_MULT, RT_MULT))
18074 /* Indicate that the `*' operator was used. */
18075 code = INDIRECT_REF;
18077 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
18078 error_at (token->location, "%qD is a namespace", parser->scope);
18079 else if (TREE_CODE (parser->scope) == ENUMERAL_TYPE)
18080 error_at (token->location, "cannot form pointer to member of "
18081 "non-class %q#T", parser->scope);
18084 /* The type of which the member is a member is given by the
18086 *type = parser->scope;
18087 /* The next name will not be qualified. */
18088 parser->scope = NULL_TREE;
18089 parser->qualifying_scope = NULL_TREE;
18090 parser->object_scope = NULL_TREE;
18091 /* Look for optional c++11 attributes. */
18092 attrs = cp_parser_std_attribute_spec_seq (parser);
18093 if (attributes != NULL)
18094 *attributes = attrs;
18095 /* Look for the optional cv-qualifier-seq. */
18096 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
18099 /* If that didn't work we don't have a ptr-operator. */
18100 if (!cp_parser_parse_definitely (parser))
18101 cp_parser_error (parser, "expected ptr-operator");
18107 /* Parse an (optional) cv-qualifier-seq.
18110 cv-qualifier cv-qualifier-seq [opt]
18121 Returns a bitmask representing the cv-qualifiers. */
18124 cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
18126 cp_cv_quals cv_quals = TYPE_UNQUALIFIED;
18131 cp_cv_quals cv_qualifier;
18133 /* Peek at the next token. */
18134 token = cp_lexer_peek_token (parser->lexer);
18135 /* See if it's a cv-qualifier. */
18136 switch (token->keyword)
18139 cv_qualifier = TYPE_QUAL_CONST;
18143 cv_qualifier = TYPE_QUAL_VOLATILE;
18147 cv_qualifier = TYPE_QUAL_RESTRICT;
18151 cv_qualifier = TYPE_UNQUALIFIED;
18158 if (cv_quals & cv_qualifier)
18160 error_at (token->location, "duplicate cv-qualifier");
18161 cp_lexer_purge_token (parser->lexer);
18165 cp_lexer_consume_token (parser->lexer);
18166 cv_quals |= cv_qualifier;
18173 /* Parse an (optional) ref-qualifier
18179 Returns cp_ref_qualifier representing ref-qualifier. */
18181 static cp_ref_qualifier
18182 cp_parser_ref_qualifier_opt (cp_parser* parser)
18184 cp_ref_qualifier ref_qual = REF_QUAL_NONE;
18186 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
18187 if (cxx_dialect < cxx11 && cp_parser_parsing_tentatively (parser))
18192 cp_ref_qualifier curr_ref_qual = REF_QUAL_NONE;
18193 cp_token *token = cp_lexer_peek_token (parser->lexer);
18195 switch (token->type)
18198 curr_ref_qual = REF_QUAL_LVALUE;
18202 curr_ref_qual = REF_QUAL_RVALUE;
18206 curr_ref_qual = REF_QUAL_NONE;
18210 if (!curr_ref_qual)
18214 error_at (token->location, "multiple ref-qualifiers");
18215 cp_lexer_purge_token (parser->lexer);
18219 ref_qual = curr_ref_qual;
18220 cp_lexer_consume_token (parser->lexer);
18227 /* Parse an (optional) virt-specifier-seq.
18229 virt-specifier-seq:
18230 virt-specifier virt-specifier-seq [opt]
18236 Returns a bitmask representing the virt-specifiers. */
18238 static cp_virt_specifiers
18239 cp_parser_virt_specifier_seq_opt (cp_parser* parser)
18241 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
18246 cp_virt_specifiers virt_specifier;
18248 /* Peek at the next token. */
18249 token = cp_lexer_peek_token (parser->lexer);
18250 /* See if it's a virt-specifier-qualifier. */
18251 if (token->type != CPP_NAME)
18253 if (!strcmp (IDENTIFIER_POINTER(token->u.value), "override"))
18255 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS);
18256 virt_specifier = VIRT_SPEC_OVERRIDE;
18258 else if (!strcmp (IDENTIFIER_POINTER(token->u.value), "final"))
18260 maybe_warn_cpp0x (CPP0X_OVERRIDE_CONTROLS);
18261 virt_specifier = VIRT_SPEC_FINAL;
18263 else if (!strcmp (IDENTIFIER_POINTER(token->u.value), "__final"))
18265 virt_specifier = VIRT_SPEC_FINAL;
18270 if (virt_specifiers & virt_specifier)
18272 error_at (token->location, "duplicate virt-specifier");
18273 cp_lexer_purge_token (parser->lexer);
18277 cp_lexer_consume_token (parser->lexer);
18278 virt_specifiers |= virt_specifier;
18281 return virt_specifiers;
18284 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
18285 is in scope even though it isn't real. */
18288 inject_this_parameter (tree ctype, cp_cv_quals quals)
18292 if (current_class_ptr)
18294 /* We don't clear this between NSDMIs. Is it already what we want? */
18295 tree type = TREE_TYPE (TREE_TYPE (current_class_ptr));
18296 if (same_type_ignoring_top_level_qualifiers_p (ctype, type)
18297 && cp_type_quals (type) == quals)
18301 this_parm = build_this_parm (ctype, quals);
18302 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
18303 current_class_ptr = NULL_TREE;
18305 = cp_build_indirect_ref (this_parm, RO_NULL, tf_warning_or_error);
18306 current_class_ptr = this_parm;
18309 /* Return true iff our current scope is a non-static data member
18313 parsing_nsdmi (void)
18315 /* We recognize NSDMI context by the context-less 'this' pointer set up
18316 by the function above. */
18317 if (current_class_ptr
18318 && TREE_CODE (current_class_ptr) == PARM_DECL
18319 && DECL_CONTEXT (current_class_ptr) == NULL_TREE)
18324 /* Parse a late-specified return type, if any. This is not a separate
18325 non-terminal, but part of a function declarator, which looks like
18327 -> trailing-type-specifier-seq abstract-declarator(opt)
18329 Returns the type indicated by the type-id.
18331 In addition to this this parses any queued up omp declare simd
18332 clauses and Cilk Plus SIMD-enabled function's vector attributes.
18334 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
18338 cp_parser_late_return_type_opt (cp_parser* parser, cp_declarator *declarator,
18342 tree type = NULL_TREE;
18343 bool declare_simd_p = (parser->omp_declare_simd
18345 && declarator->kind == cdk_id);
18347 bool cilk_simd_fn_vector_p = (parser->cilk_simd_fn_info
18348 && declarator && declarator->kind == cdk_id);
18350 /* Peek at the next token. */
18351 token = cp_lexer_peek_token (parser->lexer);
18352 /* A late-specified return type is indicated by an initial '->'. */
18353 if (token->type != CPP_DEREF && !(declare_simd_p || cilk_simd_fn_vector_p))
18356 tree save_ccp = current_class_ptr;
18357 tree save_ccr = current_class_ref;
18360 /* DR 1207: 'this' is in scope in the trailing return type. */
18361 inject_this_parameter (current_class_type, quals);
18364 if (token->type == CPP_DEREF)
18366 /* Consume the ->. */
18367 cp_lexer_consume_token (parser->lexer);
18369 type = cp_parser_trailing_type_id (parser);
18372 if (cilk_simd_fn_vector_p)
18373 declarator->std_attributes
18374 = cp_parser_late_parsing_cilk_simd_fn_info (parser,
18375 declarator->std_attributes);
18376 if (declare_simd_p)
18377 declarator->std_attributes
18378 = cp_parser_late_parsing_omp_declare_simd (parser,
18379 declarator->std_attributes);
18383 current_class_ptr = save_ccp;
18384 current_class_ref = save_ccr;
18390 /* Parse a declarator-id.
18394 :: [opt] nested-name-specifier [opt] type-name
18396 In the `id-expression' case, the value returned is as for
18397 cp_parser_id_expression if the id-expression was an unqualified-id.
18398 If the id-expression was a qualified-id, then a SCOPE_REF is
18399 returned. The first operand is the scope (either a NAMESPACE_DECL
18400 or TREE_TYPE), but the second is still just a representation of an
18404 cp_parser_declarator_id (cp_parser* parser, bool optional_p)
18407 /* The expression must be an id-expression. Assume that qualified
18408 names are the names of types so that:
18411 int S<T>::R::i = 3;
18413 will work; we must treat `S<T>::R' as the name of a type.
18414 Similarly, assume that qualified names are templates, where
18418 int S<T>::R<T>::i = 3;
18421 id = cp_parser_id_expression (parser,
18422 /*template_keyword_p=*/false,
18423 /*check_dependency_p=*/false,
18424 /*template_p=*/NULL,
18425 /*declarator_p=*/true,
18427 if (id && BASELINK_P (id))
18428 id = BASELINK_FUNCTIONS (id);
18432 /* Parse a type-id.
18435 type-specifier-seq abstract-declarator [opt]
18437 Returns the TYPE specified. */
18440 cp_parser_type_id_1 (cp_parser* parser, bool is_template_arg,
18441 bool is_trailing_return)
18443 cp_decl_specifier_seq type_specifier_seq;
18444 cp_declarator *abstract_declarator;
18446 /* Parse the type-specifier-seq. */
18447 cp_parser_type_specifier_seq (parser, /*is_declaration=*/false,
18448 is_trailing_return,
18449 &type_specifier_seq);
18450 if (type_specifier_seq.type == error_mark_node)
18451 return error_mark_node;
18453 /* There might or might not be an abstract declarator. */
18454 cp_parser_parse_tentatively (parser);
18455 /* Look for the declarator. */
18456 abstract_declarator
18457 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL,
18458 /*parenthesized_p=*/NULL,
18459 /*member_p=*/false,
18460 /*friend_p=*/false);
18461 /* Check to see if there really was a declarator. */
18462 if (!cp_parser_parse_definitely (parser))
18463 abstract_declarator = NULL;
18465 if (type_specifier_seq.type
18466 /* None of the valid uses of 'auto' in C++14 involve the type-id
18467 nonterminal, but it is valid in a trailing-return-type. */
18468 && !(cxx_dialect >= cxx14 && is_trailing_return)
18469 && type_uses_auto (type_specifier_seq.type))
18471 /* A type-id with type 'auto' is only ok if the abstract declarator
18472 is a function declarator with a late-specified return type. */
18473 if (abstract_declarator
18474 && abstract_declarator->kind == cdk_function
18475 && abstract_declarator->u.function.late_return_type)
18479 error ("invalid use of %<auto%>");
18480 return error_mark_node;
18484 return groktypename (&type_specifier_seq, abstract_declarator,
18488 static tree cp_parser_type_id (cp_parser *parser)
18490 return cp_parser_type_id_1 (parser, false, false);
18493 static tree cp_parser_template_type_arg (cp_parser *parser)
18496 const char *saved_message = parser->type_definition_forbidden_message;
18497 parser->type_definition_forbidden_message
18498 = G_("types may not be defined in template arguments");
18499 r = cp_parser_type_id_1 (parser, true, false);
18500 parser->type_definition_forbidden_message = saved_message;
18501 if (cxx_dialect >= cxx14 && type_uses_auto (r))
18503 error ("invalid use of %<auto%> in template argument");
18504 r = error_mark_node;
18509 static tree cp_parser_trailing_type_id (cp_parser *parser)
18511 return cp_parser_type_id_1 (parser, false, true);
18514 /* Parse a type-specifier-seq.
18516 type-specifier-seq:
18517 type-specifier type-specifier-seq [opt]
18521 type-specifier-seq:
18522 attributes type-specifier-seq [opt]
18524 If IS_DECLARATION is true, we are at the start of a "condition" or
18525 exception-declaration, so we might be followed by a declarator-id.
18527 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
18528 i.e. we've just seen "->".
18530 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
18533 cp_parser_type_specifier_seq (cp_parser* parser,
18534 bool is_declaration,
18535 bool is_trailing_return,
18536 cp_decl_specifier_seq *type_specifier_seq)
18538 bool seen_type_specifier = false;
18539 cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL;
18540 cp_token *start_token = NULL;
18542 /* Clear the TYPE_SPECIFIER_SEQ. */
18543 clear_decl_specs (type_specifier_seq);
18545 /* In the context of a trailing return type, enum E { } is an
18546 elaborated-type-specifier followed by a function-body, not an
18548 if (is_trailing_return)
18549 flags |= CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS;
18551 /* Parse the type-specifiers and attributes. */
18554 tree type_specifier;
18555 bool is_cv_qualifier;
18557 /* Check for attributes first. */
18558 if (cp_next_tokens_can_be_attribute_p (parser))
18560 type_specifier_seq->attributes =
18561 chainon (type_specifier_seq->attributes,
18562 cp_parser_attributes_opt (parser));
18566 /* record the token of the beginning of the type specifier seq,
18567 for error reporting purposes*/
18569 start_token = cp_lexer_peek_token (parser->lexer);
18571 /* Look for the type-specifier. */
18572 type_specifier = cp_parser_type_specifier (parser,
18574 type_specifier_seq,
18575 /*is_declaration=*/false,
18578 if (!type_specifier)
18580 /* If the first type-specifier could not be found, this is not a
18581 type-specifier-seq at all. */
18582 if (!seen_type_specifier)
18584 /* Set in_declarator_p to avoid skipping to the semicolon. */
18585 int in_decl = parser->in_declarator_p;
18586 parser->in_declarator_p = true;
18588 if (cp_parser_uncommitted_to_tentative_parse_p (parser)
18589 || !cp_parser_parse_and_diagnose_invalid_type_name (parser))
18590 cp_parser_error (parser, "expected type-specifier");
18592 parser->in_declarator_p = in_decl;
18594 type_specifier_seq->type = error_mark_node;
18597 /* If subsequent type-specifiers could not be found, the
18598 type-specifier-seq is complete. */
18602 seen_type_specifier = true;
18603 /* The standard says that a condition can be:
18605 type-specifier-seq declarator = assignment-expression
18612 we should treat the "S" as a declarator, not as a
18613 type-specifier. The standard doesn't say that explicitly for
18614 type-specifier-seq, but it does say that for
18615 decl-specifier-seq in an ordinary declaration. Perhaps it
18616 would be clearer just to allow a decl-specifier-seq here, and
18617 then add a semantic restriction that if any decl-specifiers
18618 that are not type-specifiers appear, the program is invalid. */
18619 if (is_declaration && !is_cv_qualifier)
18620 flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES;
18624 /* Return whether the function currently being declared has an associated
18625 template parameter list. */
18628 function_being_declared_is_template_p (cp_parser* parser)
18630 if (!current_template_parms || processing_template_parmlist)
18633 if (parser->implicit_template_scope)
18636 if (at_class_scope_p ()
18637 && TYPE_BEING_DEFINED (current_class_type))
18638 return parser->num_template_parameter_lists != 0;
18640 return ((int) parser->num_template_parameter_lists > template_class_depth
18641 (current_class_type));
18644 /* Parse a parameter-declaration-clause.
18646 parameter-declaration-clause:
18647 parameter-declaration-list [opt] ... [opt]
18648 parameter-declaration-list , ...
18650 Returns a representation for the parameter declarations. A return
18651 value of NULL indicates a parameter-declaration-clause consisting
18652 only of an ellipsis. */
18655 cp_parser_parameter_declaration_clause (cp_parser* parser)
18664 int auto_is_implicit_function_template_parm_p;
18666 parser->auto_is_implicit_function_template_parm_p
18667 = auto_is_implicit_function_template_parm_p;
18669 } cleanup = { parser, parser->auto_is_implicit_function_template_parm_p };
18673 if (!processing_specialization
18674 && !processing_template_parmlist
18675 && !processing_explicit_instantiation)
18676 if (!current_function_decl
18677 || (current_class_type && LAMBDA_TYPE_P (current_class_type)))
18678 parser->auto_is_implicit_function_template_parm_p = true;
18680 /* Peek at the next token. */
18681 token = cp_lexer_peek_token (parser->lexer);
18682 /* Check for trivial parameter-declaration-clauses. */
18683 if (token->type == CPP_ELLIPSIS)
18685 /* Consume the `...' token. */
18686 cp_lexer_consume_token (parser->lexer);
18689 else if (token->type == CPP_CLOSE_PAREN)
18690 /* There are no parameters. */
18692 #ifndef NO_IMPLICIT_EXTERN_C
18693 if (in_system_header_at (input_location)
18694 && current_class_type == NULL
18695 && current_lang_name == lang_name_c)
18699 return void_list_node;
18701 /* Check for `(void)', too, which is a special case. */
18702 else if (token->keyword == RID_VOID
18703 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
18704 == CPP_CLOSE_PAREN))
18706 /* Consume the `void' token. */
18707 cp_lexer_consume_token (parser->lexer);
18708 /* There are no parameters. */
18709 return void_list_node;
18712 /* Parse the parameter-declaration-list. */
18713 parameters = cp_parser_parameter_declaration_list (parser, &is_error);
18714 /* If a parse error occurred while parsing the
18715 parameter-declaration-list, then the entire
18716 parameter-declaration-clause is erroneous. */
18720 /* Peek at the next token. */
18721 token = cp_lexer_peek_token (parser->lexer);
18722 /* If it's a `,', the clause should terminate with an ellipsis. */
18723 if (token->type == CPP_COMMA)
18725 /* Consume the `,'. */
18726 cp_lexer_consume_token (parser->lexer);
18727 /* Expect an ellipsis. */
18729 = (cp_parser_require (parser, CPP_ELLIPSIS, RT_ELLIPSIS) != NULL);
18731 /* It might also be `...' if the optional trailing `,' was
18733 else if (token->type == CPP_ELLIPSIS)
18735 /* Consume the `...' token. */
18736 cp_lexer_consume_token (parser->lexer);
18737 /* And remember that we saw it. */
18741 ellipsis_p = false;
18743 /* Finish the parameter list. */
18745 parameters = chainon (parameters, void_list_node);
18750 /* Parse a parameter-declaration-list.
18752 parameter-declaration-list:
18753 parameter-declaration
18754 parameter-declaration-list , parameter-declaration
18756 Returns a representation of the parameter-declaration-list, as for
18757 cp_parser_parameter_declaration_clause. However, the
18758 `void_list_node' is never appended to the list. Upon return,
18759 *IS_ERROR will be true iff an error occurred. */
18762 cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error)
18764 tree parameters = NULL_TREE;
18765 tree *tail = ¶meters;
18766 bool saved_in_unbraced_linkage_specification_p;
18769 /* Assume all will go well. */
18771 /* The special considerations that apply to a function within an
18772 unbraced linkage specifications do not apply to the parameters
18773 to the function. */
18774 saved_in_unbraced_linkage_specification_p
18775 = parser->in_unbraced_linkage_specification_p;
18776 parser->in_unbraced_linkage_specification_p = false;
18778 /* Look for more parameters. */
18781 cp_parameter_declarator *parameter;
18782 tree decl = error_mark_node;
18783 bool parenthesized_p = false;
18784 int template_parm_idx = (function_being_declared_is_template_p (parser)?
18785 TREE_VEC_LENGTH (INNERMOST_TEMPLATE_PARMS
18786 (current_template_parms)) : 0);
18788 /* Parse the parameter. */
18790 = cp_parser_parameter_declaration (parser,
18791 /*template_parm_p=*/false,
18794 /* We don't know yet if the enclosing context is deprecated, so wait
18795 and warn in grokparms if appropriate. */
18796 deprecated_state = DEPRECATED_SUPPRESS;
18800 /* If a function parameter pack was specified and an implicit template
18801 parameter was introduced during cp_parser_parameter_declaration,
18802 change any implicit parameters introduced into packs. */
18803 if (parser->implicit_template_parms
18804 && parameter->declarator
18805 && parameter->declarator->parameter_pack_p)
18807 int latest_template_parm_idx = TREE_VEC_LENGTH
18808 (INNERMOST_TEMPLATE_PARMS (current_template_parms));
18810 if (latest_template_parm_idx != template_parm_idx)
18811 parameter->decl_specifiers.type = convert_generic_types_to_packs
18812 (parameter->decl_specifiers.type,
18813 template_parm_idx, latest_template_parm_idx);
18816 decl = grokdeclarator (parameter->declarator,
18817 ¶meter->decl_specifiers,
18819 parameter->default_argument != NULL_TREE,
18820 ¶meter->decl_specifiers.attributes);
18823 deprecated_state = DEPRECATED_NORMAL;
18825 /* If a parse error occurred parsing the parameter declaration,
18826 then the entire parameter-declaration-list is erroneous. */
18827 if (decl == error_mark_node)
18830 parameters = error_mark_node;
18834 if (parameter->decl_specifiers.attributes)
18835 cplus_decl_attributes (&decl,
18836 parameter->decl_specifiers.attributes,
18838 if (DECL_NAME (decl))
18839 decl = pushdecl (decl);
18841 if (decl != error_mark_node)
18843 retrofit_lang_decl (decl);
18844 DECL_PARM_INDEX (decl) = ++index;
18845 DECL_PARM_LEVEL (decl) = function_parm_depth ();
18848 /* Add the new parameter to the list. */
18849 *tail = build_tree_list (parameter->default_argument, decl);
18850 tail = &TREE_CHAIN (*tail);
18852 /* Peek at the next token. */
18853 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
18854 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
18855 /* These are for Objective-C++ */
18856 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
18857 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
18858 /* The parameter-declaration-list is complete. */
18860 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
18864 /* Peek at the next token. */
18865 token = cp_lexer_peek_nth_token (parser->lexer, 2);
18866 /* If it's an ellipsis, then the list is complete. */
18867 if (token->type == CPP_ELLIPSIS)
18869 /* Otherwise, there must be more parameters. Consume the
18871 cp_lexer_consume_token (parser->lexer);
18872 /* When parsing something like:
18874 int i(float f, double d)
18876 we can tell after seeing the declaration for "f" that we
18877 are not looking at an initialization of a variable "i",
18878 but rather at the declaration of a function "i".
18880 Due to the fact that the parsing of template arguments
18881 (as specified to a template-id) requires backtracking we
18882 cannot use this technique when inside a template argument
18884 if (!parser->in_template_argument_list_p
18885 && !parser->in_type_id_in_expr_p
18886 && cp_parser_uncommitted_to_tentative_parse_p (parser)
18887 /* However, a parameter-declaration of the form
18888 "float(f)" (which is a valid declaration of a
18889 parameter "f") can also be interpreted as an
18890 expression (the conversion of "f" to "float"). */
18891 && !parenthesized_p)
18892 cp_parser_commit_to_tentative_parse (parser);
18896 cp_parser_error (parser, "expected %<,%> or %<...%>");
18897 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
18898 cp_parser_skip_to_closing_parenthesis (parser,
18899 /*recovering=*/true,
18900 /*or_comma=*/false,
18901 /*consume_paren=*/false);
18906 parser->in_unbraced_linkage_specification_p
18907 = saved_in_unbraced_linkage_specification_p;
18909 /* Reset implicit_template_scope if we are about to leave the function
18910 parameter list that introduced it. Note that for out-of-line member
18911 definitions, there will be one or more class scopes before we get to
18912 the template parameter scope. */
18914 if (cp_binding_level *its = parser->implicit_template_scope)
18915 if (cp_binding_level *maybe_its = current_binding_level->level_chain)
18917 while (maybe_its->kind == sk_class)
18918 maybe_its = maybe_its->level_chain;
18919 if (maybe_its == its)
18921 parser->implicit_template_parms = 0;
18922 parser->implicit_template_scope = 0;
18929 /* Parse a parameter declaration.
18931 parameter-declaration:
18932 decl-specifier-seq ... [opt] declarator
18933 decl-specifier-seq declarator = assignment-expression
18934 decl-specifier-seq ... [opt] abstract-declarator [opt]
18935 decl-specifier-seq abstract-declarator [opt] = assignment-expression
18937 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
18938 declares a template parameter. (In that case, a non-nested `>'
18939 token encountered during the parsing of the assignment-expression
18940 is not interpreted as a greater-than operator.)
18942 Returns a representation of the parameter, or NULL if an error
18943 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
18944 true iff the declarator is of the form "(p)". */
18946 static cp_parameter_declarator *
18947 cp_parser_parameter_declaration (cp_parser *parser,
18948 bool template_parm_p,
18949 bool *parenthesized_p)
18951 int declares_class_or_enum;
18952 cp_decl_specifier_seq decl_specifiers;
18953 cp_declarator *declarator;
18954 tree default_argument;
18955 cp_token *token = NULL, *declarator_token_start = NULL;
18956 const char *saved_message;
18958 /* In a template parameter, `>' is not an operator.
18962 When parsing a default template-argument for a non-type
18963 template-parameter, the first non-nested `>' is taken as the end
18964 of the template parameter-list rather than a greater-than
18967 /* Type definitions may not appear in parameter types. */
18968 saved_message = parser->type_definition_forbidden_message;
18969 parser->type_definition_forbidden_message
18970 = G_("types may not be defined in parameter types");
18972 /* Parse the declaration-specifiers. */
18973 cp_parser_decl_specifier_seq (parser,
18974 CP_PARSER_FLAGS_NONE,
18976 &declares_class_or_enum);
18978 /* Complain about missing 'typename' or other invalid type names. */
18979 if (!decl_specifiers.any_type_specifiers_p
18980 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
18981 decl_specifiers.type = error_mark_node;
18983 /* If an error occurred, there's no reason to attempt to parse the
18984 rest of the declaration. */
18985 if (cp_parser_error_occurred (parser))
18987 parser->type_definition_forbidden_message = saved_message;
18991 /* Peek at the next token. */
18992 token = cp_lexer_peek_token (parser->lexer);
18994 /* If the next token is a `)', `,', `=', `>', or `...', then there
18995 is no declarator. However, when variadic templates are enabled,
18996 there may be a declarator following `...'. */
18997 if (token->type == CPP_CLOSE_PAREN
18998 || token->type == CPP_COMMA
18999 || token->type == CPP_EQ
19000 || token->type == CPP_GREATER)
19003 if (parenthesized_p)
19004 *parenthesized_p = false;
19006 /* Otherwise, there should be a declarator. */
19009 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
19010 parser->default_arg_ok_p = false;
19012 /* After seeing a decl-specifier-seq, if the next token is not a
19013 "(", there is no possibility that the code is a valid
19014 expression. Therefore, if parsing tentatively, we commit at
19016 if (!parser->in_template_argument_list_p
19017 /* In an expression context, having seen:
19021 we cannot be sure whether we are looking at a
19022 function-type (taking a "char" as a parameter) or a cast
19023 of some object of type "char" to "int". */
19024 && !parser->in_type_id_in_expr_p
19025 && cp_parser_uncommitted_to_tentative_parse_p (parser)
19026 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
19027 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
19028 cp_parser_commit_to_tentative_parse (parser);
19029 /* Parse the declarator. */
19030 declarator_token_start = token;
19031 declarator = cp_parser_declarator (parser,
19032 CP_PARSER_DECLARATOR_EITHER,
19033 /*ctor_dtor_or_conv_p=*/NULL,
19035 /*member_p=*/false,
19036 /*friend_p=*/false);
19037 parser->default_arg_ok_p = saved_default_arg_ok_p;
19038 /* After the declarator, allow more attributes. */
19039 decl_specifiers.attributes
19040 = chainon (decl_specifiers.attributes,
19041 cp_parser_attributes_opt (parser));
19044 /* If the next token is an ellipsis, and we have not seen a
19045 declarator name, and the type of the declarator contains parameter
19046 packs but it is not a TYPE_PACK_EXPANSION, then we actually have
19047 a parameter pack expansion expression. Otherwise, leave the
19048 ellipsis for a C-style variadic function. */
19049 token = cp_lexer_peek_token (parser->lexer);
19050 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19052 tree type = decl_specifiers.type;
19054 if (type && DECL_P (type))
19055 type = TREE_TYPE (type);
19058 && TREE_CODE (type) != TYPE_PACK_EXPANSION
19059 && declarator_can_be_parameter_pack (declarator)
19060 && (!declarator || !declarator->parameter_pack_p)
19061 && uses_parameter_packs (type))
19063 /* Consume the `...'. */
19064 cp_lexer_consume_token (parser->lexer);
19065 maybe_warn_variadic_templates ();
19067 /* Build a pack expansion type */
19069 declarator->parameter_pack_p = true;
19071 decl_specifiers.type = make_pack_expansion (type);
19075 /* The restriction on defining new types applies only to the type
19076 of the parameter, not to the default argument. */
19077 parser->type_definition_forbidden_message = saved_message;
19079 /* If the next token is `=', then process a default argument. */
19080 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
19082 token = cp_lexer_peek_token (parser->lexer);
19083 /* If we are defining a class, then the tokens that make up the
19084 default argument must be saved and processed later. */
19085 if (!template_parm_p && at_class_scope_p ()
19086 && TYPE_BEING_DEFINED (current_class_type)
19087 && !LAMBDA_TYPE_P (current_class_type))
19088 default_argument = cp_parser_cache_defarg (parser, /*nsdmi=*/false);
19089 /* Outside of a class definition, we can just parse the
19090 assignment-expression. */
19093 = cp_parser_default_argument (parser, template_parm_p);
19095 if (!parser->default_arg_ok_p)
19097 if (flag_permissive)
19098 warning (0, "deprecated use of default argument for parameter of non-function");
19101 error_at (token->location,
19102 "default arguments are only "
19103 "permitted for function parameters");
19104 default_argument = NULL_TREE;
19107 else if ((declarator && declarator->parameter_pack_p)
19108 || (decl_specifiers.type
19109 && PACK_EXPANSION_P (decl_specifiers.type)))
19111 /* Find the name of the parameter pack. */
19112 cp_declarator *id_declarator = declarator;
19113 while (id_declarator && id_declarator->kind != cdk_id)
19114 id_declarator = id_declarator->declarator;
19116 if (id_declarator && id_declarator->kind == cdk_id)
19117 error_at (declarator_token_start->location,
19119 ? G_("template parameter pack %qD "
19120 "cannot have a default argument")
19121 : G_("parameter pack %qD cannot have "
19122 "a default argument"),
19123 id_declarator->u.id.unqualified_name);
19125 error_at (declarator_token_start->location,
19127 ? G_("template parameter pack cannot have "
19128 "a default argument")
19129 : G_("parameter pack cannot have a "
19130 "default argument"));
19132 default_argument = NULL_TREE;
19136 default_argument = NULL_TREE;
19138 return make_parameter_declarator (&decl_specifiers,
19143 /* Parse a default argument and return it.
19145 TEMPLATE_PARM_P is true if this is a default argument for a
19146 non-type template parameter. */
19148 cp_parser_default_argument (cp_parser *parser, bool template_parm_p)
19150 tree default_argument = NULL_TREE;
19151 bool saved_greater_than_is_operator_p;
19152 bool saved_local_variables_forbidden_p;
19153 bool non_constant_p, is_direct_init;
19155 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
19157 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
19158 parser->greater_than_is_operator_p = !template_parm_p;
19159 /* Local variable names (and the `this' keyword) may not
19160 appear in a default argument. */
19161 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
19162 parser->local_variables_forbidden_p = true;
19163 /* Parse the assignment-expression. */
19164 if (template_parm_p)
19165 push_deferring_access_checks (dk_no_deferred);
19166 tree saved_class_ptr = NULL_TREE;
19167 tree saved_class_ref = NULL_TREE;
19168 /* The "this" pointer is not valid in a default argument. */
19171 saved_class_ptr = current_class_ptr;
19172 cp_function_chain->x_current_class_ptr = NULL_TREE;
19173 saved_class_ref = current_class_ref;
19174 cp_function_chain->x_current_class_ref = NULL_TREE;
19177 = cp_parser_initializer (parser, &is_direct_init, &non_constant_p);
19178 /* Restore the "this" pointer. */
19181 cp_function_chain->x_current_class_ptr = saved_class_ptr;
19182 cp_function_chain->x_current_class_ref = saved_class_ref;
19184 if (BRACE_ENCLOSED_INITIALIZER_P (default_argument))
19185 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
19186 if (template_parm_p)
19187 pop_deferring_access_checks ();
19188 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
19189 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
19191 return default_argument;
19194 /* Parse a function-body.
19197 compound_statement */
19200 cp_parser_function_body (cp_parser *parser, bool in_function_try_block)
19202 cp_parser_compound_statement (parser, NULL, in_function_try_block, true);
19205 /* Parse a ctor-initializer-opt followed by a function-body. Return
19206 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
19207 is true we are parsing a function-try-block. */
19210 cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser,
19211 bool in_function_try_block)
19214 bool ctor_initializer_p;
19215 const bool check_body_p =
19216 DECL_CONSTRUCTOR_P (current_function_decl)
19217 && DECL_DECLARED_CONSTEXPR_P (current_function_decl);
19220 /* Begin the function body. */
19221 body = begin_function_body ();
19222 /* Parse the optional ctor-initializer. */
19223 ctor_initializer_p = cp_parser_ctor_initializer_opt (parser);
19225 /* If we're parsing a constexpr constructor definition, we need
19226 to check that the constructor body is indeed empty. However,
19227 before we get to cp_parser_function_body lot of junk has been
19228 generated, so we can't just check that we have an empty block.
19229 Rather we take a snapshot of the outermost block, and check whether
19230 cp_parser_function_body changed its state. */
19233 list = cur_stmt_list;
19234 if (STATEMENT_LIST_TAIL (list))
19235 last = STATEMENT_LIST_TAIL (list)->stmt;
19237 /* Parse the function-body. */
19238 cp_parser_function_body (parser, in_function_try_block);
19240 check_constexpr_ctor_body (last, list, /*complain=*/true);
19241 /* Finish the function body. */
19242 finish_function_body (body);
19244 return ctor_initializer_p;
19247 /* Parse an initializer.
19250 = initializer-clause
19251 ( expression-list )
19253 Returns an expression representing the initializer. If no
19254 initializer is present, NULL_TREE is returned.
19256 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
19257 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
19258 set to TRUE if there is no initializer present. If there is an
19259 initializer, and it is not a constant-expression, *NON_CONSTANT_P
19260 is set to true; otherwise it is set to false. */
19263 cp_parser_initializer (cp_parser* parser, bool* is_direct_init,
19264 bool* non_constant_p)
19269 /* Peek at the next token. */
19270 token = cp_lexer_peek_token (parser->lexer);
19272 /* Let our caller know whether or not this initializer was
19274 *is_direct_init = (token->type != CPP_EQ);
19275 /* Assume that the initializer is constant. */
19276 *non_constant_p = false;
19278 if (token->type == CPP_EQ)
19280 /* Consume the `='. */
19281 cp_lexer_consume_token (parser->lexer);
19282 /* Parse the initializer-clause. */
19283 init = cp_parser_initializer_clause (parser, non_constant_p);
19285 else if (token->type == CPP_OPEN_PAREN)
19287 vec<tree, va_gc> *vec;
19288 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
19290 /*allow_expansion_p=*/true,
19293 return error_mark_node;
19294 init = build_tree_list_vec (vec);
19295 release_tree_vector (vec);
19297 else if (token->type == CPP_OPEN_BRACE)
19299 cp_lexer_set_source_position (parser->lexer);
19300 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
19301 init = cp_parser_braced_list (parser, non_constant_p);
19302 CONSTRUCTOR_IS_DIRECT_INIT (init) = 1;
19306 /* Anything else is an error. */
19307 cp_parser_error (parser, "expected initializer");
19308 init = error_mark_node;
19314 /* Parse an initializer-clause.
19316 initializer-clause:
19317 assignment-expression
19320 Returns an expression representing the initializer.
19322 If the `assignment-expression' production is used the value
19323 returned is simply a representation for the expression.
19325 Otherwise, calls cp_parser_braced_list. */
19328 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
19332 /* Assume the expression is constant. */
19333 *non_constant_p = false;
19335 /* If it is not a `{', then we are looking at an
19336 assignment-expression. */
19337 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
19340 = cp_parser_constant_expression (parser,
19341 /*allow_non_constant_p=*/true,
19345 initializer = cp_parser_braced_list (parser, non_constant_p);
19347 return initializer;
19350 /* Parse a brace-enclosed initializer list.
19353 { initializer-list , [opt] }
19356 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
19357 the elements of the initializer-list (or NULL, if the last
19358 production is used). The TREE_TYPE for the CONSTRUCTOR will be
19359 NULL_TREE. There is no way to detect whether or not the optional
19360 trailing `,' was provided. NON_CONSTANT_P is as for
19361 cp_parser_initializer. */
19364 cp_parser_braced_list (cp_parser* parser, bool* non_constant_p)
19368 /* Consume the `{' token. */
19369 cp_lexer_consume_token (parser->lexer);
19370 /* Create a CONSTRUCTOR to represent the braced-initializer. */
19371 initializer = make_node (CONSTRUCTOR);
19372 /* If it's not a `}', then there is a non-trivial initializer. */
19373 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
19375 /* Parse the initializer list. */
19376 CONSTRUCTOR_ELTS (initializer)
19377 = cp_parser_initializer_list (parser, non_constant_p);
19378 /* A trailing `,' token is allowed. */
19379 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
19380 cp_lexer_consume_token (parser->lexer);
19383 *non_constant_p = false;
19384 /* Now, there should be a trailing `}'. */
19385 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
19386 TREE_TYPE (initializer) = init_list_type_node;
19387 return initializer;
19390 /* Consume tokens up to, and including, the next non-nested closing `]'.
19391 Returns true iff we found a closing `]'. */
19394 cp_parser_skip_to_closing_square_bracket (cp_parser *parser)
19396 unsigned square_depth = 0;
19400 cp_token * token = cp_lexer_peek_token (parser->lexer);
19402 switch (token->type)
19405 case CPP_PRAGMA_EOL:
19406 /* If we've run out of tokens, then there is no closing `]'. */
19409 case CPP_OPEN_SQUARE:
19413 case CPP_CLOSE_SQUARE:
19414 if (!square_depth--)
19416 cp_lexer_consume_token (parser->lexer);
19425 /* Consume the token. */
19426 cp_lexer_consume_token (parser->lexer);
19430 /* Return true if we are looking at an array-designator, false otherwise. */
19433 cp_parser_array_designator_p (cp_parser *parser)
19435 /* Consume the `['. */
19436 cp_lexer_consume_token (parser->lexer);
19438 cp_lexer_save_tokens (parser->lexer);
19440 /* Skip tokens until the next token is a closing square bracket.
19441 If we find the closing `]', and the next token is a `=', then
19442 we are looking at an array designator. */
19443 bool array_designator_p
19444 = (cp_parser_skip_to_closing_square_bracket (parser)
19445 && cp_lexer_next_token_is (parser->lexer, CPP_EQ));
19447 /* Roll back the tokens we skipped. */
19448 cp_lexer_rollback_tokens (parser->lexer);
19450 return array_designator_p;
19453 /* Parse an initializer-list.
19456 initializer-clause ... [opt]
19457 initializer-list , initializer-clause ... [opt]
19462 designation initializer-clause ...[opt]
19463 initializer-list , designation initializer-clause ...[opt]
19468 [ constant-expression ] =
19470 Returns a vec of constructor_elt. The VALUE of each elt is an expression
19471 for the initializer. If the INDEX of the elt is non-NULL, it is the
19472 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
19473 as for cp_parser_initializer. */
19475 static vec<constructor_elt, va_gc> *
19476 cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p)
19478 vec<constructor_elt, va_gc> *v = NULL;
19480 /* Assume all of the expressions are constant. */
19481 *non_constant_p = false;
19483 /* Parse the rest of the list. */
19489 bool clause_non_constant_p;
19491 /* If the next token is an identifier and the following one is a
19492 colon, we are looking at the GNU designated-initializer
19494 if (cp_parser_allow_gnu_extensions_p (parser)
19495 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
19496 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
19498 /* Warn the user that they are using an extension. */
19499 pedwarn (input_location, OPT_Wpedantic,
19500 "ISO C++ does not allow designated initializers");
19501 /* Consume the identifier. */
19502 designator = cp_lexer_consume_token (parser->lexer)->u.value;
19503 /* Consume the `:'. */
19504 cp_lexer_consume_token (parser->lexer);
19506 /* Also handle the C99 syntax, '. id ='. */
19507 else if (cp_parser_allow_gnu_extensions_p (parser)
19508 && cp_lexer_next_token_is (parser->lexer, CPP_DOT)
19509 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME
19510 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
19512 /* Warn the user that they are using an extension. */
19513 pedwarn (input_location, OPT_Wpedantic,
19514 "ISO C++ does not allow C99 designated initializers");
19515 /* Consume the `.'. */
19516 cp_lexer_consume_token (parser->lexer);
19517 /* Consume the identifier. */
19518 designator = cp_lexer_consume_token (parser->lexer)->u.value;
19519 /* Consume the `='. */
19520 cp_lexer_consume_token (parser->lexer);
19522 /* Also handle C99 array designators, '[ const ] ='. */
19523 else if (cp_parser_allow_gnu_extensions_p (parser)
19524 && !c_dialect_objc ()
19525 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
19527 /* In C++11, [ could start a lambda-introducer. */
19528 bool non_const = false;
19530 cp_parser_parse_tentatively (parser);
19532 if (!cp_parser_array_designator_p (parser))
19534 cp_parser_simulate_error (parser);
19535 designator = NULL_TREE;
19539 designator = cp_parser_constant_expression (parser, true,
19541 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
19542 cp_parser_require (parser, CPP_EQ, RT_EQ);
19545 if (!cp_parser_parse_definitely (parser))
19546 designator = NULL_TREE;
19547 else if (non_const)
19548 require_potential_rvalue_constant_expression (designator);
19551 designator = NULL_TREE;
19553 /* Parse the initializer. */
19554 initializer = cp_parser_initializer_clause (parser,
19555 &clause_non_constant_p);
19556 /* If any clause is non-constant, so is the entire initializer. */
19557 if (clause_non_constant_p)
19558 *non_constant_p = true;
19560 /* If we have an ellipsis, this is an initializer pack
19562 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19564 /* Consume the `...'. */
19565 cp_lexer_consume_token (parser->lexer);
19567 /* Turn the initializer into an initializer expansion. */
19568 initializer = make_pack_expansion (initializer);
19571 /* Add it to the vector. */
19572 CONSTRUCTOR_APPEND_ELT (v, designator, initializer);
19574 /* If the next token is not a comma, we have reached the end of
19576 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
19579 /* Peek at the next token. */
19580 token = cp_lexer_peek_nth_token (parser->lexer, 2);
19581 /* If the next token is a `}', then we're still done. An
19582 initializer-clause can have a trailing `,' after the
19583 initializer-list and before the closing `}'. */
19584 if (token->type == CPP_CLOSE_BRACE)
19587 /* Consume the `,' token. */
19588 cp_lexer_consume_token (parser->lexer);
19594 /* Classes [gram.class] */
19596 /* Parse a class-name.
19602 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
19603 to indicate that names looked up in dependent types should be
19604 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
19605 keyword has been used to indicate that the name that appears next
19606 is a template. TAG_TYPE indicates the explicit tag given before
19607 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
19608 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
19609 is the class being defined in a class-head.
19611 Returns the TYPE_DECL representing the class. */
19614 cp_parser_class_name (cp_parser *parser,
19615 bool typename_keyword_p,
19616 bool template_keyword_p,
19617 enum tag_types tag_type,
19618 bool check_dependency_p,
19620 bool is_declaration)
19626 tree identifier = NULL_TREE;
19628 /* All class-names start with an identifier. */
19629 token = cp_lexer_peek_token (parser->lexer);
19630 if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID)
19632 cp_parser_error (parser, "expected class-name");
19633 return error_mark_node;
19636 /* PARSER->SCOPE can be cleared when parsing the template-arguments
19637 to a template-id, so we save it here. */
19638 scope = parser->scope;
19639 if (scope == error_mark_node)
19640 return error_mark_node;
19642 /* Any name names a type if we're following the `typename' keyword
19643 in a qualified name where the enclosing scope is type-dependent. */
19644 typename_p = (typename_keyword_p && scope && TYPE_P (scope)
19645 && dependent_type_p (scope));
19646 /* Handle the common case (an identifier, but not a template-id)
19648 if (token->type == CPP_NAME
19649 && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
19651 cp_token *identifier_token;
19654 /* Look for the identifier. */
19655 identifier_token = cp_lexer_peek_token (parser->lexer);
19656 ambiguous_p = identifier_token->error_reported;
19657 identifier = cp_parser_identifier (parser);
19658 /* If the next token isn't an identifier, we are certainly not
19659 looking at a class-name. */
19660 if (identifier == error_mark_node)
19661 decl = error_mark_node;
19662 /* If we know this is a type-name, there's no need to look it
19664 else if (typename_p)
19668 tree ambiguous_decls;
19669 /* If we already know that this lookup is ambiguous, then
19670 we've already issued an error message; there's no reason
19674 cp_parser_simulate_error (parser);
19675 return error_mark_node;
19677 /* If the next token is a `::', then the name must be a type
19680 [basic.lookup.qual]
19682 During the lookup for a name preceding the :: scope
19683 resolution operator, object, function, and enumerator
19684 names are ignored. */
19685 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
19686 tag_type = typename_type;
19687 /* Look up the name. */
19688 decl = cp_parser_lookup_name (parser, identifier,
19690 /*is_template=*/false,
19691 /*is_namespace=*/false,
19692 check_dependency_p,
19694 identifier_token->location);
19695 if (ambiguous_decls)
19697 if (cp_parser_parsing_tentatively (parser))
19698 cp_parser_simulate_error (parser);
19699 return error_mark_node;
19705 /* Try a template-id. */
19706 decl = cp_parser_template_id (parser, template_keyword_p,
19707 check_dependency_p,
19710 if (decl == error_mark_node)
19711 return error_mark_node;
19714 decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p);
19716 /* If this is a typename, create a TYPENAME_TYPE. */
19717 if (typename_p && decl != error_mark_node)
19719 decl = make_typename_type (scope, decl, typename_type,
19720 /*complain=*/tf_error);
19721 if (decl != error_mark_node)
19722 decl = TYPE_NAME (decl);
19725 decl = strip_using_decl (decl);
19727 /* Check to see that it is really the name of a class. */
19728 if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
19729 && identifier_p (TREE_OPERAND (decl, 0))
19730 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
19731 /* Situations like this:
19733 template <typename T> struct A {
19734 typename T::template X<int>::I i;
19737 are problematic. Is `T::template X<int>' a class-name? The
19738 standard does not seem to be definitive, but there is no other
19739 valid interpretation of the following `::'. Therefore, those
19740 names are considered class-names. */
19742 decl = make_typename_type (scope, decl, tag_type, tf_error);
19743 if (decl != error_mark_node)
19744 decl = TYPE_NAME (decl);
19746 else if (TREE_CODE (decl) != TYPE_DECL
19747 || TREE_TYPE (decl) == error_mark_node
19748 || !MAYBE_CLASS_TYPE_P (TREE_TYPE (decl))
19749 /* In Objective-C 2.0, a classname followed by '.' starts a
19750 dot-syntax expression, and it's not a type-name. */
19751 || (c_dialect_objc ()
19752 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
19753 && objc_is_class_name (decl)))
19754 decl = error_mark_node;
19756 if (decl == error_mark_node)
19757 cp_parser_error (parser, "expected class-name");
19758 else if (identifier && !parser->scope)
19759 maybe_note_name_used_in_class (identifier, decl);
19764 /* Parse a class-specifier.
19767 class-head { member-specification [opt] }
19769 Returns the TREE_TYPE representing the class. */
19772 cp_parser_class_specifier_1 (cp_parser* parser)
19775 tree attributes = NULL_TREE;
19776 bool nested_name_specifier_p;
19777 unsigned saved_num_template_parameter_lists;
19778 bool saved_in_function_body;
19779 unsigned char in_statement;
19780 bool in_switch_statement_p;
19781 bool saved_in_unbraced_linkage_specification_p;
19782 tree old_scope = NULL_TREE;
19783 tree scope = NULL_TREE;
19784 cp_token *closing_brace;
19786 push_deferring_access_checks (dk_no_deferred);
19788 /* Parse the class-head. */
19789 type = cp_parser_class_head (parser,
19790 &nested_name_specifier_p);
19791 /* If the class-head was a semantic disaster, skip the entire body
19795 cp_parser_skip_to_end_of_block_or_statement (parser);
19796 pop_deferring_access_checks ();
19797 return error_mark_node;
19800 /* Look for the `{'. */
19801 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
19803 pop_deferring_access_checks ();
19804 return error_mark_node;
19807 cp_ensure_no_omp_declare_simd (parser);
19809 /* Issue an error message if type-definitions are forbidden here. */
19810 cp_parser_check_type_definition (parser);
19811 /* Remember that we are defining one more class. */
19812 ++parser->num_classes_being_defined;
19813 /* Inside the class, surrounding template-parameter-lists do not
19815 saved_num_template_parameter_lists
19816 = parser->num_template_parameter_lists;
19817 parser->num_template_parameter_lists = 0;
19818 /* We are not in a function body. */
19819 saved_in_function_body = parser->in_function_body;
19820 parser->in_function_body = false;
19821 /* Or in a loop. */
19822 in_statement = parser->in_statement;
19823 parser->in_statement = 0;
19824 /* Or in a switch. */
19825 in_switch_statement_p = parser->in_switch_statement_p;
19826 parser->in_switch_statement_p = false;
19827 /* We are not immediately inside an extern "lang" block. */
19828 saved_in_unbraced_linkage_specification_p
19829 = parser->in_unbraced_linkage_specification_p;
19830 parser->in_unbraced_linkage_specification_p = false;
19832 /* Start the class. */
19833 if (nested_name_specifier_p)
19835 scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type));
19836 old_scope = push_inner_scope (scope);
19838 type = begin_class_definition (type);
19840 if (type == error_mark_node)
19841 /* If the type is erroneous, skip the entire body of the class. */
19842 cp_parser_skip_to_closing_brace (parser);
19844 /* Parse the member-specification. */
19845 cp_parser_member_specification_opt (parser);
19847 /* Look for the trailing `}'. */
19848 closing_brace = cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
19849 /* Look for trailing attributes to apply to this class. */
19850 if (cp_parser_allow_gnu_extensions_p (parser))
19851 attributes = cp_parser_gnu_attributes_opt (parser);
19852 if (type != error_mark_node)
19853 type = finish_struct (type, attributes);
19854 if (nested_name_specifier_p)
19855 pop_inner_scope (old_scope, scope);
19857 /* We've finished a type definition. Check for the common syntax
19858 error of forgetting a semicolon after the definition. We need to
19859 be careful, as we can't just check for not-a-semicolon and be done
19860 with it; the user might have typed:
19862 class X { } c = ...;
19863 class X { } *p = ...;
19865 and so forth. Instead, enumerate all the possible tokens that
19866 might follow this production; if we don't see one of them, then
19867 complain and silently insert the semicolon. */
19869 cp_token *token = cp_lexer_peek_token (parser->lexer);
19870 bool want_semicolon = true;
19872 if (cp_next_tokens_can_be_std_attribute_p (parser))
19873 /* Don't try to parse c++11 attributes here. As per the
19874 grammar, that should be a task for
19875 cp_parser_decl_specifier_seq. */
19876 want_semicolon = false;
19878 switch (token->type)
19881 case CPP_SEMICOLON:
19884 case CPP_OPEN_PAREN:
19885 case CPP_CLOSE_PAREN:
19887 want_semicolon = false;
19890 /* While it's legal for type qualifiers and storage class
19891 specifiers to follow type definitions in the grammar, only
19892 compiler testsuites contain code like that. Assume that if
19893 we see such code, then what we're really seeing is a case
19897 const <type> var = ...;
19902 static <type> func (...) ...
19904 i.e. the qualifier or specifier applies to the next
19905 declaration. To do so, however, we need to look ahead one
19906 more token to see if *that* token is a type specifier.
19908 This code could be improved to handle:
19911 static const <type> var = ...; */
19913 if (keyword_is_decl_specifier (token->keyword))
19915 cp_token *lookahead = cp_lexer_peek_nth_token (parser->lexer, 2);
19917 /* Handling user-defined types here would be nice, but very
19920 = (lookahead->type == CPP_KEYWORD
19921 && keyword_begins_type_specifier (lookahead->keyword));
19928 /* If we don't have a type, then something is very wrong and we
19929 shouldn't try to do anything clever. Likewise for not seeing the
19931 if (closing_brace && TYPE_P (type) && want_semicolon)
19933 cp_token_position prev
19934 = cp_lexer_previous_token_position (parser->lexer);
19935 cp_token *prev_token = cp_lexer_token_at (parser->lexer, prev);
19936 location_t loc = prev_token->location;
19938 if (CLASSTYPE_DECLARED_CLASS (type))
19939 error_at (loc, "expected %<;%> after class definition");
19940 else if (TREE_CODE (type) == RECORD_TYPE)
19941 error_at (loc, "expected %<;%> after struct definition");
19942 else if (TREE_CODE (type) == UNION_TYPE)
19943 error_at (loc, "expected %<;%> after union definition");
19945 gcc_unreachable ();
19947 /* Unget one token and smash it to look as though we encountered
19948 a semicolon in the input stream. */
19949 cp_lexer_set_token_position (parser->lexer, prev);
19950 token = cp_lexer_peek_token (parser->lexer);
19951 token->type = CPP_SEMICOLON;
19952 token->keyword = RID_MAX;
19956 /* If this class is not itself within the scope of another class,
19957 then we need to parse the bodies of all of the queued function
19958 definitions. Note that the queued functions defined in a class
19959 are not always processed immediately following the
19960 class-specifier for that class. Consider:
19963 struct B { void f() { sizeof (A); } };
19966 If `f' were processed before the processing of `A' were
19967 completed, there would be no way to compute the size of `A'.
19968 Note that the nesting we are interested in here is lexical --
19969 not the semantic nesting given by TYPE_CONTEXT. In particular,
19972 struct A { struct B; };
19973 struct A::B { void f() { } };
19975 there is no need to delay the parsing of `A::B::f'. */
19976 if (--parser->num_classes_being_defined == 0)
19979 tree class_type = NULL_TREE;
19980 tree pushed_scope = NULL_TREE;
19982 cp_default_arg_entry *e;
19983 tree save_ccp, save_ccr;
19985 /* In a first pass, parse default arguments to the functions.
19986 Then, in a second pass, parse the bodies of the functions.
19987 This two-phased approach handles cases like:
19995 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_default_args, ix, e)
19998 /* If there are default arguments that have not yet been processed,
19999 take care of them now. */
20000 if (class_type != e->class_type)
20003 pop_scope (pushed_scope);
20004 class_type = e->class_type;
20005 pushed_scope = push_scope (class_type);
20007 /* Make sure that any template parameters are in scope. */
20008 maybe_begin_member_template_processing (decl);
20009 /* Parse the default argument expressions. */
20010 cp_parser_late_parsing_default_args (parser, decl);
20011 /* Remove any template parameters from the symbol table. */
20012 maybe_end_member_template_processing ();
20014 vec_safe_truncate (unparsed_funs_with_default_args, 0);
20015 /* Now parse any NSDMIs. */
20016 save_ccp = current_class_ptr;
20017 save_ccr = current_class_ref;
20018 FOR_EACH_VEC_SAFE_ELT (unparsed_nsdmis, ix, decl)
20020 if (class_type != DECL_CONTEXT (decl))
20023 pop_scope (pushed_scope);
20024 class_type = DECL_CONTEXT (decl);
20025 pushed_scope = push_scope (class_type);
20027 inject_this_parameter (class_type, TYPE_UNQUALIFIED);
20028 cp_parser_late_parsing_nsdmi (parser, decl);
20030 vec_safe_truncate (unparsed_nsdmis, 0);
20031 current_class_ptr = save_ccp;
20032 current_class_ref = save_ccr;
20034 pop_scope (pushed_scope);
20036 /* Now do some post-NSDMI bookkeeping. */
20037 FOR_EACH_VEC_SAFE_ELT (unparsed_classes, ix, class_type)
20038 after_nsdmi_defaulted_late_checks (class_type);
20039 vec_safe_truncate (unparsed_classes, 0);
20040 after_nsdmi_defaulted_late_checks (type);
20042 /* Now parse the body of the functions. */
20045 /* OpenMP UDRs need to be parsed before all other functions. */
20046 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions, ix, decl)
20047 if (DECL_OMP_DECLARE_REDUCTION_P (decl))
20048 cp_parser_late_parsing_for_member (parser, decl);
20049 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions, ix, decl)
20050 if (!DECL_OMP_DECLARE_REDUCTION_P (decl))
20051 cp_parser_late_parsing_for_member (parser, decl);
20054 FOR_EACH_VEC_SAFE_ELT (unparsed_funs_with_definitions, ix, decl)
20055 cp_parser_late_parsing_for_member (parser, decl);
20056 vec_safe_truncate (unparsed_funs_with_definitions, 0);
20059 vec_safe_push (unparsed_classes, type);
20061 /* Put back any saved access checks. */
20062 pop_deferring_access_checks ();
20064 /* Restore saved state. */
20065 parser->in_switch_statement_p = in_switch_statement_p;
20066 parser->in_statement = in_statement;
20067 parser->in_function_body = saved_in_function_body;
20068 parser->num_template_parameter_lists
20069 = saved_num_template_parameter_lists;
20070 parser->in_unbraced_linkage_specification_p
20071 = saved_in_unbraced_linkage_specification_p;
20077 cp_parser_class_specifier (cp_parser* parser)
20080 timevar_push (TV_PARSE_STRUCT);
20081 ret = cp_parser_class_specifier_1 (parser);
20082 timevar_pop (TV_PARSE_STRUCT);
20086 /* Parse a class-head.
20089 class-key identifier [opt] base-clause [opt]
20090 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
20091 class-key nested-name-specifier [opt] template-id
20094 class-virt-specifier:
20098 class-key attributes identifier [opt] base-clause [opt]
20099 class-key attributes nested-name-specifier identifier base-clause [opt]
20100 class-key attributes nested-name-specifier [opt] template-id
20103 Upon return BASES is initialized to the list of base classes (or
20104 NULL, if there are none) in the same form returned by
20105 cp_parser_base_clause.
20107 Returns the TYPE of the indicated class. Sets
20108 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
20109 involving a nested-name-specifier was used, and FALSE otherwise.
20111 Returns error_mark_node if this is not a class-head.
20113 Returns NULL_TREE if the class-head is syntactically valid, but
20114 semantically invalid in a way that means we should skip the entire
20115 body of the class. */
20118 cp_parser_class_head (cp_parser* parser,
20119 bool* nested_name_specifier_p)
20121 tree nested_name_specifier;
20122 enum tag_types class_key;
20123 tree id = NULL_TREE;
20124 tree type = NULL_TREE;
20127 cp_virt_specifiers virt_specifiers = VIRT_SPEC_UNSPECIFIED;
20128 bool template_id_p = false;
20129 bool qualified_p = false;
20130 bool invalid_nested_name_p = false;
20131 bool invalid_explicit_specialization_p = false;
20132 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
20133 tree pushed_scope = NULL_TREE;
20134 unsigned num_templates;
20135 cp_token *type_start_token = NULL, *nested_name_specifier_token_start = NULL;
20136 /* Assume no nested-name-specifier will be present. */
20137 *nested_name_specifier_p = false;
20138 /* Assume no template parameter lists will be used in defining the
20141 parser->colon_corrects_to_scope_p = false;
20143 /* Look for the class-key. */
20144 class_key = cp_parser_class_key (parser);
20145 if (class_key == none_type)
20146 return error_mark_node;
20148 /* Parse the attributes. */
20149 attributes = cp_parser_attributes_opt (parser);
20151 /* If the next token is `::', that is invalid -- but sometimes
20152 people do try to write:
20156 Handle this gracefully by accepting the extra qualifier, and then
20157 issuing an error about it later if this really is a
20158 class-head. If it turns out just to be an elaborated type
20159 specifier, remain silent. */
20160 if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
20161 qualified_p = true;
20163 push_deferring_access_checks (dk_no_check);
20165 /* Determine the name of the class. Begin by looking for an
20166 optional nested-name-specifier. */
20167 nested_name_specifier_token_start = cp_lexer_peek_token (parser->lexer);
20168 nested_name_specifier
20169 = cp_parser_nested_name_specifier_opt (parser,
20170 /*typename_keyword_p=*/false,
20171 /*check_dependency_p=*/false,
20173 /*is_declaration=*/false);
20174 /* If there was a nested-name-specifier, then there *must* be an
20176 if (nested_name_specifier)
20178 type_start_token = cp_lexer_peek_token (parser->lexer);
20179 /* Although the grammar says `identifier', it really means
20180 `class-name' or `template-name'. You are only allowed to
20181 define a class that has already been declared with this
20184 The proposed resolution for Core Issue 180 says that wherever
20185 you see `class T::X' you should treat `X' as a type-name.
20187 It is OK to define an inaccessible class; for example:
20189 class A { class B; };
20192 We do not know if we will see a class-name, or a
20193 template-name. We look for a class-name first, in case the
20194 class-name is a template-id; if we looked for the
20195 template-name first we would stop after the template-name. */
20196 cp_parser_parse_tentatively (parser);
20197 type = cp_parser_class_name (parser,
20198 /*typename_keyword_p=*/false,
20199 /*template_keyword_p=*/false,
20201 /*check_dependency_p=*/false,
20202 /*class_head_p=*/true,
20203 /*is_declaration=*/false);
20204 /* If that didn't work, ignore the nested-name-specifier. */
20205 if (!cp_parser_parse_definitely (parser))
20207 invalid_nested_name_p = true;
20208 type_start_token = cp_lexer_peek_token (parser->lexer);
20209 id = cp_parser_identifier (parser);
20210 if (id == error_mark_node)
20213 /* If we could not find a corresponding TYPE, treat this
20214 declaration like an unqualified declaration. */
20215 if (type == error_mark_node)
20216 nested_name_specifier = NULL_TREE;
20217 /* Otherwise, count the number of templates used in TYPE and its
20218 containing scopes. */
20223 for (scope = TREE_TYPE (type);
20224 scope && TREE_CODE (scope) != NAMESPACE_DECL;
20225 scope = get_containing_scope (scope))
20227 && CLASS_TYPE_P (scope)
20228 && CLASSTYPE_TEMPLATE_INFO (scope)
20229 && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))
20230 && (!CLASSTYPE_TEMPLATE_SPECIALIZATION (scope)
20231 || uses_template_parms (CLASSTYPE_TI_ARGS (scope))))
20235 /* Otherwise, the identifier is optional. */
20238 /* We don't know whether what comes next is a template-id,
20239 an identifier, or nothing at all. */
20240 cp_parser_parse_tentatively (parser);
20241 /* Check for a template-id. */
20242 type_start_token = cp_lexer_peek_token (parser->lexer);
20243 id = cp_parser_template_id (parser,
20244 /*template_keyword_p=*/false,
20245 /*check_dependency_p=*/true,
20247 /*is_declaration=*/true);
20248 /* If that didn't work, it could still be an identifier. */
20249 if (!cp_parser_parse_definitely (parser))
20251 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
20253 type_start_token = cp_lexer_peek_token (parser->lexer);
20254 id = cp_parser_identifier (parser);
20261 template_id_p = true;
20266 pop_deferring_access_checks ();
20270 cp_parser_check_for_invalid_template_id (parser, id,
20272 type_start_token->location);
20274 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
20276 /* If it's not a `:' or a `{' then we can't really be looking at a
20277 class-head, since a class-head only appears as part of a
20278 class-specifier. We have to detect this situation before calling
20279 xref_tag, since that has irreversible side-effects. */
20280 if (!cp_parser_next_token_starts_class_definition_p (parser))
20282 cp_parser_error (parser, "expected %<{%> or %<:%>");
20283 type = error_mark_node;
20287 /* At this point, we're going ahead with the class-specifier, even
20288 if some other problem occurs. */
20289 cp_parser_commit_to_tentative_parse (parser);
20290 if (virt_specifiers & VIRT_SPEC_OVERRIDE)
20292 cp_parser_error (parser,
20293 "cannot specify %<override%> for a class");
20294 type = error_mark_node;
20297 /* Issue the error about the overly-qualified name now. */
20300 cp_parser_error (parser,
20301 "global qualification of class name is invalid");
20302 type = error_mark_node;
20305 else if (invalid_nested_name_p)
20307 cp_parser_error (parser,
20308 "qualified name does not name a class");
20309 type = error_mark_node;
20312 else if (nested_name_specifier)
20316 /* Reject typedef-names in class heads. */
20317 if (!DECL_IMPLICIT_TYPEDEF_P (type))
20319 error_at (type_start_token->location,
20320 "invalid class name in declaration of %qD",
20326 /* Figure out in what scope the declaration is being placed. */
20327 scope = current_scope ();
20328 /* If that scope does not contain the scope in which the
20329 class was originally declared, the program is invalid. */
20330 if (scope && !is_ancestor (scope, nested_name_specifier))
20332 if (at_namespace_scope_p ())
20333 error_at (type_start_token->location,
20334 "declaration of %qD in namespace %qD which does not "
20336 type, scope, nested_name_specifier);
20338 error_at (type_start_token->location,
20339 "declaration of %qD in %qD which does not enclose %qD",
20340 type, scope, nested_name_specifier);
20346 A declarator-id shall not be qualified except for the
20347 definition of a ... nested class outside of its class
20348 ... [or] the definition or explicit instantiation of a
20349 class member of a namespace outside of its namespace. */
20350 if (scope == nested_name_specifier)
20352 permerror (nested_name_specifier_token_start->location,
20353 "extra qualification not allowed");
20354 nested_name_specifier = NULL_TREE;
20358 /* An explicit-specialization must be preceded by "template <>". If
20359 it is not, try to recover gracefully. */
20360 if (at_namespace_scope_p ()
20361 && parser->num_template_parameter_lists == 0
20364 error_at (type_start_token->location,
20365 "an explicit specialization must be preceded by %<template <>%>");
20366 invalid_explicit_specialization_p = true;
20367 /* Take the same action that would have been taken by
20368 cp_parser_explicit_specialization. */
20369 ++parser->num_template_parameter_lists;
20370 begin_specialization ();
20372 /* There must be no "return" statements between this point and the
20373 end of this function; set "type "to the correct return value and
20374 use "goto done;" to return. */
20375 /* Make sure that the right number of template parameters were
20377 if (!cp_parser_check_template_parameters (parser, num_templates,
20378 type_start_token->location,
20379 /*declarator=*/NULL))
20381 /* If something went wrong, there is no point in even trying to
20382 process the class-definition. */
20387 /* Look up the type. */
20390 if (TREE_CODE (id) == TEMPLATE_ID_EXPR
20391 && (DECL_FUNCTION_TEMPLATE_P (TREE_OPERAND (id, 0))
20392 || TREE_CODE (TREE_OPERAND (id, 0)) == OVERLOAD))
20394 error_at (type_start_token->location,
20395 "function template %qD redeclared as a class template", id);
20396 type = error_mark_node;
20400 type = TREE_TYPE (id);
20401 type = maybe_process_partial_specialization (type);
20403 if (nested_name_specifier)
20404 pushed_scope = push_scope (nested_name_specifier);
20406 else if (nested_name_specifier)
20412 template <typename T> struct S { struct T };
20413 template <typename T> struct S<T>::T { };
20415 we will get a TYPENAME_TYPE when processing the definition of
20416 `S::T'. We need to resolve it to the actual type before we
20417 try to define it. */
20418 if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE)
20420 class_type = resolve_typename_type (TREE_TYPE (type),
20421 /*only_current_p=*/false);
20422 if (TREE_CODE (class_type) != TYPENAME_TYPE)
20423 type = TYPE_NAME (class_type);
20426 cp_parser_error (parser, "could not resolve typename type");
20427 type = error_mark_node;
20431 if (maybe_process_partial_specialization (TREE_TYPE (type))
20432 == error_mark_node)
20438 class_type = current_class_type;
20439 /* Enter the scope indicated by the nested-name-specifier. */
20440 pushed_scope = push_scope (nested_name_specifier);
20441 /* Get the canonical version of this type. */
20442 type = TYPE_MAIN_DECL (TREE_TYPE (type));
20443 /* Call push_template_decl if it seems like we should be defining a
20444 template either from the template headers or the type we're
20445 defining, so that we diagnose both extra and missing headers. */
20446 if ((PROCESSING_REAL_TEMPLATE_DECL_P ()
20447 || CLASSTYPE_TEMPLATE_INFO (TREE_TYPE (type)))
20448 && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type)))
20450 type = push_template_decl (type);
20451 if (type == error_mark_node)
20458 type = TREE_TYPE (type);
20459 *nested_name_specifier_p = true;
20461 else /* The name is not a nested name. */
20463 /* If the class was unnamed, create a dummy name. */
20465 id = make_anon_name ();
20466 type = xref_tag (class_key, id, /*tag_scope=*/ts_current,
20467 parser->num_template_parameter_lists);
20470 /* Indicate whether this class was declared as a `class' or as a
20472 if (TREE_CODE (type) == RECORD_TYPE)
20473 CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type);
20474 cp_parser_check_class_key (class_key, type);
20476 /* If this type was already complete, and we see another definition,
20477 that's an error. */
20478 if (type != error_mark_node && COMPLETE_TYPE_P (type))
20480 error_at (type_start_token->location, "redefinition of %q#T",
20482 error_at (type_start_token->location, "previous definition of %q+#T",
20487 else if (type == error_mark_node)
20492 /* Apply attributes now, before any use of the class as a template
20493 argument in its base list. */
20494 cplus_decl_attributes (&type, attributes, (int)ATTR_FLAG_TYPE_IN_PLACE);
20495 fixup_attribute_variants (type);
20498 /* We will have entered the scope containing the class; the names of
20499 base classes should be looked up in that context. For example:
20501 struct A { struct B {}; struct C; };
20502 struct A::C : B {};
20506 /* Get the list of base-classes, if there is one. */
20507 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20509 /* PR59482: enter the class scope so that base-specifiers are looked
20513 bases = cp_parser_base_clause (parser);
20514 /* PR59482: get out of the previously pushed class scope so that the
20515 subsequent pops pop the right thing. */
20522 /* If we're really defining a class, process the base classes.
20523 If they're invalid, fail. */
20524 if (type && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
20525 && !xref_basetypes (type, bases))
20529 /* Leave the scope given by the nested-name-specifier. We will
20530 enter the class scope itself while processing the members. */
20532 pop_scope (pushed_scope);
20534 if (invalid_explicit_specialization_p)
20536 end_specialization ();
20537 --parser->num_template_parameter_lists;
20541 DECL_SOURCE_LOCATION (TYPE_NAME (type)) = type_start_token->location;
20542 if (type && (virt_specifiers & VIRT_SPEC_FINAL))
20543 CLASSTYPE_FINAL (type) = 1;
20545 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
20549 /* Parse a class-key.
20556 Returns the kind of class-key specified, or none_type to indicate
20559 static enum tag_types
20560 cp_parser_class_key (cp_parser* parser)
20563 enum tag_types tag_type;
20565 /* Look for the class-key. */
20566 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_KEY);
20570 /* Check to see if the TOKEN is a class-key. */
20571 tag_type = cp_parser_token_is_class_key (token);
20573 cp_parser_error (parser, "expected class-key");
20577 /* Parse a type-parameter-key.
20579 type-parameter-key:
20585 cp_parser_type_parameter_key (cp_parser* parser)
20587 /* Look for the type-parameter-key. */
20588 enum tag_types tag_type = none_type;
20589 cp_token *token = cp_lexer_peek_token (parser->lexer);
20590 if ((tag_type = cp_parser_token_is_type_parameter_key (token)) != none_type)
20592 cp_lexer_consume_token (parser->lexer);
20593 if (pedantic && tag_type == typename_type && cxx_dialect < cxx1z)
20594 /* typename is not allowed in a template template parameter
20595 by the standard until C++1Z. */
20596 pedwarn (token->location, OPT_Wpedantic,
20597 "ISO C++ forbids typename key in template template parameter;"
20598 " use -std=c++1z or -std=gnu++1z");
20601 cp_parser_error (parser, "expected %<class%> or %<typename%>");
20606 /* Parse an (optional) member-specification.
20608 member-specification:
20609 member-declaration member-specification [opt]
20610 access-specifier : member-specification [opt] */
20613 cp_parser_member_specification_opt (cp_parser* parser)
20620 /* Peek at the next token. */
20621 token = cp_lexer_peek_token (parser->lexer);
20622 /* If it's a `}', or EOF then we've seen all the members. */
20623 if (token->type == CPP_CLOSE_BRACE
20624 || token->type == CPP_EOF
20625 || token->type == CPP_PRAGMA_EOL)
20628 /* See if this token is a keyword. */
20629 keyword = token->keyword;
20633 case RID_PROTECTED:
20635 /* Consume the access-specifier. */
20636 cp_lexer_consume_token (parser->lexer);
20637 /* Remember which access-specifier is active. */
20638 current_access_specifier = token->u.value;
20639 /* Look for the `:'. */
20640 cp_parser_require (parser, CPP_COLON, RT_COLON);
20644 /* Accept #pragmas at class scope. */
20645 if (token->type == CPP_PRAGMA)
20647 cp_parser_pragma (parser, pragma_member);
20651 /* Otherwise, the next construction must be a
20652 member-declaration. */
20653 cp_parser_member_declaration (parser);
20658 /* Parse a member-declaration.
20660 member-declaration:
20661 decl-specifier-seq [opt] member-declarator-list [opt] ;
20662 function-definition ; [opt]
20663 :: [opt] nested-name-specifier template [opt] unqualified-id ;
20665 template-declaration
20668 member-declarator-list:
20670 member-declarator-list , member-declarator
20673 declarator pure-specifier [opt]
20674 declarator constant-initializer [opt]
20675 identifier [opt] : constant-expression
20679 member-declaration:
20680 __extension__ member-declaration
20683 declarator attributes [opt] pure-specifier [opt]
20684 declarator attributes [opt] constant-initializer [opt]
20685 identifier [opt] attributes [opt] : constant-expression
20689 member-declaration:
20690 static_assert-declaration */
20693 cp_parser_member_declaration (cp_parser* parser)
20695 cp_decl_specifier_seq decl_specifiers;
20696 tree prefix_attributes;
20698 int declares_class_or_enum;
20700 cp_token *token = NULL;
20701 cp_token *decl_spec_token_start = NULL;
20702 cp_token *initializer_token_start = NULL;
20703 int saved_pedantic;
20704 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
20706 /* Check for the `__extension__' keyword. */
20707 if (cp_parser_extension_opt (parser, &saved_pedantic))
20710 cp_parser_member_declaration (parser);
20711 /* Restore the old value of the PEDANTIC flag. */
20712 pedantic = saved_pedantic;
20717 /* Check for a template-declaration. */
20718 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
20720 /* An explicit specialization here is an error condition, and we
20721 expect the specialization handler to detect and report this. */
20722 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
20723 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
20724 cp_parser_explicit_specialization (parser);
20726 cp_parser_template_declaration (parser, /*member_p=*/true);
20731 /* Check for a using-declaration. */
20732 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
20734 if (cxx_dialect < cxx11)
20736 /* Parse the using-declaration. */
20737 cp_parser_using_declaration (parser,
20738 /*access_declaration_p=*/false);
20744 bool alias_decl_expected;
20745 cp_parser_parse_tentatively (parser);
20746 decl = cp_parser_alias_declaration (parser);
20747 /* Note that if we actually see the '=' token after the
20748 identifier, cp_parser_alias_declaration commits the
20749 tentative parse. In that case, we really expects an
20750 alias-declaration. Otherwise, we expect a using
20752 alias_decl_expected =
20753 !cp_parser_uncommitted_to_tentative_parse_p (parser);
20754 cp_parser_parse_definitely (parser);
20756 if (alias_decl_expected)
20757 finish_member_declaration (decl);
20759 cp_parser_using_declaration (parser,
20760 /*access_declaration_p=*/false);
20765 /* Check for @defs. */
20766 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
20769 tree ivar_chains = cp_parser_objc_defs_expression (parser);
20770 ivar = ivar_chains;
20774 ivar = TREE_CHAIN (member);
20775 TREE_CHAIN (member) = NULL_TREE;
20776 finish_member_declaration (member);
20781 /* If the next token is `static_assert' we have a static assertion. */
20782 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
20784 cp_parser_static_assert (parser, /*member_p=*/true);
20788 parser->colon_corrects_to_scope_p = false;
20790 if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
20793 /* Parse the decl-specifier-seq. */
20794 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
20795 cp_parser_decl_specifier_seq (parser,
20796 CP_PARSER_FLAGS_OPTIONAL,
20798 &declares_class_or_enum);
20799 /* Check for an invalid type-name. */
20800 if (!decl_specifiers.any_type_specifiers_p
20801 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
20803 /* If there is no declarator, then the decl-specifier-seq should
20805 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
20807 /* If there was no decl-specifier-seq, and the next token is a
20808 `;', then we have something like:
20814 Each member-declaration shall declare at least one member
20815 name of the class. */
20816 if (!decl_specifiers.any_specifiers_p)
20818 cp_token *token = cp_lexer_peek_token (parser->lexer);
20819 if (!in_system_header_at (token->location))
20820 pedwarn (token->location, OPT_Wpedantic, "extra %<;%>");
20826 /* See if this declaration is a friend. */
20827 friend_p = cp_parser_friend_p (&decl_specifiers);
20828 /* If there were decl-specifiers, check to see if there was
20829 a class-declaration. */
20830 type = check_tag_decl (&decl_specifiers,
20831 /*explicit_type_instantiation_p=*/false);
20832 /* Nested classes have already been added to the class, but
20833 a `friend' needs to be explicitly registered. */
20836 /* If the `friend' keyword was present, the friend must
20837 be introduced with a class-key. */
20838 if (!declares_class_or_enum && cxx_dialect < cxx11)
20839 pedwarn (decl_spec_token_start->location, OPT_Wpedantic,
20840 "in C++03 a class-key must be used "
20841 "when declaring a friend");
20844 template <typename T> struct A {
20845 friend struct A<T>::B;
20848 A<T>::B will be represented by a TYPENAME_TYPE, and
20849 therefore not recognized by check_tag_decl. */
20852 type = decl_specifiers.type;
20853 if (type && TREE_CODE (type) == TYPE_DECL)
20854 type = TREE_TYPE (type);
20856 if (!type || !TYPE_P (type))
20857 error_at (decl_spec_token_start->location,
20858 "friend declaration does not name a class or "
20861 make_friend_class (current_class_type, type,
20862 /*complain=*/true);
20864 /* If there is no TYPE, an error message will already have
20866 else if (!type || type == error_mark_node)
20868 /* An anonymous aggregate has to be handled specially; such
20869 a declaration really declares a data member (with a
20870 particular type), as opposed to a nested class. */
20871 else if (ANON_AGGR_TYPE_P (type))
20874 if (decl_specifiers.storage_class != sc_none)
20875 error_at (decl_spec_token_start->location,
20876 "a storage class on an anonymous aggregate "
20877 "in class scope is not allowed");
20879 /* Remove constructors and such from TYPE, now that we
20880 know it is an anonymous aggregate. */
20881 fixup_anonymous_aggr (type);
20882 /* And make the corresponding data member. */
20883 decl = build_decl (decl_spec_token_start->location,
20884 FIELD_DECL, NULL_TREE, type);
20885 /* Add it to the class. */
20886 finish_member_declaration (decl);
20889 cp_parser_check_access_in_redeclaration
20891 decl_spec_token_start->location);
20896 bool assume_semicolon = false;
20898 /* Clear attributes from the decl_specifiers but keep them
20899 around as prefix attributes that apply them to the entity
20901 prefix_attributes = decl_specifiers.attributes;
20902 decl_specifiers.attributes = NULL_TREE;
20904 /* See if these declarations will be friends. */
20905 friend_p = cp_parser_friend_p (&decl_specifiers);
20907 /* Keep going until we hit the `;' at the end of the
20909 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
20911 tree attributes = NULL_TREE;
20912 tree first_attribute;
20914 /* Peek at the next token. */
20915 token = cp_lexer_peek_token (parser->lexer);
20917 /* Check for a bitfield declaration. */
20918 if (token->type == CPP_COLON
20919 || (token->type == CPP_NAME
20920 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
20926 /* Get the name of the bitfield. Note that we cannot just
20927 check TOKEN here because it may have been invalidated by
20928 the call to cp_lexer_peek_nth_token above. */
20929 if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON)
20930 identifier = cp_parser_identifier (parser);
20932 identifier = NULL_TREE;
20934 /* Consume the `:' token. */
20935 cp_lexer_consume_token (parser->lexer);
20936 /* Get the width of the bitfield. */
20938 = cp_parser_constant_expression (parser);
20940 /* Look for attributes that apply to the bitfield. */
20941 attributes = cp_parser_attributes_opt (parser);
20942 /* Remember which attributes are prefix attributes and
20944 first_attribute = attributes;
20945 /* Combine the attributes. */
20946 attributes = chainon (prefix_attributes, attributes);
20948 /* Create the bitfield declaration. */
20949 decl = grokbitfield (identifier
20950 ? make_id_declarator (NULL_TREE,
20960 cp_declarator *declarator;
20962 tree asm_specification;
20963 int ctor_dtor_or_conv_p;
20965 /* Parse the declarator. */
20967 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
20968 &ctor_dtor_or_conv_p,
20969 /*parenthesized_p=*/NULL,
20973 /* If something went wrong parsing the declarator, make sure
20974 that we at least consume some tokens. */
20975 if (declarator == cp_error_declarator)
20977 /* Skip to the end of the statement. */
20978 cp_parser_skip_to_end_of_statement (parser);
20979 /* If the next token is not a semicolon, that is
20980 probably because we just skipped over the body of
20981 a function. So, we consume a semicolon if
20982 present, but do not issue an error message if it
20984 if (cp_lexer_next_token_is (parser->lexer,
20986 cp_lexer_consume_token (parser->lexer);
20990 if (declares_class_or_enum & 2)
20991 cp_parser_check_for_definition_in_return_type
20992 (declarator, decl_specifiers.type,
20993 decl_specifiers.locations[ds_type_spec]);
20995 /* Look for an asm-specification. */
20996 asm_specification = cp_parser_asm_specification_opt (parser);
20997 /* Look for attributes that apply to the declaration. */
20998 attributes = cp_parser_attributes_opt (parser);
20999 /* Remember which attributes are prefix attributes and
21001 first_attribute = attributes;
21002 /* Combine the attributes. */
21003 attributes = chainon (prefix_attributes, attributes);
21005 /* If it's an `=', then we have a constant-initializer or a
21006 pure-specifier. It is not correct to parse the
21007 initializer before registering the member declaration
21008 since the member declaration should be in scope while
21009 its initializer is processed. However, the rest of the
21010 front end does not yet provide an interface that allows
21011 us to handle this correctly. */
21012 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
21016 A pure-specifier shall be used only in the declaration of
21017 a virtual function.
21019 A member-declarator can contain a constant-initializer
21020 only if it declares a static member of integral or
21023 Therefore, if the DECLARATOR is for a function, we look
21024 for a pure-specifier; otherwise, we look for a
21025 constant-initializer. When we call `grokfield', it will
21026 perform more stringent semantics checks. */
21027 initializer_token_start = cp_lexer_peek_token (parser->lexer);
21028 if (function_declarator_p (declarator)
21029 || (decl_specifiers.type
21030 && TREE_CODE (decl_specifiers.type) == TYPE_DECL
21031 && declarator->kind == cdk_id
21032 && (TREE_CODE (TREE_TYPE (decl_specifiers.type))
21033 == FUNCTION_TYPE)))
21034 initializer = cp_parser_pure_specifier (parser);
21035 else if (decl_specifiers.storage_class != sc_static)
21036 initializer = cp_parser_save_nsdmi (parser);
21037 else if (cxx_dialect >= cxx11)
21040 /* Don't require a constant rvalue in C++11, since we
21041 might want a reference constant. We'll enforce
21042 constancy later. */
21043 cp_lexer_consume_token (parser->lexer);
21044 /* Parse the initializer. */
21045 initializer = cp_parser_initializer_clause (parser,
21049 /* Parse the initializer. */
21050 initializer = cp_parser_constant_initializer (parser);
21052 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
21053 && !function_declarator_p (declarator))
21056 if (decl_specifiers.storage_class != sc_static)
21057 initializer = cp_parser_save_nsdmi (parser);
21059 initializer = cp_parser_initializer (parser, &x, &x);
21061 /* Otherwise, there is no initializer. */
21063 initializer = NULL_TREE;
21065 /* See if we are probably looking at a function
21066 definition. We are certainly not looking at a
21067 member-declarator. Calling `grokfield' has
21068 side-effects, so we must not do it unless we are sure
21069 that we are looking at a member-declarator. */
21070 if (cp_parser_token_starts_function_definition_p
21071 (cp_lexer_peek_token (parser->lexer)))
21073 /* The grammar does not allow a pure-specifier to be
21074 used when a member function is defined. (It is
21075 possible that this fact is an oversight in the
21076 standard, since a pure function may be defined
21077 outside of the class-specifier. */
21078 if (initializer && initializer_token_start)
21079 error_at (initializer_token_start->location,
21080 "pure-specifier on function-definition");
21081 decl = cp_parser_save_member_function_body (parser,
21085 if (parser->fully_implicit_function_template_p)
21086 decl = finish_fully_implicit_template (parser, decl);
21087 /* If the member was not a friend, declare it here. */
21089 finish_member_declaration (decl);
21090 /* Peek at the next token. */
21091 token = cp_lexer_peek_token (parser->lexer);
21092 /* If the next token is a semicolon, consume it. */
21093 if (token->type == CPP_SEMICOLON)
21094 cp_lexer_consume_token (parser->lexer);
21098 if (declarator->kind == cdk_function)
21099 declarator->id_loc = token->location;
21100 /* Create the declaration. */
21101 decl = grokfield (declarator, &decl_specifiers,
21102 initializer, /*init_const_expr_p=*/true,
21103 asm_specification, attributes);
21104 if (parser->fully_implicit_function_template_p)
21107 finish_fully_implicit_template (parser, 0);
21109 decl = finish_fully_implicit_template (parser, decl);
21113 cp_finalize_omp_declare_simd (parser, decl);
21115 /* Reset PREFIX_ATTRIBUTES. */
21116 while (attributes && TREE_CHAIN (attributes) != first_attribute)
21117 attributes = TREE_CHAIN (attributes);
21119 TREE_CHAIN (attributes) = NULL_TREE;
21121 /* If there is any qualification still in effect, clear it
21122 now; we will be starting fresh with the next declarator. */
21123 parser->scope = NULL_TREE;
21124 parser->qualifying_scope = NULL_TREE;
21125 parser->object_scope = NULL_TREE;
21126 /* If it's a `,', then there are more declarators. */
21127 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
21129 cp_lexer_consume_token (parser->lexer);
21130 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
21132 cp_token *token = cp_lexer_previous_token (parser->lexer);
21133 error_at (token->location,
21134 "stray %<,%> at end of member declaration");
21137 /* If the next token isn't a `;', then we have a parse error. */
21138 else if (cp_lexer_next_token_is_not (parser->lexer,
21141 /* The next token might be a ways away from where the
21142 actual semicolon is missing. Find the previous token
21143 and use that for our error position. */
21144 cp_token *token = cp_lexer_previous_token (parser->lexer);
21145 error_at (token->location,
21146 "expected %<;%> at end of member declaration");
21148 /* Assume that the user meant to provide a semicolon. If
21149 we were to cp_parser_skip_to_end_of_statement, we might
21150 skip to a semicolon inside a member function definition
21151 and issue nonsensical error messages. */
21152 assume_semicolon = true;
21157 /* Add DECL to the list of members. */
21159 /* Explicitly include, eg, NSDMIs, for better error
21160 recovery (c++/58650). */
21161 || !DECL_DECLARES_FUNCTION_P (decl))
21162 finish_member_declaration (decl);
21164 if (TREE_CODE (decl) == FUNCTION_DECL)
21165 cp_parser_save_default_args (parser, decl);
21166 else if (TREE_CODE (decl) == FIELD_DECL
21167 && !DECL_C_BIT_FIELD (decl)
21168 && DECL_INITIAL (decl))
21169 /* Add DECL to the queue of NSDMI to be parsed later. */
21170 vec_safe_push (unparsed_nsdmis, decl);
21173 if (assume_semicolon)
21178 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
21180 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
21183 /* Parse a pure-specifier.
21188 Returns INTEGER_ZERO_NODE if a pure specifier is found.
21189 Otherwise, ERROR_MARK_NODE is returned. */
21192 cp_parser_pure_specifier (cp_parser* parser)
21196 /* Look for the `=' token. */
21197 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
21198 return error_mark_node;
21199 /* Look for the `0' token. */
21200 token = cp_lexer_peek_token (parser->lexer);
21202 if (token->type == CPP_EOF
21203 || token->type == CPP_PRAGMA_EOL)
21204 return error_mark_node;
21206 cp_lexer_consume_token (parser->lexer);
21208 /* Accept = default or = delete in c++0x mode. */
21209 if (token->keyword == RID_DEFAULT
21210 || token->keyword == RID_DELETE)
21212 maybe_warn_cpp0x (CPP0X_DEFAULTED_DELETED);
21213 return token->u.value;
21216 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
21217 if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO))
21219 cp_parser_error (parser,
21220 "invalid pure specifier (only %<= 0%> is allowed)");
21221 cp_parser_skip_to_end_of_statement (parser);
21222 return error_mark_node;
21224 if (PROCESSING_REAL_TEMPLATE_DECL_P ())
21226 error_at (token->location, "templates may not be %<virtual%>");
21227 return error_mark_node;
21230 return integer_zero_node;
21233 /* Parse a constant-initializer.
21235 constant-initializer:
21236 = constant-expression
21238 Returns a representation of the constant-expression. */
21241 cp_parser_constant_initializer (cp_parser* parser)
21243 /* Look for the `=' token. */
21244 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
21245 return error_mark_node;
21247 /* It is invalid to write:
21249 struct S { static const int i = { 7 }; };
21252 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
21254 cp_parser_error (parser,
21255 "a brace-enclosed initializer is not allowed here");
21256 /* Consume the opening brace. */
21257 cp_lexer_consume_token (parser->lexer);
21258 /* Skip the initializer. */
21259 cp_parser_skip_to_closing_brace (parser);
21260 /* Look for the trailing `}'. */
21261 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
21263 return error_mark_node;
21266 return cp_parser_constant_expression (parser);
21269 /* Derived classes [gram.class.derived] */
21271 /* Parse a base-clause.
21274 : base-specifier-list
21276 base-specifier-list:
21277 base-specifier ... [opt]
21278 base-specifier-list , base-specifier ... [opt]
21280 Returns a TREE_LIST representing the base-classes, in the order in
21281 which they were declared. The representation of each node is as
21282 described by cp_parser_base_specifier.
21284 In the case that no bases are specified, this function will return
21285 NULL_TREE, not ERROR_MARK_NODE. */
21288 cp_parser_base_clause (cp_parser* parser)
21290 tree bases = NULL_TREE;
21292 /* Look for the `:' that begins the list. */
21293 cp_parser_require (parser, CPP_COLON, RT_COLON);
21295 /* Scan the base-specifier-list. */
21300 bool pack_expansion_p = false;
21302 /* Look for the base-specifier. */
21303 base = cp_parser_base_specifier (parser);
21304 /* Look for the (optional) ellipsis. */
21305 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
21307 /* Consume the `...'. */
21308 cp_lexer_consume_token (parser->lexer);
21310 pack_expansion_p = true;
21313 /* Add BASE to the front of the list. */
21314 if (base && base != error_mark_node)
21316 if (pack_expansion_p)
21317 /* Make this a pack expansion type. */
21318 TREE_VALUE (base) = make_pack_expansion (TREE_VALUE (base));
21320 if (!check_for_bare_parameter_packs (TREE_VALUE (base)))
21322 TREE_CHAIN (base) = bases;
21326 /* Peek at the next token. */
21327 token = cp_lexer_peek_token (parser->lexer);
21328 /* If it's not a comma, then the list is complete. */
21329 if (token->type != CPP_COMMA)
21331 /* Consume the `,'. */
21332 cp_lexer_consume_token (parser->lexer);
21335 /* PARSER->SCOPE may still be non-NULL at this point, if the last
21336 base class had a qualified name. However, the next name that
21337 appears is certainly not qualified. */
21338 parser->scope = NULL_TREE;
21339 parser->qualifying_scope = NULL_TREE;
21340 parser->object_scope = NULL_TREE;
21342 return nreverse (bases);
21345 /* Parse a base-specifier.
21348 :: [opt] nested-name-specifier [opt] class-name
21349 virtual access-specifier [opt] :: [opt] nested-name-specifier
21351 access-specifier virtual [opt] :: [opt] nested-name-specifier
21354 Returns a TREE_LIST. The TREE_PURPOSE will be one of
21355 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
21356 indicate the specifiers provided. The TREE_VALUE will be a TYPE
21357 (or the ERROR_MARK_NODE) indicating the type that was specified. */
21360 cp_parser_base_specifier (cp_parser* parser)
21364 bool virtual_p = false;
21365 bool duplicate_virtual_error_issued_p = false;
21366 bool duplicate_access_error_issued_p = false;
21367 bool class_scope_p, template_p;
21368 tree access = access_default_node;
21371 /* Process the optional `virtual' and `access-specifier'. */
21374 /* Peek at the next token. */
21375 token = cp_lexer_peek_token (parser->lexer);
21376 /* Process `virtual'. */
21377 switch (token->keyword)
21380 /* If `virtual' appears more than once, issue an error. */
21381 if (virtual_p && !duplicate_virtual_error_issued_p)
21383 cp_parser_error (parser,
21384 "%<virtual%> specified more than once in base-specified");
21385 duplicate_virtual_error_issued_p = true;
21390 /* Consume the `virtual' token. */
21391 cp_lexer_consume_token (parser->lexer);
21396 case RID_PROTECTED:
21398 /* If more than one access specifier appears, issue an
21400 if (access != access_default_node
21401 && !duplicate_access_error_issued_p)
21403 cp_parser_error (parser,
21404 "more than one access specifier in base-specified");
21405 duplicate_access_error_issued_p = true;
21408 access = ridpointers[(int) token->keyword];
21410 /* Consume the access-specifier. */
21411 cp_lexer_consume_token (parser->lexer);
21420 /* It is not uncommon to see programs mechanically, erroneously, use
21421 the 'typename' keyword to denote (dependent) qualified types
21422 as base classes. */
21423 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
21425 token = cp_lexer_peek_token (parser->lexer);
21426 if (!processing_template_decl)
21427 error_at (token->location,
21428 "keyword %<typename%> not allowed outside of templates");
21430 error_at (token->location,
21431 "keyword %<typename%> not allowed in this context "
21432 "(the base class is implicitly a type)");
21433 cp_lexer_consume_token (parser->lexer);
21436 /* Look for the optional `::' operator. */
21437 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
21438 /* Look for the nested-name-specifier. The simplest way to
21443 The keyword `typename' is not permitted in a base-specifier or
21444 mem-initializer; in these contexts a qualified name that
21445 depends on a template-parameter is implicitly assumed to be a
21448 is to pretend that we have seen the `typename' keyword at this
21450 cp_parser_nested_name_specifier_opt (parser,
21451 /*typename_keyword_p=*/true,
21452 /*check_dependency_p=*/true,
21454 /*is_declaration=*/true);
21455 /* If the base class is given by a qualified name, assume that names
21456 we see are type names or templates, as appropriate. */
21457 class_scope_p = (parser->scope && TYPE_P (parser->scope));
21458 template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
21461 && cp_lexer_next_token_is_decltype (parser->lexer))
21462 /* DR 950 allows decltype as a base-specifier. */
21463 type = cp_parser_decltype (parser);
21466 /* Otherwise, look for the class-name. */
21467 type = cp_parser_class_name (parser,
21471 /*check_dependency_p=*/true,
21472 /*class_head_p=*/false,
21473 /*is_declaration=*/true);
21474 type = TREE_TYPE (type);
21477 if (type == error_mark_node)
21478 return error_mark_node;
21480 return finish_base_specifier (type, access, virtual_p);
21483 /* Exception handling [gram.exception] */
21485 /* Parse an (optional) noexcept-specification.
21487 noexcept-specification:
21488 noexcept ( constant-expression ) [opt]
21490 If no noexcept-specification is present, returns NULL_TREE.
21491 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
21492 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
21493 there are no parentheses. CONSUMED_EXPR will be set accordingly.
21494 Otherwise, returns a noexcept specification unless RETURN_COND is true,
21495 in which case a boolean condition is returned instead. */
21498 cp_parser_noexcept_specification_opt (cp_parser* parser,
21499 bool require_constexpr,
21500 bool* consumed_expr,
21504 const char *saved_message;
21506 /* Peek at the next token. */
21507 token = cp_lexer_peek_token (parser->lexer);
21509 /* Is it a noexcept-specification? */
21510 if (cp_parser_is_keyword (token, RID_NOEXCEPT))
21513 cp_lexer_consume_token (parser->lexer);
21515 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
21517 cp_lexer_consume_token (parser->lexer);
21519 if (require_constexpr)
21521 /* Types may not be defined in an exception-specification. */
21522 saved_message = parser->type_definition_forbidden_message;
21523 parser->type_definition_forbidden_message
21524 = G_("types may not be defined in an exception-specification");
21526 expr = cp_parser_constant_expression (parser);
21528 /* Restore the saved message. */
21529 parser->type_definition_forbidden_message = saved_message;
21533 expr = cp_parser_expression (parser);
21534 *consumed_expr = true;
21537 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21541 expr = boolean_true_node;
21542 if (!require_constexpr)
21543 *consumed_expr = false;
21546 /* We cannot build a noexcept-spec right away because this will check
21547 that expr is a constexpr. */
21549 return build_noexcept_spec (expr, tf_warning_or_error);
21557 /* Parse an (optional) exception-specification.
21559 exception-specification:
21560 throw ( type-id-list [opt] )
21562 Returns a TREE_LIST representing the exception-specification. The
21563 TREE_VALUE of each node is a type. */
21566 cp_parser_exception_specification_opt (cp_parser* parser)
21570 const char *saved_message;
21572 /* Peek at the next token. */
21573 token = cp_lexer_peek_token (parser->lexer);
21575 /* Is it a noexcept-specification? */
21576 type_id_list = cp_parser_noexcept_specification_opt(parser, true, NULL,
21578 if (type_id_list != NULL_TREE)
21579 return type_id_list;
21581 /* If it's not `throw', then there's no exception-specification. */
21582 if (!cp_parser_is_keyword (token, RID_THROW))
21586 /* Enable this once a lot of code has transitioned to noexcept? */
21587 if (cxx_dialect >= cxx11 && !in_system_header_at (input_location))
21588 warning (OPT_Wdeprecated, "dynamic exception specifications are "
21589 "deprecated in C++0x; use %<noexcept%> instead");
21592 /* Consume the `throw'. */
21593 cp_lexer_consume_token (parser->lexer);
21595 /* Look for the `('. */
21596 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21598 /* Peek at the next token. */
21599 token = cp_lexer_peek_token (parser->lexer);
21600 /* If it's not a `)', then there is a type-id-list. */
21601 if (token->type != CPP_CLOSE_PAREN)
21603 /* Types may not be defined in an exception-specification. */
21604 saved_message = parser->type_definition_forbidden_message;
21605 parser->type_definition_forbidden_message
21606 = G_("types may not be defined in an exception-specification");
21607 /* Parse the type-id-list. */
21608 type_id_list = cp_parser_type_id_list (parser);
21609 /* Restore the saved message. */
21610 parser->type_definition_forbidden_message = saved_message;
21613 type_id_list = empty_except_spec;
21615 /* Look for the `)'. */
21616 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21618 return type_id_list;
21621 /* Parse an (optional) type-id-list.
21625 type-id-list , type-id ... [opt]
21627 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
21628 in the order that the types were presented. */
21631 cp_parser_type_id_list (cp_parser* parser)
21633 tree types = NULL_TREE;
21640 /* Get the next type-id. */
21641 type = cp_parser_type_id (parser);
21642 /* Parse the optional ellipsis. */
21643 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
21645 /* Consume the `...'. */
21646 cp_lexer_consume_token (parser->lexer);
21648 /* Turn the type into a pack expansion expression. */
21649 type = make_pack_expansion (type);
21651 /* Add it to the list. */
21652 types = add_exception_specifier (types, type, /*complain=*/1);
21653 /* Peek at the next token. */
21654 token = cp_lexer_peek_token (parser->lexer);
21655 /* If it is not a `,', we are done. */
21656 if (token->type != CPP_COMMA)
21658 /* Consume the `,'. */
21659 cp_lexer_consume_token (parser->lexer);
21662 return nreverse (types);
21665 /* Parse a try-block.
21668 try compound-statement handler-seq */
21671 cp_parser_try_block (cp_parser* parser)
21675 cp_parser_require_keyword (parser, RID_TRY, RT_TRY);
21676 if (parser->in_function_body
21677 && DECL_DECLARED_CONSTEXPR_P (current_function_decl))
21678 error ("%<try%> in %<constexpr%> function");
21680 try_block = begin_try_block ();
21681 cp_parser_compound_statement (parser, NULL, true, false);
21682 finish_try_block (try_block);
21683 cp_parser_handler_seq (parser);
21684 finish_handler_sequence (try_block);
21689 /* Parse a function-try-block.
21691 function-try-block:
21692 try ctor-initializer [opt] function-body handler-seq */
21695 cp_parser_function_try_block (cp_parser* parser)
21697 tree compound_stmt;
21699 bool ctor_initializer_p;
21701 /* Look for the `try' keyword. */
21702 if (!cp_parser_require_keyword (parser, RID_TRY, RT_TRY))
21704 /* Let the rest of the front end know where we are. */
21705 try_block = begin_function_try_block (&compound_stmt);
21706 /* Parse the function-body. */
21707 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
21708 (parser, /*in_function_try_block=*/true);
21709 /* We're done with the `try' part. */
21710 finish_function_try_block (try_block);
21711 /* Parse the handlers. */
21712 cp_parser_handler_seq (parser);
21713 /* We're done with the handlers. */
21714 finish_function_handler_sequence (try_block, compound_stmt);
21716 return ctor_initializer_p;
21719 /* Parse a handler-seq.
21722 handler handler-seq [opt] */
21725 cp_parser_handler_seq (cp_parser* parser)
21731 /* Parse the handler. */
21732 cp_parser_handler (parser);
21733 /* Peek at the next token. */
21734 token = cp_lexer_peek_token (parser->lexer);
21735 /* If it's not `catch' then there are no more handlers. */
21736 if (!cp_parser_is_keyword (token, RID_CATCH))
21741 /* Parse a handler.
21744 catch ( exception-declaration ) compound-statement */
21747 cp_parser_handler (cp_parser* parser)
21752 cp_parser_require_keyword (parser, RID_CATCH, RT_CATCH);
21753 handler = begin_handler ();
21754 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21755 declaration = cp_parser_exception_declaration (parser);
21756 finish_handler_parms (declaration, handler);
21757 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21758 cp_parser_compound_statement (parser, NULL, false, false);
21759 finish_handler (handler);
21762 /* Parse an exception-declaration.
21764 exception-declaration:
21765 type-specifier-seq declarator
21766 type-specifier-seq abstract-declarator
21770 Returns a VAR_DECL for the declaration, or NULL_TREE if the
21771 ellipsis variant is used. */
21774 cp_parser_exception_declaration (cp_parser* parser)
21776 cp_decl_specifier_seq type_specifiers;
21777 cp_declarator *declarator;
21778 const char *saved_message;
21780 /* If it's an ellipsis, it's easy to handle. */
21781 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
21783 /* Consume the `...' token. */
21784 cp_lexer_consume_token (parser->lexer);
21788 /* Types may not be defined in exception-declarations. */
21789 saved_message = parser->type_definition_forbidden_message;
21790 parser->type_definition_forbidden_message
21791 = G_("types may not be defined in exception-declarations");
21793 /* Parse the type-specifier-seq. */
21794 cp_parser_type_specifier_seq (parser, /*is_declaration=*/true,
21795 /*is_trailing_return=*/false,
21797 /* If it's a `)', then there is no declarator. */
21798 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
21801 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
21802 /*ctor_dtor_or_conv_p=*/NULL,
21803 /*parenthesized_p=*/NULL,
21804 /*member_p=*/false,
21805 /*friend_p=*/false);
21807 /* Restore the saved message. */
21808 parser->type_definition_forbidden_message = saved_message;
21810 if (!type_specifiers.any_specifiers_p)
21811 return error_mark_node;
21813 return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL);
21816 /* Parse a throw-expression.
21819 throw assignment-expression [opt]
21821 Returns a THROW_EXPR representing the throw-expression. */
21824 cp_parser_throw_expression (cp_parser* parser)
21829 cp_parser_require_keyword (parser, RID_THROW, RT_THROW);
21830 token = cp_lexer_peek_token (parser->lexer);
21831 /* Figure out whether or not there is an assignment-expression
21832 following the "throw" keyword. */
21833 if (token->type == CPP_COMMA
21834 || token->type == CPP_SEMICOLON
21835 || token->type == CPP_CLOSE_PAREN
21836 || token->type == CPP_CLOSE_SQUARE
21837 || token->type == CPP_CLOSE_BRACE
21838 || token->type == CPP_COLON)
21839 expression = NULL_TREE;
21841 expression = cp_parser_assignment_expression (parser);
21843 return build_throw (expression);
21846 /* GNU Extensions */
21848 /* Parse an (optional) asm-specification.
21851 asm ( string-literal )
21853 If the asm-specification is present, returns a STRING_CST
21854 corresponding to the string-literal. Otherwise, returns
21858 cp_parser_asm_specification_opt (cp_parser* parser)
21861 tree asm_specification;
21863 /* Peek at the next token. */
21864 token = cp_lexer_peek_token (parser->lexer);
21865 /* If the next token isn't the `asm' keyword, then there's no
21866 asm-specification. */
21867 if (!cp_parser_is_keyword (token, RID_ASM))
21870 /* Consume the `asm' token. */
21871 cp_lexer_consume_token (parser->lexer);
21872 /* Look for the `('. */
21873 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21875 /* Look for the string-literal. */
21876 asm_specification = cp_parser_string_literal (parser, false, false);
21878 /* Look for the `)'. */
21879 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21881 return asm_specification;
21884 /* Parse an asm-operand-list.
21888 asm-operand-list , asm-operand
21891 string-literal ( expression )
21892 [ string-literal ] string-literal ( expression )
21894 Returns a TREE_LIST representing the operands. The TREE_VALUE of
21895 each node is the expression. The TREE_PURPOSE is itself a
21896 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
21897 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
21898 is a STRING_CST for the string literal before the parenthesis. Returns
21899 ERROR_MARK_NODE if any of the operands are invalid. */
21902 cp_parser_asm_operand_list (cp_parser* parser)
21904 tree asm_operands = NULL_TREE;
21905 bool invalid_operands = false;
21909 tree string_literal;
21913 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
21915 /* Consume the `[' token. */
21916 cp_lexer_consume_token (parser->lexer);
21917 /* Read the operand name. */
21918 name = cp_parser_identifier (parser);
21919 if (name != error_mark_node)
21920 name = build_string (IDENTIFIER_LENGTH (name),
21921 IDENTIFIER_POINTER (name));
21922 /* Look for the closing `]'. */
21923 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
21927 /* Look for the string-literal. */
21928 string_literal = cp_parser_string_literal (parser, false, false);
21930 /* Look for the `('. */
21931 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
21932 /* Parse the expression. */
21933 expression = cp_parser_expression (parser);
21934 /* Look for the `)'. */
21935 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
21937 if (name == error_mark_node
21938 || string_literal == error_mark_node
21939 || expression == error_mark_node)
21940 invalid_operands = true;
21942 /* Add this operand to the list. */
21943 asm_operands = tree_cons (build_tree_list (name, string_literal),
21946 /* If the next token is not a `,', there are no more
21948 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
21950 /* Consume the `,'. */
21951 cp_lexer_consume_token (parser->lexer);
21954 return invalid_operands ? error_mark_node : nreverse (asm_operands);
21957 /* Parse an asm-clobber-list.
21961 asm-clobber-list , string-literal
21963 Returns a TREE_LIST, indicating the clobbers in the order that they
21964 appeared. The TREE_VALUE of each node is a STRING_CST. */
21967 cp_parser_asm_clobber_list (cp_parser* parser)
21969 tree clobbers = NULL_TREE;
21973 tree string_literal;
21975 /* Look for the string literal. */
21976 string_literal = cp_parser_string_literal (parser, false, false);
21977 /* Add it to the list. */
21978 clobbers = tree_cons (NULL_TREE, string_literal, clobbers);
21979 /* If the next token is not a `,', then the list is
21981 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
21983 /* Consume the `,' token. */
21984 cp_lexer_consume_token (parser->lexer);
21990 /* Parse an asm-label-list.
21994 asm-label-list , identifier
21996 Returns a TREE_LIST, indicating the labels in the order that they
21997 appeared. The TREE_VALUE of each node is a label. */
22000 cp_parser_asm_label_list (cp_parser* parser)
22002 tree labels = NULL_TREE;
22006 tree identifier, label, name;
22008 /* Look for the identifier. */
22009 identifier = cp_parser_identifier (parser);
22010 if (!error_operand_p (identifier))
22012 label = lookup_label (identifier);
22013 if (TREE_CODE (label) == LABEL_DECL)
22015 TREE_USED (label) = 1;
22016 check_goto (label);
22017 name = build_string (IDENTIFIER_LENGTH (identifier),
22018 IDENTIFIER_POINTER (identifier));
22019 labels = tree_cons (name, label, labels);
22022 /* If the next token is not a `,', then the list is
22024 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
22026 /* Consume the `,' token. */
22027 cp_lexer_consume_token (parser->lexer);
22030 return nreverse (labels);
22033 /* Return TRUE iff the next tokens in the stream are possibly the
22034 beginning of a GNU extension attribute. */
22037 cp_next_tokens_can_be_gnu_attribute_p (cp_parser *parser)
22039 return cp_nth_tokens_can_be_gnu_attribute_p (parser, 1);
22042 /* Return TRUE iff the next tokens in the stream are possibly the
22043 beginning of a standard C++-11 attribute specifier. */
22046 cp_next_tokens_can_be_std_attribute_p (cp_parser *parser)
22048 return cp_nth_tokens_can_be_std_attribute_p (parser, 1);
22051 /* Return TRUE iff the next Nth tokens in the stream are possibly the
22052 beginning of a standard C++-11 attribute specifier. */
22055 cp_nth_tokens_can_be_std_attribute_p (cp_parser *parser, size_t n)
22057 cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
22059 return (cxx_dialect >= cxx11
22060 && ((token->type == CPP_KEYWORD && token->keyword == RID_ALIGNAS)
22061 || (token->type == CPP_OPEN_SQUARE
22062 && (token = cp_lexer_peek_nth_token (parser->lexer, n + 1))
22063 && token->type == CPP_OPEN_SQUARE)));
22066 /* Return TRUE iff the next Nth tokens in the stream are possibly the
22067 beginning of a GNU extension attribute. */
22070 cp_nth_tokens_can_be_gnu_attribute_p (cp_parser *parser, size_t n)
22072 cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
22074 return token->type == CPP_KEYWORD && token->keyword == RID_ATTRIBUTE;
22077 /* Return true iff the next tokens can be the beginning of either a
22078 GNU attribute list, or a standard C++11 attribute sequence. */
22081 cp_next_tokens_can_be_attribute_p (cp_parser *parser)
22083 return (cp_next_tokens_can_be_gnu_attribute_p (parser)
22084 || cp_next_tokens_can_be_std_attribute_p (parser));
22087 /* Return true iff the next Nth tokens can be the beginning of either
22088 a GNU attribute list, or a standard C++11 attribute sequence. */
22091 cp_nth_tokens_can_be_attribute_p (cp_parser *parser, size_t n)
22093 return (cp_nth_tokens_can_be_gnu_attribute_p (parser, n)
22094 || cp_nth_tokens_can_be_std_attribute_p (parser, n));
22097 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
22098 of GNU attributes, or return NULL. */
22101 cp_parser_attributes_opt (cp_parser *parser)
22103 if (cp_next_tokens_can_be_gnu_attribute_p (parser))
22104 return cp_parser_gnu_attributes_opt (parser);
22105 return cp_parser_std_attribute_spec_seq (parser);
22108 #define CILK_SIMD_FN_CLAUSE_MASK \
22109 ((OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_VECTORLENGTH) \
22110 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_LINEAR) \
22111 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_UNIFORM) \
22112 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_MASK) \
22113 | (OMP_CLAUSE_MASK_1 << PRAGMA_CILK_CLAUSE_NOMASK))
22115 /* Parses the Cilk Plus SIMD-enabled function's attribute. Syntax:
22116 vector [(<clauses>)] */
22119 cp_parser_cilk_simd_fn_vector_attrs (cp_parser *parser, cp_token *v_token)
22121 bool first_p = parser->cilk_simd_fn_info == NULL;
22122 cp_token *token = v_token;
22125 parser->cilk_simd_fn_info = XNEW (cp_omp_declare_simd_data);
22126 parser->cilk_simd_fn_info->error_seen = false;
22127 parser->cilk_simd_fn_info->fndecl_seen = false;
22128 parser->cilk_simd_fn_info->tokens = vNULL;
22130 int paren_scope = 0;
22131 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
22133 cp_lexer_consume_token (parser->lexer);
22134 v_token = cp_lexer_peek_token (parser->lexer);
22137 while (paren_scope > 0)
22139 token = cp_lexer_peek_token (parser->lexer);
22140 if (token->type == CPP_OPEN_PAREN)
22142 else if (token->type == CPP_CLOSE_PAREN)
22144 /* Do not push the last ')' */
22145 if (!(token->type == CPP_CLOSE_PAREN && paren_scope == 0))
22146 cp_lexer_consume_token (parser->lexer);
22149 token->type = CPP_PRAGMA_EOL;
22150 parser->lexer->next_token = token;
22151 cp_lexer_consume_token (parser->lexer);
22153 struct cp_token_cache *cp
22154 = cp_token_cache_new (v_token, cp_lexer_peek_token (parser->lexer));
22155 parser->cilk_simd_fn_info->tokens.safe_push (cp);
22158 /* Parse an (optional) series of attributes.
22161 attributes attribute
22164 __attribute__ (( attribute-list [opt] ))
22166 The return value is as for cp_parser_gnu_attribute_list. */
22169 cp_parser_gnu_attributes_opt (cp_parser* parser)
22171 tree attributes = NULL_TREE;
22176 tree attribute_list;
22179 /* Peek at the next token. */
22180 token = cp_lexer_peek_token (parser->lexer);
22181 /* If it's not `__attribute__', then we're done. */
22182 if (token->keyword != RID_ATTRIBUTE)
22185 /* Consume the `__attribute__' keyword. */
22186 cp_lexer_consume_token (parser->lexer);
22187 /* Look for the two `(' tokens. */
22188 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
22189 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
22191 /* Peek at the next token. */
22192 token = cp_lexer_peek_token (parser->lexer);
22193 if (token->type != CPP_CLOSE_PAREN)
22194 /* Parse the attribute-list. */
22195 attribute_list = cp_parser_gnu_attribute_list (parser);
22197 /* If the next token is a `)', then there is no attribute
22199 attribute_list = NULL;
22201 /* Look for the two `)' tokens. */
22202 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
22204 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
22207 cp_parser_skip_to_end_of_statement (parser);
22209 /* Add these new attributes to the list. */
22210 attributes = chainon (attributes, attribute_list);
22216 /* Returns true of NAME is an IDENTIFIER_NODE with identiifer "vector,"
22217 "__vector" or "__vector__." */
22220 is_cilkplus_vector_p (tree name)
22222 if (flag_cilkplus && is_attribute_p ("vector", name))
22227 /* Parse a GNU attribute-list.
22231 attribute-list , attribute
22235 identifier ( identifier )
22236 identifier ( identifier , expression-list )
22237 identifier ( expression-list )
22239 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
22240 to an attribute. The TREE_PURPOSE of each node is the identifier
22241 indicating which attribute is in use. The TREE_VALUE represents
22242 the arguments, if any. */
22245 cp_parser_gnu_attribute_list (cp_parser* parser)
22247 tree attribute_list = NULL_TREE;
22248 bool save_translate_strings_p = parser->translate_strings_p;
22250 parser->translate_strings_p = false;
22257 /* Look for the identifier. We also allow keywords here; for
22258 example `__attribute__ ((const))' is legal. */
22259 token = cp_lexer_peek_token (parser->lexer);
22260 if (token->type == CPP_NAME
22261 || token->type == CPP_KEYWORD)
22263 tree arguments = NULL_TREE;
22265 /* Consume the token, but save it since we need it for the
22266 SIMD enabled function parsing. */
22267 cp_token *id_token = cp_lexer_consume_token (parser->lexer);
22269 /* Save away the identifier that indicates which attribute
22271 identifier = (token->type == CPP_KEYWORD)
22272 /* For keywords, use the canonical spelling, not the
22273 parsed identifier. */
22274 ? ridpointers[(int) token->keyword]
22275 : id_token->u.value;
22277 attribute = build_tree_list (identifier, NULL_TREE);
22279 /* Peek at the next token. */
22280 token = cp_lexer_peek_token (parser->lexer);
22281 /* If it's an `(', then parse the attribute arguments. */
22282 if (token->type == CPP_OPEN_PAREN)
22284 vec<tree, va_gc> *vec;
22285 int attr_flag = (attribute_takes_identifier_p (identifier)
22286 ? id_attr : normal_attr);
22287 if (is_cilkplus_vector_p (identifier))
22289 cp_parser_cilk_simd_fn_vector_attrs (parser, id_token);
22293 vec = cp_parser_parenthesized_expression_list
22294 (parser, attr_flag, /*cast_p=*/false,
22295 /*allow_expansion_p=*/false,
22296 /*non_constant_p=*/NULL);
22298 arguments = error_mark_node;
22301 arguments = build_tree_list_vec (vec);
22302 release_tree_vector (vec);
22304 /* Save the arguments away. */
22305 TREE_VALUE (attribute) = arguments;
22307 else if (is_cilkplus_vector_p (identifier))
22309 cp_parser_cilk_simd_fn_vector_attrs (parser, id_token);
22313 if (arguments != error_mark_node)
22315 /* Add this attribute to the list. */
22316 TREE_CHAIN (attribute) = attribute_list;
22317 attribute_list = attribute;
22320 token = cp_lexer_peek_token (parser->lexer);
22322 /* Now, look for more attributes. If the next token isn't a
22323 `,', we're done. */
22324 if (token->type != CPP_COMMA)
22327 /* Consume the comma and keep going. */
22328 cp_lexer_consume_token (parser->lexer);
22330 parser->translate_strings_p = save_translate_strings_p;
22332 /* We built up the list in reverse order. */
22333 return nreverse (attribute_list);
22336 /* Parse a standard C++11 attribute.
22338 The returned representation is a TREE_LIST which TREE_PURPOSE is
22339 the scoped name of the attribute, and the TREE_VALUE is its
22342 Note that the scoped name of the attribute is itself a TREE_LIST
22343 which TREE_PURPOSE is the namespace of the attribute, and
22344 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
22345 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
22346 and which TREE_PURPOSE is directly the attribute name.
22348 Clients of the attribute code should use get_attribute_namespace
22349 and get_attribute_name to get the actual namespace and name of
22350 attributes, regardless of their being GNU or C++11 attributes.
22353 attribute-token attribute-argument-clause [opt]
22357 attribute-scoped-token
22359 attribute-scoped-token:
22360 attribute-namespace :: identifier
22362 attribute-namespace:
22365 attribute-argument-clause:
22366 ( balanced-token-seq )
22368 balanced-token-seq:
22369 balanced-token [opt]
22370 balanced-token-seq balanced-token
22373 ( balanced-token-seq )
22374 [ balanced-token-seq ]
22375 { balanced-token-seq }. */
22378 cp_parser_std_attribute (cp_parser *parser)
22380 tree attribute, attr_ns = NULL_TREE, attr_id = NULL_TREE, arguments;
22383 /* First, parse name of the the attribute, a.k.a
22384 attribute-token. */
22386 token = cp_lexer_peek_token (parser->lexer);
22387 if (token->type == CPP_NAME)
22388 attr_id = token->u.value;
22389 else if (token->type == CPP_KEYWORD)
22390 attr_id = ridpointers[(int) token->keyword];
22391 else if (token->flags & NAMED_OP)
22392 attr_id = get_identifier (cpp_type2name (token->type, token->flags));
22394 if (attr_id == NULL_TREE)
22397 cp_lexer_consume_token (parser->lexer);
22399 token = cp_lexer_peek_token (parser->lexer);
22400 if (token->type == CPP_SCOPE)
22402 /* We are seeing a scoped attribute token. */
22404 cp_lexer_consume_token (parser->lexer);
22407 token = cp_lexer_consume_token (parser->lexer);
22408 if (token->type == CPP_NAME)
22409 attr_id = token->u.value;
22410 else if (token->type == CPP_KEYWORD)
22411 attr_id = ridpointers[(int) token->keyword];
22414 error_at (token->location,
22415 "expected an identifier for the attribute name");
22416 return error_mark_node;
22418 attribute = build_tree_list (build_tree_list (attr_ns, attr_id),
22420 token = cp_lexer_peek_token (parser->lexer);
22424 attribute = build_tree_list (build_tree_list (NULL_TREE, attr_id),
22426 /* C++11 noreturn attribute is equivalent to GNU's. */
22427 if (is_attribute_p ("noreturn", attr_id))
22428 TREE_PURPOSE (TREE_PURPOSE (attribute)) = get_identifier ("gnu");
22429 /* C++14 deprecated attribute is equivalent to GNU's. */
22430 else if (cxx_dialect >= cxx11 && is_attribute_p ("deprecated", attr_id))
22432 if (cxx_dialect == cxx11)
22433 pedwarn (token->location, OPT_Wpedantic,
22434 "%<deprecated%> is a C++14 feature;"
22435 " use %<gnu::deprecated%>");
22436 TREE_PURPOSE (TREE_PURPOSE (attribute)) = get_identifier ("gnu");
22440 /* Now parse the optional argument clause of the attribute. */
22442 if (token->type != CPP_OPEN_PAREN)
22446 vec<tree, va_gc> *vec;
22447 int attr_flag = normal_attr;
22449 if (attr_ns == get_identifier ("gnu")
22450 && attribute_takes_identifier_p (attr_id))
22451 /* A GNU attribute that takes an identifier in parameter. */
22452 attr_flag = id_attr;
22454 vec = cp_parser_parenthesized_expression_list
22455 (parser, attr_flag, /*cast_p=*/false,
22456 /*allow_expansion_p=*/true,
22457 /*non_constant_p=*/NULL);
22459 arguments = error_mark_node;
22462 arguments = build_tree_list_vec (vec);
22463 release_tree_vector (vec);
22466 if (arguments == error_mark_node)
22467 attribute = error_mark_node;
22469 TREE_VALUE (attribute) = arguments;
22475 /* Parse a list of standard C++-11 attributes.
22479 attribute-list , attribute[opt]
22481 attribute-list , attribute ...
22485 cp_parser_std_attribute_list (cp_parser *parser)
22487 tree attributes = NULL_TREE, attribute = NULL_TREE;
22488 cp_token *token = NULL;
22492 attribute = cp_parser_std_attribute (parser);
22493 if (attribute == error_mark_node)
22495 if (attribute != NULL_TREE)
22497 TREE_CHAIN (attribute) = attributes;
22498 attributes = attribute;
22500 token = cp_lexer_peek_token (parser->lexer);
22501 if (token->type != CPP_COMMA)
22503 cp_lexer_consume_token (parser->lexer);
22505 attributes = nreverse (attributes);
22509 /* Parse a standard C++-11 attribute specifier.
22511 attribute-specifier:
22512 [ [ attribute-list ] ]
22513 alignment-specifier
22515 alignment-specifier:
22516 alignas ( type-id ... [opt] )
22517 alignas ( alignment-expression ... [opt] ). */
22520 cp_parser_std_attribute_spec (cp_parser *parser)
22522 tree attributes = NULL_TREE;
22523 cp_token *token = cp_lexer_peek_token (parser->lexer);
22525 if (token->type == CPP_OPEN_SQUARE
22526 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_OPEN_SQUARE)
22528 cp_lexer_consume_token (parser->lexer);
22529 cp_lexer_consume_token (parser->lexer);
22531 attributes = cp_parser_std_attribute_list (parser);
22533 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE)
22534 || !cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
22535 cp_parser_skip_to_end_of_statement (parser);
22537 /* Warn about parsing c++11 attribute in non-c++1 mode, only
22538 when we are sure that we have actually parsed them. */
22539 maybe_warn_cpp0x (CPP0X_ATTRIBUTES);
22545 /* Look for an alignment-specifier. */
22547 token = cp_lexer_peek_token (parser->lexer);
22549 if (token->type != CPP_KEYWORD
22550 || token->keyword != RID_ALIGNAS)
22553 cp_lexer_consume_token (parser->lexer);
22554 maybe_warn_cpp0x (CPP0X_ATTRIBUTES);
22556 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN) == NULL)
22558 cp_parser_error (parser, "expected %<(%>");
22559 return error_mark_node;
22562 cp_parser_parse_tentatively (parser);
22563 alignas_expr = cp_parser_type_id (parser);
22565 if (!cp_parser_parse_definitely (parser))
22567 gcc_assert (alignas_expr == error_mark_node
22568 || alignas_expr == NULL_TREE);
22571 cp_parser_assignment_expression (parser);
22572 if (alignas_expr == error_mark_node)
22573 cp_parser_skip_to_end_of_statement (parser);
22574 if (alignas_expr == NULL_TREE
22575 || alignas_expr == error_mark_node)
22576 return alignas_expr;
22579 if (cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN) == NULL)
22581 cp_parser_error (parser, "expected %<)%>");
22582 return error_mark_node;
22585 alignas_expr = cxx_alignas_expr (alignas_expr);
22587 /* Build the C++-11 representation of an 'aligned'
22590 build_tree_list (build_tree_list (get_identifier ("gnu"),
22591 get_identifier ("aligned")),
22592 build_tree_list (NULL_TREE, alignas_expr));
22598 /* Parse a standard C++-11 attribute-specifier-seq.
22600 attribute-specifier-seq:
22601 attribute-specifier-seq [opt] attribute-specifier
22605 cp_parser_std_attribute_spec_seq (cp_parser *parser)
22607 tree attr_specs = NULL;
22611 tree attr_spec = cp_parser_std_attribute_spec (parser);
22612 if (attr_spec == NULL_TREE)
22614 if (attr_spec == error_mark_node)
22615 return error_mark_node;
22617 TREE_CHAIN (attr_spec) = attr_specs;
22618 attr_specs = attr_spec;
22621 attr_specs = nreverse (attr_specs);
22625 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
22626 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
22627 current value of the PEDANTIC flag, regardless of whether or not
22628 the `__extension__' keyword is present. The caller is responsible
22629 for restoring the value of the PEDANTIC flag. */
22632 cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
22634 /* Save the old value of the PEDANTIC flag. */
22635 *saved_pedantic = pedantic;
22637 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
22639 /* Consume the `__extension__' token. */
22640 cp_lexer_consume_token (parser->lexer);
22641 /* We're not being pedantic while the `__extension__' keyword is
22651 /* Parse a label declaration.
22654 __label__ label-declarator-seq ;
22656 label-declarator-seq:
22657 identifier , label-declarator-seq
22661 cp_parser_label_declaration (cp_parser* parser)
22663 /* Look for the `__label__' keyword. */
22664 cp_parser_require_keyword (parser, RID_LABEL, RT_LABEL);
22670 /* Look for an identifier. */
22671 identifier = cp_parser_identifier (parser);
22672 /* If we failed, stop. */
22673 if (identifier == error_mark_node)
22675 /* Declare it as a label. */
22676 finish_label_decl (identifier);
22677 /* If the next token is a `;', stop. */
22678 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
22680 /* Look for the `,' separating the label declarations. */
22681 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
22684 /* Look for the final `;'. */
22685 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
22688 /* Support Functions */
22690 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
22691 NAME should have one of the representations used for an
22692 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
22693 is returned. If PARSER->SCOPE is a dependent type, then a
22694 SCOPE_REF is returned.
22696 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
22697 returned; the name was already resolved when the TEMPLATE_ID_EXPR
22698 was formed. Abstractly, such entities should not be passed to this
22699 function, because they do not need to be looked up, but it is
22700 simpler to check for this special case here, rather than at the
22703 In cases not explicitly covered above, this function returns a
22704 DECL, OVERLOAD, or baselink representing the result of the lookup.
22705 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
22708 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
22709 (e.g., "struct") that was used. In that case bindings that do not
22710 refer to types are ignored.
22712 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
22715 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
22718 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
22721 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
22722 TREE_LIST of candidates if name-lookup results in an ambiguity, and
22723 NULL_TREE otherwise. */
22726 cp_parser_lookup_name (cp_parser *parser, tree name,
22727 enum tag_types tag_type,
22730 bool check_dependency,
22731 tree *ambiguous_decls,
22732 location_t name_location)
22735 tree object_type = parser->context->object_type;
22737 /* Assume that the lookup will be unambiguous. */
22738 if (ambiguous_decls)
22739 *ambiguous_decls = NULL_TREE;
22741 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
22742 no longer valid. Note that if we are parsing tentatively, and
22743 the parse fails, OBJECT_TYPE will be automatically restored. */
22744 parser->context->object_type = NULL_TREE;
22746 if (name == error_mark_node)
22747 return error_mark_node;
22749 /* A template-id has already been resolved; there is no lookup to
22751 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
22753 if (BASELINK_P (name))
22755 gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name))
22756 == TEMPLATE_ID_EXPR);
22760 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
22761 it should already have been checked to make sure that the name
22762 used matches the type being destroyed. */
22763 if (TREE_CODE (name) == BIT_NOT_EXPR)
22767 /* Figure out to which type this destructor applies. */
22769 type = parser->scope;
22770 else if (object_type)
22771 type = object_type;
22773 type = current_class_type;
22774 /* If that's not a class type, there is no destructor. */
22775 if (!type || !CLASS_TYPE_P (type))
22776 return error_mark_node;
22777 if (CLASSTYPE_LAZY_DESTRUCTOR (type))
22778 lazily_declare_fn (sfk_destructor, type);
22779 if (!CLASSTYPE_DESTRUCTORS (type))
22780 return error_mark_node;
22781 /* If it was a class type, return the destructor. */
22782 return CLASSTYPE_DESTRUCTORS (type);
22785 /* By this point, the NAME should be an ordinary identifier. If
22786 the id-expression was a qualified name, the qualifying scope is
22787 stored in PARSER->SCOPE at this point. */
22788 gcc_assert (identifier_p (name));
22790 /* Perform the lookup. */
22795 if (parser->scope == error_mark_node)
22796 return error_mark_node;
22798 /* If the SCOPE is dependent, the lookup must be deferred until
22799 the template is instantiated -- unless we are explicitly
22800 looking up names in uninstantiated templates. Even then, we
22801 cannot look up the name if the scope is not a class type; it
22802 might, for example, be a template type parameter. */
22803 dependent_p = (TYPE_P (parser->scope)
22804 && dependent_scope_p (parser->scope));
22805 if ((check_dependency || !CLASS_TYPE_P (parser->scope))
22807 /* Defer lookup. */
22808 decl = error_mark_node;
22811 tree pushed_scope = NULL_TREE;
22813 /* If PARSER->SCOPE is a dependent type, then it must be a
22814 class type, and we must not be checking dependencies;
22815 otherwise, we would have processed this lookup above. So
22816 that PARSER->SCOPE is not considered a dependent base by
22817 lookup_member, we must enter the scope here. */
22819 pushed_scope = push_scope (parser->scope);
22821 /* If the PARSER->SCOPE is a template specialization, it
22822 may be instantiated during name lookup. In that case,
22823 errors may be issued. Even if we rollback the current
22824 tentative parse, those errors are valid. */
22825 decl = lookup_qualified_name (parser->scope, name,
22826 tag_type != none_type,
22827 /*complain=*/true);
22829 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
22830 lookup result and the nested-name-specifier nominates a class C:
22831 * if the name specified after the nested-name-specifier, when
22832 looked up in C, is the injected-class-name of C (Clause 9), or
22833 * if the name specified after the nested-name-specifier is the
22834 same as the identifier or the simple-template-id's template-
22835 name in the last component of the nested-name-specifier,
22836 the name is instead considered to name the constructor of
22837 class C. [ Note: for example, the constructor is not an
22838 acceptable lookup result in an elaborated-type-specifier so
22839 the constructor would not be used in place of the
22840 injected-class-name. --end note ] Such a constructor name
22841 shall be used only in the declarator-id of a declaration that
22842 names a constructor or in a using-declaration. */
22843 if (tag_type == none_type
22844 && DECL_SELF_REFERENCE_P (decl)
22845 && same_type_p (DECL_CONTEXT (decl), parser->scope))
22846 decl = lookup_qualified_name (parser->scope, ctor_identifier,
22847 tag_type != none_type,
22848 /*complain=*/true);
22850 /* If we have a single function from a using decl, pull it out. */
22851 if (TREE_CODE (decl) == OVERLOAD
22852 && !really_overloaded_fn (decl))
22853 decl = OVL_FUNCTION (decl);
22856 pop_scope (pushed_scope);
22859 /* If the scope is a dependent type and either we deferred lookup or
22860 we did lookup but didn't find the name, rememeber the name. */
22861 if (decl == error_mark_node && TYPE_P (parser->scope)
22862 && dependent_type_p (parser->scope))
22868 /* The resolution to Core Issue 180 says that `struct
22869 A::B' should be considered a type-name, even if `A'
22871 type = make_typename_type (parser->scope, name, tag_type,
22872 /*complain=*/tf_error);
22873 if (type != error_mark_node)
22874 decl = TYPE_NAME (type);
22876 else if (is_template
22877 && (cp_parser_next_token_ends_template_argument_p (parser)
22878 || cp_lexer_next_token_is (parser->lexer,
22880 decl = make_unbound_class_template (parser->scope,
22882 /*complain=*/tf_error);
22884 decl = build_qualified_name (/*type=*/NULL_TREE,
22885 parser->scope, name,
22888 parser->qualifying_scope = parser->scope;
22889 parser->object_scope = NULL_TREE;
22891 else if (object_type)
22893 /* Look up the name in the scope of the OBJECT_TYPE, unless the
22894 OBJECT_TYPE is not a class. */
22895 if (CLASS_TYPE_P (object_type))
22896 /* If the OBJECT_TYPE is a template specialization, it may
22897 be instantiated during name lookup. In that case, errors
22898 may be issued. Even if we rollback the current tentative
22899 parse, those errors are valid. */
22900 decl = lookup_member (object_type,
22903 tag_type != none_type,
22904 tf_warning_or_error);
22909 /* Look it up in the enclosing context. */
22910 decl = lookup_name_real (name, tag_type != none_type,
22912 /*block_p=*/true, is_namespace, 0);
22913 parser->object_scope = object_type;
22914 parser->qualifying_scope = NULL_TREE;
22918 decl = lookup_name_real (name, tag_type != none_type,
22920 /*block_p=*/true, is_namespace, 0);
22921 parser->qualifying_scope = NULL_TREE;
22922 parser->object_scope = NULL_TREE;
22925 /* If the lookup failed, let our caller know. */
22926 if (!decl || decl == error_mark_node)
22927 return error_mark_node;
22929 /* Pull out the template from an injected-class-name (or multiple). */
22931 decl = maybe_get_template_decl_from_type_decl (decl);
22933 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
22934 if (TREE_CODE (decl) == TREE_LIST)
22936 if (ambiguous_decls)
22937 *ambiguous_decls = decl;
22938 /* The error message we have to print is too complicated for
22939 cp_parser_error, so we incorporate its actions directly. */
22940 if (!cp_parser_simulate_error (parser))
22942 error_at (name_location, "reference to %qD is ambiguous",
22944 print_candidates (decl);
22946 return error_mark_node;
22949 gcc_assert (DECL_P (decl)
22950 || TREE_CODE (decl) == OVERLOAD
22951 || TREE_CODE (decl) == SCOPE_REF
22952 || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE
22953 || BASELINK_P (decl));
22955 /* If we have resolved the name of a member declaration, check to
22956 see if the declaration is accessible. When the name resolves to
22957 set of overloaded functions, accessibility is checked when
22958 overload resolution is done.
22960 During an explicit instantiation, access is not checked at all,
22961 as per [temp.explicit]. */
22963 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
22965 maybe_record_typedef_use (decl);
22970 /* Like cp_parser_lookup_name, but for use in the typical case where
22971 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
22972 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
22975 cp_parser_lookup_name_simple (cp_parser* parser, tree name, location_t location)
22977 return cp_parser_lookup_name (parser, name,
22979 /*is_template=*/false,
22980 /*is_namespace=*/false,
22981 /*check_dependency=*/true,
22982 /*ambiguous_decls=*/NULL,
22986 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
22987 the current context, return the TYPE_DECL. If TAG_NAME_P is
22988 true, the DECL indicates the class being defined in a class-head,
22989 or declared in an elaborated-type-specifier.
22991 Otherwise, return DECL. */
22994 cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p)
22996 /* If the TEMPLATE_DECL is being declared as part of a class-head,
22997 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
23000 template <typename T> struct B;
23003 template <typename T> struct A::B {};
23005 Similarly, in an elaborated-type-specifier:
23007 namespace N { struct X{}; }
23010 template <typename T> friend struct N::X;
23013 However, if the DECL refers to a class type, and we are in
23014 the scope of the class, then the name lookup automatically
23015 finds the TYPE_DECL created by build_self_reference rather
23016 than a TEMPLATE_DECL. For example, in:
23018 template <class T> struct S {
23022 there is no need to handle such case. */
23024 if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p)
23025 return DECL_TEMPLATE_RESULT (decl);
23030 /* If too many, or too few, template-parameter lists apply to the
23031 declarator, issue an error message. Returns TRUE if all went well,
23032 and FALSE otherwise. */
23035 cp_parser_check_declarator_template_parameters (cp_parser* parser,
23036 cp_declarator *declarator,
23037 location_t declarator_location)
23039 switch (declarator->kind)
23043 unsigned num_templates = 0;
23044 tree scope = declarator->u.id.qualifying_scope;
23047 num_templates = num_template_headers_for_class (scope);
23048 else if (TREE_CODE (declarator->u.id.unqualified_name)
23049 == TEMPLATE_ID_EXPR)
23050 /* If the DECLARATOR has the form `X<y>' then it uses one
23051 additional level of template parameters. */
23054 return cp_parser_check_template_parameters
23055 (parser, num_templates, declarator_location, declarator);
23061 case cdk_reference:
23063 return (cp_parser_check_declarator_template_parameters
23064 (parser, declarator->declarator, declarator_location));
23070 gcc_unreachable ();
23075 /* NUM_TEMPLATES were used in the current declaration. If that is
23076 invalid, return FALSE and issue an error messages. Otherwise,
23077 return TRUE. If DECLARATOR is non-NULL, then we are checking a
23078 declarator and we can print more accurate diagnostics. */
23081 cp_parser_check_template_parameters (cp_parser* parser,
23082 unsigned num_templates,
23083 location_t location,
23084 cp_declarator *declarator)
23086 /* If there are the same number of template classes and parameter
23087 lists, that's OK. */
23088 if (parser->num_template_parameter_lists == num_templates)
23090 /* If there are more, but only one more, then we are referring to a
23091 member template. That's OK too. */
23092 if (parser->num_template_parameter_lists == num_templates + 1)
23094 /* If there are more template classes than parameter lists, we have
23097 template <class T> void S<T>::R<T>::f (); */
23098 if (parser->num_template_parameter_lists < num_templates)
23100 if (declarator && !current_function_decl)
23101 error_at (location, "specializing member %<%T::%E%> "
23102 "requires %<template<>%> syntax",
23103 declarator->u.id.qualifying_scope,
23104 declarator->u.id.unqualified_name);
23105 else if (declarator)
23106 error_at (location, "invalid declaration of %<%T::%E%>",
23107 declarator->u.id.qualifying_scope,
23108 declarator->u.id.unqualified_name);
23110 error_at (location, "too few template-parameter-lists");
23113 /* Otherwise, there are too many template parameter lists. We have
23116 template <class T> template <class U> void S::f(); */
23117 error_at (location, "too many template-parameter-lists");
23121 /* Parse an optional `::' token indicating that the following name is
23122 from the global namespace. If so, PARSER->SCOPE is set to the
23123 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
23124 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
23125 Returns the new value of PARSER->SCOPE, if the `::' token is
23126 present, and NULL_TREE otherwise. */
23129 cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
23133 /* Peek at the next token. */
23134 token = cp_lexer_peek_token (parser->lexer);
23135 /* If we're looking at a `::' token then we're starting from the
23136 global namespace, not our current location. */
23137 if (token->type == CPP_SCOPE)
23139 /* Consume the `::' token. */
23140 cp_lexer_consume_token (parser->lexer);
23141 /* Set the SCOPE so that we know where to start the lookup. */
23142 parser->scope = global_namespace;
23143 parser->qualifying_scope = global_namespace;
23144 parser->object_scope = NULL_TREE;
23146 return parser->scope;
23148 else if (!current_scope_valid_p)
23150 parser->scope = NULL_TREE;
23151 parser->qualifying_scope = NULL_TREE;
23152 parser->object_scope = NULL_TREE;
23158 /* Returns TRUE if the upcoming token sequence is the start of a
23159 constructor declarator. If FRIEND_P is true, the declarator is
23160 preceded by the `friend' specifier. */
23163 cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p)
23165 bool constructor_p;
23166 bool outside_class_specifier_p;
23167 tree nested_name_specifier;
23168 cp_token *next_token;
23170 /* The common case is that this is not a constructor declarator, so
23171 try to avoid doing lots of work if at all possible. It's not
23172 valid declare a constructor at function scope. */
23173 if (parser->in_function_body)
23175 /* And only certain tokens can begin a constructor declarator. */
23176 next_token = cp_lexer_peek_token (parser->lexer);
23177 if (next_token->type != CPP_NAME
23178 && next_token->type != CPP_SCOPE
23179 && next_token->type != CPP_NESTED_NAME_SPECIFIER
23180 && next_token->type != CPP_TEMPLATE_ID)
23183 /* Parse tentatively; we are going to roll back all of the tokens
23185 cp_parser_parse_tentatively (parser);
23186 /* Assume that we are looking at a constructor declarator. */
23187 constructor_p = true;
23189 /* Look for the optional `::' operator. */
23190 cp_parser_global_scope_opt (parser,
23191 /*current_scope_valid_p=*/false);
23192 /* Look for the nested-name-specifier. */
23193 nested_name_specifier
23194 = (cp_parser_nested_name_specifier_opt (parser,
23195 /*typename_keyword_p=*/false,
23196 /*check_dependency_p=*/false,
23198 /*is_declaration=*/false));
23200 outside_class_specifier_p = (!at_class_scope_p ()
23201 || !TYPE_BEING_DEFINED (current_class_type)
23204 /* Outside of a class-specifier, there must be a
23205 nested-name-specifier. */
23206 if (!nested_name_specifier && outside_class_specifier_p)
23207 constructor_p = false;
23208 else if (nested_name_specifier == error_mark_node)
23209 constructor_p = false;
23211 /* If we have a class scope, this is easy; DR 147 says that S::S always
23212 names the constructor, and no other qualified name could. */
23213 if (constructor_p && nested_name_specifier
23214 && CLASS_TYPE_P (nested_name_specifier))
23216 tree id = cp_parser_unqualified_id (parser,
23217 /*template_keyword_p=*/false,
23218 /*check_dependency_p=*/false,
23219 /*declarator_p=*/true,
23220 /*optional_p=*/false);
23221 if (is_overloaded_fn (id))
23222 id = DECL_NAME (get_first_fn (id));
23223 if (!constructor_name_p (id, nested_name_specifier))
23224 constructor_p = false;
23226 /* If we still think that this might be a constructor-declarator,
23227 look for a class-name. */
23228 else if (constructor_p)
23232 template <typename T> struct S {
23236 we must recognize that the nested `S' names a class. */
23238 type_decl = cp_parser_class_name (parser,
23239 /*typename_keyword_p=*/false,
23240 /*template_keyword_p=*/false,
23242 /*check_dependency_p=*/false,
23243 /*class_head_p=*/false,
23244 /*is_declaration=*/false);
23245 /* If there was no class-name, then this is not a constructor.
23246 Otherwise, if we are in a class-specifier and we aren't
23247 handling a friend declaration, check that its type matches
23248 current_class_type (c++/38313). Note: error_mark_node
23249 is left alone for error recovery purposes. */
23250 constructor_p = (!cp_parser_error_occurred (parser)
23251 && (outside_class_specifier_p
23252 || type_decl == error_mark_node
23253 || same_type_p (current_class_type,
23254 TREE_TYPE (type_decl))));
23256 /* If we're still considering a constructor, we have to see a `(',
23257 to begin the parameter-declaration-clause, followed by either a
23258 `)', an `...', or a decl-specifier. We need to check for a
23259 type-specifier to avoid being fooled into thinking that:
23263 is a constructor. (It is actually a function named `f' that
23264 takes one parameter (of type `int') and returns a value of type
23267 && !cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
23268 constructor_p = false;
23271 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
23272 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
23273 /* A parameter declaration begins with a decl-specifier,
23274 which is either the "attribute" keyword, a storage class
23275 specifier, or (usually) a type-specifier. */
23276 && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer))
23279 tree pushed_scope = NULL_TREE;
23280 unsigned saved_num_template_parameter_lists;
23282 /* Names appearing in the type-specifier should be looked up
23283 in the scope of the class. */
23284 if (current_class_type)
23288 type = TREE_TYPE (type_decl);
23289 if (TREE_CODE (type) == TYPENAME_TYPE)
23291 type = resolve_typename_type (type,
23292 /*only_current_p=*/false);
23293 if (TREE_CODE (type) == TYPENAME_TYPE)
23295 cp_parser_abort_tentative_parse (parser);
23299 pushed_scope = push_scope (type);
23302 /* Inside the constructor parameter list, surrounding
23303 template-parameter-lists do not apply. */
23304 saved_num_template_parameter_lists
23305 = parser->num_template_parameter_lists;
23306 parser->num_template_parameter_lists = 0;
23308 /* Look for the type-specifier. */
23309 cp_parser_type_specifier (parser,
23310 CP_PARSER_FLAGS_NONE,
23311 /*decl_specs=*/NULL,
23312 /*is_declarator=*/true,
23313 /*declares_class_or_enum=*/NULL,
23314 /*is_cv_qualifier=*/NULL);
23316 parser->num_template_parameter_lists
23317 = saved_num_template_parameter_lists;
23319 /* Leave the scope of the class. */
23321 pop_scope (pushed_scope);
23323 constructor_p = !cp_parser_error_occurred (parser);
23327 /* We did not really want to consume any tokens. */
23328 cp_parser_abort_tentative_parse (parser);
23330 return constructor_p;
23333 /* Parse the definition of the function given by the DECL_SPECIFIERS,
23334 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
23335 they must be performed once we are in the scope of the function.
23337 Returns the function defined. */
23340 cp_parser_function_definition_from_specifiers_and_declarator
23341 (cp_parser* parser,
23342 cp_decl_specifier_seq *decl_specifiers,
23344 const cp_declarator *declarator)
23349 /* Begin the function-definition. */
23350 success_p = start_function (decl_specifiers, declarator, attributes);
23352 /* The things we're about to see are not directly qualified by any
23353 template headers we've seen thus far. */
23354 reset_specialization ();
23356 /* If there were names looked up in the decl-specifier-seq that we
23357 did not check, check them now. We must wait until we are in the
23358 scope of the function to perform the checks, since the function
23359 might be a friend. */
23360 perform_deferred_access_checks (tf_warning_or_error);
23364 cp_finalize_omp_declare_simd (parser, current_function_decl);
23365 parser->omp_declare_simd = NULL;
23370 /* Skip the entire function. */
23371 cp_parser_skip_to_end_of_block_or_statement (parser);
23372 fn = error_mark_node;
23374 else if (DECL_INITIAL (current_function_decl) != error_mark_node)
23376 /* Seen already, skip it. An error message has already been output. */
23377 cp_parser_skip_to_end_of_block_or_statement (parser);
23378 fn = current_function_decl;
23379 current_function_decl = NULL_TREE;
23380 /* If this is a function from a class, pop the nested class. */
23381 if (current_class_name)
23382 pop_nested_class ();
23387 if (DECL_DECLARED_INLINE_P (current_function_decl))
23388 tv = TV_PARSE_INLINE;
23390 tv = TV_PARSE_FUNC;
23392 fn = cp_parser_function_definition_after_declarator (parser,
23393 /*inline_p=*/false);
23400 /* Parse the part of a function-definition that follows the
23401 declarator. INLINE_P is TRUE iff this function is an inline
23402 function defined within a class-specifier.
23404 Returns the function defined. */
23407 cp_parser_function_definition_after_declarator (cp_parser* parser,
23411 bool ctor_initializer_p = false;
23412 bool saved_in_unbraced_linkage_specification_p;
23413 bool saved_in_function_body;
23414 unsigned saved_num_template_parameter_lists;
23416 bool fully_implicit_function_template_p
23417 = parser->fully_implicit_function_template_p;
23418 parser->fully_implicit_function_template_p = false;
23419 tree implicit_template_parms
23420 = parser->implicit_template_parms;
23421 parser->implicit_template_parms = 0;
23422 cp_binding_level* implicit_template_scope
23423 = parser->implicit_template_scope;
23424 parser->implicit_template_scope = 0;
23426 saved_in_function_body = parser->in_function_body;
23427 parser->in_function_body = true;
23428 /* If the next token is `return', then the code may be trying to
23429 make use of the "named return value" extension that G++ used to
23431 token = cp_lexer_peek_token (parser->lexer);
23432 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
23434 /* Consume the `return' keyword. */
23435 cp_lexer_consume_token (parser->lexer);
23436 /* Look for the identifier that indicates what value is to be
23438 cp_parser_identifier (parser);
23439 /* Issue an error message. */
23440 error_at (token->location,
23441 "named return values are no longer supported");
23442 /* Skip tokens until we reach the start of the function body. */
23445 cp_token *token = cp_lexer_peek_token (parser->lexer);
23446 if (token->type == CPP_OPEN_BRACE
23447 || token->type == CPP_EOF
23448 || token->type == CPP_PRAGMA_EOL)
23450 cp_lexer_consume_token (parser->lexer);
23453 /* The `extern' in `extern "C" void f () { ... }' does not apply to
23454 anything declared inside `f'. */
23455 saved_in_unbraced_linkage_specification_p
23456 = parser->in_unbraced_linkage_specification_p;
23457 parser->in_unbraced_linkage_specification_p = false;
23458 /* Inside the function, surrounding template-parameter-lists do not
23460 saved_num_template_parameter_lists
23461 = parser->num_template_parameter_lists;
23462 parser->num_template_parameter_lists = 0;
23464 start_lambda_scope (current_function_decl);
23466 /* If the next token is `try', `__transaction_atomic', or
23467 `__transaction_relaxed`, then we are looking at either function-try-block
23468 or function-transaction-block. Note that all of these include the
23470 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_ATOMIC))
23471 ctor_initializer_p = cp_parser_function_transaction (parser,
23472 RID_TRANSACTION_ATOMIC);
23473 else if (cp_lexer_next_token_is_keyword (parser->lexer,
23474 RID_TRANSACTION_RELAXED))
23475 ctor_initializer_p = cp_parser_function_transaction (parser,
23476 RID_TRANSACTION_RELAXED);
23477 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
23478 ctor_initializer_p = cp_parser_function_try_block (parser);
23480 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
23481 (parser, /*in_function_try_block=*/false);
23483 finish_lambda_scope ();
23485 /* Finish the function. */
23486 fn = finish_function ((ctor_initializer_p ? 1 : 0) |
23487 (inline_p ? 2 : 0));
23488 /* Generate code for it, if necessary. */
23489 expand_or_defer_fn (fn);
23490 /* Restore the saved values. */
23491 parser->in_unbraced_linkage_specification_p
23492 = saved_in_unbraced_linkage_specification_p;
23493 parser->num_template_parameter_lists
23494 = saved_num_template_parameter_lists;
23495 parser->in_function_body = saved_in_function_body;
23497 parser->fully_implicit_function_template_p
23498 = fully_implicit_function_template_p;
23499 parser->implicit_template_parms
23500 = implicit_template_parms;
23501 parser->implicit_template_scope
23502 = implicit_template_scope;
23504 if (parser->fully_implicit_function_template_p)
23505 finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
23510 /* Parse a template-declaration, assuming that the `export' (and
23511 `extern') keywords, if present, has already been scanned. MEMBER_P
23512 is as for cp_parser_template_declaration. */
23515 cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
23517 tree decl = NULL_TREE;
23518 vec<deferred_access_check, va_gc> *checks;
23519 tree parameter_list;
23520 bool friend_p = false;
23521 bool need_lang_pop;
23524 /* Look for the `template' keyword. */
23525 token = cp_lexer_peek_token (parser->lexer);
23526 if (!cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE))
23530 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
23532 if (at_class_scope_p () && current_function_decl)
23534 /* 14.5.2.2 [temp.mem]
23536 A local class shall not have member templates. */
23537 error_at (token->location,
23538 "invalid declaration of member template in local class");
23539 cp_parser_skip_to_end_of_block_or_statement (parser);
23544 A template ... shall not have C linkage. */
23545 if (current_lang_name == lang_name_c)
23547 error_at (token->location, "template with C linkage");
23548 /* Give it C++ linkage to avoid confusing other parts of the
23550 push_lang_context (lang_name_cplusplus);
23551 need_lang_pop = true;
23554 need_lang_pop = false;
23556 /* We cannot perform access checks on the template parameter
23557 declarations until we know what is being declared, just as we
23558 cannot check the decl-specifier list. */
23559 push_deferring_access_checks (dk_deferred);
23561 /* If the next token is `>', then we have an invalid
23562 specialization. Rather than complain about an invalid template
23563 parameter, issue an error message here. */
23564 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
23566 cp_parser_error (parser, "invalid explicit specialization");
23567 begin_specialization ();
23568 parameter_list = NULL_TREE;
23572 /* Parse the template parameters. */
23573 parameter_list = cp_parser_template_parameter_list (parser);
23576 /* Get the deferred access checks from the parameter list. These
23577 will be checked once we know what is being declared, as for a
23578 member template the checks must be performed in the scope of the
23579 class containing the member. */
23580 checks = get_deferred_access_checks ();
23582 /* Look for the `>'. */
23583 cp_parser_skip_to_end_of_template_parameter_list (parser);
23584 /* We just processed one more parameter list. */
23585 ++parser->num_template_parameter_lists;
23586 /* If the next token is `template', there are more template
23588 if (cp_lexer_next_token_is_keyword (parser->lexer,
23590 cp_parser_template_declaration_after_export (parser, member_p);
23591 else if (cxx_dialect >= cxx11
23592 && cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
23593 decl = cp_parser_alias_declaration (parser);
23596 /* There are no access checks when parsing a template, as we do not
23597 know if a specialization will be a friend. */
23598 push_deferring_access_checks (dk_no_check);
23599 token = cp_lexer_peek_token (parser->lexer);
23600 decl = cp_parser_single_declaration (parser,
23603 /*explicit_specialization_p=*/false,
23605 pop_deferring_access_checks ();
23607 /* If this is a member template declaration, let the front
23609 if (member_p && !friend_p && decl)
23611 if (TREE_CODE (decl) == TYPE_DECL)
23612 cp_parser_check_access_in_redeclaration (decl, token->location);
23614 decl = finish_member_template_decl (decl);
23616 else if (friend_p && decl
23617 && DECL_DECLARES_TYPE_P (decl))
23618 make_friend_class (current_class_type, TREE_TYPE (decl),
23619 /*complain=*/true);
23621 /* We are done with the current parameter list. */
23622 --parser->num_template_parameter_lists;
23624 pop_deferring_access_checks ();
23627 finish_template_decl (parameter_list);
23629 /* Check the template arguments for a literal operator template. */
23631 && DECL_DECLARES_FUNCTION_P (decl)
23632 && UDLIT_OPER_P (DECL_NAME (decl)))
23635 if (parameter_list == NULL_TREE)
23639 int num_parms = TREE_VEC_LENGTH (parameter_list);
23640 if (num_parms == 1)
23642 tree parm_list = TREE_VEC_ELT (parameter_list, 0);
23643 tree parm = INNERMOST_TEMPLATE_PARMS (parm_list);
23644 if (TREE_TYPE (parm) != char_type_node
23645 || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
23648 else if (num_parms == 2 && cxx_dialect >= cxx14)
23650 tree parm_type = TREE_VEC_ELT (parameter_list, 0);
23651 tree type = INNERMOST_TEMPLATE_PARMS (parm_type);
23652 tree parm_list = TREE_VEC_ELT (parameter_list, 1);
23653 tree parm = INNERMOST_TEMPLATE_PARMS (parm_list);
23654 if (TREE_TYPE (parm) != TREE_TYPE (type)
23655 || !TEMPLATE_PARM_PARAMETER_PACK (DECL_INITIAL (parm)))
23663 if (cxx_dialect >= cxx14)
23664 error ("literal operator template %qD has invalid parameter list."
23665 " Expected non-type template argument pack <char...>"
23666 " or <typename CharT, CharT...>",
23669 error ("literal operator template %qD has invalid parameter list."
23670 " Expected non-type template argument pack <char...>",
23674 /* Register member declarations. */
23675 if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl))
23676 finish_member_declaration (decl);
23677 /* For the erroneous case of a template with C linkage, we pushed an
23678 implicit C++ linkage scope; exit that scope now. */
23680 pop_lang_context ();
23681 /* If DECL is a function template, we must return to parse it later.
23682 (Even though there is no definition, there might be default
23683 arguments that need handling.) */
23684 if (member_p && decl
23685 && DECL_DECLARES_FUNCTION_P (decl))
23686 vec_safe_push (unparsed_funs_with_definitions, decl);
23689 /* Perform the deferred access checks from a template-parameter-list.
23690 CHECKS is a TREE_LIST of access checks, as returned by
23691 get_deferred_access_checks. */
23694 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
23696 ++processing_template_parmlist;
23697 perform_access_checks (checks, tf_warning_or_error);
23698 --processing_template_parmlist;
23701 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
23702 `function-definition' sequence that follows a template header.
23703 If MEMBER_P is true, this declaration appears in a class scope.
23705 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
23706 *FRIEND_P is set to TRUE iff the declaration is a friend. */
23709 cp_parser_single_declaration (cp_parser* parser,
23710 vec<deferred_access_check, va_gc> *checks,
23712 bool explicit_specialization_p,
23715 int declares_class_or_enum;
23716 tree decl = NULL_TREE;
23717 cp_decl_specifier_seq decl_specifiers;
23718 bool function_definition_p = false;
23719 cp_token *decl_spec_token_start;
23721 /* This function is only used when processing a template
23723 gcc_assert (innermost_scope_kind () == sk_template_parms
23724 || innermost_scope_kind () == sk_template_spec);
23726 /* Defer access checks until we know what is being declared. */
23727 push_deferring_access_checks (dk_deferred);
23729 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
23731 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
23732 cp_parser_decl_specifier_seq (parser,
23733 CP_PARSER_FLAGS_OPTIONAL,
23735 &declares_class_or_enum);
23737 *friend_p = cp_parser_friend_p (&decl_specifiers);
23739 /* There are no template typedefs. */
23740 if (decl_spec_seq_has_spec_p (&decl_specifiers, ds_typedef))
23742 error_at (decl_spec_token_start->location,
23743 "template declaration of %<typedef%>");
23744 decl = error_mark_node;
23747 /* Gather up the access checks that occurred the
23748 decl-specifier-seq. */
23749 stop_deferring_access_checks ();
23751 /* Check for the declaration of a template class. */
23752 if (declares_class_or_enum)
23754 if (cp_parser_declares_only_class_p (parser))
23756 decl = shadow_tag (&decl_specifiers);
23761 friend template <typename T> struct A<T>::B;
23764 A<T>::B will be represented by a TYPENAME_TYPE, and
23765 therefore not recognized by shadow_tag. */
23766 if (friend_p && *friend_p
23768 && decl_specifiers.type
23769 && TYPE_P (decl_specifiers.type))
23770 decl = decl_specifiers.type;
23772 if (decl && decl != error_mark_node)
23773 decl = TYPE_NAME (decl);
23775 decl = error_mark_node;
23777 /* Perform access checks for template parameters. */
23778 cp_parser_perform_template_parameter_access_checks (checks);
23782 /* Complain about missing 'typename' or other invalid type names. */
23783 if (!decl_specifiers.any_type_specifiers_p
23784 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
23786 /* cp_parser_parse_and_diagnose_invalid_type_name calls
23787 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
23788 the rest of this declaration. */
23789 decl = error_mark_node;
23793 /* If it's not a template class, try for a template function. If
23794 the next token is a `;', then this declaration does not declare
23795 anything. But, if there were errors in the decl-specifiers, then
23796 the error might well have come from an attempted class-specifier.
23797 In that case, there's no need to warn about a missing declarator. */
23799 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
23800 || decl_specifiers.type != error_mark_node))
23802 decl = cp_parser_init_declarator (parser,
23805 /*function_definition_allowed_p=*/true,
23807 declares_class_or_enum,
23808 &function_definition_p,
23811 /* 7.1.1-1 [dcl.stc]
23813 A storage-class-specifier shall not be specified in an explicit
23814 specialization... */
23816 && explicit_specialization_p
23817 && decl_specifiers.storage_class != sc_none)
23819 error_at (decl_spec_token_start->location,
23820 "explicit template specialization cannot have a storage class");
23821 decl = error_mark_node;
23824 if (decl && VAR_P (decl))
23825 check_template_variable (decl);
23828 /* Look for a trailing `;' after the declaration. */
23829 if (!function_definition_p
23830 && (decl == error_mark_node
23831 || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON)))
23832 cp_parser_skip_to_end_of_block_or_statement (parser);
23835 pop_deferring_access_checks ();
23837 /* Clear any current qualification; whatever comes next is the start
23838 of something new. */
23839 parser->scope = NULL_TREE;
23840 parser->qualifying_scope = NULL_TREE;
23841 parser->object_scope = NULL_TREE;
23846 /* Parse a cast-expression that is not the operand of a unary "&". */
23849 cp_parser_simple_cast_expression (cp_parser *parser)
23851 return cp_parser_cast_expression (parser, /*address_p=*/false,
23852 /*cast_p=*/false, /*decltype*/false, NULL);
23855 /* Parse a functional cast to TYPE. Returns an expression
23856 representing the cast. */
23859 cp_parser_functional_cast (cp_parser* parser, tree type)
23861 vec<tree, va_gc> *vec;
23862 tree expression_list;
23867 type = error_mark_node;
23869 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
23871 cp_lexer_set_source_position (parser->lexer);
23872 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
23873 expression_list = cp_parser_braced_list (parser, &nonconst_p);
23874 CONSTRUCTOR_IS_DIRECT_INIT (expression_list) = 1;
23875 if (TREE_CODE (type) == TYPE_DECL)
23876 type = TREE_TYPE (type);
23877 return finish_compound_literal (type, expression_list,
23878 tf_warning_or_error);
23882 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
23884 /*allow_expansion_p=*/true,
23885 /*non_constant_p=*/NULL);
23887 expression_list = error_mark_node;
23890 expression_list = build_tree_list_vec (vec);
23891 release_tree_vector (vec);
23894 cast = build_functional_cast (type, expression_list,
23895 tf_warning_or_error);
23896 /* [expr.const]/1: In an integral constant expression "only type
23897 conversions to integral or enumeration type can be used". */
23898 if (TREE_CODE (type) == TYPE_DECL)
23899 type = TREE_TYPE (type);
23900 if (cast != error_mark_node
23901 && !cast_valid_in_integral_constant_expression_p (type)
23902 && cp_parser_non_integral_constant_expression (parser,
23904 return error_mark_node;
23908 /* Save the tokens that make up the body of a member function defined
23909 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
23910 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
23911 specifiers applied to the declaration. Returns the FUNCTION_DECL
23912 for the member function. */
23915 cp_parser_save_member_function_body (cp_parser* parser,
23916 cp_decl_specifier_seq *decl_specifiers,
23917 cp_declarator *declarator,
23924 /* Create the FUNCTION_DECL. */
23925 fn = grokmethod (decl_specifiers, declarator, attributes);
23926 cp_finalize_omp_declare_simd (parser, fn);
23927 /* If something went badly wrong, bail out now. */
23928 if (fn == error_mark_node)
23930 /* If there's a function-body, skip it. */
23931 if (cp_parser_token_starts_function_definition_p
23932 (cp_lexer_peek_token (parser->lexer)))
23933 cp_parser_skip_to_end_of_block_or_statement (parser);
23934 return error_mark_node;
23937 /* Remember it, if there default args to post process. */
23938 cp_parser_save_default_args (parser, fn);
23940 /* Save away the tokens that make up the body of the
23942 first = parser->lexer->next_token;
23943 /* Handle function try blocks. */
23944 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
23945 cp_lexer_consume_token (parser->lexer);
23946 /* We can have braced-init-list mem-initializers before the fn body. */
23947 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
23949 cp_lexer_consume_token (parser->lexer);
23950 while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
23952 /* cache_group will stop after an un-nested { } pair, too. */
23953 if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
23956 /* variadic mem-inits have ... after the ')'. */
23957 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
23958 cp_lexer_consume_token (parser->lexer);
23961 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
23962 /* Handle function try blocks. */
23963 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
23964 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
23965 last = parser->lexer->next_token;
23967 /* Save away the inline definition; we will process it when the
23968 class is complete. */
23969 DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last);
23970 DECL_PENDING_INLINE_P (fn) = 1;
23972 /* We need to know that this was defined in the class, so that
23973 friend templates are handled correctly. */
23974 DECL_INITIALIZED_IN_CLASS_P (fn) = 1;
23976 /* Add FN to the queue of functions to be parsed later. */
23977 vec_safe_push (unparsed_funs_with_definitions, fn);
23982 /* Save the tokens that make up the in-class initializer for a non-static
23983 data member. Returns a DEFAULT_ARG. */
23986 cp_parser_save_nsdmi (cp_parser* parser)
23988 return cp_parser_cache_defarg (parser, /*nsdmi=*/true);
23991 /* Parse a template-argument-list, as well as the trailing ">" (but
23992 not the opening "<"). See cp_parser_template_argument_list for the
23996 cp_parser_enclosed_template_argument_list (cp_parser* parser)
24000 tree saved_qualifying_scope;
24001 tree saved_object_scope;
24002 bool saved_greater_than_is_operator_p;
24003 int saved_unevaluated_operand;
24004 int saved_inhibit_evaluation_warnings;
24008 When parsing a template-id, the first non-nested `>' is taken as
24009 the end of the template-argument-list rather than a greater-than
24011 saved_greater_than_is_operator_p
24012 = parser->greater_than_is_operator_p;
24013 parser->greater_than_is_operator_p = false;
24014 /* Parsing the argument list may modify SCOPE, so we save it
24016 saved_scope = parser->scope;
24017 saved_qualifying_scope = parser->qualifying_scope;
24018 saved_object_scope = parser->object_scope;
24019 /* We need to evaluate the template arguments, even though this
24020 template-id may be nested within a "sizeof". */
24021 saved_unevaluated_operand = cp_unevaluated_operand;
24022 cp_unevaluated_operand = 0;
24023 saved_inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
24024 c_inhibit_evaluation_warnings = 0;
24025 /* Parse the template-argument-list itself. */
24026 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
24027 || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
24028 arguments = NULL_TREE;
24030 arguments = cp_parser_template_argument_list (parser);
24031 /* Look for the `>' that ends the template-argument-list. If we find
24032 a '>>' instead, it's probably just a typo. */
24033 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
24035 if (cxx_dialect != cxx98)
24037 /* In C++0x, a `>>' in a template argument list or cast
24038 expression is considered to be two separate `>'
24039 tokens. So, change the current token to a `>', but don't
24040 consume it: it will be consumed later when the outer
24041 template argument list (or cast expression) is parsed.
24042 Note that this replacement of `>' for `>>' is necessary
24043 even if we are parsing tentatively: in the tentative
24044 case, after calling
24045 cp_parser_enclosed_template_argument_list we will always
24046 throw away all of the template arguments and the first
24047 closing `>', either because the template argument list
24048 was erroneous or because we are replacing those tokens
24049 with a CPP_TEMPLATE_ID token. The second `>' (which will
24050 not have been thrown away) is needed either to close an
24051 outer template argument list or to complete a new-style
24053 cp_token *token = cp_lexer_peek_token (parser->lexer);
24054 token->type = CPP_GREATER;
24056 else if (!saved_greater_than_is_operator_p)
24058 /* If we're in a nested template argument list, the '>>' has
24059 to be a typo for '> >'. We emit the error message, but we
24060 continue parsing and we push a '>' as next token, so that
24061 the argument list will be parsed correctly. Note that the
24062 global source location is still on the token before the
24063 '>>', so we need to say explicitly where we want it. */
24064 cp_token *token = cp_lexer_peek_token (parser->lexer);
24065 error_at (token->location, "%<>>%> should be %<> >%> "
24066 "within a nested template argument list");
24068 token->type = CPP_GREATER;
24072 /* If this is not a nested template argument list, the '>>'
24073 is a typo for '>'. Emit an error message and continue.
24074 Same deal about the token location, but here we can get it
24075 right by consuming the '>>' before issuing the diagnostic. */
24076 cp_token *token = cp_lexer_consume_token (parser->lexer);
24077 error_at (token->location,
24078 "spurious %<>>%>, use %<>%> to terminate "
24079 "a template argument list");
24083 cp_parser_skip_to_end_of_template_parameter_list (parser);
24084 /* The `>' token might be a greater-than operator again now. */
24085 parser->greater_than_is_operator_p
24086 = saved_greater_than_is_operator_p;
24087 /* Restore the SAVED_SCOPE. */
24088 parser->scope = saved_scope;
24089 parser->qualifying_scope = saved_qualifying_scope;
24090 parser->object_scope = saved_object_scope;
24091 cp_unevaluated_operand = saved_unevaluated_operand;
24092 c_inhibit_evaluation_warnings = saved_inhibit_evaluation_warnings;
24097 /* MEMBER_FUNCTION is a member function, or a friend. If default
24098 arguments, or the body of the function have not yet been parsed,
24102 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
24104 timevar_push (TV_PARSE_INMETH);
24105 /* If this member is a template, get the underlying
24107 if (DECL_FUNCTION_TEMPLATE_P (member_function))
24108 member_function = DECL_TEMPLATE_RESULT (member_function);
24110 /* There should not be any class definitions in progress at this
24111 point; the bodies of members are only parsed outside of all class
24113 gcc_assert (parser->num_classes_being_defined == 0);
24114 /* While we're parsing the member functions we might encounter more
24115 classes. We want to handle them right away, but we don't want
24116 them getting mixed up with functions that are currently in the
24118 push_unparsed_function_queues (parser);
24120 /* Make sure that any template parameters are in scope. */
24121 maybe_begin_member_template_processing (member_function);
24123 /* If the body of the function has not yet been parsed, parse it
24125 if (DECL_PENDING_INLINE_P (member_function))
24127 tree function_scope;
24128 cp_token_cache *tokens;
24130 /* The function is no longer pending; we are processing it. */
24131 tokens = DECL_PENDING_INLINE_INFO (member_function);
24132 DECL_PENDING_INLINE_INFO (member_function) = NULL;
24133 DECL_PENDING_INLINE_P (member_function) = 0;
24135 /* If this is a local class, enter the scope of the containing
24137 function_scope = current_function_decl;
24138 if (function_scope)
24139 push_function_context ();
24141 /* Push the body of the function onto the lexer stack. */
24142 cp_parser_push_lexer_for_tokens (parser, tokens);
24144 /* Let the front end know that we going to be defining this
24146 start_preparsed_function (member_function, NULL_TREE,
24147 SF_PRE_PARSED | SF_INCLASS_INLINE);
24149 /* Don't do access checking if it is a templated function. */
24150 if (processing_template_decl)
24151 push_deferring_access_checks (dk_no_check);
24153 /* #pragma omp declare reduction needs special parsing. */
24154 if (DECL_OMP_DECLARE_REDUCTION_P (member_function))
24156 parser->lexer->in_pragma = true;
24157 cp_parser_omp_declare_reduction_exprs (member_function, parser);
24158 finish_function (/*inline*/2);
24159 cp_check_omp_declare_reduction (member_function);
24162 /* Now, parse the body of the function. */
24163 cp_parser_function_definition_after_declarator (parser,
24164 /*inline_p=*/true);
24166 if (processing_template_decl)
24167 pop_deferring_access_checks ();
24169 /* Leave the scope of the containing function. */
24170 if (function_scope)
24171 pop_function_context ();
24172 cp_parser_pop_lexer (parser);
24175 /* Remove any template parameters from the symbol table. */
24176 maybe_end_member_template_processing ();
24178 /* Restore the queue. */
24179 pop_unparsed_function_queues (parser);
24180 timevar_pop (TV_PARSE_INMETH);
24183 /* If DECL contains any default args, remember it on the unparsed
24184 functions queue. */
24187 cp_parser_save_default_args (cp_parser* parser, tree decl)
24191 for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl));
24193 probe = TREE_CHAIN (probe))
24194 if (TREE_PURPOSE (probe))
24196 cp_default_arg_entry entry = {current_class_type, decl};
24197 vec_safe_push (unparsed_funs_with_default_args, entry);
24202 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
24203 which is either a FIELD_DECL or PARM_DECL. Parse it and return
24204 the result. For a PARM_DECL, PARMTYPE is the corresponding type
24205 from the parameter-type-list. */
24208 cp_parser_late_parse_one_default_arg (cp_parser *parser, tree decl,
24209 tree default_arg, tree parmtype)
24211 cp_token_cache *tokens;
24215 if (default_arg == error_mark_node)
24216 return error_mark_node;
24218 /* Push the saved tokens for the default argument onto the parser's
24220 tokens = DEFARG_TOKENS (default_arg);
24221 cp_parser_push_lexer_for_tokens (parser, tokens);
24223 start_lambda_scope (decl);
24225 /* Parse the default argument. */
24226 parsed_arg = cp_parser_initializer (parser, &dummy, &dummy);
24227 if (BRACE_ENCLOSED_INITIALIZER_P (parsed_arg))
24228 maybe_warn_cpp0x (CPP0X_INITIALIZER_LISTS);
24230 finish_lambda_scope ();
24232 if (parsed_arg == error_mark_node)
24233 cp_parser_skip_to_end_of_statement (parser);
24235 if (!processing_template_decl)
24237 /* In a non-template class, check conversions now. In a template,
24238 we'll wait and instantiate these as needed. */
24239 if (TREE_CODE (decl) == PARM_DECL)
24240 parsed_arg = check_default_argument (parmtype, parsed_arg,
24241 tf_warning_or_error);
24243 parsed_arg = digest_nsdmi_init (decl, parsed_arg);
24246 /* If the token stream has not been completely used up, then
24247 there was extra junk after the end of the default
24249 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
24251 if (TREE_CODE (decl) == PARM_DECL)
24252 cp_parser_error (parser, "expected %<,%>");
24254 cp_parser_error (parser, "expected %<;%>");
24257 /* Revert to the main lexer. */
24258 cp_parser_pop_lexer (parser);
24263 /* FIELD is a non-static data member with an initializer which we saved for
24264 later; parse it now. */
24267 cp_parser_late_parsing_nsdmi (cp_parser *parser, tree field)
24271 maybe_begin_member_template_processing (field);
24273 push_unparsed_function_queues (parser);
24274 def = cp_parser_late_parse_one_default_arg (parser, field,
24275 DECL_INITIAL (field),
24277 pop_unparsed_function_queues (parser);
24279 maybe_end_member_template_processing ();
24281 DECL_INITIAL (field) = def;
24284 /* FN is a FUNCTION_DECL which may contains a parameter with an
24285 unparsed DEFAULT_ARG. Parse the default args now. This function
24286 assumes that the current scope is the scope in which the default
24287 argument should be processed. */
24290 cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
24292 bool saved_local_variables_forbidden_p;
24293 tree parm, parmdecl;
24295 /* While we're parsing the default args, we might (due to the
24296 statement expression extension) encounter more classes. We want
24297 to handle them right away, but we don't want them getting mixed
24298 up with default args that are currently in the queue. */
24299 push_unparsed_function_queues (parser);
24301 /* Local variable names (and the `this' keyword) may not appear
24302 in a default argument. */
24303 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
24304 parser->local_variables_forbidden_p = true;
24306 push_defarg_context (fn);
24308 for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn)),
24309 parmdecl = DECL_ARGUMENTS (fn);
24310 parm && parm != void_list_node;
24311 parm = TREE_CHAIN (parm),
24312 parmdecl = DECL_CHAIN (parmdecl))
24314 tree default_arg = TREE_PURPOSE (parm);
24316 vec<tree, va_gc> *insts;
24323 if (TREE_CODE (default_arg) != DEFAULT_ARG)
24324 /* This can happen for a friend declaration for a function
24325 already declared with default arguments. */
24329 = cp_parser_late_parse_one_default_arg (parser, parmdecl,
24331 TREE_VALUE (parm));
24332 if (parsed_arg == error_mark_node)
24337 TREE_PURPOSE (parm) = parsed_arg;
24339 /* Update any instantiations we've already created. */
24340 for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0;
24341 vec_safe_iterate (insts, ix, ©); ix++)
24342 TREE_PURPOSE (copy) = parsed_arg;
24345 pop_defarg_context ();
24347 /* Make sure no default arg is missing. */
24348 check_default_args (fn);
24350 /* Restore the state of local_variables_forbidden_p. */
24351 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
24353 /* Restore the queue. */
24354 pop_unparsed_function_queues (parser);
24357 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
24359 sizeof ... ( identifier )
24361 where the 'sizeof' token has already been consumed. */
24364 cp_parser_sizeof_pack (cp_parser *parser)
24366 /* Consume the `...'. */
24367 cp_lexer_consume_token (parser->lexer);
24368 maybe_warn_variadic_templates ();
24370 bool paren = cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN);
24372 cp_lexer_consume_token (parser->lexer);
24374 permerror (cp_lexer_peek_token (parser->lexer)->location,
24375 "%<sizeof...%> argument must be surrounded by parentheses");
24377 cp_token *token = cp_lexer_peek_token (parser->lexer);
24378 tree name = cp_parser_identifier (parser);
24379 if (name == error_mark_node)
24380 return error_mark_node;
24381 /* The name is not qualified. */
24382 parser->scope = NULL_TREE;
24383 parser->qualifying_scope = NULL_TREE;
24384 parser->object_scope = NULL_TREE;
24385 tree expr = cp_parser_lookup_name_simple (parser, name, token->location);
24386 if (expr == error_mark_node)
24387 cp_parser_name_lookup_error (parser, name, expr, NLE_NULL,
24389 if (TREE_CODE (expr) == TYPE_DECL)
24390 expr = TREE_TYPE (expr);
24391 else if (TREE_CODE (expr) == CONST_DECL)
24392 expr = DECL_INITIAL (expr);
24393 expr = make_pack_expansion (expr);
24396 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
24401 /* Parse the operand of `sizeof' (or a similar operator). Returns
24402 either a TYPE or an expression, depending on the form of the
24403 input. The KEYWORD indicates which kind of expression we have
24407 cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
24409 tree expr = NULL_TREE;
24410 const char *saved_message;
24412 bool saved_integral_constant_expression_p;
24413 bool saved_non_integral_constant_expression_p;
24415 /* If it's a `...', then we are computing the length of a parameter
24417 if (keyword == RID_SIZEOF
24418 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
24419 return cp_parser_sizeof_pack (parser);
24421 /* Types cannot be defined in a `sizeof' expression. Save away the
24423 saved_message = parser->type_definition_forbidden_message;
24424 /* And create the new one. */
24425 tmp = concat ("types may not be defined in %<",
24426 IDENTIFIER_POINTER (ridpointers[keyword]),
24427 "%> expressions", NULL);
24428 parser->type_definition_forbidden_message = tmp;
24430 /* The restrictions on constant-expressions do not apply inside
24431 sizeof expressions. */
24432 saved_integral_constant_expression_p
24433 = parser->integral_constant_expression_p;
24434 saved_non_integral_constant_expression_p
24435 = parser->non_integral_constant_expression_p;
24436 parser->integral_constant_expression_p = false;
24438 /* Do not actually evaluate the expression. */
24439 ++cp_unevaluated_operand;
24440 ++c_inhibit_evaluation_warnings;
24441 /* If it's a `(', then we might be looking at the type-id
24443 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
24445 tree type = NULL_TREE;
24447 /* We can't be sure yet whether we're looking at a type-id or an
24449 cp_parser_parse_tentatively (parser);
24450 /* Note: as a GNU Extension, compound literals are considered
24451 postfix-expressions as they are in C99, so they are valid
24452 arguments to sizeof. See comment in cp_parser_cast_expression
24454 if (cp_parser_compound_literal_p (parser))
24455 cp_parser_simulate_error (parser);
24458 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
24459 parser->in_type_id_in_expr_p = true;
24460 /* Look for the type-id. */
24461 type = cp_parser_type_id (parser);
24462 /* Look for the closing `)'. */
24463 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
24464 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
24467 /* If all went well, then we're done. */
24468 if (cp_parser_parse_definitely (parser))
24470 cp_decl_specifier_seq decl_specs;
24472 /* Build a trivial decl-specifier-seq. */
24473 clear_decl_specs (&decl_specs);
24474 decl_specs.type = type;
24476 /* Call grokdeclarator to figure out what type this is. */
24477 expr = grokdeclarator (NULL,
24481 /*attrlist=*/NULL);
24485 /* If the type-id production did not work out, then we must be
24486 looking at the unary-expression production. */
24488 expr = cp_parser_unary_expression (parser);
24490 /* Go back to evaluating expressions. */
24491 --cp_unevaluated_operand;
24492 --c_inhibit_evaluation_warnings;
24494 /* Free the message we created. */
24496 /* And restore the old one. */
24497 parser->type_definition_forbidden_message = saved_message;
24498 parser->integral_constant_expression_p
24499 = saved_integral_constant_expression_p;
24500 parser->non_integral_constant_expression_p
24501 = saved_non_integral_constant_expression_p;
24506 /* If the current declaration has no declarator, return true. */
24509 cp_parser_declares_only_class_p (cp_parser *parser)
24511 /* If the next token is a `;' or a `,' then there is no
24513 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
24514 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
24517 /* Update the DECL_SPECS to reflect the storage class indicated by
24521 cp_parser_set_storage_class (cp_parser *parser,
24522 cp_decl_specifier_seq *decl_specs,
24526 cp_storage_class storage_class;
24528 if (parser->in_unbraced_linkage_specification_p)
24530 error_at (token->location, "invalid use of %qD in linkage specification",
24531 ridpointers[keyword]);
24534 else if (decl_specs->storage_class != sc_none)
24536 decl_specs->conflicting_specifiers_p = true;
24540 if ((keyword == RID_EXTERN || keyword == RID_STATIC)
24541 && decl_spec_seq_has_spec_p (decl_specs, ds_thread)
24542 && decl_specs->gnu_thread_keyword_p)
24544 pedwarn (decl_specs->locations[ds_thread], 0,
24545 "%<__thread%> before %qD", ridpointers[keyword]);
24551 storage_class = sc_auto;
24554 storage_class = sc_register;
24557 storage_class = sc_static;
24560 storage_class = sc_extern;
24563 storage_class = sc_mutable;
24566 gcc_unreachable ();
24568 decl_specs->storage_class = storage_class;
24569 set_and_check_decl_spec_loc (decl_specs, ds_storage_class, token);
24571 /* A storage class specifier cannot be applied alongside a typedef
24572 specifier. If there is a typedef specifier present then set
24573 conflicting_specifiers_p which will trigger an error later
24574 on in grokdeclarator. */
24575 if (decl_spec_seq_has_spec_p (decl_specs, ds_typedef))
24576 decl_specs->conflicting_specifiers_p = true;
24579 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
24580 is true, the type is a class or enum definition. */
24583 cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs,
24586 bool type_definition_p)
24588 decl_specs->any_specifiers_p = true;
24590 /* If the user tries to redeclare bool, char16_t, char32_t, or wchar_t
24591 (with, for example, in "typedef int wchar_t;") we remember that
24592 this is what happened. In system headers, we ignore these
24593 declarations so that G++ can work with system headers that are not
24595 if (decl_spec_seq_has_spec_p (decl_specs, ds_typedef)
24596 && !type_definition_p
24597 && (type_spec == boolean_type_node
24598 || type_spec == char16_type_node
24599 || type_spec == char32_type_node
24600 || type_spec == wchar_type_node)
24601 && (decl_specs->type
24602 || decl_spec_seq_has_spec_p (decl_specs, ds_long)
24603 || decl_spec_seq_has_spec_p (decl_specs, ds_short)
24604 || decl_spec_seq_has_spec_p (decl_specs, ds_unsigned)
24605 || decl_spec_seq_has_spec_p (decl_specs, ds_signed)))
24607 decl_specs->redefined_builtin_type = type_spec;
24608 set_and_check_decl_spec_loc (decl_specs,
24609 ds_redefined_builtin_type_spec,
24611 if (!decl_specs->type)
24613 decl_specs->type = type_spec;
24614 decl_specs->type_definition_p = false;
24615 set_and_check_decl_spec_loc (decl_specs,ds_type_spec, token);
24618 else if (decl_specs->type)
24619 decl_specs->multiple_types_p = true;
24622 decl_specs->type = type_spec;
24623 decl_specs->type_definition_p = type_definition_p;
24624 decl_specs->redefined_builtin_type = NULL_TREE;
24625 set_and_check_decl_spec_loc (decl_specs, ds_type_spec, token);
24629 /* True iff TOKEN is the GNU keyword __thread. */
24632 token_is__thread (cp_token *token)
24634 gcc_assert (token->keyword == RID_THREAD);
24635 return !strcmp (IDENTIFIER_POINTER (token->u.value), "__thread");
24638 /* Set the location for a declarator specifier and check if it is
24641 DECL_SPECS is the sequence of declarator specifiers onto which to
24644 DS is the single declarator specifier to set which location is to
24645 be set onto the existing sequence of declarators.
24647 LOCATION is the location for the declarator specifier to
24651 set_and_check_decl_spec_loc (cp_decl_specifier_seq *decl_specs,
24652 cp_decl_spec ds, cp_token *token)
24654 gcc_assert (ds < ds_last);
24656 if (decl_specs == NULL)
24659 source_location location = token->location;
24661 if (decl_specs->locations[ds] == 0)
24663 decl_specs->locations[ds] = location;
24664 if (ds == ds_thread)
24665 decl_specs->gnu_thread_keyword_p = token_is__thread (token);
24671 if (decl_specs->locations[ds_long_long] != 0)
24672 error_at (location,
24673 "%<long long long%> is too long for GCC");
24676 decl_specs->locations[ds_long_long] = location;
24677 pedwarn_cxx98 (location,
24679 "ISO C++ 1998 does not support %<long long%>");
24682 else if (ds == ds_thread)
24684 bool gnu = token_is__thread (token);
24685 if (gnu != decl_specs->gnu_thread_keyword_p)
24686 error_at (location,
24687 "both %<__thread%> and %<thread_local%> specified");
24689 error_at (location, "duplicate %qD", token->u.value);
24693 static const char *const decl_spec_names[] = {
24710 error_at (location,
24711 "duplicate %qs", decl_spec_names[ds]);
24716 /* Return true iff the declarator specifier DS is present in the
24717 sequence of declarator specifiers DECL_SPECS. */
24720 decl_spec_seq_has_spec_p (const cp_decl_specifier_seq * decl_specs,
24723 gcc_assert (ds < ds_last);
24725 if (decl_specs == NULL)
24728 return decl_specs->locations[ds] != 0;
24731 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
24732 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
24735 cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers)
24737 return decl_spec_seq_has_spec_p (decl_specifiers, ds_friend);
24740 /* Issue an error message indicating that TOKEN_DESC was expected.
24741 If KEYWORD is true, it indicated this function is called by
24742 cp_parser_require_keword and the required token can only be
24743 a indicated keyword. */
24746 cp_parser_required_error (cp_parser *parser,
24747 required_token token_desc,
24750 switch (token_desc)
24753 cp_parser_error (parser, "expected %<new%>");
24756 cp_parser_error (parser, "expected %<delete%>");
24759 cp_parser_error (parser, "expected %<return%>");
24762 cp_parser_error (parser, "expected %<while%>");
24765 cp_parser_error (parser, "expected %<extern%>");
24767 case RT_STATIC_ASSERT:
24768 cp_parser_error (parser, "expected %<static_assert%>");
24771 cp_parser_error (parser, "expected %<decltype%>");
24774 cp_parser_error (parser, "expected %<operator%>");
24777 cp_parser_error (parser, "expected %<class%>");
24780 cp_parser_error (parser, "expected %<template%>");
24783 cp_parser_error (parser, "expected %<namespace%>");
24786 cp_parser_error (parser, "expected %<using%>");
24789 cp_parser_error (parser, "expected %<asm%>");
24792 cp_parser_error (parser, "expected %<try%>");
24795 cp_parser_error (parser, "expected %<catch%>");
24798 cp_parser_error (parser, "expected %<throw%>");
24801 cp_parser_error (parser, "expected %<__label__%>");
24804 cp_parser_error (parser, "expected %<@try%>");
24806 case RT_AT_SYNCHRONIZED:
24807 cp_parser_error (parser, "expected %<@synchronized%>");
24810 cp_parser_error (parser, "expected %<@throw%>");
24812 case RT_TRANSACTION_ATOMIC:
24813 cp_parser_error (parser, "expected %<__transaction_atomic%>");
24815 case RT_TRANSACTION_RELAXED:
24816 cp_parser_error (parser, "expected %<__transaction_relaxed%>");
24823 switch (token_desc)
24826 cp_parser_error (parser, "expected %<;%>");
24828 case RT_OPEN_PAREN:
24829 cp_parser_error (parser, "expected %<(%>");
24831 case RT_CLOSE_BRACE:
24832 cp_parser_error (parser, "expected %<}%>");
24834 case RT_OPEN_BRACE:
24835 cp_parser_error (parser, "expected %<{%>");
24837 case RT_CLOSE_SQUARE:
24838 cp_parser_error (parser, "expected %<]%>");
24840 case RT_OPEN_SQUARE:
24841 cp_parser_error (parser, "expected %<[%>");
24844 cp_parser_error (parser, "expected %<,%>");
24847 cp_parser_error (parser, "expected %<::%>");
24850 cp_parser_error (parser, "expected %<<%>");
24853 cp_parser_error (parser, "expected %<>%>");
24856 cp_parser_error (parser, "expected %<=%>");
24859 cp_parser_error (parser, "expected %<...%>");
24862 cp_parser_error (parser, "expected %<*%>");
24865 cp_parser_error (parser, "expected %<~%>");
24868 cp_parser_error (parser, "expected %<:%>");
24870 case RT_COLON_SCOPE:
24871 cp_parser_error (parser, "expected %<:%> or %<::%>");
24873 case RT_CLOSE_PAREN:
24874 cp_parser_error (parser, "expected %<)%>");
24876 case RT_COMMA_CLOSE_PAREN:
24877 cp_parser_error (parser, "expected %<,%> or %<)%>");
24879 case RT_PRAGMA_EOL:
24880 cp_parser_error (parser, "expected end of line");
24883 cp_parser_error (parser, "expected identifier");
24886 cp_parser_error (parser, "expected selection-statement");
24888 case RT_INTERATION:
24889 cp_parser_error (parser, "expected iteration-statement");
24892 cp_parser_error (parser, "expected jump-statement");
24895 cp_parser_error (parser, "expected class-key");
24897 case RT_CLASS_TYPENAME_TEMPLATE:
24898 cp_parser_error (parser,
24899 "expected %<class%>, %<typename%>, or %<template%>");
24902 gcc_unreachable ();
24906 gcc_unreachable ();
24911 /* If the next token is of the indicated TYPE, consume it. Otherwise,
24912 issue an error message indicating that TOKEN_DESC was expected.
24914 Returns the token consumed, if the token had the appropriate type.
24915 Otherwise, returns NULL. */
24918 cp_parser_require (cp_parser* parser,
24919 enum cpp_ttype type,
24920 required_token token_desc)
24922 if (cp_lexer_next_token_is (parser->lexer, type))
24923 return cp_lexer_consume_token (parser->lexer);
24926 /* Output the MESSAGE -- unless we're parsing tentatively. */
24927 if (!cp_parser_simulate_error (parser))
24928 cp_parser_required_error (parser, token_desc, /*keyword=*/false);
24933 /* An error message is produced if the next token is not '>'.
24934 All further tokens are skipped until the desired token is
24935 found or '{', '}', ';' or an unbalanced ')' or ']'. */
24938 cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
24940 /* Current level of '< ... >'. */
24941 unsigned level = 0;
24942 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
24943 unsigned nesting_depth = 0;
24945 /* Are we ready, yet? If not, issue error message. */
24946 if (cp_parser_require (parser, CPP_GREATER, RT_GREATER))
24949 /* Skip tokens until the desired token is found. */
24952 /* Peek at the next token. */
24953 switch (cp_lexer_peek_token (parser->lexer)->type)
24956 if (!nesting_depth)
24961 if (cxx_dialect == cxx98)
24962 /* C++0x views the `>>' operator as two `>' tokens, but
24965 else if (!nesting_depth && level-- == 0)
24967 /* We've hit a `>>' where the first `>' closes the
24968 template argument list, and the second `>' is
24969 spurious. Just consume the `>>' and stop; we've
24970 already produced at least one error. */
24971 cp_lexer_consume_token (parser->lexer);
24974 /* Fall through for C++0x, so we handle the second `>' in
24978 if (!nesting_depth && level-- == 0)
24980 /* We've reached the token we want, consume it and stop. */
24981 cp_lexer_consume_token (parser->lexer);
24986 case CPP_OPEN_PAREN:
24987 case CPP_OPEN_SQUARE:
24991 case CPP_CLOSE_PAREN:
24992 case CPP_CLOSE_SQUARE:
24993 if (nesting_depth-- == 0)
24998 case CPP_PRAGMA_EOL:
24999 case CPP_SEMICOLON:
25000 case CPP_OPEN_BRACE:
25001 case CPP_CLOSE_BRACE:
25002 /* The '>' was probably forgotten, don't look further. */
25009 /* Consume this token. */
25010 cp_lexer_consume_token (parser->lexer);
25014 /* If the next token is the indicated keyword, consume it. Otherwise,
25015 issue an error message indicating that TOKEN_DESC was expected.
25017 Returns the token consumed, if the token had the appropriate type.
25018 Otherwise, returns NULL. */
25021 cp_parser_require_keyword (cp_parser* parser,
25023 required_token token_desc)
25025 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
25027 if (token && token->keyword != keyword)
25029 cp_parser_required_error (parser, token_desc, /*keyword=*/true);
25036 /* Returns TRUE iff TOKEN is a token that can begin the body of a
25037 function-definition. */
25040 cp_parser_token_starts_function_definition_p (cp_token* token)
25042 return (/* An ordinary function-body begins with an `{'. */
25043 token->type == CPP_OPEN_BRACE
25044 /* A ctor-initializer begins with a `:'. */
25045 || token->type == CPP_COLON
25046 /* A function-try-block begins with `try'. */
25047 || token->keyword == RID_TRY
25048 /* A function-transaction-block begins with `__transaction_atomic'
25049 or `__transaction_relaxed'. */
25050 || token->keyword == RID_TRANSACTION_ATOMIC
25051 || token->keyword == RID_TRANSACTION_RELAXED
25052 /* The named return value extension begins with `return'. */
25053 || token->keyword == RID_RETURN);
25056 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
25060 cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
25064 token = cp_lexer_peek_token (parser->lexer);
25065 return (token->type == CPP_OPEN_BRACE
25066 || (token->type == CPP_COLON
25067 && !parser->colon_doesnt_start_class_def_p));
25070 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
25071 C++0x) ending a template-argument. */
25074 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
25078 token = cp_lexer_peek_token (parser->lexer);
25079 return (token->type == CPP_COMMA
25080 || token->type == CPP_GREATER
25081 || token->type == CPP_ELLIPSIS
25082 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT));
25085 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
25086 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
25089 cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
25094 token = cp_lexer_peek_nth_token (parser->lexer, n);
25095 if (token->type == CPP_LESS)
25097 /* Check for the sequence `<::' in the original code. It would be lexed as
25098 `[:', where `[' is a digraph, and there is no whitespace before
25100 if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH)
25103 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
25104 if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE))
25110 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
25111 or none_type otherwise. */
25113 static enum tag_types
25114 cp_parser_token_is_class_key (cp_token* token)
25116 switch (token->keyword)
25121 return record_type;
25130 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
25131 or none_type otherwise or if the token is null. */
25133 static enum tag_types
25134 cp_parser_token_is_type_parameter_key (cp_token* token)
25139 switch (token->keyword)
25144 return typename_type;
25151 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
25154 cp_parser_check_class_key (enum tag_types class_key, tree type)
25156 if (type == error_mark_node)
25158 if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type))
25160 if (permerror (input_location, "%qs tag used in naming %q#T",
25161 class_key == union_type ? "union"
25162 : class_key == record_type ? "struct" : "class",
25164 inform (DECL_SOURCE_LOCATION (TYPE_NAME (type)),
25165 "%q#T was previously declared here", type);
25169 /* Issue an error message if DECL is redeclared with different
25170 access than its original declaration [class.access.spec/3].
25171 This applies to nested classes and nested class templates.
25175 cp_parser_check_access_in_redeclaration (tree decl, location_t location)
25177 if (!decl || !CLASS_TYPE_P (TREE_TYPE (decl)))
25180 if ((TREE_PRIVATE (decl)
25181 != (current_access_specifier == access_private_node))
25182 || (TREE_PROTECTED (decl)
25183 != (current_access_specifier == access_protected_node)))
25184 error_at (location, "%qD redeclared with different access", decl);
25187 /* Look for the `template' keyword, as a syntactic disambiguator.
25188 Return TRUE iff it is present, in which case it will be
25192 cp_parser_optional_template_keyword (cp_parser *parser)
25194 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
25196 /* In C++98 the `template' keyword can only be used within templates;
25197 outside templates the parser can always figure out what is a
25198 template and what is not. In C++11, per the resolution of DR 468,
25199 `template' is allowed in cases where it is not strictly necessary. */
25200 if (!processing_template_decl
25201 && pedantic && cxx_dialect == cxx98)
25203 cp_token *token = cp_lexer_peek_token (parser->lexer);
25204 pedwarn (token->location, OPT_Wpedantic,
25205 "in C++98 %<template%> (as a disambiguator) is only "
25206 "allowed within templates");
25207 /* If this part of the token stream is rescanned, the same
25208 error message would be generated. So, we purge the token
25209 from the stream. */
25210 cp_lexer_purge_token (parser->lexer);
25215 /* Consume the `template' keyword. */
25216 cp_lexer_consume_token (parser->lexer);
25223 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
25224 set PARSER->SCOPE, and perform other related actions. */
25227 cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
25230 struct tree_check *check_value;
25231 deferred_access_check *chk;
25232 vec<deferred_access_check, va_gc> *checks;
25234 /* Get the stored value. */
25235 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
25236 /* Perform any access checks that were deferred. */
25237 checks = check_value->checks;
25240 FOR_EACH_VEC_SAFE_ELT (checks, i, chk)
25241 perform_or_defer_access_check (chk->binfo,
25243 chk->diag_decl, tf_warning_or_error);
25245 /* Set the scope from the stored value. */
25246 parser->scope = check_value->value;
25247 parser->qualifying_scope = check_value->qualifying_scope;
25248 parser->object_scope = NULL_TREE;
25251 /* Consume tokens up through a non-nested END token. Returns TRUE if we
25252 encounter the end of a block before what we were looking for. */
25255 cp_parser_cache_group (cp_parser *parser,
25256 enum cpp_ttype end,
25261 cp_token *token = cp_lexer_peek_token (parser->lexer);
25263 /* Abort a parenthesized expression if we encounter a semicolon. */
25264 if ((end == CPP_CLOSE_PAREN || depth == 0)
25265 && token->type == CPP_SEMICOLON)
25267 /* If we've reached the end of the file, stop. */
25268 if (token->type == CPP_EOF
25269 || (end != CPP_PRAGMA_EOL
25270 && token->type == CPP_PRAGMA_EOL))
25272 if (token->type == CPP_CLOSE_BRACE && depth == 0)
25273 /* We've hit the end of an enclosing block, so there's been some
25274 kind of syntax error. */
25277 /* Consume the token. */
25278 cp_lexer_consume_token (parser->lexer);
25279 /* See if it starts a new group. */
25280 if (token->type == CPP_OPEN_BRACE)
25282 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
25283 /* In theory this should probably check end == '}', but
25284 cp_parser_save_member_function_body needs it to exit
25285 after either '}' or ')' when called with ')'. */
25289 else if (token->type == CPP_OPEN_PAREN)
25291 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
25292 if (depth == 0 && end == CPP_CLOSE_PAREN)
25295 else if (token->type == CPP_PRAGMA)
25296 cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
25297 else if (token->type == end)
25302 /* Like above, for caching a default argument or NSDMI. Both of these are
25303 terminated by a non-nested comma, but it can be unclear whether or not a
25304 comma is nested in a template argument list unless we do more parsing.
25305 In order to handle this ambiguity, when we encounter a ',' after a '<'
25306 we try to parse what follows as a parameter-declaration-list (in the
25307 case of a default argument) or a member-declarator (in the case of an
25308 NSDMI). If that succeeds, then we stop caching. */
25311 cp_parser_cache_defarg (cp_parser *parser, bool nsdmi)
25313 unsigned depth = 0;
25314 int maybe_template_id = 0;
25315 cp_token *first_token;
25317 tree default_argument;
25319 /* Add tokens until we have processed the entire default
25320 argument. We add the range [first_token, token). */
25321 first_token = cp_lexer_peek_token (parser->lexer);
25322 if (first_token->type == CPP_OPEN_BRACE)
25324 /* For list-initialization, this is straightforward. */
25325 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
25326 token = cp_lexer_peek_token (parser->lexer);
25332 /* Peek at the next token. */
25333 token = cp_lexer_peek_token (parser->lexer);
25334 /* What we do depends on what token we have. */
25335 switch (token->type)
25337 /* In valid code, a default argument must be
25338 immediately followed by a `,' `)', or `...'. */
25340 if (depth == 0 && maybe_template_id)
25342 /* If we've seen a '<', we might be in a
25343 template-argument-list. Until Core issue 325 is
25344 resolved, we don't know how this situation ought
25345 to be handled, so try to DTRT. We check whether
25346 what comes after the comma is a valid parameter
25347 declaration list. If it is, then the comma ends
25348 the default argument; otherwise the default
25349 argument continues. */
25350 bool error = false;
25352 /* Set ITALP so cp_parser_parameter_declaration_list
25353 doesn't decide to commit to this parse. */
25354 bool saved_italp = parser->in_template_argument_list_p;
25355 parser->in_template_argument_list_p = true;
25357 cp_parser_parse_tentatively (parser);
25358 cp_lexer_consume_token (parser->lexer);
25362 int ctor_dtor_or_conv_p;
25363 cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
25364 &ctor_dtor_or_conv_p,
25365 /*parenthesized_p=*/NULL,
25367 /*friend_p=*/false);
25371 begin_scope (sk_function_parms, NULL_TREE);
25372 cp_parser_parameter_declaration_list (parser, &error);
25373 pop_bindings_and_leave_scope ();
25375 if (!cp_parser_error_occurred (parser) && !error)
25377 cp_parser_abort_tentative_parse (parser);
25379 parser->in_template_argument_list_p = saved_italp;
25382 case CPP_CLOSE_PAREN:
25384 /* If we run into a non-nested `;', `}', or `]',
25385 then the code is invalid -- but the default
25386 argument is certainly over. */
25387 case CPP_SEMICOLON:
25388 case CPP_CLOSE_BRACE:
25389 case CPP_CLOSE_SQUARE:
25391 /* Handle correctly int n = sizeof ... ( p ); */
25392 && token->type != CPP_ELLIPSIS)
25394 /* Update DEPTH, if necessary. */
25395 else if (token->type == CPP_CLOSE_PAREN
25396 || token->type == CPP_CLOSE_BRACE
25397 || token->type == CPP_CLOSE_SQUARE)
25401 case CPP_OPEN_PAREN:
25402 case CPP_OPEN_SQUARE:
25403 case CPP_OPEN_BRACE:
25409 /* This might be the comparison operator, or it might
25410 start a template argument list. */
25411 ++maybe_template_id;
25415 if (cxx_dialect == cxx98)
25417 /* Fall through for C++0x, which treats the `>>'
25418 operator like two `>' tokens in certain
25424 /* This might be an operator, or it might close a
25425 template argument list. But if a previous '<'
25426 started a template argument list, this will have
25427 closed it, so we can't be in one anymore. */
25428 maybe_template_id -= 1 + (token->type == CPP_RSHIFT);
25429 if (maybe_template_id < 0)
25430 maybe_template_id = 0;
25434 /* If we run out of tokens, issue an error message. */
25436 case CPP_PRAGMA_EOL:
25437 error_at (token->location, "file ends in default argument");
25443 /* In these cases, we should look for template-ids.
25444 For example, if the default argument is
25445 `X<int, double>()', we need to do name lookup to
25446 figure out whether or not `X' is a template; if
25447 so, the `,' does not end the default argument.
25449 That is not yet done. */
25456 /* If we've reached the end, stop. */
25460 /* Add the token to the token block. */
25461 token = cp_lexer_consume_token (parser->lexer);
25464 /* Create a DEFAULT_ARG to represent the unparsed default
25466 default_argument = make_node (DEFAULT_ARG);
25467 DEFARG_TOKENS (default_argument)
25468 = cp_token_cache_new (first_token, token);
25469 DEFARG_INSTANTIATIONS (default_argument) = NULL;
25471 return default_argument;
25474 /* Begin parsing tentatively. We always save tokens while parsing
25475 tentatively so that if the tentative parsing fails we can restore the
25479 cp_parser_parse_tentatively (cp_parser* parser)
25481 /* Enter a new parsing context. */
25482 parser->context = cp_parser_context_new (parser->context);
25483 /* Begin saving tokens. */
25484 cp_lexer_save_tokens (parser->lexer);
25485 /* In order to avoid repetitive access control error messages,
25486 access checks are queued up until we are no longer parsing
25488 push_deferring_access_checks (dk_deferred);
25491 /* Commit to the currently active tentative parse. */
25494 cp_parser_commit_to_tentative_parse (cp_parser* parser)
25496 cp_parser_context *context;
25499 /* Mark all of the levels as committed. */
25500 lexer = parser->lexer;
25501 for (context = parser->context; context->next; context = context->next)
25503 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
25505 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
25506 while (!cp_lexer_saving_tokens (lexer))
25507 lexer = lexer->next;
25508 cp_lexer_commit_tokens (lexer);
25512 /* Commit to the topmost currently active tentative parse.
25514 Note that this function shouldn't be called when there are
25515 irreversible side-effects while in a tentative state. For
25516 example, we shouldn't create a permanent entry in the symbol
25517 table, or issue an error message that might not apply if the
25518 tentative parse is aborted. */
25521 cp_parser_commit_to_topmost_tentative_parse (cp_parser* parser)
25523 cp_parser_context *context = parser->context;
25524 cp_lexer *lexer = parser->lexer;
25528 if (context->status == CP_PARSER_STATUS_KIND_COMMITTED)
25530 context->status = CP_PARSER_STATUS_KIND_COMMITTED;
25532 while (!cp_lexer_saving_tokens (lexer))
25533 lexer = lexer->next;
25534 cp_lexer_commit_tokens (lexer);
25538 /* Abort the currently active tentative parse. All consumed tokens
25539 will be rolled back, and no diagnostics will be issued. */
25542 cp_parser_abort_tentative_parse (cp_parser* parser)
25544 gcc_assert (parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED
25545 || errorcount > 0);
25546 cp_parser_simulate_error (parser);
25547 /* Now, pretend that we want to see if the construct was
25548 successfully parsed. */
25549 cp_parser_parse_definitely (parser);
25552 /* Stop parsing tentatively. If a parse error has occurred, restore the
25553 token stream. Otherwise, commit to the tokens we have consumed.
25554 Returns true if no error occurred; false otherwise. */
25557 cp_parser_parse_definitely (cp_parser* parser)
25559 bool error_occurred;
25560 cp_parser_context *context;
25562 /* Remember whether or not an error occurred, since we are about to
25563 destroy that information. */
25564 error_occurred = cp_parser_error_occurred (parser);
25565 /* Remove the topmost context from the stack. */
25566 context = parser->context;
25567 parser->context = context->next;
25568 /* If no parse errors occurred, commit to the tentative parse. */
25569 if (!error_occurred)
25571 /* Commit to the tokens read tentatively, unless that was
25573 if (context->status != CP_PARSER_STATUS_KIND_COMMITTED)
25574 cp_lexer_commit_tokens (parser->lexer);
25576 pop_to_parent_deferring_access_checks ();
25578 /* Otherwise, if errors occurred, roll back our state so that things
25579 are just as they were before we began the tentative parse. */
25582 cp_lexer_rollback_tokens (parser->lexer);
25583 pop_deferring_access_checks ();
25585 /* Add the context to the front of the free list. */
25586 context->next = cp_parser_context_free_list;
25587 cp_parser_context_free_list = context;
25589 return !error_occurred;
25592 /* Returns true if we are parsing tentatively and are not committed to
25593 this tentative parse. */
25596 cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
25598 return (cp_parser_parsing_tentatively (parser)
25599 && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
25602 /* Returns nonzero iff an error has occurred during the most recent
25603 tentative parse. */
25606 cp_parser_error_occurred (cp_parser* parser)
25608 return (cp_parser_parsing_tentatively (parser)
25609 && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
25612 /* Returns nonzero if GNU extensions are allowed. */
25615 cp_parser_allow_gnu_extensions_p (cp_parser* parser)
25617 return parser->allow_gnu_extensions_p;
25620 /* Objective-C++ Productions */
25623 /* Parse an Objective-C expression, which feeds into a primary-expression
25627 objc-message-expression
25628 objc-string-literal
25629 objc-encode-expression
25630 objc-protocol-expression
25631 objc-selector-expression
25633 Returns a tree representation of the expression. */
25636 cp_parser_objc_expression (cp_parser* parser)
25638 /* Try to figure out what kind of declaration is present. */
25639 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
25643 case CPP_OPEN_SQUARE:
25644 return cp_parser_objc_message_expression (parser);
25646 case CPP_OBJC_STRING:
25647 kwd = cp_lexer_consume_token (parser->lexer);
25648 return objc_build_string_object (kwd->u.value);
25651 switch (kwd->keyword)
25653 case RID_AT_ENCODE:
25654 return cp_parser_objc_encode_expression (parser);
25656 case RID_AT_PROTOCOL:
25657 return cp_parser_objc_protocol_expression (parser);
25659 case RID_AT_SELECTOR:
25660 return cp_parser_objc_selector_expression (parser);
25666 error_at (kwd->location,
25667 "misplaced %<@%D%> Objective-C++ construct",
25669 cp_parser_skip_to_end_of_block_or_statement (parser);
25672 return error_mark_node;
25675 /* Parse an Objective-C message expression.
25677 objc-message-expression:
25678 [ objc-message-receiver objc-message-args ]
25680 Returns a representation of an Objective-C message. */
25683 cp_parser_objc_message_expression (cp_parser* parser)
25685 tree receiver, messageargs;
25687 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
25688 receiver = cp_parser_objc_message_receiver (parser);
25689 messageargs = cp_parser_objc_message_args (parser);
25690 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
25692 return objc_build_message_expr (receiver, messageargs);
25695 /* Parse an objc-message-receiver.
25697 objc-message-receiver:
25699 simple-type-specifier
25701 Returns a representation of the type or expression. */
25704 cp_parser_objc_message_receiver (cp_parser* parser)
25708 /* An Objective-C message receiver may be either (1) a type
25709 or (2) an expression. */
25710 cp_parser_parse_tentatively (parser);
25711 rcv = cp_parser_expression (parser);
25713 /* If that worked out, fine. */
25714 if (cp_parser_parse_definitely (parser))
25717 cp_parser_parse_tentatively (parser);
25718 rcv = cp_parser_simple_type_specifier (parser,
25719 /*decl_specs=*/NULL,
25720 CP_PARSER_FLAGS_NONE);
25722 if (cp_parser_parse_definitely (parser))
25723 return objc_get_class_reference (rcv);
25725 cp_parser_error (parser, "objective-c++ message receiver expected");
25726 return error_mark_node;
25729 /* Parse the arguments and selectors comprising an Objective-C message.
25734 objc-selector-args , objc-comma-args
25736 objc-selector-args:
25737 objc-selector [opt] : assignment-expression
25738 objc-selector-args objc-selector [opt] : assignment-expression
25741 assignment-expression
25742 objc-comma-args , assignment-expression
25744 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
25745 selector arguments and TREE_VALUE containing a list of comma
25749 cp_parser_objc_message_args (cp_parser* parser)
25751 tree sel_args = NULL_TREE, addl_args = NULL_TREE;
25752 bool maybe_unary_selector_p = true;
25753 cp_token *token = cp_lexer_peek_token (parser->lexer);
25755 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
25757 tree selector = NULL_TREE, arg;
25759 if (token->type != CPP_COLON)
25760 selector = cp_parser_objc_selector (parser);
25762 /* Detect if we have a unary selector. */
25763 if (maybe_unary_selector_p
25764 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
25765 return build_tree_list (selector, NULL_TREE);
25767 maybe_unary_selector_p = false;
25768 cp_parser_require (parser, CPP_COLON, RT_COLON);
25769 arg = cp_parser_assignment_expression (parser);
25772 = chainon (sel_args,
25773 build_tree_list (selector, arg));
25775 token = cp_lexer_peek_token (parser->lexer);
25778 /* Handle non-selector arguments, if any. */
25779 while (token->type == CPP_COMMA)
25783 cp_lexer_consume_token (parser->lexer);
25784 arg = cp_parser_assignment_expression (parser);
25787 = chainon (addl_args,
25788 build_tree_list (NULL_TREE, arg));
25790 token = cp_lexer_peek_token (parser->lexer);
25793 if (sel_args == NULL_TREE && addl_args == NULL_TREE)
25795 cp_parser_error (parser, "objective-c++ message argument(s) are expected");
25796 return build_tree_list (error_mark_node, error_mark_node);
25799 return build_tree_list (sel_args, addl_args);
25802 /* Parse an Objective-C encode expression.
25804 objc-encode-expression:
25805 @encode objc-typename
25807 Returns an encoded representation of the type argument. */
25810 cp_parser_objc_encode_expression (cp_parser* parser)
25815 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
25816 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
25817 token = cp_lexer_peek_token (parser->lexer);
25818 type = complete_type (cp_parser_type_id (parser));
25819 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
25823 error_at (token->location,
25824 "%<@encode%> must specify a type as an argument");
25825 return error_mark_node;
25828 /* This happens if we find @encode(T) (where T is a template
25829 typename or something dependent on a template typename) when
25830 parsing a template. In that case, we can't compile it
25831 immediately, but we rather create an AT_ENCODE_EXPR which will
25832 need to be instantiated when the template is used.
25834 if (dependent_type_p (type))
25836 tree value = build_min (AT_ENCODE_EXPR, size_type_node, type);
25837 TREE_READONLY (value) = 1;
25841 return objc_build_encode_expr (type);
25844 /* Parse an Objective-C @defs expression. */
25847 cp_parser_objc_defs_expression (cp_parser *parser)
25851 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
25852 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
25853 name = cp_parser_identifier (parser);
25854 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
25856 return objc_get_class_ivars (name);
25859 /* Parse an Objective-C protocol expression.
25861 objc-protocol-expression:
25862 @protocol ( identifier )
25864 Returns a representation of the protocol expression. */
25867 cp_parser_objc_protocol_expression (cp_parser* parser)
25871 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
25872 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
25873 proto = cp_parser_identifier (parser);
25874 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
25876 return objc_build_protocol_expr (proto);
25879 /* Parse an Objective-C selector expression.
25881 objc-selector-expression:
25882 @selector ( objc-method-signature )
25884 objc-method-signature:
25890 objc-selector-seq objc-selector :
25892 Returns a representation of the method selector. */
25895 cp_parser_objc_selector_expression (cp_parser* parser)
25897 tree sel_seq = NULL_TREE;
25898 bool maybe_unary_selector_p = true;
25900 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
25902 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
25903 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
25904 token = cp_lexer_peek_token (parser->lexer);
25906 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON
25907 || token->type == CPP_SCOPE)
25909 tree selector = NULL_TREE;
25911 if (token->type != CPP_COLON
25912 || token->type == CPP_SCOPE)
25913 selector = cp_parser_objc_selector (parser);
25915 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
25916 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
25918 /* Detect if we have a unary selector. */
25919 if (maybe_unary_selector_p)
25921 sel_seq = selector;
25922 goto finish_selector;
25926 cp_parser_error (parser, "expected %<:%>");
25929 maybe_unary_selector_p = false;
25930 token = cp_lexer_consume_token (parser->lexer);
25932 if (token->type == CPP_SCOPE)
25935 = chainon (sel_seq,
25936 build_tree_list (selector, NULL_TREE));
25938 = chainon (sel_seq,
25939 build_tree_list (NULL_TREE, NULL_TREE));
25943 = chainon (sel_seq,
25944 build_tree_list (selector, NULL_TREE));
25946 token = cp_lexer_peek_token (parser->lexer);
25950 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
25952 return objc_build_selector_expr (loc, sel_seq);
25955 /* Parse a list of identifiers.
25957 objc-identifier-list:
25959 objc-identifier-list , identifier
25961 Returns a TREE_LIST of identifier nodes. */
25964 cp_parser_objc_identifier_list (cp_parser* parser)
25970 identifier = cp_parser_identifier (parser);
25971 if (identifier == error_mark_node)
25972 return error_mark_node;
25974 list = build_tree_list (NULL_TREE, identifier);
25975 sep = cp_lexer_peek_token (parser->lexer);
25977 while (sep->type == CPP_COMMA)
25979 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
25980 identifier = cp_parser_identifier (parser);
25981 if (identifier == error_mark_node)
25984 list = chainon (list, build_tree_list (NULL_TREE,
25986 sep = cp_lexer_peek_token (parser->lexer);
25992 /* Parse an Objective-C alias declaration.
25994 objc-alias-declaration:
25995 @compatibility_alias identifier identifier ;
25997 This function registers the alias mapping with the Objective-C front end.
25998 It returns nothing. */
26001 cp_parser_objc_alias_declaration (cp_parser* parser)
26005 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
26006 alias = cp_parser_identifier (parser);
26007 orig = cp_parser_identifier (parser);
26008 objc_declare_alias (alias, orig);
26009 cp_parser_consume_semicolon_at_end_of_statement (parser);
26012 /* Parse an Objective-C class forward-declaration.
26014 objc-class-declaration:
26015 @class objc-identifier-list ;
26017 The function registers the forward declarations with the Objective-C
26018 front end. It returns nothing. */
26021 cp_parser_objc_class_declaration (cp_parser* parser)
26023 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
26028 id = cp_parser_identifier (parser);
26029 if (id == error_mark_node)
26032 objc_declare_class (id);
26034 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
26035 cp_lexer_consume_token (parser->lexer);
26039 cp_parser_consume_semicolon_at_end_of_statement (parser);
26042 /* Parse a list of Objective-C protocol references.
26044 objc-protocol-refs-opt:
26045 objc-protocol-refs [opt]
26047 objc-protocol-refs:
26048 < objc-identifier-list >
26050 Returns a TREE_LIST of identifiers, if any. */
26053 cp_parser_objc_protocol_refs_opt (cp_parser* parser)
26055 tree protorefs = NULL_TREE;
26057 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
26059 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
26060 protorefs = cp_parser_objc_identifier_list (parser);
26061 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
26067 /* Parse a Objective-C visibility specification. */
26070 cp_parser_objc_visibility_spec (cp_parser* parser)
26072 cp_token *vis = cp_lexer_peek_token (parser->lexer);
26074 switch (vis->keyword)
26076 case RID_AT_PRIVATE:
26077 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE);
26079 case RID_AT_PROTECTED:
26080 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED);
26082 case RID_AT_PUBLIC:
26083 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC);
26085 case RID_AT_PACKAGE:
26086 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE);
26092 /* Eat '@private'/'@protected'/'@public'. */
26093 cp_lexer_consume_token (parser->lexer);
26096 /* Parse an Objective-C method type. Return 'true' if it is a class
26097 (+) method, and 'false' if it is an instance (-) method. */
26100 cp_parser_objc_method_type (cp_parser* parser)
26102 if (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS)
26108 /* Parse an Objective-C protocol qualifier. */
26111 cp_parser_objc_protocol_qualifiers (cp_parser* parser)
26113 tree quals = NULL_TREE, node;
26114 cp_token *token = cp_lexer_peek_token (parser->lexer);
26116 node = token->u.value;
26118 while (node && identifier_p (node)
26119 && (node == ridpointers [(int) RID_IN]
26120 || node == ridpointers [(int) RID_OUT]
26121 || node == ridpointers [(int) RID_INOUT]
26122 || node == ridpointers [(int) RID_BYCOPY]
26123 || node == ridpointers [(int) RID_BYREF]
26124 || node == ridpointers [(int) RID_ONEWAY]))
26126 quals = tree_cons (NULL_TREE, node, quals);
26127 cp_lexer_consume_token (parser->lexer);
26128 token = cp_lexer_peek_token (parser->lexer);
26129 node = token->u.value;
26135 /* Parse an Objective-C typename. */
26138 cp_parser_objc_typename (cp_parser* parser)
26140 tree type_name = NULL_TREE;
26142 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
26144 tree proto_quals, cp_type = NULL_TREE;
26146 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
26147 proto_quals = cp_parser_objc_protocol_qualifiers (parser);
26149 /* An ObjC type name may consist of just protocol qualifiers, in which
26150 case the type shall default to 'id'. */
26151 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
26153 cp_type = cp_parser_type_id (parser);
26155 /* If the type could not be parsed, an error has already
26156 been produced. For error recovery, behave as if it had
26157 not been specified, which will use the default type
26159 if (cp_type == error_mark_node)
26161 cp_type = NULL_TREE;
26162 /* We need to skip to the closing parenthesis as
26163 cp_parser_type_id() does not seem to do it for
26165 cp_parser_skip_to_closing_parenthesis (parser,
26166 /*recovering=*/true,
26167 /*or_comma=*/false,
26168 /*consume_paren=*/false);
26172 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
26173 type_name = build_tree_list (proto_quals, cp_type);
26179 /* Check to see if TYPE refers to an Objective-C selector name. */
26182 cp_parser_objc_selector_p (enum cpp_ttype type)
26184 return (type == CPP_NAME || type == CPP_KEYWORD
26185 || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND
26186 || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT
26187 || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ
26188 || type == CPP_XOR || type == CPP_XOR_EQ);
26191 /* Parse an Objective-C selector. */
26194 cp_parser_objc_selector (cp_parser* parser)
26196 cp_token *token = cp_lexer_consume_token (parser->lexer);
26198 if (!cp_parser_objc_selector_p (token->type))
26200 error_at (token->location, "invalid Objective-C++ selector name");
26201 return error_mark_node;
26204 /* C++ operator names are allowed to appear in ObjC selectors. */
26205 switch (token->type)
26207 case CPP_AND_AND: return get_identifier ("and");
26208 case CPP_AND_EQ: return get_identifier ("and_eq");
26209 case CPP_AND: return get_identifier ("bitand");
26210 case CPP_OR: return get_identifier ("bitor");
26211 case CPP_COMPL: return get_identifier ("compl");
26212 case CPP_NOT: return get_identifier ("not");
26213 case CPP_NOT_EQ: return get_identifier ("not_eq");
26214 case CPP_OR_OR: return get_identifier ("or");
26215 case CPP_OR_EQ: return get_identifier ("or_eq");
26216 case CPP_XOR: return get_identifier ("xor");
26217 case CPP_XOR_EQ: return get_identifier ("xor_eq");
26218 default: return token->u.value;
26222 /* Parse an Objective-C params list. */
26225 cp_parser_objc_method_keyword_params (cp_parser* parser, tree* attributes)
26227 tree params = NULL_TREE;
26228 bool maybe_unary_selector_p = true;
26229 cp_token *token = cp_lexer_peek_token (parser->lexer);
26231 while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
26233 tree selector = NULL_TREE, type_name, identifier;
26234 tree parm_attr = NULL_TREE;
26236 if (token->keyword == RID_ATTRIBUTE)
26239 if (token->type != CPP_COLON)
26240 selector = cp_parser_objc_selector (parser);
26242 /* Detect if we have a unary selector. */
26243 if (maybe_unary_selector_p
26244 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
26246 params = selector; /* Might be followed by attributes. */
26250 maybe_unary_selector_p = false;
26251 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
26253 /* Something went quite wrong. There should be a colon
26254 here, but there is not. Stop parsing parameters. */
26257 type_name = cp_parser_objc_typename (parser);
26258 /* New ObjC allows attributes on parameters too. */
26259 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
26260 parm_attr = cp_parser_attributes_opt (parser);
26261 identifier = cp_parser_identifier (parser);
26265 objc_build_keyword_decl (selector,
26270 token = cp_lexer_peek_token (parser->lexer);
26273 if (params == NULL_TREE)
26275 cp_parser_error (parser, "objective-c++ method declaration is expected");
26276 return error_mark_node;
26279 /* We allow tail attributes for the method. */
26280 if (token->keyword == RID_ATTRIBUTE)
26282 *attributes = cp_parser_attributes_opt (parser);
26283 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
26284 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
26286 cp_parser_error (parser,
26287 "method attributes must be specified at the end");
26288 return error_mark_node;
26291 if (params == NULL_TREE)
26293 cp_parser_error (parser, "objective-c++ method declaration is expected");
26294 return error_mark_node;
26299 /* Parse the non-keyword Objective-C params. */
26302 cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp,
26305 tree params = make_node (TREE_LIST);
26306 cp_token *token = cp_lexer_peek_token (parser->lexer);
26307 *ellipsisp = false; /* Initially, assume no ellipsis. */
26309 while (token->type == CPP_COMMA)
26311 cp_parameter_declarator *parmdecl;
26314 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
26315 token = cp_lexer_peek_token (parser->lexer);
26317 if (token->type == CPP_ELLIPSIS)
26319 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
26321 token = cp_lexer_peek_token (parser->lexer);
26325 /* TODO: parse attributes for tail parameters. */
26326 parmdecl = cp_parser_parameter_declaration (parser, false, NULL);
26327 parm = grokdeclarator (parmdecl->declarator,
26328 &parmdecl->decl_specifiers,
26329 PARM, /*initialized=*/0,
26330 /*attrlist=*/NULL);
26332 chainon (params, build_tree_list (NULL_TREE, parm));
26333 token = cp_lexer_peek_token (parser->lexer);
26336 /* We allow tail attributes for the method. */
26337 if (token->keyword == RID_ATTRIBUTE)
26339 if (*attributes == NULL_TREE)
26341 *attributes = cp_parser_attributes_opt (parser);
26342 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
26343 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
26347 /* We have an error, but parse the attributes, so that we can
26349 *attributes = cp_parser_attributes_opt (parser);
26351 cp_parser_error (parser,
26352 "method attributes must be specified at the end");
26353 return error_mark_node;
26359 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
26362 cp_parser_objc_interstitial_code (cp_parser* parser)
26364 cp_token *token = cp_lexer_peek_token (parser->lexer);
26366 /* If the next token is `extern' and the following token is a string
26367 literal, then we have a linkage specification. */
26368 if (token->keyword == RID_EXTERN
26369 && cp_parser_is_pure_string_literal
26370 (cp_lexer_peek_nth_token (parser->lexer, 2)))
26371 cp_parser_linkage_specification (parser);
26372 /* Handle #pragma, if any. */
26373 else if (token->type == CPP_PRAGMA)
26374 cp_parser_pragma (parser, pragma_objc_icode);
26375 /* Allow stray semicolons. */
26376 else if (token->type == CPP_SEMICOLON)
26377 cp_lexer_consume_token (parser->lexer);
26378 /* Mark methods as optional or required, when building protocols. */
26379 else if (token->keyword == RID_AT_OPTIONAL)
26381 cp_lexer_consume_token (parser->lexer);
26382 objc_set_method_opt (true);
26384 else if (token->keyword == RID_AT_REQUIRED)
26386 cp_lexer_consume_token (parser->lexer);
26387 objc_set_method_opt (false);
26389 else if (token->keyword == RID_NAMESPACE)
26390 cp_parser_namespace_definition (parser);
26391 /* Other stray characters must generate errors. */
26392 else if (token->type == CPP_OPEN_BRACE || token->type == CPP_CLOSE_BRACE)
26394 cp_lexer_consume_token (parser->lexer);
26395 error ("stray %qs between Objective-C++ methods",
26396 token->type == CPP_OPEN_BRACE ? "{" : "}");
26398 /* Finally, try to parse a block-declaration, or a function-definition. */
26400 cp_parser_block_declaration (parser, /*statement_p=*/false);
26403 /* Parse a method signature. */
26406 cp_parser_objc_method_signature (cp_parser* parser, tree* attributes)
26408 tree rettype, kwdparms, optparms;
26409 bool ellipsis = false;
26410 bool is_class_method;
26412 is_class_method = cp_parser_objc_method_type (parser);
26413 rettype = cp_parser_objc_typename (parser);
26414 *attributes = NULL_TREE;
26415 kwdparms = cp_parser_objc_method_keyword_params (parser, attributes);
26416 if (kwdparms == error_mark_node)
26417 return error_mark_node;
26418 optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis, attributes);
26419 if (optparms == error_mark_node)
26420 return error_mark_node;
26422 return objc_build_method_signature (is_class_method, rettype, kwdparms, optparms, ellipsis);
26426 cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser* parser)
26429 cp_lexer_save_tokens (parser->lexer);
26430 tattr = cp_parser_attributes_opt (parser);
26431 gcc_assert (tattr) ;
26433 /* If the attributes are followed by a method introducer, this is not allowed.
26434 Dump the attributes and flag the situation. */
26435 if (cp_lexer_next_token_is (parser->lexer, CPP_PLUS)
26436 || cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
26439 /* Otherwise, the attributes introduce some interstitial code, possibly so
26440 rewind to allow that check. */
26441 cp_lexer_rollback_tokens (parser->lexer);
26445 /* Parse an Objective-C method prototype list. */
26448 cp_parser_objc_method_prototype_list (cp_parser* parser)
26450 cp_token *token = cp_lexer_peek_token (parser->lexer);
26452 while (token->keyword != RID_AT_END && token->type != CPP_EOF)
26454 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
26456 tree attributes, sig;
26457 bool is_class_method;
26458 if (token->type == CPP_PLUS)
26459 is_class_method = true;
26461 is_class_method = false;
26462 sig = cp_parser_objc_method_signature (parser, &attributes);
26463 if (sig == error_mark_node)
26465 cp_parser_skip_to_end_of_block_or_statement (parser);
26466 token = cp_lexer_peek_token (parser->lexer);
26469 objc_add_method_declaration (is_class_method, sig, attributes);
26470 cp_parser_consume_semicolon_at_end_of_statement (parser);
26472 else if (token->keyword == RID_AT_PROPERTY)
26473 cp_parser_objc_at_property_declaration (parser);
26474 else if (token->keyword == RID_ATTRIBUTE
26475 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
26476 warning_at (cp_lexer_peek_token (parser->lexer)->location,
26478 "prefix attributes are ignored for methods");
26480 /* Allow for interspersed non-ObjC++ code. */
26481 cp_parser_objc_interstitial_code (parser);
26483 token = cp_lexer_peek_token (parser->lexer);
26486 if (token->type != CPP_EOF)
26487 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
26489 cp_parser_error (parser, "expected %<@end%>");
26491 objc_finish_interface ();
26494 /* Parse an Objective-C method definition list. */
26497 cp_parser_objc_method_definition_list (cp_parser* parser)
26499 cp_token *token = cp_lexer_peek_token (parser->lexer);
26501 while (token->keyword != RID_AT_END && token->type != CPP_EOF)
26505 if (token->type == CPP_PLUS || token->type == CPP_MINUS)
26508 tree sig, attribute;
26509 bool is_class_method;
26510 if (token->type == CPP_PLUS)
26511 is_class_method = true;
26513 is_class_method = false;
26514 push_deferring_access_checks (dk_deferred);
26515 sig = cp_parser_objc_method_signature (parser, &attribute);
26516 if (sig == error_mark_node)
26518 cp_parser_skip_to_end_of_block_or_statement (parser);
26519 token = cp_lexer_peek_token (parser->lexer);
26522 objc_start_method_definition (is_class_method, sig, attribute,
26525 /* For historical reasons, we accept an optional semicolon. */
26526 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
26527 cp_lexer_consume_token (parser->lexer);
26529 ptk = cp_lexer_peek_token (parser->lexer);
26530 if (!(ptk->type == CPP_PLUS || ptk->type == CPP_MINUS
26531 || ptk->type == CPP_EOF || ptk->keyword == RID_AT_END))
26533 perform_deferred_access_checks (tf_warning_or_error);
26534 stop_deferring_access_checks ();
26535 meth = cp_parser_function_definition_after_declarator (parser,
26537 pop_deferring_access_checks ();
26538 objc_finish_method_definition (meth);
26541 /* The following case will be removed once @synthesize is
26542 completely implemented. */
26543 else if (token->keyword == RID_AT_PROPERTY)
26544 cp_parser_objc_at_property_declaration (parser);
26545 else if (token->keyword == RID_AT_SYNTHESIZE)
26546 cp_parser_objc_at_synthesize_declaration (parser);
26547 else if (token->keyword == RID_AT_DYNAMIC)
26548 cp_parser_objc_at_dynamic_declaration (parser);
26549 else if (token->keyword == RID_ATTRIBUTE
26550 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
26551 warning_at (token->location, OPT_Wattributes,
26552 "prefix attributes are ignored for methods");
26554 /* Allow for interspersed non-ObjC++ code. */
26555 cp_parser_objc_interstitial_code (parser);
26557 token = cp_lexer_peek_token (parser->lexer);
26560 if (token->type != CPP_EOF)
26561 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
26563 cp_parser_error (parser, "expected %<@end%>");
26565 objc_finish_implementation ();
26568 /* Parse Objective-C ivars. */
26571 cp_parser_objc_class_ivars (cp_parser* parser)
26573 cp_token *token = cp_lexer_peek_token (parser->lexer);
26575 if (token->type != CPP_OPEN_BRACE)
26576 return; /* No ivars specified. */
26578 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
26579 token = cp_lexer_peek_token (parser->lexer);
26581 while (token->type != CPP_CLOSE_BRACE
26582 && token->keyword != RID_AT_END && token->type != CPP_EOF)
26584 cp_decl_specifier_seq declspecs;
26585 int decl_class_or_enum_p;
26586 tree prefix_attributes;
26588 cp_parser_objc_visibility_spec (parser);
26590 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
26593 cp_parser_decl_specifier_seq (parser,
26594 CP_PARSER_FLAGS_OPTIONAL,
26596 &decl_class_or_enum_p);
26598 /* auto, register, static, extern, mutable. */
26599 if (declspecs.storage_class != sc_none)
26601 cp_parser_error (parser, "invalid type for instance variable");
26602 declspecs.storage_class = sc_none;
26605 /* thread_local. */
26606 if (decl_spec_seq_has_spec_p (&declspecs, ds_thread))
26608 cp_parser_error (parser, "invalid type for instance variable");
26609 declspecs.locations[ds_thread] = 0;
26613 if (decl_spec_seq_has_spec_p (&declspecs, ds_typedef))
26615 cp_parser_error (parser, "invalid type for instance variable");
26616 declspecs.locations[ds_typedef] = 0;
26619 prefix_attributes = declspecs.attributes;
26620 declspecs.attributes = NULL_TREE;
26622 /* Keep going until we hit the `;' at the end of the
26624 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
26626 tree width = NULL_TREE, attributes, first_attribute, decl;
26627 cp_declarator *declarator = NULL;
26628 int ctor_dtor_or_conv_p;
26630 /* Check for a (possibly unnamed) bitfield declaration. */
26631 token = cp_lexer_peek_token (parser->lexer);
26632 if (token->type == CPP_COLON)
26635 if (token->type == CPP_NAME
26636 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
26639 /* Get the name of the bitfield. */
26640 declarator = make_id_declarator (NULL_TREE,
26641 cp_parser_identifier (parser),
26645 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
26646 /* Get the width of the bitfield. */
26648 = cp_parser_constant_expression (parser);
26652 /* Parse the declarator. */
26654 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
26655 &ctor_dtor_or_conv_p,
26656 /*parenthesized_p=*/NULL,
26657 /*member_p=*/false,
26658 /*friend_p=*/false);
26661 /* Look for attributes that apply to the ivar. */
26662 attributes = cp_parser_attributes_opt (parser);
26663 /* Remember which attributes are prefix attributes and
26665 first_attribute = attributes;
26666 /* Combine the attributes. */
26667 attributes = chainon (prefix_attributes, attributes);
26670 /* Create the bitfield declaration. */
26671 decl = grokbitfield (declarator, &declspecs,
26675 decl = grokfield (declarator, &declspecs,
26676 NULL_TREE, /*init_const_expr_p=*/false,
26677 NULL_TREE, attributes);
26679 /* Add the instance variable. */
26680 if (decl != error_mark_node && decl != NULL_TREE)
26681 objc_add_instance_variable (decl);
26683 /* Reset PREFIX_ATTRIBUTES. */
26684 while (attributes && TREE_CHAIN (attributes) != first_attribute)
26685 attributes = TREE_CHAIN (attributes);
26687 TREE_CHAIN (attributes) = NULL_TREE;
26689 token = cp_lexer_peek_token (parser->lexer);
26691 if (token->type == CPP_COMMA)
26693 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
26699 cp_parser_consume_semicolon_at_end_of_statement (parser);
26700 token = cp_lexer_peek_token (parser->lexer);
26703 if (token->keyword == RID_AT_END)
26704 cp_parser_error (parser, "expected %<}%>");
26706 /* Do not consume the RID_AT_END, so it will be read again as terminating
26707 the @interface of @implementation. */
26708 if (token->keyword != RID_AT_END && token->type != CPP_EOF)
26709 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
26711 /* For historical reasons, we accept an optional semicolon. */
26712 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
26713 cp_lexer_consume_token (parser->lexer);
26716 /* Parse an Objective-C protocol declaration. */
26719 cp_parser_objc_protocol_declaration (cp_parser* parser, tree attributes)
26721 tree proto, protorefs;
26724 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
26725 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
26727 tok = cp_lexer_peek_token (parser->lexer);
26728 error_at (tok->location, "identifier expected after %<@protocol%>");
26729 cp_parser_consume_semicolon_at_end_of_statement (parser);
26733 /* See if we have a forward declaration or a definition. */
26734 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
26736 /* Try a forward declaration first. */
26737 if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON)
26743 id = cp_parser_identifier (parser);
26744 if (id == error_mark_node)
26747 objc_declare_protocol (id, attributes);
26749 if(cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
26750 cp_lexer_consume_token (parser->lexer);
26754 cp_parser_consume_semicolon_at_end_of_statement (parser);
26757 /* Ok, we got a full-fledged definition (or at least should). */
26760 proto = cp_parser_identifier (parser);
26761 protorefs = cp_parser_objc_protocol_refs_opt (parser);
26762 objc_start_protocol (proto, protorefs, attributes);
26763 cp_parser_objc_method_prototype_list (parser);
26767 /* Parse an Objective-C superclass or category. */
26770 cp_parser_objc_superclass_or_category (cp_parser *parser,
26773 tree *categ, bool *is_class_extension)
26775 cp_token *next = cp_lexer_peek_token (parser->lexer);
26777 *super = *categ = NULL_TREE;
26778 *is_class_extension = false;
26779 if (next->type == CPP_COLON)
26781 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
26782 *super = cp_parser_identifier (parser);
26784 else if (next->type == CPP_OPEN_PAREN)
26786 cp_lexer_consume_token (parser->lexer); /* Eat '('. */
26788 /* If there is no category name, and this is an @interface, we
26789 have a class extension. */
26790 if (iface_p && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
26792 *categ = NULL_TREE;
26793 *is_class_extension = true;
26796 *categ = cp_parser_identifier (parser);
26798 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
26802 /* Parse an Objective-C class interface. */
26805 cp_parser_objc_class_interface (cp_parser* parser, tree attributes)
26807 tree name, super, categ, protos;
26808 bool is_class_extension;
26810 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
26811 name = cp_parser_identifier (parser);
26812 if (name == error_mark_node)
26814 /* It's hard to recover because even if valid @interface stuff
26815 is to follow, we can't compile it (or validate it) if we
26816 don't even know which class it refers to. Let's assume this
26817 was a stray '@interface' token in the stream and skip it.
26821 cp_parser_objc_superclass_or_category (parser, true, &super, &categ,
26822 &is_class_extension);
26823 protos = cp_parser_objc_protocol_refs_opt (parser);
26825 /* We have either a class or a category on our hands. */
26826 if (categ || is_class_extension)
26827 objc_start_category_interface (name, categ, protos, attributes);
26830 objc_start_class_interface (name, super, protos, attributes);
26831 /* Handle instance variable declarations, if any. */
26832 cp_parser_objc_class_ivars (parser);
26833 objc_continue_interface ();
26836 cp_parser_objc_method_prototype_list (parser);
26839 /* Parse an Objective-C class implementation. */
26842 cp_parser_objc_class_implementation (cp_parser* parser)
26844 tree name, super, categ;
26845 bool is_class_extension;
26847 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
26848 name = cp_parser_identifier (parser);
26849 if (name == error_mark_node)
26851 /* It's hard to recover because even if valid @implementation
26852 stuff is to follow, we can't compile it (or validate it) if
26853 we don't even know which class it refers to. Let's assume
26854 this was a stray '@implementation' token in the stream and
26859 cp_parser_objc_superclass_or_category (parser, false, &super, &categ,
26860 &is_class_extension);
26862 /* We have either a class or a category on our hands. */
26864 objc_start_category_implementation (name, categ);
26867 objc_start_class_implementation (name, super);
26868 /* Handle instance variable declarations, if any. */
26869 cp_parser_objc_class_ivars (parser);
26870 objc_continue_implementation ();
26873 cp_parser_objc_method_definition_list (parser);
26876 /* Consume the @end token and finish off the implementation. */
26879 cp_parser_objc_end_implementation (cp_parser* parser)
26881 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
26882 objc_finish_implementation ();
26885 /* Parse an Objective-C declaration. */
26888 cp_parser_objc_declaration (cp_parser* parser, tree attributes)
26890 /* Try to figure out what kind of declaration is present. */
26891 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
26894 switch (kwd->keyword)
26899 error_at (kwd->location, "attributes may not be specified before"
26900 " the %<@%D%> Objective-C++ keyword",
26904 case RID_AT_IMPLEMENTATION:
26905 warning_at (kwd->location, OPT_Wattributes,
26906 "prefix attributes are ignored before %<@%D%>",
26913 switch (kwd->keyword)
26916 cp_parser_objc_alias_declaration (parser);
26919 cp_parser_objc_class_declaration (parser);
26921 case RID_AT_PROTOCOL:
26922 cp_parser_objc_protocol_declaration (parser, attributes);
26924 case RID_AT_INTERFACE:
26925 cp_parser_objc_class_interface (parser, attributes);
26927 case RID_AT_IMPLEMENTATION:
26928 cp_parser_objc_class_implementation (parser);
26931 cp_parser_objc_end_implementation (parser);
26934 error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
26936 cp_parser_skip_to_end_of_block_or_statement (parser);
26940 /* Parse an Objective-C try-catch-finally statement.
26942 objc-try-catch-finally-stmt:
26943 @try compound-statement objc-catch-clause-seq [opt]
26944 objc-finally-clause [opt]
26946 objc-catch-clause-seq:
26947 objc-catch-clause objc-catch-clause-seq [opt]
26950 @catch ( objc-exception-declaration ) compound-statement
26952 objc-finally-clause:
26953 @finally compound-statement
26955 objc-exception-declaration:
26956 parameter-declaration
26959 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
26963 PS: This function is identical to c_parser_objc_try_catch_finally_statement
26964 for C. Keep them in sync. */
26967 cp_parser_objc_try_catch_finally_statement (cp_parser *parser)
26969 location_t location;
26972 cp_parser_require_keyword (parser, RID_AT_TRY, RT_AT_TRY);
26973 location = cp_lexer_peek_token (parser->lexer)->location;
26974 objc_maybe_warn_exceptions (location);
26975 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
26976 node, lest it get absorbed into the surrounding block. */
26977 stmt = push_stmt_list ();
26978 cp_parser_compound_statement (parser, NULL, false, false);
26979 objc_begin_try_stmt (location, pop_stmt_list (stmt));
26981 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
26983 cp_parameter_declarator *parm;
26984 tree parameter_declaration = error_mark_node;
26985 bool seen_open_paren = false;
26987 cp_lexer_consume_token (parser->lexer);
26988 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
26989 seen_open_paren = true;
26990 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
26992 /* We have "@catch (...)" (where the '...' are literally
26993 what is in the code). Skip the '...'.
26994 parameter_declaration is set to NULL_TREE, and
26995 objc_being_catch_clauses() knows that that means
26997 cp_lexer_consume_token (parser->lexer);
26998 parameter_declaration = NULL_TREE;
27002 /* We have "@catch (NSException *exception)" or something
27003 like that. Parse the parameter declaration. */
27004 parm = cp_parser_parameter_declaration (parser, false, NULL);
27006 parameter_declaration = error_mark_node;
27008 parameter_declaration = grokdeclarator (parm->declarator,
27009 &parm->decl_specifiers,
27010 PARM, /*initialized=*/0,
27011 /*attrlist=*/NULL);
27013 if (seen_open_paren)
27014 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
27017 /* If there was no open parenthesis, we are recovering from
27018 an error, and we are trying to figure out what mistake
27019 the user has made. */
27021 /* If there is an immediate closing parenthesis, the user
27022 probably forgot the opening one (ie, they typed "@catch
27023 NSException *e)". Parse the closing parenthesis and keep
27025 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
27026 cp_lexer_consume_token (parser->lexer);
27028 /* If these is no immediate closing parenthesis, the user
27029 probably doesn't know that parenthesis are required at
27030 all (ie, they typed "@catch NSException *e"). So, just
27031 forget about the closing parenthesis and keep going. */
27033 objc_begin_catch_clause (parameter_declaration);
27034 cp_parser_compound_statement (parser, NULL, false, false);
27035 objc_finish_catch_clause ();
27037 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
27039 cp_lexer_consume_token (parser->lexer);
27040 location = cp_lexer_peek_token (parser->lexer)->location;
27041 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
27042 node, lest it get absorbed into the surrounding block. */
27043 stmt = push_stmt_list ();
27044 cp_parser_compound_statement (parser, NULL, false, false);
27045 objc_build_finally_clause (location, pop_stmt_list (stmt));
27048 return objc_finish_try_stmt ();
27051 /* Parse an Objective-C synchronized statement.
27053 objc-synchronized-stmt:
27054 @synchronized ( expression ) compound-statement
27056 Returns NULL_TREE. */
27059 cp_parser_objc_synchronized_statement (cp_parser *parser)
27061 location_t location;
27064 cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, RT_AT_SYNCHRONIZED);
27066 location = cp_lexer_peek_token (parser->lexer)->location;
27067 objc_maybe_warn_exceptions (location);
27068 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
27069 lock = cp_parser_expression (parser);
27070 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
27072 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
27073 node, lest it get absorbed into the surrounding block. */
27074 stmt = push_stmt_list ();
27075 cp_parser_compound_statement (parser, NULL, false, false);
27077 return objc_build_synchronized (location, lock, pop_stmt_list (stmt));
27080 /* Parse an Objective-C throw statement.
27083 @throw assignment-expression [opt] ;
27085 Returns a constructed '@throw' statement. */
27088 cp_parser_objc_throw_statement (cp_parser *parser)
27090 tree expr = NULL_TREE;
27091 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
27093 cp_parser_require_keyword (parser, RID_AT_THROW, RT_AT_THROW);
27095 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
27096 expr = cp_parser_expression (parser);
27098 cp_parser_consume_semicolon_at_end_of_statement (parser);
27100 return objc_build_throw_stmt (loc, expr);
27103 /* Parse an Objective-C statement. */
27106 cp_parser_objc_statement (cp_parser * parser)
27108 /* Try to figure out what kind of declaration is present. */
27109 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
27111 switch (kwd->keyword)
27114 return cp_parser_objc_try_catch_finally_statement (parser);
27115 case RID_AT_SYNCHRONIZED:
27116 return cp_parser_objc_synchronized_statement (parser);
27118 return cp_parser_objc_throw_statement (parser);
27120 error_at (kwd->location, "misplaced %<@%D%> Objective-C++ construct",
27122 cp_parser_skip_to_end_of_block_or_statement (parser);
27125 return error_mark_node;
27128 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
27129 look ahead to see if an objc keyword follows the attributes. This
27130 is to detect the use of prefix attributes on ObjC @interface and
27134 cp_parser_objc_valid_prefix_attributes (cp_parser* parser, tree *attrib)
27136 cp_lexer_save_tokens (parser->lexer);
27137 *attrib = cp_parser_attributes_opt (parser);
27138 gcc_assert (*attrib);
27139 if (OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser->lexer)->keyword))
27141 cp_lexer_commit_tokens (parser->lexer);
27144 cp_lexer_rollback_tokens (parser->lexer);
27148 /* This routine is a minimal replacement for
27149 c_parser_struct_declaration () used when parsing the list of
27150 types/names or ObjC++ properties. For example, when parsing the
27153 @property (readonly) int a, b, c;
27155 this function is responsible for parsing "int a, int b, int c" and
27156 returning the declarations as CHAIN of DECLs.
27158 TODO: Share this code with cp_parser_objc_class_ivars. It's very
27159 similar parsing. */
27161 cp_parser_objc_struct_declaration (cp_parser *parser)
27163 tree decls = NULL_TREE;
27164 cp_decl_specifier_seq declspecs;
27165 int decl_class_or_enum_p;
27166 tree prefix_attributes;
27168 cp_parser_decl_specifier_seq (parser,
27169 CP_PARSER_FLAGS_NONE,
27171 &decl_class_or_enum_p);
27173 if (declspecs.type == error_mark_node)
27174 return error_mark_node;
27176 /* auto, register, static, extern, mutable. */
27177 if (declspecs.storage_class != sc_none)
27179 cp_parser_error (parser, "invalid type for property");
27180 declspecs.storage_class = sc_none;
27183 /* thread_local. */
27184 if (decl_spec_seq_has_spec_p (&declspecs, ds_thread))
27186 cp_parser_error (parser, "invalid type for property");
27187 declspecs.locations[ds_thread] = 0;
27191 if (decl_spec_seq_has_spec_p (&declspecs, ds_typedef))
27193 cp_parser_error (parser, "invalid type for property");
27194 declspecs.locations[ds_typedef] = 0;
27197 prefix_attributes = declspecs.attributes;
27198 declspecs.attributes = NULL_TREE;
27200 /* Keep going until we hit the `;' at the end of the declaration. */
27201 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
27203 tree attributes, first_attribute, decl;
27204 cp_declarator *declarator;
27207 /* Parse the declarator. */
27208 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
27209 NULL, NULL, false, false);
27211 /* Look for attributes that apply to the ivar. */
27212 attributes = cp_parser_attributes_opt (parser);
27213 /* Remember which attributes are prefix attributes and
27215 first_attribute = attributes;
27216 /* Combine the attributes. */
27217 attributes = chainon (prefix_attributes, attributes);
27219 decl = grokfield (declarator, &declspecs,
27220 NULL_TREE, /*init_const_expr_p=*/false,
27221 NULL_TREE, attributes);
27223 if (decl == error_mark_node || decl == NULL_TREE)
27224 return error_mark_node;
27226 /* Reset PREFIX_ATTRIBUTES. */
27227 while (attributes && TREE_CHAIN (attributes) != first_attribute)
27228 attributes = TREE_CHAIN (attributes);
27230 TREE_CHAIN (attributes) = NULL_TREE;
27232 DECL_CHAIN (decl) = decls;
27235 token = cp_lexer_peek_token (parser->lexer);
27236 if (token->type == CPP_COMMA)
27238 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
27247 /* Parse an Objective-C @property declaration. The syntax is:
27249 objc-property-declaration:
27250 '@property' objc-property-attributes[opt] struct-declaration ;
27252 objc-property-attributes:
27253 '(' objc-property-attribute-list ')'
27255 objc-property-attribute-list:
27256 objc-property-attribute
27257 objc-property-attribute-list, objc-property-attribute
27259 objc-property-attribute
27260 'getter' = identifier
27261 'setter' = identifier
27270 @property NSString *name;
27271 @property (readonly) id object;
27272 @property (retain, nonatomic, getter=getTheName) id name;
27273 @property int a, b, c;
27275 PS: This function is identical to
27276 c_parser_objc_at_property_declaration for C. Keep them in sync. */
27278 cp_parser_objc_at_property_declaration (cp_parser *parser)
27280 /* The following variables hold the attributes of the properties as
27281 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
27282 seen. When we see an attribute, we set them to 'true' (if they
27283 are boolean properties) or to the identifier (if they have an
27284 argument, ie, for getter and setter). Note that here we only
27285 parse the list of attributes, check the syntax and accumulate the
27286 attributes that we find. objc_add_property_declaration() will
27287 then process the information. */
27288 bool property_assign = false;
27289 bool property_copy = false;
27290 tree property_getter_ident = NULL_TREE;
27291 bool property_nonatomic = false;
27292 bool property_readonly = false;
27293 bool property_readwrite = false;
27294 bool property_retain = false;
27295 tree property_setter_ident = NULL_TREE;
27297 /* 'properties' is the list of properties that we read. Usually a
27298 single one, but maybe more (eg, in "@property int a, b, c;" there
27303 loc = cp_lexer_peek_token (parser->lexer)->location;
27305 cp_lexer_consume_token (parser->lexer); /* Eat '@property'. */
27307 /* Parse the optional attribute list... */
27308 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
27311 cp_lexer_consume_token (parser->lexer);
27315 bool syntax_error = false;
27316 cp_token *token = cp_lexer_peek_token (parser->lexer);
27319 if (token->type != CPP_NAME)
27321 cp_parser_error (parser, "expected identifier");
27324 keyword = C_RID_CODE (token->u.value);
27325 cp_lexer_consume_token (parser->lexer);
27328 case RID_ASSIGN: property_assign = true; break;
27329 case RID_COPY: property_copy = true; break;
27330 case RID_NONATOMIC: property_nonatomic = true; break;
27331 case RID_READONLY: property_readonly = true; break;
27332 case RID_READWRITE: property_readwrite = true; break;
27333 case RID_RETAIN: property_retain = true; break;
27337 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
27339 if (keyword == RID_GETTER)
27340 cp_parser_error (parser,
27341 "missing %<=%> (after %<getter%> attribute)");
27343 cp_parser_error (parser,
27344 "missing %<=%> (after %<setter%> attribute)");
27345 syntax_error = true;
27348 cp_lexer_consume_token (parser->lexer); /* eat the = */
27349 if (!cp_parser_objc_selector_p (cp_lexer_peek_token (parser->lexer)->type))
27351 cp_parser_error (parser, "expected identifier");
27352 syntax_error = true;
27355 if (keyword == RID_SETTER)
27357 if (property_setter_ident != NULL_TREE)
27359 cp_parser_error (parser, "the %<setter%> attribute may only be specified once");
27360 cp_lexer_consume_token (parser->lexer);
27363 property_setter_ident = cp_parser_objc_selector (parser);
27364 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
27365 cp_parser_error (parser, "setter name must terminate with %<:%>");
27367 cp_lexer_consume_token (parser->lexer);
27371 if (property_getter_ident != NULL_TREE)
27373 cp_parser_error (parser, "the %<getter%> attribute may only be specified once");
27374 cp_lexer_consume_token (parser->lexer);
27377 property_getter_ident = cp_parser_objc_selector (parser);
27381 cp_parser_error (parser, "unknown property attribute");
27382 syntax_error = true;
27389 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
27390 cp_lexer_consume_token (parser->lexer);
27395 /* FIXME: "@property (setter, assign);" will generate a spurious
27396 "error: expected ‘)’ before ‘,’ token". This is because
27397 cp_parser_require, unlike the C counterpart, will produce an
27398 error even if we are in error recovery. */
27399 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
27401 cp_parser_skip_to_closing_parenthesis (parser,
27402 /*recovering=*/true,
27403 /*or_comma=*/false,
27404 /*consume_paren=*/true);
27408 /* ... and the property declaration(s). */
27409 properties = cp_parser_objc_struct_declaration (parser);
27411 if (properties == error_mark_node)
27413 cp_parser_skip_to_end_of_statement (parser);
27414 /* If the next token is now a `;', consume it. */
27415 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
27416 cp_lexer_consume_token (parser->lexer);
27420 if (properties == NULL_TREE)
27421 cp_parser_error (parser, "expected identifier");
27424 /* Comma-separated properties are chained together in
27425 reverse order; add them one by one. */
27426 properties = nreverse (properties);
27428 for (; properties; properties = TREE_CHAIN (properties))
27429 objc_add_property_declaration (loc, copy_node (properties),
27430 property_readonly, property_readwrite,
27431 property_assign, property_retain,
27432 property_copy, property_nonatomic,
27433 property_getter_ident, property_setter_ident);
27436 cp_parser_consume_semicolon_at_end_of_statement (parser);
27439 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
27441 objc-synthesize-declaration:
27442 @synthesize objc-synthesize-identifier-list ;
27444 objc-synthesize-identifier-list:
27445 objc-synthesize-identifier
27446 objc-synthesize-identifier-list, objc-synthesize-identifier
27448 objc-synthesize-identifier
27450 identifier = identifier
27453 @synthesize MyProperty;
27454 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
27456 PS: This function is identical to c_parser_objc_at_synthesize_declaration
27457 for C. Keep them in sync.
27460 cp_parser_objc_at_synthesize_declaration (cp_parser *parser)
27462 tree list = NULL_TREE;
27464 loc = cp_lexer_peek_token (parser->lexer)->location;
27466 cp_lexer_consume_token (parser->lexer); /* Eat '@synthesize'. */
27469 tree property, ivar;
27470 property = cp_parser_identifier (parser);
27471 if (property == error_mark_node)
27473 cp_parser_consume_semicolon_at_end_of_statement (parser);
27476 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
27478 cp_lexer_consume_token (parser->lexer);
27479 ivar = cp_parser_identifier (parser);
27480 if (ivar == error_mark_node)
27482 cp_parser_consume_semicolon_at_end_of_statement (parser);
27488 list = chainon (list, build_tree_list (ivar, property));
27489 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
27490 cp_lexer_consume_token (parser->lexer);
27494 cp_parser_consume_semicolon_at_end_of_statement (parser);
27495 objc_add_synthesize_declaration (loc, list);
27498 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
27500 objc-dynamic-declaration:
27501 @dynamic identifier-list ;
27504 @dynamic MyProperty;
27505 @dynamic MyProperty, AnotherProperty;
27507 PS: This function is identical to c_parser_objc_at_dynamic_declaration
27508 for C. Keep them in sync.
27511 cp_parser_objc_at_dynamic_declaration (cp_parser *parser)
27513 tree list = NULL_TREE;
27515 loc = cp_lexer_peek_token (parser->lexer)->location;
27517 cp_lexer_consume_token (parser->lexer); /* Eat '@dynamic'. */
27521 property = cp_parser_identifier (parser);
27522 if (property == error_mark_node)
27524 cp_parser_consume_semicolon_at_end_of_statement (parser);
27527 list = chainon (list, build_tree_list (NULL, property));
27528 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
27529 cp_lexer_consume_token (parser->lexer);
27533 cp_parser_consume_semicolon_at_end_of_statement (parser);
27534 objc_add_dynamic_declaration (loc, list);
27538 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 parsing routines. */
27540 /* Returns name of the next clause.
27541 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
27542 the token is not consumed. Otherwise appropriate pragma_omp_clause is
27543 returned and the token is consumed. */
27545 static pragma_omp_clause
27546 cp_parser_omp_clause_name (cp_parser *parser)
27548 pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE;
27550 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
27551 result = PRAGMA_OMP_CLAUSE_IF;
27552 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
27553 result = PRAGMA_OMP_CLAUSE_DEFAULT;
27554 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE))
27555 result = PRAGMA_OACC_CLAUSE_DELETE;
27556 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
27557 result = PRAGMA_OMP_CLAUSE_PRIVATE;
27558 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
27559 result = PRAGMA_OMP_CLAUSE_FOR;
27560 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
27562 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
27563 const char *p = IDENTIFIER_POINTER (id);
27568 if (!strcmp ("aligned", p))
27569 result = PRAGMA_OMP_CLAUSE_ALIGNED;
27570 else if (!strcmp ("async", p))
27571 result = PRAGMA_OACC_CLAUSE_ASYNC;
27574 if (!strcmp ("collapse", p))
27575 result = PRAGMA_OMP_CLAUSE_COLLAPSE;
27576 else if (!strcmp ("copy", p))
27577 result = PRAGMA_OACC_CLAUSE_COPY;
27578 else if (!strcmp ("copyin", p))
27579 result = PRAGMA_OMP_CLAUSE_COPYIN;
27580 else if (!strcmp ("copyout", p))
27581 result = PRAGMA_OACC_CLAUSE_COPYOUT;
27582 else if (!strcmp ("copyprivate", p))
27583 result = PRAGMA_OMP_CLAUSE_COPYPRIVATE;
27584 else if (!strcmp ("create", p))
27585 result = PRAGMA_OACC_CLAUSE_CREATE;
27588 if (!strcmp ("depend", p))
27589 result = PRAGMA_OMP_CLAUSE_DEPEND;
27590 else if (!strcmp ("device", p))
27591 result = PRAGMA_OMP_CLAUSE_DEVICE;
27592 else if (!strcmp ("deviceptr", p))
27593 result = PRAGMA_OACC_CLAUSE_DEVICEPTR;
27594 else if (!strcmp ("dist_schedule", p))
27595 result = PRAGMA_OMP_CLAUSE_DIST_SCHEDULE;
27598 if (!strcmp ("final", p))
27599 result = PRAGMA_OMP_CLAUSE_FINAL;
27600 else if (!strcmp ("firstprivate", p))
27601 result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE;
27602 else if (!strcmp ("from", p))
27603 result = PRAGMA_OMP_CLAUSE_FROM;
27606 if (!strcmp ("host", p))
27607 result = PRAGMA_OACC_CLAUSE_HOST;
27610 if (!strcmp ("inbranch", p))
27611 result = PRAGMA_OMP_CLAUSE_INBRANCH;
27614 if (!strcmp ("lastprivate", p))
27615 result = PRAGMA_OMP_CLAUSE_LASTPRIVATE;
27616 else if (!strcmp ("linear", p))
27617 result = PRAGMA_OMP_CLAUSE_LINEAR;
27620 if (!strcmp ("map", p))
27621 result = PRAGMA_OMP_CLAUSE_MAP;
27622 else if (!strcmp ("mergeable", p))
27623 result = PRAGMA_OMP_CLAUSE_MERGEABLE;
27624 else if (flag_cilkplus && !strcmp ("mask", p))
27625 result = PRAGMA_CILK_CLAUSE_MASK;
27628 if (!strcmp ("notinbranch", p))
27629 result = PRAGMA_OMP_CLAUSE_NOTINBRANCH;
27630 else if (!strcmp ("nowait", p))
27631 result = PRAGMA_OMP_CLAUSE_NOWAIT;
27632 else if (flag_cilkplus && !strcmp ("nomask", p))
27633 result = PRAGMA_CILK_CLAUSE_NOMASK;
27634 else if (!strcmp ("num_gangs", p))
27635 result = PRAGMA_OACC_CLAUSE_NUM_GANGS;
27636 else if (!strcmp ("num_teams", p))
27637 result = PRAGMA_OMP_CLAUSE_NUM_TEAMS;
27638 else if (!strcmp ("num_threads", p))
27639 result = PRAGMA_OMP_CLAUSE_NUM_THREADS;
27640 else if (!strcmp ("num_workers", p))
27641 result = PRAGMA_OACC_CLAUSE_NUM_WORKERS;
27644 if (!strcmp ("ordered", p))
27645 result = PRAGMA_OMP_CLAUSE_ORDERED;
27648 if (!strcmp ("parallel", p))
27649 result = PRAGMA_OMP_CLAUSE_PARALLEL;
27650 else if (!strcmp ("present", p))
27651 result = PRAGMA_OACC_CLAUSE_PRESENT;
27652 else if (!strcmp ("present_or_copy", p)
27653 || !strcmp ("pcopy", p))
27654 result = PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY;
27655 else if (!strcmp ("present_or_copyin", p)
27656 || !strcmp ("pcopyin", p))
27657 result = PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN;
27658 else if (!strcmp ("present_or_copyout", p)
27659 || !strcmp ("pcopyout", p))
27660 result = PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT;
27661 else if (!strcmp ("present_or_create", p)
27662 || !strcmp ("pcreate", p))
27663 result = PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE;
27664 else if (!strcmp ("proc_bind", p))
27665 result = PRAGMA_OMP_CLAUSE_PROC_BIND;
27668 if (!strcmp ("reduction", p))
27669 result = PRAGMA_OMP_CLAUSE_REDUCTION;
27672 if (!strcmp ("safelen", p))
27673 result = PRAGMA_OMP_CLAUSE_SAFELEN;
27674 else if (!strcmp ("schedule", p))
27675 result = PRAGMA_OMP_CLAUSE_SCHEDULE;
27676 else if (!strcmp ("sections", p))
27677 result = PRAGMA_OMP_CLAUSE_SECTIONS;
27678 else if (!strcmp ("self", p))
27679 result = PRAGMA_OACC_CLAUSE_SELF;
27680 else if (!strcmp ("shared", p))
27681 result = PRAGMA_OMP_CLAUSE_SHARED;
27682 else if (!strcmp ("simdlen", p))
27683 result = PRAGMA_OMP_CLAUSE_SIMDLEN;
27686 if (!strcmp ("taskgroup", p))
27687 result = PRAGMA_OMP_CLAUSE_TASKGROUP;
27688 else if (!strcmp ("thread_limit", p))
27689 result = PRAGMA_OMP_CLAUSE_THREAD_LIMIT;
27690 else if (!strcmp ("to", p))
27691 result = PRAGMA_OMP_CLAUSE_TO;
27694 if (!strcmp ("uniform", p))
27695 result = PRAGMA_OMP_CLAUSE_UNIFORM;
27696 else if (!strcmp ("untied", p))
27697 result = PRAGMA_OMP_CLAUSE_UNTIED;
27700 if (!strcmp ("vector_length", p))
27701 result = PRAGMA_OACC_CLAUSE_VECTOR_LENGTH;
27702 else if (flag_cilkplus && !strcmp ("vectorlength", p))
27703 result = PRAGMA_CILK_CLAUSE_VECTORLENGTH;
27706 if (!strcmp ("wait", p))
27707 result = PRAGMA_OACC_CLAUSE_WAIT;
27712 if (result != PRAGMA_OMP_CLAUSE_NONE)
27713 cp_lexer_consume_token (parser->lexer);
27718 /* Validate that a clause of the given type does not already exist. */
27721 check_no_duplicate_clause (tree clauses, enum omp_clause_code code,
27722 const char *name, location_t location)
27726 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
27727 if (OMP_CLAUSE_CODE (c) == code)
27729 error_at (location, "too many %qs clauses", name);
27737 variable-list , identifier
27739 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
27740 colon). An opening parenthesis will have been consumed by the caller.
27742 If KIND is nonzero, create the appropriate node and install the decl
27743 in OMP_CLAUSE_DECL and add the node to the head of the list.
27745 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
27746 return the list created.
27748 COLON can be NULL if only closing parenthesis should end the list,
27749 or pointer to bool which will receive false if the list is terminated
27750 by closing parenthesis or true if the list is terminated by colon. */
27753 cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
27754 tree list, bool *colon)
27757 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
27760 parser->colon_corrects_to_scope_p = false;
27767 token = cp_lexer_peek_token (parser->lexer);
27768 name = cp_parser_id_expression (parser, /*template_p=*/false,
27769 /*check_dependency_p=*/true,
27770 /*template_p=*/NULL,
27771 /*declarator_p=*/false,
27772 /*optional_p=*/false);
27773 if (name == error_mark_node)
27776 decl = cp_parser_lookup_name_simple (parser, name, token->location);
27777 if (decl == error_mark_node)
27778 cp_parser_name_lookup_error (parser, name, decl, NLE_NULL,
27780 else if (kind != 0)
27784 case OMP_CLAUSE__CACHE_:
27785 if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_SQUARE)
27787 error_at (token->location, "expected %<[%>");
27788 decl = error_mark_node;
27791 /* FALL THROUGH. */
27792 case OMP_CLAUSE_MAP:
27793 case OMP_CLAUSE_FROM:
27794 case OMP_CLAUSE_TO:
27795 case OMP_CLAUSE_DEPEND:
27796 while (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
27798 tree low_bound = NULL_TREE, length = NULL_TREE;
27800 parser->colon_corrects_to_scope_p = false;
27801 cp_lexer_consume_token (parser->lexer);
27802 if (!cp_lexer_next_token_is (parser->lexer, CPP_COLON))
27803 low_bound = cp_parser_expression (parser);
27805 parser->colon_corrects_to_scope_p
27806 = saved_colon_corrects_to_scope_p;
27807 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
27808 length = integer_one_node;
27811 /* Look for `:'. */
27812 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
27814 if (!cp_lexer_next_token_is (parser->lexer,
27816 length = cp_parser_expression (parser);
27818 /* Look for the closing `]'. */
27819 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE,
27823 if (kind == OMP_CLAUSE__CACHE_)
27825 if (TREE_CODE (low_bound) != INTEGER_CST
27826 && !TREE_READONLY (low_bound))
27828 error_at (token->location,
27829 "%qD is not a constant", low_bound);
27830 decl = error_mark_node;
27833 if (TREE_CODE (length) != INTEGER_CST
27834 && !TREE_READONLY (length))
27836 error_at (token->location,
27837 "%qD is not a constant", length);
27838 decl = error_mark_node;
27842 decl = tree_cons (low_bound, length, decl);
27849 tree u = build_omp_clause (token->location, kind);
27850 OMP_CLAUSE_DECL (u) = decl;
27851 OMP_CLAUSE_CHAIN (u) = list;
27855 list = tree_cons (decl, NULL_TREE, list);
27858 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
27860 cp_lexer_consume_token (parser->lexer);
27864 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
27866 if (colon != NULL && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
27869 cp_parser_require (parser, CPP_COLON, RT_COLON);
27873 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
27877 /* Try to resync to an unnested comma. Copied from
27878 cp_parser_parenthesized_expression_list. */
27881 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
27882 ending = cp_parser_skip_to_closing_parenthesis (parser,
27883 /*recovering=*/true,
27885 /*consume_paren=*/true);
27893 /* Similarly, but expect leading and trailing parenthesis. This is a very
27894 common case for omp clauses. */
27897 cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list)
27899 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
27900 return cp_parser_omp_var_list_no_open (parser, kind, list, NULL);
27905 copy ( variable-list )
27906 copyin ( variable-list )
27907 copyout ( variable-list )
27908 create ( variable-list )
27909 delete ( variable-list )
27910 present ( variable-list )
27911 present_or_copy ( variable-list )
27912 pcopy ( variable-list )
27913 present_or_copyin ( variable-list )
27914 pcopyin ( variable-list )
27915 present_or_copyout ( variable-list )
27916 pcopyout ( variable-list )
27917 present_or_create ( variable-list )
27918 pcreate ( variable-list ) */
27921 cp_parser_oacc_data_clause (cp_parser *parser, pragma_omp_clause c_kind,
27924 enum gomp_map_kind kind;
27927 case PRAGMA_OACC_CLAUSE_COPY:
27928 kind = GOMP_MAP_FORCE_TOFROM;
27930 case PRAGMA_OACC_CLAUSE_COPYIN:
27931 kind = GOMP_MAP_FORCE_TO;
27933 case PRAGMA_OACC_CLAUSE_COPYOUT:
27934 kind = GOMP_MAP_FORCE_FROM;
27936 case PRAGMA_OACC_CLAUSE_CREATE:
27937 kind = GOMP_MAP_FORCE_ALLOC;
27939 case PRAGMA_OACC_CLAUSE_DELETE:
27940 kind = GOMP_MAP_FORCE_DEALLOC;
27942 case PRAGMA_OACC_CLAUSE_DEVICE:
27943 kind = GOMP_MAP_FORCE_TO;
27945 case PRAGMA_OACC_CLAUSE_HOST:
27946 case PRAGMA_OACC_CLAUSE_SELF:
27947 kind = GOMP_MAP_FORCE_FROM;
27949 case PRAGMA_OACC_CLAUSE_PRESENT:
27950 kind = GOMP_MAP_FORCE_PRESENT;
27952 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY:
27953 kind = GOMP_MAP_TOFROM;
27955 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN:
27956 kind = GOMP_MAP_TO;
27958 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT:
27959 kind = GOMP_MAP_FROM;
27961 case PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE:
27962 kind = GOMP_MAP_ALLOC;
27965 gcc_unreachable ();
27968 nl = cp_parser_omp_var_list (parser, OMP_CLAUSE_MAP, list);
27970 for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c))
27971 OMP_CLAUSE_SET_MAP_KIND (c, kind);
27977 deviceptr ( variable-list ) */
27980 cp_parser_oacc_data_clause_deviceptr (cp_parser *parser, tree list)
27982 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
27985 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
27986 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
27987 variable-list must only allow for pointer variables. */
27988 vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
27989 for (t = vars; t; t = TREE_CHAIN (t))
27991 tree v = TREE_PURPOSE (t);
27993 /* FIXME diagnostics: Ideally we should keep individual
27994 locations for all the variables in the var list to make the
27995 following errors more precise. Perhaps
27996 c_parser_omp_var_list_parens should construct a list of
27997 locations to go along with the var list. */
27999 if (TREE_CODE (v) != VAR_DECL)
28000 error_at (loc, "%qD is not a variable", v);
28001 else if (TREE_TYPE (v) == error_mark_node)
28003 else if (!POINTER_TYPE_P (TREE_TYPE (v)))
28004 error_at (loc, "%qD is not a pointer variable", v);
28006 tree u = build_omp_clause (loc, OMP_CLAUSE_MAP);
28007 OMP_CLAUSE_SET_MAP_KIND (u, GOMP_MAP_FORCE_DEVICEPTR);
28008 OMP_CLAUSE_DECL (u) = v;
28009 OMP_CLAUSE_CHAIN (u) = list;
28017 vector_length ( expression ) */
28020 cp_parser_oacc_clause_vector_length (cp_parser *parser, tree list)
28023 location_t location = cp_lexer_peek_token (parser->lexer)->location;
28024 bool error = false;
28026 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28029 t = cp_parser_condition (parser);
28030 if (t == error_mark_node || !INTEGRAL_TYPE_P (TREE_TYPE (t)))
28032 error_at (location, "expected positive integer expression");
28036 if (error || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28038 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28039 /*or_comma=*/false,
28040 /*consume_paren=*/true);
28044 check_no_duplicate_clause (list, OMP_CLAUSE_VECTOR_LENGTH, "vector_length",
28047 c = build_omp_clause (location, OMP_CLAUSE_VECTOR_LENGTH);
28048 OMP_CLAUSE_VECTOR_LENGTH_EXPR (c) = t;
28049 OMP_CLAUSE_CHAIN (c) = list;
28056 Parse wait clause or directive parameters. */
28059 cp_parser_oacc_wait_list (cp_parser *parser, location_t clause_loc, tree list)
28061 vec<tree, va_gc> *args;
28064 args = cp_parser_parenthesized_expression_list (parser, non_attr,
28066 /*allow_expansion_p=*/true,
28067 /*non_constant_p=*/NULL);
28069 if (args == NULL || args->length () == 0)
28071 cp_parser_error (parser, "expected integer expression before ')'");
28073 release_tree_vector (args);
28077 args_tree = build_tree_list_vec (args);
28079 release_tree_vector (args);
28081 for (t = args_tree; t; t = TREE_CHAIN (t))
28083 tree targ = TREE_VALUE (t);
28085 if (targ != error_mark_node)
28087 if (!INTEGRAL_TYPE_P (TREE_TYPE (targ)))
28088 error ("%<wait%> expression must be integral");
28091 tree c = build_omp_clause (clause_loc, OMP_CLAUSE_WAIT);
28093 mark_rvalue_use (targ);
28094 OMP_CLAUSE_DECL (c) = targ;
28095 OMP_CLAUSE_CHAIN (c) = list;
28105 wait ( int-expr-list ) */
28108 cp_parser_oacc_clause_wait (cp_parser *parser, tree list)
28110 location_t location = cp_lexer_peek_token (parser->lexer)->location;
28112 if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_PAREN)
28115 list = cp_parser_oacc_wait_list (parser, location, list);
28121 collapse ( constant-expression ) */
28124 cp_parser_omp_clause_collapse (cp_parser *parser, tree list, location_t location)
28130 loc = cp_lexer_peek_token (parser->lexer)->location;
28131 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28134 num = cp_parser_constant_expression (parser);
28136 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28137 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28138 /*or_comma=*/false,
28139 /*consume_paren=*/true);
28141 if (num == error_mark_node)
28143 num = fold_non_dependent_expr (num);
28144 if (!INTEGRAL_TYPE_P (TREE_TYPE (num))
28145 || !tree_fits_shwi_p (num)
28146 || (n = tree_to_shwi (num)) <= 0
28149 error_at (loc, "collapse argument needs positive constant integer expression");
28153 check_no_duplicate_clause (list, OMP_CLAUSE_COLLAPSE, "collapse", location);
28154 c = build_omp_clause (loc, OMP_CLAUSE_COLLAPSE);
28155 OMP_CLAUSE_CHAIN (c) = list;
28156 OMP_CLAUSE_COLLAPSE_EXPR (c) = num;
28162 default ( shared | none ) */
28165 cp_parser_omp_clause_default (cp_parser *parser, tree list, location_t location)
28167 enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
28170 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28172 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
28174 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
28175 const char *p = IDENTIFIER_POINTER (id);
28180 if (strcmp ("none", p) != 0)
28182 kind = OMP_CLAUSE_DEFAULT_NONE;
28186 if (strcmp ("shared", p) != 0)
28188 kind = OMP_CLAUSE_DEFAULT_SHARED;
28195 cp_lexer_consume_token (parser->lexer);
28200 cp_parser_error (parser, "expected %<none%> or %<shared%>");
28203 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28204 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28205 /*or_comma=*/false,
28206 /*consume_paren=*/true);
28208 if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED)
28211 check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default", location);
28212 c = build_omp_clause (location, OMP_CLAUSE_DEFAULT);
28213 OMP_CLAUSE_CHAIN (c) = list;
28214 OMP_CLAUSE_DEFAULT_KIND (c) = kind;
28220 final ( expression ) */
28223 cp_parser_omp_clause_final (cp_parser *parser, tree list, location_t location)
28227 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28230 t = cp_parser_condition (parser);
28232 if (t == error_mark_node
28233 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28234 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28235 /*or_comma=*/false,
28236 /*consume_paren=*/true);
28238 check_no_duplicate_clause (list, OMP_CLAUSE_FINAL, "final", location);
28240 c = build_omp_clause (location, OMP_CLAUSE_FINAL);
28241 OMP_CLAUSE_FINAL_EXPR (c) = t;
28242 OMP_CLAUSE_CHAIN (c) = list;
28248 if ( expression ) */
28251 cp_parser_omp_clause_if (cp_parser *parser, tree list, location_t location)
28255 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28258 t = cp_parser_condition (parser);
28260 if (t == error_mark_node
28261 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28262 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28263 /*or_comma=*/false,
28264 /*consume_paren=*/true);
28266 check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if", location);
28268 c = build_omp_clause (location, OMP_CLAUSE_IF);
28269 OMP_CLAUSE_IF_EXPR (c) = t;
28270 OMP_CLAUSE_CHAIN (c) = list;
28279 cp_parser_omp_clause_mergeable (cp_parser * /*parser*/,
28280 tree list, location_t location)
28284 check_no_duplicate_clause (list, OMP_CLAUSE_MERGEABLE, "mergeable",
28287 c = build_omp_clause (location, OMP_CLAUSE_MERGEABLE);
28288 OMP_CLAUSE_CHAIN (c) = list;
28296 cp_parser_omp_clause_nowait (cp_parser * /*parser*/,
28297 tree list, location_t location)
28301 check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait", location);
28303 c = build_omp_clause (location, OMP_CLAUSE_NOWAIT);
28304 OMP_CLAUSE_CHAIN (c) = list;
28309 num_gangs ( expression ) */
28312 cp_parser_omp_clause_num_gangs (cp_parser *parser, tree list)
28315 location_t location = cp_lexer_peek_token (parser->lexer)->location;
28317 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28320 t = cp_parser_condition (parser);
28322 if (t == error_mark_node
28323 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28324 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28325 /*or_comma=*/false,
28326 /*consume_paren=*/true);
28328 if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
28330 error_at (location, "expected positive integer expression");
28334 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_GANGS, "num_gangs", location);
28336 c = build_omp_clause (location, OMP_CLAUSE_NUM_GANGS);
28337 OMP_CLAUSE_NUM_GANGS_EXPR (c) = t;
28338 OMP_CLAUSE_CHAIN (c) = list;
28345 num_threads ( expression ) */
28348 cp_parser_omp_clause_num_threads (cp_parser *parser, tree list,
28349 location_t location)
28353 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28356 t = cp_parser_expression (parser);
28358 if (t == error_mark_node
28359 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28360 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28361 /*or_comma=*/false,
28362 /*consume_paren=*/true);
28364 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS,
28365 "num_threads", location);
28367 c = build_omp_clause (location, OMP_CLAUSE_NUM_THREADS);
28368 OMP_CLAUSE_NUM_THREADS_EXPR (c) = t;
28369 OMP_CLAUSE_CHAIN (c) = list;
28375 num_workers ( expression ) */
28378 cp_parser_omp_clause_num_workers (cp_parser *parser, tree list)
28381 location_t location = cp_lexer_peek_token (parser->lexer)->location;
28383 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28386 t = cp_parser_condition (parser);
28388 if (t == error_mark_node
28389 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28390 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28391 /*or_comma=*/false,
28392 /*consume_paren=*/true);
28394 if (!INTEGRAL_TYPE_P (TREE_TYPE (t)))
28396 error_at (location, "expected positive integer expression");
28400 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_WORKERS, "num_gangs",
28403 c = build_omp_clause (location, OMP_CLAUSE_NUM_WORKERS);
28404 OMP_CLAUSE_NUM_WORKERS_EXPR (c) = t;
28405 OMP_CLAUSE_CHAIN (c) = list;
28415 cp_parser_omp_clause_ordered (cp_parser * /*parser*/,
28416 tree list, location_t location)
28420 check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED,
28421 "ordered", location);
28423 c = build_omp_clause (location, OMP_CLAUSE_ORDERED);
28424 OMP_CLAUSE_CHAIN (c) = list;
28429 reduction ( reduction-operator : variable-list )
28431 reduction-operator:
28432 One of: + * - & ^ | && ||
28436 reduction-operator:
28437 One of: + * - & ^ | && || min max
28441 reduction-operator:
28442 One of: + * - & ^ | && ||
28446 cp_parser_omp_clause_reduction (cp_parser *parser, tree list)
28448 enum tree_code code = ERROR_MARK;
28449 tree nlist, c, id = NULL_TREE;
28451 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28454 switch (cp_lexer_peek_token (parser->lexer)->type)
28456 case CPP_PLUS: code = PLUS_EXPR; break;
28457 case CPP_MULT: code = MULT_EXPR; break;
28458 case CPP_MINUS: code = MINUS_EXPR; break;
28459 case CPP_AND: code = BIT_AND_EXPR; break;
28460 case CPP_XOR: code = BIT_XOR_EXPR; break;
28461 case CPP_OR: code = BIT_IOR_EXPR; break;
28462 case CPP_AND_AND: code = TRUTH_ANDIF_EXPR; break;
28463 case CPP_OR_OR: code = TRUTH_ORIF_EXPR; break;
28467 if (code != ERROR_MARK)
28468 cp_lexer_consume_token (parser->lexer);
28471 bool saved_colon_corrects_to_scope_p;
28472 saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
28473 parser->colon_corrects_to_scope_p = false;
28474 id = cp_parser_id_expression (parser, /*template_p=*/false,
28475 /*check_dependency_p=*/true,
28476 /*template_p=*/NULL,
28477 /*declarator_p=*/false,
28478 /*optional_p=*/false);
28479 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
28480 if (identifier_p (id))
28482 const char *p = IDENTIFIER_POINTER (id);
28484 if (strcmp (p, "min") == 0)
28486 else if (strcmp (p, "max") == 0)
28488 else if (id == ansi_opname (PLUS_EXPR))
28490 else if (id == ansi_opname (MULT_EXPR))
28492 else if (id == ansi_opname (MINUS_EXPR))
28494 else if (id == ansi_opname (BIT_AND_EXPR))
28495 code = BIT_AND_EXPR;
28496 else if (id == ansi_opname (BIT_IOR_EXPR))
28497 code = BIT_IOR_EXPR;
28498 else if (id == ansi_opname (BIT_XOR_EXPR))
28499 code = BIT_XOR_EXPR;
28500 else if (id == ansi_opname (TRUTH_ANDIF_EXPR))
28501 code = TRUTH_ANDIF_EXPR;
28502 else if (id == ansi_opname (TRUTH_ORIF_EXPR))
28503 code = TRUTH_ORIF_EXPR;
28504 id = omp_reduction_id (code, id, NULL_TREE);
28505 tree scope = parser->scope;
28507 id = build_qualified_name (NULL_TREE, scope, id, false);
28508 parser->scope = NULL_TREE;
28509 parser->qualifying_scope = NULL_TREE;
28510 parser->object_scope = NULL_TREE;
28514 error ("invalid reduction-identifier");
28516 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28517 /*or_comma=*/false,
28518 /*consume_paren=*/true);
28523 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
28526 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list,
28528 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
28530 OMP_CLAUSE_REDUCTION_CODE (c) = code;
28531 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c) = id;
28538 schedule ( schedule-kind )
28539 schedule ( schedule-kind , expression )
28542 static | dynamic | guided | runtime | auto */
28545 cp_parser_omp_clause_schedule (cp_parser *parser, tree list, location_t location)
28549 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28552 c = build_omp_clause (location, OMP_CLAUSE_SCHEDULE);
28554 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
28556 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
28557 const char *p = IDENTIFIER_POINTER (id);
28562 if (strcmp ("dynamic", p) != 0)
28564 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC;
28568 if (strcmp ("guided", p) != 0)
28570 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED;
28574 if (strcmp ("runtime", p) != 0)
28576 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME;
28583 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
28584 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC;
28585 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
28586 OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_AUTO;
28589 cp_lexer_consume_token (parser->lexer);
28591 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
28594 cp_lexer_consume_token (parser->lexer);
28596 token = cp_lexer_peek_token (parser->lexer);
28597 t = cp_parser_assignment_expression (parser);
28599 if (t == error_mark_node)
28601 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME)
28602 error_at (token->location, "schedule %<runtime%> does not take "
28603 "a %<chunk_size%> parameter");
28604 else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_AUTO)
28605 error_at (token->location, "schedule %<auto%> does not take "
28606 "a %<chunk_size%> parameter");
28608 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t;
28610 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28613 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
28616 check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule", location);
28617 OMP_CLAUSE_CHAIN (c) = list;
28621 cp_parser_error (parser, "invalid schedule kind");
28623 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28624 /*or_comma=*/false,
28625 /*consume_paren=*/true);
28633 cp_parser_omp_clause_untied (cp_parser * /*parser*/,
28634 tree list, location_t location)
28638 check_no_duplicate_clause (list, OMP_CLAUSE_UNTIED, "untied", location);
28640 c = build_omp_clause (location, OMP_CLAUSE_UNTIED);
28641 OMP_CLAUSE_CHAIN (c) = list;
28650 cp_parser_omp_clause_branch (cp_parser * /*parser*/, enum omp_clause_code code,
28651 tree list, location_t location)
28653 check_no_duplicate_clause (list, code, omp_clause_code_name[code], location);
28654 tree c = build_omp_clause (location, code);
28655 OMP_CLAUSE_CHAIN (c) = list;
28666 cp_parser_omp_clause_cancelkind (cp_parser * /*parser*/,
28667 enum omp_clause_code code,
28668 tree list, location_t location)
28670 tree c = build_omp_clause (location, code);
28671 OMP_CLAUSE_CHAIN (c) = list;
28676 num_teams ( expression ) */
28679 cp_parser_omp_clause_num_teams (cp_parser *parser, tree list,
28680 location_t location)
28684 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28687 t = cp_parser_expression (parser);
28689 if (t == error_mark_node
28690 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28691 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28692 /*or_comma=*/false,
28693 /*consume_paren=*/true);
28695 check_no_duplicate_clause (list, OMP_CLAUSE_NUM_TEAMS,
28696 "num_teams", location);
28698 c = build_omp_clause (location, OMP_CLAUSE_NUM_TEAMS);
28699 OMP_CLAUSE_NUM_TEAMS_EXPR (c) = t;
28700 OMP_CLAUSE_CHAIN (c) = list;
28706 thread_limit ( expression ) */
28709 cp_parser_omp_clause_thread_limit (cp_parser *parser, tree list,
28710 location_t location)
28714 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28717 t = cp_parser_expression (parser);
28719 if (t == error_mark_node
28720 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28721 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28722 /*or_comma=*/false,
28723 /*consume_paren=*/true);
28725 check_no_duplicate_clause (list, OMP_CLAUSE_THREAD_LIMIT,
28726 "thread_limit", location);
28728 c = build_omp_clause (location, OMP_CLAUSE_THREAD_LIMIT);
28729 OMP_CLAUSE_THREAD_LIMIT_EXPR (c) = t;
28730 OMP_CLAUSE_CHAIN (c) = list;
28736 aligned ( variable-list )
28737 aligned ( variable-list : constant-expression ) */
28740 cp_parser_omp_clause_aligned (cp_parser *parser, tree list)
28742 tree nlist, c, alignment = NULL_TREE;
28745 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28748 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_ALIGNED, list,
28753 alignment = cp_parser_constant_expression (parser);
28755 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28756 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28757 /*or_comma=*/false,
28758 /*consume_paren=*/true);
28760 if (alignment == error_mark_node)
28761 alignment = NULL_TREE;
28764 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
28765 OMP_CLAUSE_ALIGNED_ALIGNMENT (c) = alignment;
28771 linear ( variable-list )
28772 linear ( variable-list : expression ) */
28775 cp_parser_omp_clause_linear (cp_parser *parser, tree list,
28776 bool is_cilk_simd_fn)
28778 tree nlist, c, step = integer_one_node;
28781 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28784 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_LINEAR, list,
28789 step = cp_parser_expression (parser);
28791 if (is_cilk_simd_fn && TREE_CODE (step) == PARM_DECL)
28793 sorry ("using parameters for %<linear%> step is not supported yet");
28794 step = integer_one_node;
28796 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28797 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28798 /*or_comma=*/false,
28799 /*consume_paren=*/true);
28801 if (step == error_mark_node)
28805 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
28806 OMP_CLAUSE_LINEAR_STEP (c) = step;
28812 safelen ( constant-expression ) */
28815 cp_parser_omp_clause_safelen (cp_parser *parser, tree list,
28816 location_t location)
28820 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28823 t = cp_parser_constant_expression (parser);
28825 if (t == error_mark_node
28826 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28827 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28828 /*or_comma=*/false,
28829 /*consume_paren=*/true);
28831 check_no_duplicate_clause (list, OMP_CLAUSE_SAFELEN, "safelen", location);
28833 c = build_omp_clause (location, OMP_CLAUSE_SAFELEN);
28834 OMP_CLAUSE_SAFELEN_EXPR (c) = t;
28835 OMP_CLAUSE_CHAIN (c) = list;
28841 simdlen ( constant-expression ) */
28844 cp_parser_omp_clause_simdlen (cp_parser *parser, tree list,
28845 location_t location)
28849 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28852 t = cp_parser_constant_expression (parser);
28854 if (t == error_mark_node
28855 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28856 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28857 /*or_comma=*/false,
28858 /*consume_paren=*/true);
28860 check_no_duplicate_clause (list, OMP_CLAUSE_SIMDLEN, "simdlen", location);
28862 c = build_omp_clause (location, OMP_CLAUSE_SIMDLEN);
28863 OMP_CLAUSE_SIMDLEN_EXPR (c) = t;
28864 OMP_CLAUSE_CHAIN (c) = list;
28870 depend ( depend-kind : variable-list )
28873 in | out | inout */
28876 cp_parser_omp_clause_depend (cp_parser *parser, tree list)
28879 enum omp_clause_depend_kind kind = OMP_CLAUSE_DEPEND_INOUT;
28881 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28884 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
28886 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
28887 const char *p = IDENTIFIER_POINTER (id);
28889 if (strcmp ("in", p) == 0)
28890 kind = OMP_CLAUSE_DEPEND_IN;
28891 else if (strcmp ("inout", p) == 0)
28892 kind = OMP_CLAUSE_DEPEND_INOUT;
28893 else if (strcmp ("out", p) == 0)
28894 kind = OMP_CLAUSE_DEPEND_OUT;
28901 cp_lexer_consume_token (parser->lexer);
28902 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
28905 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_DEPEND, list,
28908 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
28909 OMP_CLAUSE_DEPEND_KIND (c) = kind;
28914 cp_parser_error (parser, "invalid depend kind");
28916 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28917 /*or_comma=*/false,
28918 /*consume_paren=*/true);
28923 map ( map-kind : variable-list )
28924 map ( variable-list )
28927 alloc | to | from | tofrom */
28930 cp_parser_omp_clause_map (cp_parser *parser, tree list)
28933 enum gomp_map_kind kind = GOMP_MAP_TOFROM;
28935 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28938 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
28939 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
28941 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
28942 const char *p = IDENTIFIER_POINTER (id);
28944 if (strcmp ("alloc", p) == 0)
28945 kind = GOMP_MAP_ALLOC;
28946 else if (strcmp ("to", p) == 0)
28947 kind = GOMP_MAP_TO;
28948 else if (strcmp ("from", p) == 0)
28949 kind = GOMP_MAP_FROM;
28950 else if (strcmp ("tofrom", p) == 0)
28951 kind = GOMP_MAP_TOFROM;
28954 cp_parser_error (parser, "invalid map kind");
28955 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28956 /*or_comma=*/false,
28957 /*consume_paren=*/true);
28960 cp_lexer_consume_token (parser->lexer);
28961 cp_lexer_consume_token (parser->lexer);
28964 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_MAP, list,
28967 for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c))
28968 OMP_CLAUSE_SET_MAP_KIND (c, kind);
28974 device ( expression ) */
28977 cp_parser_omp_clause_device (cp_parser *parser, tree list,
28978 location_t location)
28982 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28985 t = cp_parser_expression (parser);
28987 if (t == error_mark_node
28988 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
28989 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
28990 /*or_comma=*/false,
28991 /*consume_paren=*/true);
28993 check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE,
28994 "device", location);
28996 c = build_omp_clause (location, OMP_CLAUSE_DEVICE);
28997 OMP_CLAUSE_DEVICE_ID (c) = t;
28998 OMP_CLAUSE_CHAIN (c) = list;
29004 dist_schedule ( static )
29005 dist_schedule ( static , expression ) */
29008 cp_parser_omp_clause_dist_schedule (cp_parser *parser, tree list,
29009 location_t location)
29013 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
29016 c = build_omp_clause (location, OMP_CLAUSE_DIST_SCHEDULE);
29018 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
29020 cp_lexer_consume_token (parser->lexer);
29022 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
29024 cp_lexer_consume_token (parser->lexer);
29026 t = cp_parser_assignment_expression (parser);
29028 if (t == error_mark_node)
29030 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c) = t;
29032 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
29035 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
29038 check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE, "dist_schedule",
29040 OMP_CLAUSE_CHAIN (c) = list;
29044 cp_parser_error (parser, "invalid dist_schedule kind");
29046 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
29047 /*or_comma=*/false,
29048 /*consume_paren=*/true);
29053 proc_bind ( proc-bind-kind )
29056 master | close | spread */
29059 cp_parser_omp_clause_proc_bind (cp_parser *parser, tree list,
29060 location_t location)
29063 enum omp_clause_proc_bind_kind kind;
29065 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
29068 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
29070 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
29071 const char *p = IDENTIFIER_POINTER (id);
29073 if (strcmp ("master", p) == 0)
29074 kind = OMP_CLAUSE_PROC_BIND_MASTER;
29075 else if (strcmp ("close", p) == 0)
29076 kind = OMP_CLAUSE_PROC_BIND_CLOSE;
29077 else if (strcmp ("spread", p) == 0)
29078 kind = OMP_CLAUSE_PROC_BIND_SPREAD;
29085 cp_lexer_consume_token (parser->lexer);
29086 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
29089 c = build_omp_clause (location, OMP_CLAUSE_PROC_BIND);
29090 check_no_duplicate_clause (list, OMP_CLAUSE_PROC_BIND, "proc_bind",
29092 OMP_CLAUSE_PROC_BIND_KIND (c) = kind;
29093 OMP_CLAUSE_CHAIN (c) = list;
29097 cp_parser_error (parser, "invalid depend kind");
29099 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
29100 /*or_comma=*/false,
29101 /*consume_paren=*/true);
29106 async [( int-expr )] */
29109 cp_parser_oacc_clause_async (cp_parser *parser, tree list)
29112 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
29114 t = build_int_cst (integer_type_node, GOMP_ASYNC_NOVAL);
29116 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
29118 cp_lexer_consume_token (parser->lexer);
29120 t = cp_parser_expression (parser);
29121 if (t == error_mark_node
29122 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
29123 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
29124 /*or_comma=*/false,
29125 /*consume_paren=*/true);
29128 check_no_duplicate_clause (list, OMP_CLAUSE_ASYNC, "async", loc);
29130 c = build_omp_clause (loc, OMP_CLAUSE_ASYNC);
29131 OMP_CLAUSE_ASYNC_EXPR (c) = t;
29132 OMP_CLAUSE_CHAIN (c) = list;
29138 /* Parse all OpenACC clauses. The set clauses allowed by the directive
29139 is a bitmask in MASK. Return the list of clauses found. */
29142 cp_parser_oacc_all_clauses (cp_parser *parser, omp_clause_mask mask,
29143 const char *where, cp_token *pragma_tok,
29144 bool finish_p = true)
29146 tree clauses = NULL;
29149 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
29152 pragma_omp_clause c_kind;
29153 const char *c_name;
29154 tree prev = clauses;
29156 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
29157 cp_lexer_consume_token (parser->lexer);
29159 here = cp_lexer_peek_token (parser->lexer)->location;
29160 c_kind = cp_parser_omp_clause_name (parser);
29164 case PRAGMA_OACC_CLAUSE_ASYNC:
29165 clauses = cp_parser_oacc_clause_async (parser, clauses);
29168 case PRAGMA_OACC_CLAUSE_COLLAPSE:
29169 clauses = cp_parser_omp_clause_collapse (parser, clauses, here);
29170 c_name = "collapse";
29172 case PRAGMA_OACC_CLAUSE_COPY:
29173 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29176 case PRAGMA_OACC_CLAUSE_COPYIN:
29177 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29180 case PRAGMA_OACC_CLAUSE_COPYOUT:
29181 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29182 c_name = "copyout";
29184 case PRAGMA_OACC_CLAUSE_CREATE:
29185 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29188 case PRAGMA_OACC_CLAUSE_DELETE:
29189 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29192 case PRAGMA_OACC_CLAUSE_DEVICE:
29193 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29196 case PRAGMA_OACC_CLAUSE_DEVICEPTR:
29197 clauses = cp_parser_oacc_data_clause_deviceptr (parser, clauses);
29198 c_name = "deviceptr";
29200 case PRAGMA_OACC_CLAUSE_HOST:
29201 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29204 case PRAGMA_OACC_CLAUSE_IF:
29205 clauses = cp_parser_omp_clause_if (parser, clauses, here);
29208 case PRAGMA_OACC_CLAUSE_NUM_GANGS:
29209 clauses = cp_parser_omp_clause_num_gangs (parser, clauses);
29210 c_name = "num_gangs";
29212 case PRAGMA_OACC_CLAUSE_NUM_WORKERS:
29213 clauses = cp_parser_omp_clause_num_workers (parser, clauses);
29214 c_name = "num_workers";
29216 case PRAGMA_OACC_CLAUSE_PRESENT:
29217 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29218 c_name = "present";
29220 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY:
29221 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29222 c_name = "present_or_copy";
29224 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN:
29225 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29226 c_name = "present_or_copyin";
29228 case PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT:
29229 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29230 c_name = "present_or_copyout";
29232 case PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE:
29233 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29234 c_name = "present_or_create";
29236 case PRAGMA_OACC_CLAUSE_REDUCTION:
29237 clauses = cp_parser_omp_clause_reduction (parser, clauses);
29238 c_name = "reduction";
29240 case PRAGMA_OACC_CLAUSE_SELF:
29241 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
29244 case PRAGMA_OACC_CLAUSE_VECTOR_LENGTH:
29245 clauses = cp_parser_oacc_clause_vector_length (parser, clauses);
29246 c_name = "vector_length";
29248 case PRAGMA_OACC_CLAUSE_WAIT:
29249 clauses = cp_parser_oacc_clause_wait (parser, clauses);
29253 cp_parser_error (parser, "expected %<#pragma acc%> clause");
29259 if (((mask >> c_kind) & 1) == 0)
29261 /* Remove the invalid clause(s) from the list to avoid
29262 confusing the rest of the compiler. */
29264 error_at (here, "%qs is not valid for %qs", c_name, where);
29269 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
29272 return finish_omp_clauses (clauses);
29277 /* Parse all OpenMP clauses. The set clauses allowed by the directive
29278 is a bitmask in MASK. Return the list of clauses found; the result
29279 of clause default goes in *pdefault. */
29282 cp_parser_omp_all_clauses (cp_parser *parser, omp_clause_mask mask,
29283 const char *where, cp_token *pragma_tok,
29284 bool finish_p = true)
29286 tree clauses = NULL;
29288 cp_token *token = NULL;
29289 bool cilk_simd_fn = false;
29291 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
29293 pragma_omp_clause c_kind;
29294 const char *c_name;
29295 tree prev = clauses;
29297 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
29298 cp_lexer_consume_token (parser->lexer);
29300 token = cp_lexer_peek_token (parser->lexer);
29301 c_kind = cp_parser_omp_clause_name (parser);
29305 case PRAGMA_OMP_CLAUSE_COLLAPSE:
29306 clauses = cp_parser_omp_clause_collapse (parser, clauses,
29308 c_name = "collapse";
29310 case PRAGMA_OMP_CLAUSE_COPYIN:
29311 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
29314 case PRAGMA_OMP_CLAUSE_COPYPRIVATE:
29315 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
29317 c_name = "copyprivate";
29319 case PRAGMA_OMP_CLAUSE_DEFAULT:
29320 clauses = cp_parser_omp_clause_default (parser, clauses,
29322 c_name = "default";
29324 case PRAGMA_OMP_CLAUSE_FINAL:
29325 clauses = cp_parser_omp_clause_final (parser, clauses, token->location);
29328 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE:
29329 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
29331 c_name = "firstprivate";
29333 case PRAGMA_OMP_CLAUSE_IF:
29334 clauses = cp_parser_omp_clause_if (parser, clauses, token->location);
29337 case PRAGMA_OMP_CLAUSE_LASTPRIVATE:
29338 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
29340 c_name = "lastprivate";
29342 case PRAGMA_OMP_CLAUSE_MERGEABLE:
29343 clauses = cp_parser_omp_clause_mergeable (parser, clauses,
29345 c_name = "mergeable";
29347 case PRAGMA_OMP_CLAUSE_NOWAIT:
29348 clauses = cp_parser_omp_clause_nowait (parser, clauses, token->location);
29351 case PRAGMA_OMP_CLAUSE_NUM_THREADS:
29352 clauses = cp_parser_omp_clause_num_threads (parser, clauses,
29354 c_name = "num_threads";
29356 case PRAGMA_OMP_CLAUSE_ORDERED:
29357 clauses = cp_parser_omp_clause_ordered (parser, clauses,
29359 c_name = "ordered";
29361 case PRAGMA_OMP_CLAUSE_PRIVATE:
29362 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
29364 c_name = "private";
29366 case PRAGMA_OMP_CLAUSE_REDUCTION:
29367 clauses = cp_parser_omp_clause_reduction (parser, clauses);
29368 c_name = "reduction";
29370 case PRAGMA_OMP_CLAUSE_SCHEDULE:
29371 clauses = cp_parser_omp_clause_schedule (parser, clauses,
29373 c_name = "schedule";
29375 case PRAGMA_OMP_CLAUSE_SHARED:
29376 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
29380 case PRAGMA_OMP_CLAUSE_UNTIED:
29381 clauses = cp_parser_omp_clause_untied (parser, clauses,
29385 case PRAGMA_OMP_CLAUSE_INBRANCH:
29386 case PRAGMA_CILK_CLAUSE_MASK:
29387 clauses = cp_parser_omp_clause_branch (parser, OMP_CLAUSE_INBRANCH,
29388 clauses, token->location);
29389 c_name = "inbranch";
29391 case PRAGMA_OMP_CLAUSE_NOTINBRANCH:
29392 case PRAGMA_CILK_CLAUSE_NOMASK:
29393 clauses = cp_parser_omp_clause_branch (parser,
29394 OMP_CLAUSE_NOTINBRANCH,
29395 clauses, token->location);
29396 c_name = "notinbranch";
29398 case PRAGMA_OMP_CLAUSE_PARALLEL:
29399 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_PARALLEL,
29400 clauses, token->location);
29401 c_name = "parallel";
29405 error_at (token->location, "%qs must be the first clause of %qs",
29410 case PRAGMA_OMP_CLAUSE_FOR:
29411 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_FOR,
29412 clauses, token->location);
29415 goto clause_not_first;
29417 case PRAGMA_OMP_CLAUSE_SECTIONS:
29418 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_SECTIONS,
29419 clauses, token->location);
29420 c_name = "sections";
29422 goto clause_not_first;
29424 case PRAGMA_OMP_CLAUSE_TASKGROUP:
29425 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_TASKGROUP,
29426 clauses, token->location);
29427 c_name = "taskgroup";
29429 goto clause_not_first;
29431 case PRAGMA_OMP_CLAUSE_TO:
29432 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_TO,
29436 case PRAGMA_OMP_CLAUSE_FROM:
29437 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FROM,
29441 case PRAGMA_OMP_CLAUSE_UNIFORM:
29442 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_UNIFORM,
29444 c_name = "uniform";
29446 case PRAGMA_OMP_CLAUSE_NUM_TEAMS:
29447 clauses = cp_parser_omp_clause_num_teams (parser, clauses,
29449 c_name = "num_teams";
29451 case PRAGMA_OMP_CLAUSE_THREAD_LIMIT:
29452 clauses = cp_parser_omp_clause_thread_limit (parser, clauses,
29454 c_name = "thread_limit";
29456 case PRAGMA_OMP_CLAUSE_ALIGNED:
29457 clauses = cp_parser_omp_clause_aligned (parser, clauses);
29458 c_name = "aligned";
29460 case PRAGMA_OMP_CLAUSE_LINEAR:
29461 if (((mask >> PRAGMA_CILK_CLAUSE_VECTORLENGTH) & 1) != 0)
29462 cilk_simd_fn = true;
29463 clauses = cp_parser_omp_clause_linear (parser, clauses, cilk_simd_fn);
29466 case PRAGMA_OMP_CLAUSE_DEPEND:
29467 clauses = cp_parser_omp_clause_depend (parser, clauses);
29470 case PRAGMA_OMP_CLAUSE_MAP:
29471 clauses = cp_parser_omp_clause_map (parser, clauses);
29474 case PRAGMA_OMP_CLAUSE_DEVICE:
29475 clauses = cp_parser_omp_clause_device (parser, clauses,
29479 case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE:
29480 clauses = cp_parser_omp_clause_dist_schedule (parser, clauses,
29482 c_name = "dist_schedule";
29484 case PRAGMA_OMP_CLAUSE_PROC_BIND:
29485 clauses = cp_parser_omp_clause_proc_bind (parser, clauses,
29487 c_name = "proc_bind";
29489 case PRAGMA_OMP_CLAUSE_SAFELEN:
29490 clauses = cp_parser_omp_clause_safelen (parser, clauses,
29492 c_name = "safelen";
29494 case PRAGMA_OMP_CLAUSE_SIMDLEN:
29495 clauses = cp_parser_omp_clause_simdlen (parser, clauses,
29497 c_name = "simdlen";
29499 case PRAGMA_CILK_CLAUSE_VECTORLENGTH:
29500 clauses = cp_parser_cilk_simd_vectorlength (parser, clauses, true);
29501 c_name = "simdlen";
29504 cp_parser_error (parser, "expected %<#pragma omp%> clause");
29510 if (((mask >> c_kind) & 1) == 0)
29512 /* Remove the invalid clause(s) from the list to avoid
29513 confusing the rest of the compiler. */
29515 error_at (token->location, "%qs is not valid for %qs", c_name, where);
29519 /* In Cilk Plus SIMD enabled functions there is no pragma_token, so
29520 no reason to skip to the end. */
29521 if (!(flag_cilkplus && pragma_tok == NULL))
29522 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
29524 return finish_omp_clauses (clauses);
29532 In practice, we're also interested in adding the statement to an
29533 outer node. So it is convenient if we work around the fact that
29534 cp_parser_statement calls add_stmt. */
29537 cp_parser_begin_omp_structured_block (cp_parser *parser)
29539 unsigned save = parser->in_statement;
29541 /* Only move the values to IN_OMP_BLOCK if they weren't false.
29542 This preserves the "not within loop or switch" style error messages
29543 for nonsense cases like
29549 if (parser->in_statement)
29550 parser->in_statement = IN_OMP_BLOCK;
29556 cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
29558 parser->in_statement = save;
29562 cp_parser_omp_structured_block (cp_parser *parser)
29564 tree stmt = begin_omp_structured_block ();
29565 unsigned int save = cp_parser_begin_omp_structured_block (parser);
29567 cp_parser_statement (parser, NULL_TREE, false, NULL);
29569 cp_parser_end_omp_structured_block (parser, save);
29570 return finish_omp_structured_block (stmt);
29574 # pragma omp atomic new-line
29578 x binop= expr | x++ | ++x | x-- | --x
29580 +, *, -, /, &, ^, |, <<, >>
29582 where x is an lvalue expression with scalar type.
29585 # pragma omp atomic new-line
29588 # pragma omp atomic read new-line
29591 # pragma omp atomic write new-line
29594 # pragma omp atomic update new-line
29597 # pragma omp atomic capture new-line
29600 # pragma omp atomic capture new-line
29608 expression-stmt | x = x binop expr
29610 v = expression-stmt
29612 { v = x; update-stmt; } | { update-stmt; v = x; }
29616 expression-stmt | x = x binop expr | x = expr binop x
29620 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
29622 where x and v are lvalue expressions with scalar type. */
29625 cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok)
29627 tree lhs = NULL_TREE, rhs = NULL_TREE, v = NULL_TREE, lhs1 = NULL_TREE;
29628 tree rhs1 = NULL_TREE, orig_lhs;
29629 enum tree_code code = OMP_ATOMIC, opcode = NOP_EXPR;
29630 bool structured_block = false;
29631 bool seq_cst = false;
29633 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
29635 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
29636 const char *p = IDENTIFIER_POINTER (id);
29638 if (!strcmp (p, "seq_cst"))
29641 cp_lexer_consume_token (parser->lexer);
29642 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
29643 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME)
29644 cp_lexer_consume_token (parser->lexer);
29647 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
29649 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
29650 const char *p = IDENTIFIER_POINTER (id);
29652 if (!strcmp (p, "read"))
29653 code = OMP_ATOMIC_READ;
29654 else if (!strcmp (p, "write"))
29656 else if (!strcmp (p, "update"))
29658 else if (!strcmp (p, "capture"))
29659 code = OMP_ATOMIC_CAPTURE_NEW;
29663 cp_lexer_consume_token (parser->lexer);
29667 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
29668 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME)
29669 cp_lexer_consume_token (parser->lexer);
29671 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
29673 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
29674 const char *p = IDENTIFIER_POINTER (id);
29676 if (!strcmp (p, "seq_cst"))
29679 cp_lexer_consume_token (parser->lexer);
29683 cp_parser_require_pragma_eol (parser, pragma_tok);
29687 case OMP_ATOMIC_READ:
29688 case NOP_EXPR: /* atomic write */
29689 v = cp_parser_unary_expression (parser);
29690 if (v == error_mark_node)
29692 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
29694 if (code == NOP_EXPR)
29695 lhs = cp_parser_expression (parser);
29697 lhs = cp_parser_unary_expression (parser);
29698 if (lhs == error_mark_node)
29700 if (code == NOP_EXPR)
29702 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
29710 case OMP_ATOMIC_CAPTURE_NEW:
29711 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
29713 cp_lexer_consume_token (parser->lexer);
29714 structured_block = true;
29718 v = cp_parser_unary_expression (parser);
29719 if (v == error_mark_node)
29721 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
29729 lhs = cp_parser_unary_expression (parser);
29731 switch (TREE_CODE (lhs))
29736 case POSTINCREMENT_EXPR:
29737 if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
29738 code = OMP_ATOMIC_CAPTURE_OLD;
29740 case PREINCREMENT_EXPR:
29741 lhs = TREE_OPERAND (lhs, 0);
29742 opcode = PLUS_EXPR;
29743 rhs = integer_one_node;
29746 case POSTDECREMENT_EXPR:
29747 if (code == OMP_ATOMIC_CAPTURE_NEW && !structured_block)
29748 code = OMP_ATOMIC_CAPTURE_OLD;
29750 case PREDECREMENT_EXPR:
29751 lhs = TREE_OPERAND (lhs, 0);
29752 opcode = MINUS_EXPR;
29753 rhs = integer_one_node;
29756 case COMPOUND_EXPR:
29757 if (TREE_CODE (TREE_OPERAND (lhs, 0)) == SAVE_EXPR
29758 && TREE_CODE (TREE_OPERAND (lhs, 1)) == COMPOUND_EXPR
29759 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs, 1), 0)) == MODIFY_EXPR
29760 && TREE_OPERAND (TREE_OPERAND (lhs, 1), 1) == TREE_OPERAND (lhs, 0)
29761 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
29762 (TREE_OPERAND (lhs, 1), 0), 0)))
29764 /* Undo effects of boolean_increment for post {in,de}crement. */
29765 lhs = TREE_OPERAND (TREE_OPERAND (lhs, 1), 0);
29768 if (TREE_CODE (lhs) == MODIFY_EXPR
29769 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs, 0))) == BOOLEAN_TYPE)
29771 /* Undo effects of boolean_increment. */
29772 if (integer_onep (TREE_OPERAND (lhs, 1)))
29774 /* This is pre or post increment. */
29775 rhs = TREE_OPERAND (lhs, 1);
29776 lhs = TREE_OPERAND (lhs, 0);
29778 if (code == OMP_ATOMIC_CAPTURE_NEW
29779 && !structured_block
29780 && TREE_CODE (orig_lhs) == COMPOUND_EXPR)
29781 code = OMP_ATOMIC_CAPTURE_OLD;
29787 switch (cp_lexer_peek_token (parser->lexer)->type)
29790 opcode = MULT_EXPR;
29793 opcode = TRUNC_DIV_EXPR;
29796 opcode = PLUS_EXPR;
29799 opcode = MINUS_EXPR;
29801 case CPP_LSHIFT_EQ:
29802 opcode = LSHIFT_EXPR;
29804 case CPP_RSHIFT_EQ:
29805 opcode = RSHIFT_EXPR;
29808 opcode = BIT_AND_EXPR;
29811 opcode = BIT_IOR_EXPR;
29814 opcode = BIT_XOR_EXPR;
29817 enum cp_parser_prec oprec;
29819 cp_lexer_consume_token (parser->lexer);
29820 cp_parser_parse_tentatively (parser);
29821 rhs1 = cp_parser_simple_cast_expression (parser);
29822 if (rhs1 == error_mark_node)
29824 cp_parser_abort_tentative_parse (parser);
29825 cp_parser_simple_cast_expression (parser);
29828 token = cp_lexer_peek_token (parser->lexer);
29829 if (token->type != CPP_SEMICOLON && !cp_tree_equal (lhs, rhs1))
29831 cp_parser_abort_tentative_parse (parser);
29832 cp_parser_parse_tentatively (parser);
29833 rhs = cp_parser_binary_expression (parser, false, true,
29834 PREC_NOT_OPERATOR, NULL);
29835 if (rhs == error_mark_node)
29837 cp_parser_abort_tentative_parse (parser);
29838 cp_parser_binary_expression (parser, false, true,
29839 PREC_NOT_OPERATOR, NULL);
29842 switch (TREE_CODE (rhs))
29845 case TRUNC_DIV_EXPR:
29854 if (cp_tree_equal (lhs, TREE_OPERAND (rhs, 1)))
29856 if (cp_parser_parse_definitely (parser))
29858 opcode = TREE_CODE (rhs);
29859 rhs1 = TREE_OPERAND (rhs, 0);
29860 rhs = TREE_OPERAND (rhs, 1);
29870 cp_parser_abort_tentative_parse (parser);
29871 if (structured_block && code == OMP_ATOMIC_CAPTURE_OLD)
29873 rhs = cp_parser_expression (parser);
29874 if (rhs == error_mark_node)
29880 cp_parser_error (parser,
29881 "invalid form of %<#pragma omp atomic%>");
29884 if (!cp_parser_parse_definitely (parser))
29886 switch (token->type)
29888 case CPP_SEMICOLON:
29889 if (structured_block && code == OMP_ATOMIC_CAPTURE_NEW)
29891 code = OMP_ATOMIC_CAPTURE_OLD;
29896 cp_lexer_consume_token (parser->lexer);
29899 else if (structured_block)
29906 cp_parser_error (parser,
29907 "invalid form of %<#pragma omp atomic%>");
29910 opcode = MULT_EXPR;
29913 opcode = TRUNC_DIV_EXPR;
29916 opcode = PLUS_EXPR;
29919 opcode = MINUS_EXPR;
29922 opcode = LSHIFT_EXPR;
29925 opcode = RSHIFT_EXPR;
29928 opcode = BIT_AND_EXPR;
29931 opcode = BIT_IOR_EXPR;
29934 opcode = BIT_XOR_EXPR;
29937 cp_parser_error (parser,
29938 "invalid operator for %<#pragma omp atomic%>");
29941 oprec = TOKEN_PRECEDENCE (token);
29942 gcc_assert (oprec != PREC_NOT_OPERATOR);
29943 if (commutative_tree_code (opcode))
29944 oprec = (enum cp_parser_prec) (oprec - 1);
29945 cp_lexer_consume_token (parser->lexer);
29946 rhs = cp_parser_binary_expression (parser, false, false,
29948 if (rhs == error_mark_node)
29953 cp_parser_error (parser,
29954 "invalid operator for %<#pragma omp atomic%>");
29957 cp_lexer_consume_token (parser->lexer);
29959 rhs = cp_parser_expression (parser);
29960 if (rhs == error_mark_node)
29965 if (structured_block && code == OMP_ATOMIC_CAPTURE_NEW)
29967 if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
29969 v = cp_parser_unary_expression (parser);
29970 if (v == error_mark_node)
29972 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
29974 lhs1 = cp_parser_unary_expression (parser);
29975 if (lhs1 == error_mark_node)
29978 if (structured_block)
29980 cp_parser_consume_semicolon_at_end_of_statement (parser);
29981 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
29984 finish_omp_atomic (code, opcode, lhs, rhs, v, lhs1, rhs1, seq_cst);
29985 if (!structured_block)
29986 cp_parser_consume_semicolon_at_end_of_statement (parser);
29990 cp_parser_skip_to_end_of_block_or_statement (parser);
29991 if (structured_block)
29993 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
29994 cp_lexer_consume_token (parser->lexer);
29995 else if (code == OMP_ATOMIC_CAPTURE_NEW)
29997 cp_parser_skip_to_end_of_block_or_statement (parser);
29998 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
29999 cp_lexer_consume_token (parser->lexer);
30006 # pragma omp barrier new-line */
30009 cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
30011 cp_parser_require_pragma_eol (parser, pragma_tok);
30012 finish_omp_barrier ();
30016 # pragma omp critical [(name)] new-line
30017 structured-block */
30020 cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok)
30022 tree stmt, name = NULL;
30024 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
30026 cp_lexer_consume_token (parser->lexer);
30028 name = cp_parser_identifier (parser);
30030 if (name == error_mark_node
30031 || !cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
30032 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
30033 /*or_comma=*/false,
30034 /*consume_paren=*/true);
30035 if (name == error_mark_node)
30038 cp_parser_require_pragma_eol (parser, pragma_tok);
30040 stmt = cp_parser_omp_structured_block (parser);
30041 return c_finish_omp_critical (input_location, stmt, name);
30045 # pragma omp flush flush-vars[opt] new-line
30048 ( variable-list ) */
30051 cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
30053 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
30054 (void) cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
30055 cp_parser_require_pragma_eol (parser, pragma_tok);
30057 finish_omp_flush ();
30060 /* Helper function, to parse omp for increment expression. */
30063 cp_parser_omp_for_cond (cp_parser *parser, tree decl, enum tree_code code)
30065 tree cond = cp_parser_binary_expression (parser, false, true,
30066 PREC_NOT_OPERATOR, NULL);
30067 if (cond == error_mark_node
30068 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
30070 cp_parser_skip_to_end_of_statement (parser);
30071 return error_mark_node;
30074 switch (TREE_CODE (cond))
30082 if (code == CILK_SIMD || code == CILK_FOR)
30084 /* Fall through: OpenMP disallows NE_EXPR. */
30086 return error_mark_node;
30089 /* If decl is an iterator, preserve LHS and RHS of the relational
30090 expr until finish_omp_for. */
30092 && (type_dependent_expression_p (decl)
30093 || CLASS_TYPE_P (TREE_TYPE (decl))))
30096 return build_x_binary_op (input_location, TREE_CODE (cond),
30097 TREE_OPERAND (cond, 0), ERROR_MARK,
30098 TREE_OPERAND (cond, 1), ERROR_MARK,
30099 /*overload=*/NULL, tf_warning_or_error);
30102 /* Helper function, to parse omp for increment expression. */
30105 cp_parser_omp_for_incr (cp_parser *parser, tree decl)
30107 cp_token *token = cp_lexer_peek_token (parser->lexer);
30113 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
30115 op = (token->type == CPP_PLUS_PLUS
30116 ? PREINCREMENT_EXPR : PREDECREMENT_EXPR);
30117 cp_lexer_consume_token (parser->lexer);
30118 lhs = cp_parser_simple_cast_expression (parser);
30120 return error_mark_node;
30121 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
30124 lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
30126 return error_mark_node;
30128 token = cp_lexer_peek_token (parser->lexer);
30129 if (token->type == CPP_PLUS_PLUS || token->type == CPP_MINUS_MINUS)
30131 op = (token->type == CPP_PLUS_PLUS
30132 ? POSTINCREMENT_EXPR : POSTDECREMENT_EXPR);
30133 cp_lexer_consume_token (parser->lexer);
30134 return build2 (op, TREE_TYPE (decl), decl, NULL_TREE);
30137 op = cp_parser_assignment_operator_opt (parser);
30138 if (op == ERROR_MARK)
30139 return error_mark_node;
30141 if (op != NOP_EXPR)
30143 rhs = cp_parser_assignment_expression (parser);
30144 rhs = build2 (op, TREE_TYPE (decl), decl, rhs);
30145 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
30148 lhs = cp_parser_binary_expression (parser, false, false,
30149 PREC_ADDITIVE_EXPRESSION, NULL);
30150 token = cp_lexer_peek_token (parser->lexer);
30151 decl_first = lhs == decl;
30154 if (token->type != CPP_PLUS
30155 && token->type != CPP_MINUS)
30156 return error_mark_node;
30160 op = token->type == CPP_PLUS ? PLUS_EXPR : MINUS_EXPR;
30161 cp_lexer_consume_token (parser->lexer);
30162 rhs = cp_parser_binary_expression (parser, false, false,
30163 PREC_ADDITIVE_EXPRESSION, NULL);
30164 token = cp_lexer_peek_token (parser->lexer);
30165 if (token->type == CPP_PLUS || token->type == CPP_MINUS || decl_first)
30167 if (lhs == NULL_TREE)
30169 if (op == PLUS_EXPR)
30172 lhs = build_x_unary_op (input_location, NEGATE_EXPR, rhs,
30173 tf_warning_or_error);
30176 lhs = build_x_binary_op (input_location, op, lhs, ERROR_MARK, rhs,
30177 ERROR_MARK, NULL, tf_warning_or_error);
30180 while (token->type == CPP_PLUS || token->type == CPP_MINUS);
30184 if (rhs != decl || op == MINUS_EXPR)
30185 return error_mark_node;
30186 rhs = build2 (op, TREE_TYPE (decl), lhs, decl);
30189 rhs = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, lhs);
30191 return build2 (MODIFY_EXPR, TREE_TYPE (decl), decl, rhs);
30194 /* Parse the initialization statement of either an OpenMP for loop or
30195 a Cilk Plus for loop.
30197 Return true if the resulting construct should have an
30198 OMP_CLAUSE_PRIVATE added to it. */
30201 cp_parser_omp_for_loop_init (cp_parser *parser,
30202 enum tree_code code,
30203 tree &this_pre_body,
30204 vec<tree, va_gc> *for_block,
30209 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
30212 bool add_private_clause = false;
30214 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
30218 integer-type var = lb
30219 random-access-iterator-type var = lb
30220 pointer-type var = lb
30222 cp_decl_specifier_seq type_specifiers;
30224 /* First, try to parse as an initialized declaration. See
30225 cp_parser_condition, from whence the bulk of this is copied. */
30227 cp_parser_parse_tentatively (parser);
30228 cp_parser_type_specifier_seq (parser, /*is_declaration=*/true,
30229 /*is_trailing_return=*/false,
30231 if (cp_parser_parse_definitely (parser))
30233 /* If parsing a type specifier seq succeeded, then this
30234 MUST be a initialized declaration. */
30235 tree asm_specification, attributes;
30236 cp_declarator *declarator;
30238 declarator = cp_parser_declarator (parser,
30239 CP_PARSER_DECLARATOR_NAMED,
30240 /*ctor_dtor_or_conv_p=*/NULL,
30241 /*parenthesized_p=*/NULL,
30242 /*member_p=*/false,
30243 /*friend_p=*/false);
30244 attributes = cp_parser_attributes_opt (parser);
30245 asm_specification = cp_parser_asm_specification_opt (parser);
30247 if (declarator == cp_error_declarator)
30248 cp_parser_skip_to_end_of_statement (parser);
30252 tree pushed_scope, auto_node;
30254 decl = start_decl (declarator, &type_specifiers,
30255 SD_INITIALIZED, attributes,
30256 /*prefix_attributes=*/NULL_TREE,
30259 auto_node = type_uses_auto (TREE_TYPE (decl));
30260 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
30262 if (cp_lexer_next_token_is (parser->lexer,
30265 if (code != CILK_SIMD && code != CILK_FOR)
30266 error ("parenthesized initialization is not allowed in "
30267 "OpenMP %<for%> loop");
30269 error ("parenthesized initialization is "
30270 "not allowed in for-loop");
30273 /* Trigger an error. */
30274 cp_parser_require (parser, CPP_EQ, RT_EQ);
30276 init = error_mark_node;
30277 cp_parser_skip_to_end_of_statement (parser);
30279 else if (CLASS_TYPE_P (TREE_TYPE (decl))
30280 || type_dependent_expression_p (decl)
30283 bool is_direct_init, is_non_constant_init;
30285 init = cp_parser_initializer (parser,
30287 &is_non_constant_init);
30292 = do_auto_deduction (TREE_TYPE (decl), init,
30295 if (!CLASS_TYPE_P (TREE_TYPE (decl))
30296 && !type_dependent_expression_p (decl))
30300 cp_finish_decl (decl, init, !is_non_constant_init,
30302 LOOKUP_ONLYCONVERTING);
30303 if (CLASS_TYPE_P (TREE_TYPE (decl)))
30305 vec_safe_push (for_block, this_pre_body);
30309 init = pop_stmt_list (this_pre_body);
30310 this_pre_body = NULL_TREE;
30315 cp_lexer_consume_token (parser->lexer);
30316 init = cp_parser_assignment_expression (parser);
30319 if (TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE)
30320 init = error_mark_node;
30322 cp_finish_decl (decl, NULL_TREE,
30323 /*init_const_expr_p=*/false,
30325 LOOKUP_ONLYCONVERTING);
30329 pop_scope (pushed_scope);
30335 /* If parsing a type specifier sequence failed, then
30336 this MUST be a simple expression. */
30337 if (code == CILK_FOR)
30338 error ("%<_Cilk_for%> allows expression instead of declaration only "
30339 "in C, not in C++");
30340 cp_parser_parse_tentatively (parser);
30341 decl = cp_parser_primary_expression (parser, false, false,
30343 if (!cp_parser_error_occurred (parser)
30346 && CLASS_TYPE_P (TREE_TYPE (decl)))
30350 cp_parser_parse_definitely (parser);
30351 cp_parser_require (parser, CPP_EQ, RT_EQ);
30352 rhs = cp_parser_assignment_expression (parser);
30353 finish_expr_stmt (build_x_modify_expr (EXPR_LOCATION (rhs),
30356 tf_warning_or_error));
30357 add_private_clause = true;
30362 cp_parser_abort_tentative_parse (parser);
30363 init = cp_parser_expression (parser);
30366 if (TREE_CODE (init) == MODIFY_EXPR
30367 || TREE_CODE (init) == MODOP_EXPR)
30368 real_decl = TREE_OPERAND (init, 0);
30372 return add_private_clause;
30375 /* Parse the restricted form of the for statement allowed by OpenMP. */
30378 cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
30381 tree init, cond, incr, body, decl, pre_body = NULL_TREE, ret;
30382 tree real_decl, initv, condv, incrv, declv;
30383 tree this_pre_body, cl;
30384 location_t loc_first;
30385 bool collapse_err = false;
30386 int i, collapse = 1, nbraces = 0;
30387 vec<tree, va_gc> *for_block = make_tree_vector ();
30389 for (cl = clauses; cl; cl = OMP_CLAUSE_CHAIN (cl))
30390 if (OMP_CLAUSE_CODE (cl) == OMP_CLAUSE_COLLAPSE)
30391 collapse = tree_to_shwi (OMP_CLAUSE_COLLAPSE_EXPR (cl));
30393 gcc_assert (collapse >= 1);
30395 declv = make_tree_vec (collapse);
30396 initv = make_tree_vec (collapse);
30397 condv = make_tree_vec (collapse);
30398 incrv = make_tree_vec (collapse);
30400 loc_first = cp_lexer_peek_token (parser->lexer)->location;
30402 for (i = 0; i < collapse; i++)
30404 int bracecount = 0;
30405 bool add_private_clause = false;
30408 if (code != CILK_FOR
30409 && !cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
30411 cp_parser_error (parser, "for statement expected");
30414 if (code == CILK_FOR
30415 && !cp_lexer_next_token_is_keyword (parser->lexer, RID_CILK_FOR))
30417 cp_parser_error (parser, "_Cilk_for statement expected");
30420 loc = cp_lexer_consume_token (parser->lexer)->location;
30422 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
30425 init = decl = real_decl = NULL;
30426 this_pre_body = push_stmt_list ();
30429 |= cp_parser_omp_for_loop_init (parser, code,
30430 this_pre_body, for_block,
30431 init, decl, real_decl);
30433 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
30436 this_pre_body = pop_stmt_list (this_pre_body);
30440 pre_body = push_stmt_list ();
30442 add_stmt (this_pre_body);
30443 pre_body = pop_stmt_list (pre_body);
30446 pre_body = this_pre_body;
30451 if (cclauses != NULL
30452 && cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL] != NULL
30453 && real_decl != NULL_TREE)
30456 for (c = &cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL]; *c ; )
30457 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_FIRSTPRIVATE
30458 && OMP_CLAUSE_DECL (*c) == real_decl)
30460 error_at (loc, "iteration variable %qD"
30461 " should not be firstprivate", real_decl);
30462 *c = OMP_CLAUSE_CHAIN (*c);
30464 else if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_LASTPRIVATE
30465 && OMP_CLAUSE_DECL (*c) == real_decl)
30467 /* Add lastprivate (decl) clause to OMP_FOR_CLAUSES,
30468 change it to shared (decl) in OMP_PARALLEL_CLAUSES. */
30469 tree l = build_omp_clause (loc, OMP_CLAUSE_LASTPRIVATE);
30470 OMP_CLAUSE_DECL (l) = real_decl;
30471 CP_OMP_CLAUSE_INFO (l) = CP_OMP_CLAUSE_INFO (*c);
30472 if (code == OMP_SIMD)
30474 OMP_CLAUSE_CHAIN (l) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
30475 cclauses[C_OMP_CLAUSE_SPLIT_FOR] = l;
30479 OMP_CLAUSE_CHAIN (l) = clauses;
30482 OMP_CLAUSE_SET_CODE (*c, OMP_CLAUSE_SHARED);
30483 CP_OMP_CLAUSE_INFO (*c) = NULL;
30484 add_private_clause = false;
30488 if (OMP_CLAUSE_CODE (*c) == OMP_CLAUSE_PRIVATE
30489 && OMP_CLAUSE_DECL (*c) == real_decl)
30490 add_private_clause = false;
30491 c = &OMP_CLAUSE_CHAIN (*c);
30495 if (add_private_clause)
30498 for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c))
30500 if ((OMP_CLAUSE_CODE (c) == OMP_CLAUSE_PRIVATE
30501 || OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE)
30502 && OMP_CLAUSE_DECL (c) == decl)
30504 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
30505 && OMP_CLAUSE_DECL (c) == decl)
30506 error_at (loc, "iteration variable %qD "
30507 "should not be firstprivate",
30509 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
30510 && OMP_CLAUSE_DECL (c) == decl)
30511 error_at (loc, "iteration variable %qD should not be reduction",
30516 c = build_omp_clause (loc, OMP_CLAUSE_PRIVATE);
30517 OMP_CLAUSE_DECL (c) = decl;
30518 c = finish_omp_clauses (c);
30521 OMP_CLAUSE_CHAIN (c) = clauses;
30528 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
30529 cond = cp_parser_omp_for_cond (parser, decl, code);
30530 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
30533 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
30535 /* If decl is an iterator, preserve the operator on decl
30536 until finish_omp_for. */
30538 && ((processing_template_decl
30539 && !POINTER_TYPE_P (TREE_TYPE (real_decl)))
30540 || CLASS_TYPE_P (TREE_TYPE (real_decl))))
30541 incr = cp_parser_omp_for_incr (parser, real_decl);
30543 incr = cp_parser_expression (parser);
30544 if (CAN_HAVE_LOCATION_P (incr) && !EXPR_HAS_LOCATION (incr))
30545 SET_EXPR_LOCATION (incr, input_location);
30548 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
30549 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
30550 /*or_comma=*/false,
30551 /*consume_paren=*/true);
30553 TREE_VEC_ELT (declv, i) = decl;
30554 TREE_VEC_ELT (initv, i) = init;
30555 TREE_VEC_ELT (condv, i) = cond;
30556 TREE_VEC_ELT (incrv, i) = incr;
30558 if (i == collapse - 1)
30561 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
30562 in between the collapsed for loops to be still considered perfectly
30563 nested. Hopefully the final version clarifies this.
30564 For now handle (multiple) {'s and empty statements. */
30565 cp_parser_parse_tentatively (parser);
30568 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
30570 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
30572 cp_lexer_consume_token (parser->lexer);
30575 else if (bracecount
30576 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
30577 cp_lexer_consume_token (parser->lexer);
30580 loc = cp_lexer_peek_token (parser->lexer)->location;
30581 error_at (loc, "not enough collapsed for loops");
30582 collapse_err = true;
30583 cp_parser_abort_tentative_parse (parser);
30592 cp_parser_parse_definitely (parser);
30593 nbraces += bracecount;
30597 /* Note that we saved the original contents of this flag when we entered
30598 the structured block, and so we don't need to re-save it here. */
30599 if (code == CILK_SIMD || code == CILK_FOR)
30600 parser->in_statement = IN_CILK_SIMD_FOR;
30602 parser->in_statement = IN_OMP_FOR;
30604 /* Note that the grammar doesn't call for a structured block here,
30605 though the loop as a whole is a structured block. */
30606 body = push_stmt_list ();
30607 cp_parser_statement (parser, NULL_TREE, false, NULL);
30608 body = pop_stmt_list (body);
30610 if (declv == NULL_TREE)
30613 ret = finish_omp_for (loc_first, code, declv, initv, condv, incrv, body,
30614 pre_body, clauses);
30618 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
30620 cp_lexer_consume_token (parser->lexer);
30623 else if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
30624 cp_lexer_consume_token (parser->lexer);
30629 error_at (cp_lexer_peek_token (parser->lexer)->location,
30630 "collapsed loops not perfectly nested");
30632 collapse_err = true;
30633 cp_parser_statement_seq_opt (parser, NULL);
30634 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
30639 while (!for_block->is_empty ())
30640 add_stmt (pop_stmt_list (for_block->pop ()));
30641 release_tree_vector (for_block);
30646 /* Helper function for OpenMP parsing, split clauses and call
30647 finish_omp_clauses on each of the set of clauses afterwards. */
30650 cp_omp_split_clauses (location_t loc, enum tree_code code,
30651 omp_clause_mask mask, tree clauses, tree *cclauses)
30654 c_omp_split_clauses (loc, code, mask, clauses, cclauses);
30655 for (i = 0; i < C_OMP_CLAUSE_SPLIT_COUNT; i++)
30657 cclauses[i] = finish_omp_clauses (cclauses[i]);
30661 #pragma omp simd simd-clause[optseq] new-line
30664 #define OMP_SIMD_CLAUSE_MASK \
30665 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
30666 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
30667 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
30668 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30669 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30670 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30671 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30674 cp_parser_omp_simd (cp_parser *parser, cp_token *pragma_tok,
30675 char *p_name, omp_clause_mask mask, tree *cclauses)
30677 tree clauses, sb, ret;
30679 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30681 strcat (p_name, " simd");
30682 mask |= OMP_SIMD_CLAUSE_MASK;
30683 mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED);
30685 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
30689 cp_omp_split_clauses (loc, OMP_SIMD, mask, clauses, cclauses);
30690 clauses = cclauses[C_OMP_CLAUSE_SPLIT_SIMD];
30693 sb = begin_omp_structured_block ();
30694 save = cp_parser_begin_omp_structured_block (parser);
30696 ret = cp_parser_omp_for_loop (parser, OMP_SIMD, clauses, cclauses);
30698 cp_parser_end_omp_structured_block (parser, save);
30699 add_stmt (finish_omp_structured_block (sb));
30705 #pragma omp for for-clause[optseq] new-line
30709 #pragma omp for simd for-simd-clause[optseq] new-line
30712 #define OMP_FOR_CLAUSE_MASK \
30713 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30714 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30715 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30716 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30717 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
30718 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
30719 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
30720 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
30723 cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok,
30724 char *p_name, omp_clause_mask mask, tree *cclauses)
30726 tree clauses, sb, ret;
30728 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30730 strcat (p_name, " for");
30731 mask |= OMP_FOR_CLAUSE_MASK;
30733 mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
30735 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
30737 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
30738 const char *p = IDENTIFIER_POINTER (id);
30740 if (strcmp (p, "simd") == 0)
30742 tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
30743 if (cclauses == NULL)
30744 cclauses = cclauses_buf;
30746 cp_lexer_consume_token (parser->lexer);
30747 if (!flag_openmp) /* flag_openmp_simd */
30748 return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
30750 sb = begin_omp_structured_block ();
30751 save = cp_parser_begin_omp_structured_block (parser);
30752 ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
30754 cp_parser_end_omp_structured_block (parser, save);
30755 tree body = finish_omp_structured_block (sb);
30758 ret = make_node (OMP_FOR);
30759 TREE_TYPE (ret) = void_type_node;
30760 OMP_FOR_BODY (ret) = body;
30761 OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
30762 SET_EXPR_LOCATION (ret, loc);
30767 if (!flag_openmp) /* flag_openmp_simd */
30769 cp_parser_require_pragma_eol (parser, pragma_tok);
30773 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
30777 cp_omp_split_clauses (loc, OMP_FOR, mask, clauses, cclauses);
30778 clauses = cclauses[C_OMP_CLAUSE_SPLIT_FOR];
30781 sb = begin_omp_structured_block ();
30782 save = cp_parser_begin_omp_structured_block (parser);
30784 ret = cp_parser_omp_for_loop (parser, OMP_FOR, clauses, cclauses);
30786 cp_parser_end_omp_structured_block (parser, save);
30787 add_stmt (finish_omp_structured_block (sb));
30793 # pragma omp master new-line
30794 structured-block */
30797 cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok)
30799 cp_parser_require_pragma_eol (parser, pragma_tok);
30800 return c_finish_omp_master (input_location,
30801 cp_parser_omp_structured_block (parser));
30805 # pragma omp ordered new-line
30806 structured-block */
30809 cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok)
30811 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30812 cp_parser_require_pragma_eol (parser, pragma_tok);
30813 return c_finish_omp_ordered (loc, cp_parser_omp_structured_block (parser));
30819 { section-sequence }
30822 section-directive[opt] structured-block
30823 section-sequence section-directive structured-block */
30826 cp_parser_omp_sections_scope (cp_parser *parser)
30828 tree stmt, substmt;
30829 bool error_suppress = false;
30832 if (!cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
30835 stmt = push_stmt_list ();
30837 if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION)
30839 substmt = cp_parser_omp_structured_block (parser);
30840 substmt = build1 (OMP_SECTION, void_type_node, substmt);
30841 add_stmt (substmt);
30846 tok = cp_lexer_peek_token (parser->lexer);
30847 if (tok->type == CPP_CLOSE_BRACE)
30849 if (tok->type == CPP_EOF)
30852 if (tok->pragma_kind == PRAGMA_OMP_SECTION)
30854 cp_lexer_consume_token (parser->lexer);
30855 cp_parser_require_pragma_eol (parser, tok);
30856 error_suppress = false;
30858 else if (!error_suppress)
30860 cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
30861 error_suppress = true;
30864 substmt = cp_parser_omp_structured_block (parser);
30865 substmt = build1 (OMP_SECTION, void_type_node, substmt);
30866 add_stmt (substmt);
30868 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
30870 substmt = pop_stmt_list (stmt);
30872 stmt = make_node (OMP_SECTIONS);
30873 TREE_TYPE (stmt) = void_type_node;
30874 OMP_SECTIONS_BODY (stmt) = substmt;
30881 # pragma omp sections sections-clause[optseq] newline
30884 #define OMP_SECTIONS_CLAUSE_MASK \
30885 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30886 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30887 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
30888 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30889 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
30892 cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok,
30893 char *p_name, omp_clause_mask mask, tree *cclauses)
30896 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30898 strcat (p_name, " sections");
30899 mask |= OMP_SECTIONS_CLAUSE_MASK;
30901 mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
30903 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
30907 cp_omp_split_clauses (loc, OMP_SECTIONS, mask, clauses, cclauses);
30908 clauses = cclauses[C_OMP_CLAUSE_SPLIT_SECTIONS];
30911 ret = cp_parser_omp_sections_scope (parser);
30913 OMP_SECTIONS_CLAUSES (ret) = clauses;
30919 # pragma omp parallel parallel-clause[optseq] new-line
30921 # pragma omp parallel for parallel-for-clause[optseq] new-line
30923 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
30927 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
30928 structured-block */
30930 #define OMP_PARALLEL_CLAUSE_MASK \
30931 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
30932 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
30933 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
30934 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
30935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
30936 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
30937 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
30938 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
30939 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
30942 cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok,
30943 char *p_name, omp_clause_mask mask, tree *cclauses)
30945 tree stmt, clauses, block;
30947 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
30949 strcat (p_name, " parallel");
30950 mask |= OMP_PARALLEL_CLAUSE_MASK;
30952 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
30954 tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
30955 if (cclauses == NULL)
30956 cclauses = cclauses_buf;
30958 cp_lexer_consume_token (parser->lexer);
30959 if (!flag_openmp) /* flag_openmp_simd */
30960 return cp_parser_omp_for (parser, pragma_tok, p_name, mask, cclauses);
30961 block = begin_omp_parallel ();
30962 save = cp_parser_begin_omp_structured_block (parser);
30963 tree ret = cp_parser_omp_for (parser, pragma_tok, p_name, mask, cclauses);
30964 cp_parser_end_omp_structured_block (parser, save);
30965 stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
30967 if (ret == NULL_TREE)
30969 OMP_PARALLEL_COMBINED (stmt) = 1;
30974 error_at (loc, "expected %<for%> after %qs", p_name);
30975 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
30978 else if (!flag_openmp) /* flag_openmp_simd */
30980 cp_parser_require_pragma_eol (parser, pragma_tok);
30983 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
30985 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
30986 const char *p = IDENTIFIER_POINTER (id);
30987 if (strcmp (p, "sections") == 0)
30989 tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
30990 cclauses = cclauses_buf;
30992 cp_lexer_consume_token (parser->lexer);
30993 block = begin_omp_parallel ();
30994 save = cp_parser_begin_omp_structured_block (parser);
30995 cp_parser_omp_sections (parser, pragma_tok, p_name, mask, cclauses);
30996 cp_parser_end_omp_structured_block (parser, save);
30997 stmt = finish_omp_parallel (cclauses[C_OMP_CLAUSE_SPLIT_PARALLEL],
30999 OMP_PARALLEL_COMBINED (stmt) = 1;
31004 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
31006 block = begin_omp_parallel ();
31007 save = cp_parser_begin_omp_structured_block (parser);
31008 cp_parser_statement (parser, NULL_TREE, false, NULL);
31009 cp_parser_end_omp_structured_block (parser, save);
31010 stmt = finish_omp_parallel (clauses, block);
31015 # pragma omp single single-clause[optseq] new-line
31016 structured-block */
31018 #define OMP_SINGLE_CLAUSE_MASK \
31019 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31020 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31021 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
31022 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
31025 cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok)
31027 tree stmt = make_node (OMP_SINGLE);
31028 TREE_TYPE (stmt) = void_type_node;
31030 OMP_SINGLE_CLAUSES (stmt)
31031 = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
31032 "#pragma omp single", pragma_tok);
31033 OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser);
31035 return add_stmt (stmt);
31039 # pragma omp task task-clause[optseq] new-line
31040 structured-block */
31042 #define OMP_TASK_CLAUSE_MASK \
31043 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
31044 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
31045 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
31046 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31047 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31048 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
31049 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
31050 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
31051 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND))
31054 cp_parser_omp_task (cp_parser *parser, cp_token *pragma_tok)
31056 tree clauses, block;
31059 clauses = cp_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
31060 "#pragma omp task", pragma_tok);
31061 block = begin_omp_task ();
31062 save = cp_parser_begin_omp_structured_block (parser);
31063 cp_parser_statement (parser, NULL_TREE, false, NULL);
31064 cp_parser_end_omp_structured_block (parser, save);
31065 return finish_omp_task (clauses, block);
31069 # pragma omp taskwait new-line */
31072 cp_parser_omp_taskwait (cp_parser *parser, cp_token *pragma_tok)
31074 cp_parser_require_pragma_eol (parser, pragma_tok);
31075 finish_omp_taskwait ();
31079 # pragma omp taskyield new-line */
31082 cp_parser_omp_taskyield (cp_parser *parser, cp_token *pragma_tok)
31084 cp_parser_require_pragma_eol (parser, pragma_tok);
31085 finish_omp_taskyield ();
31089 # pragma omp taskgroup new-line
31090 structured-block */
31093 cp_parser_omp_taskgroup (cp_parser *parser, cp_token *pragma_tok)
31095 cp_parser_require_pragma_eol (parser, pragma_tok);
31096 return c_finish_omp_taskgroup (input_location,
31097 cp_parser_omp_structured_block (parser));
31102 # pragma omp threadprivate (variable-list) */
31105 cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
31109 vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
31110 cp_parser_require_pragma_eol (parser, pragma_tok);
31112 finish_omp_threadprivate (vars);
31116 # pragma omp cancel cancel-clause[optseq] new-line */
31118 #define OMP_CANCEL_CLAUSE_MASK \
31119 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
31120 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
31121 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
31122 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
31123 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31126 cp_parser_omp_cancel (cp_parser *parser, cp_token *pragma_tok)
31128 tree clauses = cp_parser_omp_all_clauses (parser, OMP_CANCEL_CLAUSE_MASK,
31129 "#pragma omp cancel", pragma_tok);
31130 finish_omp_cancel (clauses);
31134 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
31136 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
31137 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
31138 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
31139 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
31140 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
31143 cp_parser_omp_cancellation_point (cp_parser *parser, cp_token *pragma_tok)
31146 bool point_seen = false;
31148 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31150 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
31151 const char *p = IDENTIFIER_POINTER (id);
31153 if (strcmp (p, "point") == 0)
31155 cp_lexer_consume_token (parser->lexer);
31161 cp_parser_error (parser, "expected %<point%>");
31162 cp_parser_require_pragma_eol (parser, pragma_tok);
31166 clauses = cp_parser_omp_all_clauses (parser,
31167 OMP_CANCELLATION_POINT_CLAUSE_MASK,
31168 "#pragma omp cancellation point",
31170 finish_omp_cancellation_point (clauses);
31174 #pragma omp distribute distribute-clause[optseq] new-line
31177 #define OMP_DISTRIBUTE_CLAUSE_MASK \
31178 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31179 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31180 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
31181 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
31184 cp_parser_omp_distribute (cp_parser *parser, cp_token *pragma_tok,
31185 char *p_name, omp_clause_mask mask, tree *cclauses)
31187 tree clauses, sb, ret;
31189 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
31191 strcat (p_name, " distribute");
31192 mask |= OMP_DISTRIBUTE_CLAUSE_MASK;
31194 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31196 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
31197 const char *p = IDENTIFIER_POINTER (id);
31199 bool parallel = false;
31201 if (strcmp (p, "simd") == 0)
31204 parallel = strcmp (p, "parallel") == 0;
31205 if (parallel || simd)
31207 tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
31208 if (cclauses == NULL)
31209 cclauses = cclauses_buf;
31210 cp_lexer_consume_token (parser->lexer);
31211 if (!flag_openmp) /* flag_openmp_simd */
31214 return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
31217 return cp_parser_omp_parallel (parser, pragma_tok, p_name, mask,
31220 sb = begin_omp_structured_block ();
31221 save = cp_parser_begin_omp_structured_block (parser);
31223 ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
31226 ret = cp_parser_omp_parallel (parser, pragma_tok, p_name, mask,
31228 cp_parser_end_omp_structured_block (parser, save);
31229 tree body = finish_omp_structured_block (sb);
31232 ret = make_node (OMP_DISTRIBUTE);
31233 TREE_TYPE (ret) = void_type_node;
31234 OMP_FOR_BODY (ret) = body;
31235 OMP_FOR_CLAUSES (ret) = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
31236 SET_EXPR_LOCATION (ret, loc);
31241 if (!flag_openmp) /* flag_openmp_simd */
31243 cp_parser_require_pragma_eol (parser, pragma_tok);
31247 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
31251 cp_omp_split_clauses (loc, OMP_DISTRIBUTE, mask, clauses, cclauses);
31252 clauses = cclauses[C_OMP_CLAUSE_SPLIT_DISTRIBUTE];
31255 sb = begin_omp_structured_block ();
31256 save = cp_parser_begin_omp_structured_block (parser);
31258 ret = cp_parser_omp_for_loop (parser, OMP_DISTRIBUTE, clauses, NULL);
31260 cp_parser_end_omp_structured_block (parser, save);
31261 add_stmt (finish_omp_structured_block (sb));
31267 # pragma omp teams teams-clause[optseq] new-line
31268 structured-block */
31270 #define OMP_TEAMS_CLAUSE_MASK \
31271 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
31272 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
31273 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
31274 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
31275 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
31276 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
31277 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
31280 cp_parser_omp_teams (cp_parser *parser, cp_token *pragma_tok,
31281 char *p_name, omp_clause_mask mask, tree *cclauses)
31283 tree clauses, sb, ret;
31285 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
31287 strcat (p_name, " teams");
31288 mask |= OMP_TEAMS_CLAUSE_MASK;
31290 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31292 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
31293 const char *p = IDENTIFIER_POINTER (id);
31294 if (strcmp (p, "distribute") == 0)
31296 tree cclauses_buf[C_OMP_CLAUSE_SPLIT_COUNT];
31297 if (cclauses == NULL)
31298 cclauses = cclauses_buf;
31300 cp_lexer_consume_token (parser->lexer);
31301 if (!flag_openmp) /* flag_openmp_simd */
31302 return cp_parser_omp_distribute (parser, pragma_tok, p_name, mask,
31304 sb = begin_omp_structured_block ();
31305 save = cp_parser_begin_omp_structured_block (parser);
31306 ret = cp_parser_omp_distribute (parser, pragma_tok, p_name, mask,
31308 cp_parser_end_omp_structured_block (parser, save);
31309 tree body = finish_omp_structured_block (sb);
31312 clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
31313 ret = make_node (OMP_TEAMS);
31314 TREE_TYPE (ret) = void_type_node;
31315 OMP_TEAMS_CLAUSES (ret) = clauses;
31316 OMP_TEAMS_BODY (ret) = body;
31317 return add_stmt (ret);
31320 if (!flag_openmp) /* flag_openmp_simd */
31322 cp_parser_require_pragma_eol (parser, pragma_tok);
31326 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
31330 cp_omp_split_clauses (loc, OMP_TEAMS, mask, clauses, cclauses);
31331 clauses = cclauses[C_OMP_CLAUSE_SPLIT_TEAMS];
31334 tree stmt = make_node (OMP_TEAMS);
31335 TREE_TYPE (stmt) = void_type_node;
31336 OMP_TEAMS_CLAUSES (stmt) = clauses;
31337 OMP_TEAMS_BODY (stmt) = cp_parser_omp_structured_block (parser);
31339 return add_stmt (stmt);
31343 # pragma omp target data target-data-clause[optseq] new-line
31344 structured-block */
31346 #define OMP_TARGET_DATA_CLAUSE_MASK \
31347 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31348 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
31349 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31352 cp_parser_omp_target_data (cp_parser *parser, cp_token *pragma_tok)
31354 tree stmt = make_node (OMP_TARGET_DATA);
31355 TREE_TYPE (stmt) = void_type_node;
31357 OMP_TARGET_DATA_CLAUSES (stmt)
31358 = cp_parser_omp_all_clauses (parser, OMP_TARGET_DATA_CLAUSE_MASK,
31359 "#pragma omp target data", pragma_tok);
31360 keep_next_level (true);
31361 OMP_TARGET_DATA_BODY (stmt) = cp_parser_omp_structured_block (parser);
31363 SET_EXPR_LOCATION (stmt, pragma_tok->location);
31364 return add_stmt (stmt);
31368 # pragma omp target update target-update-clause[optseq] new-line */
31370 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
31371 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
31372 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
31373 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31374 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31377 cp_parser_omp_target_update (cp_parser *parser, cp_token *pragma_tok,
31378 enum pragma_context context)
31380 if (context == pragma_stmt)
31382 error_at (pragma_tok->location,
31383 "%<#pragma omp target update%> may only be "
31384 "used in compound statements");
31385 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
31390 = cp_parser_omp_all_clauses (parser, OMP_TARGET_UPDATE_CLAUSE_MASK,
31391 "#pragma omp target update", pragma_tok);
31392 if (find_omp_clause (clauses, OMP_CLAUSE_TO) == NULL_TREE
31393 && find_omp_clause (clauses, OMP_CLAUSE_FROM) == NULL_TREE)
31395 error_at (pragma_tok->location,
31396 "%<#pragma omp target update must contain at least one "
31397 "%<from%> or %<to%> clauses");
31401 tree stmt = make_node (OMP_TARGET_UPDATE);
31402 TREE_TYPE (stmt) = void_type_node;
31403 OMP_TARGET_UPDATE_CLAUSES (stmt) = clauses;
31404 SET_EXPR_LOCATION (stmt, pragma_tok->location);
31410 # pragma omp target target-clause[optseq] new-line
31411 structured-block */
31413 #define OMP_TARGET_CLAUSE_MASK \
31414 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
31415 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
31416 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
31419 cp_parser_omp_target (cp_parser *parser, cp_token *pragma_tok,
31420 enum pragma_context context)
31422 if (context != pragma_stmt && context != pragma_compound)
31424 cp_parser_error (parser, "expected declaration specifiers");
31425 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
31429 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31431 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
31432 const char *p = IDENTIFIER_POINTER (id);
31434 if (strcmp (p, "teams") == 0)
31436 tree cclauses[C_OMP_CLAUSE_SPLIT_COUNT];
31437 char p_name[sizeof ("#pragma omp target teams distribute "
31438 "parallel for simd")];
31440 cp_lexer_consume_token (parser->lexer);
31441 strcpy (p_name, "#pragma omp target");
31442 if (!flag_openmp) /* flag_openmp_simd */
31444 tree stmt = cp_parser_omp_teams (parser, pragma_tok, p_name,
31445 OMP_TARGET_CLAUSE_MASK,
31447 return stmt != NULL_TREE;
31449 keep_next_level (true);
31450 tree sb = begin_omp_structured_block ();
31451 unsigned save = cp_parser_begin_omp_structured_block (parser);
31452 tree ret = cp_parser_omp_teams (parser, pragma_tok, p_name,
31453 OMP_TARGET_CLAUSE_MASK, cclauses);
31454 cp_parser_end_omp_structured_block (parser, save);
31455 tree body = finish_omp_structured_block (sb);
31456 if (ret == NULL_TREE)
31458 tree stmt = make_node (OMP_TARGET);
31459 TREE_TYPE (stmt) = void_type_node;
31460 OMP_TARGET_CLAUSES (stmt) = cclauses[C_OMP_CLAUSE_SPLIT_TARGET];
31461 OMP_TARGET_BODY (stmt) = body;
31465 else if (!flag_openmp) /* flag_openmp_simd */
31467 cp_parser_require_pragma_eol (parser, pragma_tok);
31470 else if (strcmp (p, "data") == 0)
31472 cp_lexer_consume_token (parser->lexer);
31473 cp_parser_omp_target_data (parser, pragma_tok);
31476 else if (strcmp (p, "update") == 0)
31478 cp_lexer_consume_token (parser->lexer);
31479 return cp_parser_omp_target_update (parser, pragma_tok, context);
31483 tree stmt = make_node (OMP_TARGET);
31484 TREE_TYPE (stmt) = void_type_node;
31486 OMP_TARGET_CLAUSES (stmt)
31487 = cp_parser_omp_all_clauses (parser, OMP_TARGET_CLAUSE_MASK,
31488 "#pragma omp target", pragma_tok);
31489 keep_next_level (true);
31490 OMP_TARGET_BODY (stmt) = cp_parser_omp_structured_block (parser);
31492 SET_EXPR_LOCATION (stmt, pragma_tok->location);
31498 # pragma acc cache (variable-list) new-line
31502 cp_parser_oacc_cache (cp_parser *parser, cp_token *pragma_tok)
31504 tree stmt, clauses;
31506 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE__CACHE_, NULL_TREE);
31507 clauses = finish_omp_clauses (clauses);
31509 cp_parser_require_pragma_eol (parser, cp_lexer_peek_token (parser->lexer));
31511 stmt = make_node (OACC_CACHE);
31512 TREE_TYPE (stmt) = void_type_node;
31513 OACC_CACHE_CLAUSES (stmt) = clauses;
31514 SET_EXPR_LOCATION (stmt, pragma_tok->location);
31521 # pragma acc data oacc-data-clause[optseq] new-line
31522 structured-block */
31524 #define OACC_DATA_CLAUSE_MASK \
31525 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31526 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31527 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31528 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31529 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31530 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31531 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31532 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31533 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31534 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31535 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE))
31538 cp_parser_oacc_data (cp_parser *parser, cp_token *pragma_tok)
31540 tree stmt, clauses, block;
31543 clauses = cp_parser_oacc_all_clauses (parser, OACC_DATA_CLAUSE_MASK,
31544 "#pragma acc data", pragma_tok);
31546 block = begin_omp_parallel ();
31547 save = cp_parser_begin_omp_structured_block (parser);
31548 cp_parser_statement (parser, NULL_TREE, false, NULL);
31549 cp_parser_end_omp_structured_block (parser, save);
31550 stmt = finish_oacc_data (clauses, block);
31555 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
31559 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
31561 LOC is the location of the #pragma token.
31564 #define OACC_ENTER_DATA_CLAUSE_MASK \
31565 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31566 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31567 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31568 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31569 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31570 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31571 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
31573 #define OACC_EXIT_DATA_CLAUSE_MASK \
31574 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31575 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31576 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31577 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
31578 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
31581 cp_parser_oacc_enter_exit_data (cp_parser *parser, cp_token *pragma_tok,
31584 tree stmt, clauses;
31586 if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL)
31587 || cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
31589 cp_parser_error (parser, enter
31590 ? "expected %<data%> in %<#pragma acc enter data%>"
31591 : "expected %<data%> in %<#pragma acc exit data%>");
31592 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
31597 IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
31598 if (strcmp (p, "data") != 0)
31600 cp_parser_error (parser, "invalid pragma");
31601 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
31605 cp_lexer_consume_token (parser->lexer);
31608 clauses = cp_parser_oacc_all_clauses (parser, OACC_ENTER_DATA_CLAUSE_MASK,
31609 "#pragma acc enter data", pragma_tok);
31611 clauses = cp_parser_oacc_all_clauses (parser, OACC_EXIT_DATA_CLAUSE_MASK,
31612 "#pragma acc exit data", pragma_tok);
31614 if (find_omp_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
31616 error_at (pragma_tok->location,
31617 "%<#pragma acc enter data%> has no data movement clause");
31621 stmt = enter ? make_node (OACC_ENTER_DATA) : make_node (OACC_EXIT_DATA);
31622 TREE_TYPE (stmt) = void_type_node;
31624 OACC_ENTER_DATA_CLAUSES (stmt) = clauses;
31626 OACC_EXIT_DATA_CLAUSES (stmt) = clauses;
31627 SET_EXPR_LOCATION (stmt, pragma_tok->location);
31633 # pragma acc kernels oacc-kernels-clause[optseq] new-line
31634 structured-block */
31636 #define OACC_KERNELS_CLAUSE_MASK \
31637 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31638 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31639 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31640 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31641 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31642 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31643 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31644 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31645 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31646 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31647 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31648 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31649 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31652 cp_parser_oacc_kernels (cp_parser *parser, cp_token *pragma_tok)
31654 tree stmt, clauses, block;
31657 clauses = cp_parser_oacc_all_clauses (parser, OACC_KERNELS_CLAUSE_MASK,
31658 "#pragma acc kernels", pragma_tok);
31660 block = begin_omp_parallel ();
31661 save = cp_parser_begin_omp_structured_block (parser);
31662 cp_parser_statement (parser, NULL_TREE, false, NULL);
31663 cp_parser_end_omp_structured_block (parser, save);
31664 stmt = finish_oacc_kernels (clauses, block);
31669 # pragma acc loop oacc-loop-clause[optseq] new-line
31670 structured-block */
31672 #define OACC_LOOP_CLAUSE_MASK \
31673 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
31674 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION))
31677 cp_parser_oacc_loop (cp_parser *parser, cp_token *pragma_tok)
31679 tree stmt, clauses, block;
31682 clauses = cp_parser_oacc_all_clauses (parser, OACC_LOOP_CLAUSE_MASK,
31683 "#pragma acc loop", pragma_tok);
31685 block = begin_omp_structured_block ();
31686 save = cp_parser_begin_omp_structured_block (parser);
31687 stmt = cp_parser_omp_for_loop (parser, OACC_LOOP, clauses, NULL);
31688 cp_parser_end_omp_structured_block (parser, save);
31689 add_stmt (finish_omp_structured_block (block));
31694 # pragma acc parallel oacc-parallel-clause[optseq] new-line
31695 structured-block */
31697 #define OACC_PARALLEL_CLAUSE_MASK \
31698 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31699 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
31700 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
31701 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
31702 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
31703 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
31704 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31705 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
31706 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
31707 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
31708 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPY) \
31709 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYIN) \
31710 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_COPYOUT) \
31711 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT_OR_CREATE) \
31712 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
31713 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
31714 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31717 cp_parser_oacc_parallel (cp_parser *parser, cp_token *pragma_tok)
31719 tree stmt, clauses, block;
31722 clauses = cp_parser_oacc_all_clauses (parser, OACC_PARALLEL_CLAUSE_MASK,
31723 "#pragma acc parallel", pragma_tok);
31725 block = begin_omp_parallel ();
31726 save = cp_parser_begin_omp_structured_block (parser);
31727 cp_parser_statement (parser, NULL_TREE, false, NULL);
31728 cp_parser_end_omp_structured_block (parser, save);
31729 stmt = finish_oacc_parallel (clauses, block);
31734 # pragma acc update oacc-update-clause[optseq] new-line
31737 #define OACC_UPDATE_CLAUSE_MASK \
31738 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
31739 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
31740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
31741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
31742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
31743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
31746 cp_parser_oacc_update (cp_parser *parser, cp_token *pragma_tok)
31748 tree stmt, clauses;
31750 clauses = cp_parser_oacc_all_clauses (parser, OACC_UPDATE_CLAUSE_MASK,
31751 "#pragma acc update", pragma_tok);
31753 if (find_omp_clause (clauses, OMP_CLAUSE_MAP) == NULL_TREE)
31755 error_at (pragma_tok->location,
31756 "%<#pragma acc update%> must contain at least one "
31757 "%<device%> or %<host/self%> clause");
31761 stmt = make_node (OACC_UPDATE);
31762 TREE_TYPE (stmt) = void_type_node;
31763 OACC_UPDATE_CLAUSES (stmt) = clauses;
31764 SET_EXPR_LOCATION (stmt, pragma_tok->location);
31770 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
31772 LOC is the location of the #pragma token.
31775 #define OACC_WAIT_CLAUSE_MASK \
31776 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
31779 cp_parser_oacc_wait (cp_parser *parser, cp_token *pragma_tok)
31781 tree clauses, list = NULL_TREE, stmt = NULL_TREE;
31782 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
31784 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
31785 list = cp_parser_oacc_wait_list (parser, loc, list);
31787 clauses = cp_parser_oacc_all_clauses (parser, OACC_WAIT_CLAUSE_MASK,
31788 "#pragma acc wait", pragma_tok);
31790 stmt = c_finish_oacc_wait (loc, list, clauses);
31796 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
31798 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
31799 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
31800 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
31801 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
31802 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
31803 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
31804 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
31807 cp_parser_omp_declare_simd (cp_parser *parser, cp_token *pragma_tok,
31808 enum pragma_context context)
31810 bool first_p = parser->omp_declare_simd == NULL;
31811 cp_omp_declare_simd_data data;
31814 data.error_seen = false;
31815 data.fndecl_seen = false;
31816 data.tokens = vNULL;
31817 parser->omp_declare_simd = &data;
31819 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)
31820 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
31821 cp_lexer_consume_token (parser->lexer);
31822 if (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
31823 parser->omp_declare_simd->error_seen = true;
31824 cp_parser_require_pragma_eol (parser, pragma_tok);
31825 struct cp_token_cache *cp
31826 = cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
31827 parser->omp_declare_simd->tokens.safe_push (cp);
31830 while (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
31831 cp_parser_pragma (parser, context);
31834 case pragma_external:
31835 cp_parser_declaration (parser);
31837 case pragma_member:
31838 cp_parser_member_declaration (parser);
31840 case pragma_objc_icode:
31841 cp_parser_block_declaration (parser, /*statement_p=*/false);
31844 cp_parser_declaration_statement (parser);
31847 if (parser->omp_declare_simd
31848 && !parser->omp_declare_simd->error_seen
31849 && !parser->omp_declare_simd->fndecl_seen)
31850 error_at (pragma_tok->location,
31851 "%<#pragma omp declare simd%> not immediately followed by "
31852 "function declaration or definition");
31853 data.tokens.release ();
31854 parser->omp_declare_simd = NULL;
31858 /* Handles the delayed parsing of the Cilk Plus SIMD-enabled function.
31859 This function is modelled similar to the late parsing of omp declare
31863 cp_parser_late_parsing_cilk_simd_fn_info (cp_parser *parser, tree attrs)
31865 struct cp_token_cache *ce;
31866 cp_omp_declare_simd_data *info = parser->cilk_simd_fn_info;
31869 if (parser->omp_declare_simd != NULL)
31871 error ("%<#pragma omp declare simd%> cannot be used in the same function"
31872 " marked as a Cilk Plus SIMD-enabled function");
31873 XDELETE (parser->cilk_simd_fn_info);
31874 parser->cilk_simd_fn_info = NULL;
31877 if (!info->error_seen && info->fndecl_seen)
31879 error ("vector attribute not immediately followed by a single function"
31880 " declaration or definition");
31881 info->error_seen = true;
31883 if (info->error_seen)
31886 FOR_EACH_VEC_ELT (info->tokens, ii, ce)
31890 cp_parser_push_lexer_for_tokens (parser, ce);
31891 parser->lexer->in_pragma = true;
31892 cl = cp_parser_omp_all_clauses (parser, CILK_SIMD_FN_CLAUSE_MASK,
31893 "SIMD-enabled functions attribute",
31895 cp_parser_pop_lexer (parser);
31897 cl = tree_cons (NULL_TREE, cl, NULL_TREE);
31899 c = build_tree_list (get_identifier ("cilk simd function"), NULL_TREE);
31900 TREE_CHAIN (c) = attrs;
31903 c = build_tree_list (get_identifier ("omp declare simd"), cl);
31904 TREE_CHAIN (c) = attrs;
31905 if (processing_template_decl)
31906 ATTR_IS_DEPENDENT (c) = 1;
31909 info->fndecl_seen = true;
31910 XDELETE (parser->cilk_simd_fn_info);
31911 parser->cilk_simd_fn_info = NULL;
31915 /* Finalize #pragma omp declare simd clauses after direct declarator has
31916 been parsed, and put that into "omp declare simd" attribute. */
31919 cp_parser_late_parsing_omp_declare_simd (cp_parser *parser, tree attrs)
31921 struct cp_token_cache *ce;
31922 cp_omp_declare_simd_data *data = parser->omp_declare_simd;
31925 if (!data->error_seen && data->fndecl_seen)
31927 error ("%<#pragma omp declare simd%> not immediately followed by "
31928 "a single function declaration or definition");
31929 data->error_seen = true;
31932 if (data->error_seen)
31935 FOR_EACH_VEC_ELT (data->tokens, i, ce)
31939 cp_parser_push_lexer_for_tokens (parser, ce);
31940 parser->lexer->in_pragma = true;
31941 gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
31942 cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
31943 cp_lexer_consume_token (parser->lexer);
31944 cl = cp_parser_omp_all_clauses (parser, OMP_DECLARE_SIMD_CLAUSE_MASK,
31945 "#pragma omp declare simd", pragma_tok);
31946 cp_parser_pop_lexer (parser);
31948 cl = tree_cons (NULL_TREE, cl, NULL_TREE);
31949 c = build_tree_list (get_identifier ("omp declare simd"), cl);
31950 TREE_CHAIN (c) = attrs;
31951 if (processing_template_decl)
31952 ATTR_IS_DEPENDENT (c) = 1;
31956 data->fndecl_seen = true;
31962 # pragma omp declare target new-line
31963 declarations and definitions
31964 # pragma omp end declare target new-line */
31967 cp_parser_omp_declare_target (cp_parser *parser, cp_token *pragma_tok)
31969 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
31970 scope_chain->omp_declare_target_attribute++;
31974 cp_parser_omp_end_declare_target (cp_parser *parser, cp_token *pragma_tok)
31976 const char *p = "";
31977 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31979 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
31980 p = IDENTIFIER_POINTER (id);
31982 if (strcmp (p, "declare") == 0)
31984 cp_lexer_consume_token (parser->lexer);
31986 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
31988 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
31989 p = IDENTIFIER_POINTER (id);
31991 if (strcmp (p, "target") == 0)
31992 cp_lexer_consume_token (parser->lexer);
31995 cp_parser_error (parser, "expected %<target%>");
31996 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
32002 cp_parser_error (parser, "expected %<declare%>");
32003 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
32006 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
32007 if (!scope_chain->omp_declare_target_attribute)
32008 error_at (pragma_tok->location,
32009 "%<#pragma omp end declare target%> without corresponding "
32010 "%<#pragma omp declare target%>");
32012 scope_chain->omp_declare_target_attribute--;
32015 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
32016 expression and optional initializer clause of
32017 #pragma omp declare reduction. We store the expression(s) as
32018 either 3, 6 or 7 special statements inside of the artificial function's
32019 body. The first two statements are DECL_EXPRs for the artificial
32020 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
32021 expression that uses those variables.
32022 If there was any INITIALIZER clause, this is followed by further statements,
32023 the fourth and fifth statements are DECL_EXPRs for the artificial
32024 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
32025 constructor variant (first token after open paren is not omp_priv),
32026 then the sixth statement is a statement with the function call expression
32027 that uses the OMP_PRIV and optionally OMP_ORIG variable.
32028 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
32029 to initialize the OMP_PRIV artificial variable and there is seventh
32030 statement, a DECL_EXPR of the OMP_PRIV statement again. */
32033 cp_parser_omp_declare_reduction_exprs (tree fndecl, cp_parser *parser)
32035 tree type = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)));
32036 gcc_assert (TREE_CODE (type) == REFERENCE_TYPE);
32037 type = TREE_TYPE (type);
32038 tree omp_out = build_lang_decl (VAR_DECL, get_identifier ("omp_out"), type);
32039 DECL_ARTIFICIAL (omp_out) = 1;
32040 pushdecl (omp_out);
32041 add_decl_expr (omp_out);
32042 tree omp_in = build_lang_decl (VAR_DECL, get_identifier ("omp_in"), type);
32043 DECL_ARTIFICIAL (omp_in) = 1;
32045 add_decl_expr (omp_in);
32047 tree omp_priv = NULL_TREE, omp_orig = NULL_TREE, initializer = NULL_TREE;
32049 keep_next_level (true);
32050 tree block = begin_omp_structured_block ();
32051 combiner = cp_parser_expression (parser);
32052 finish_expr_stmt (combiner);
32053 block = finish_omp_structured_block (block);
32056 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
32059 const char *p = "";
32060 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
32062 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
32063 p = IDENTIFIER_POINTER (id);
32066 if (strcmp (p, "initializer") == 0)
32068 cp_lexer_consume_token (parser->lexer);
32069 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
32073 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
32075 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
32076 p = IDENTIFIER_POINTER (id);
32079 omp_priv = build_lang_decl (VAR_DECL, get_identifier ("omp_priv"), type);
32080 DECL_ARTIFICIAL (omp_priv) = 1;
32081 pushdecl (omp_priv);
32082 add_decl_expr (omp_priv);
32083 omp_orig = build_lang_decl (VAR_DECL, get_identifier ("omp_orig"), type);
32084 DECL_ARTIFICIAL (omp_orig) = 1;
32085 pushdecl (omp_orig);
32086 add_decl_expr (omp_orig);
32088 keep_next_level (true);
32089 block = begin_omp_structured_block ();
32092 if (strcmp (p, "omp_priv") == 0)
32094 bool is_direct_init, is_non_constant_init;
32096 cp_lexer_consume_token (parser->lexer);
32097 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
32098 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
32099 || (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
32100 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
32102 && cp_lexer_peek_nth_token (parser->lexer, 3)->type
32103 == CPP_CLOSE_PAREN))
32105 finish_omp_structured_block (block);
32106 error ("invalid initializer clause");
32109 initializer = cp_parser_initializer (parser, &is_direct_init,
32110 &is_non_constant_init);
32111 cp_finish_decl (omp_priv, initializer, !is_non_constant_init,
32112 NULL_TREE, LOOKUP_ONLYCONVERTING);
32116 cp_parser_parse_tentatively (parser);
32117 tree fn_name = cp_parser_id_expression (parser, /*template_p=*/false,
32118 /*check_dependency_p=*/true,
32119 /*template_p=*/NULL,
32120 /*declarator_p=*/false,
32121 /*optional_p=*/false);
32122 vec<tree, va_gc> *args;
32123 if (fn_name == error_mark_node
32124 || cp_parser_error_occurred (parser)
32125 || !cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
32126 || ((args = cp_parser_parenthesized_expression_list
32127 (parser, non_attr, /*cast_p=*/false,
32128 /*allow_expansion_p=*/true,
32129 /*non_constant_p=*/NULL)),
32130 cp_parser_error_occurred (parser)))
32132 finish_omp_structured_block (block);
32133 cp_parser_abort_tentative_parse (parser);
32134 cp_parser_error (parser, "expected id-expression (arguments)");
32139 FOR_EACH_VEC_SAFE_ELT (args, i, arg)
32140 if (arg == omp_priv
32141 || (TREE_CODE (arg) == ADDR_EXPR
32142 && TREE_OPERAND (arg, 0) == omp_priv))
32144 cp_parser_abort_tentative_parse (parser);
32145 if (arg == NULL_TREE)
32146 error ("one of the initializer call arguments should be %<omp_priv%>"
32147 " or %<&omp_priv%>");
32148 initializer = cp_parser_postfix_expression (parser, false, false, false,
32150 finish_expr_stmt (initializer);
32153 block = finish_omp_structured_block (block);
32154 cp_walk_tree (&block, cp_remove_omp_priv_cleanup_stmt, omp_priv, NULL);
32158 add_decl_expr (omp_orig);
32160 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
32164 if (!cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL))
32165 cp_parser_required_error (parser, RT_PRAGMA_EOL, /*keyword=*/false);
32171 #pragma omp declare reduction (reduction-id : typename-list : expression) \
32172 initializer-clause[opt] new-line
32174 initializer-clause:
32175 initializer (omp_priv initializer)
32176 initializer (function-name (argument-list)) */
32179 cp_parser_omp_declare_reduction (cp_parser *parser, cp_token *pragma_tok,
32180 enum pragma_context)
32182 auto_vec<tree> types;
32183 enum tree_code reduc_code = ERROR_MARK;
32184 tree reduc_id = NULL_TREE, orig_reduc_id = NULL_TREE, type;
32186 cp_token *first_token;
32187 cp_token_cache *cp;
32191 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
32192 p = obstack_alloc (&declarator_obstack, 0);
32194 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
32197 switch (cp_lexer_peek_token (parser->lexer)->type)
32200 reduc_code = PLUS_EXPR;
32203 reduc_code = MULT_EXPR;
32206 reduc_code = MINUS_EXPR;
32209 reduc_code = BIT_AND_EXPR;
32212 reduc_code = BIT_XOR_EXPR;
32215 reduc_code = BIT_IOR_EXPR;
32218 reduc_code = TRUTH_ANDIF_EXPR;
32221 reduc_code = TRUTH_ORIF_EXPR;
32224 reduc_id = orig_reduc_id = cp_parser_identifier (parser);
32227 cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
32228 "%<|%>, %<&&%>, %<||%> or identifier");
32232 if (reduc_code != ERROR_MARK)
32233 cp_lexer_consume_token (parser->lexer);
32235 reduc_id = omp_reduction_id (reduc_code, reduc_id, NULL_TREE);
32236 if (reduc_id == error_mark_node)
32239 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
32242 /* Types may not be defined in declare reduction type list. */
32243 const char *saved_message;
32244 saved_message = parser->type_definition_forbidden_message;
32245 parser->type_definition_forbidden_message
32246 = G_("types may not be defined in declare reduction type list");
32247 bool saved_colon_corrects_to_scope_p;
32248 saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
32249 parser->colon_corrects_to_scope_p = false;
32250 bool saved_colon_doesnt_start_class_def_p;
32251 saved_colon_doesnt_start_class_def_p
32252 = parser->colon_doesnt_start_class_def_p;
32253 parser->colon_doesnt_start_class_def_p = true;
32257 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
32258 type = cp_parser_type_id (parser);
32259 if (type == error_mark_node)
32261 else if (ARITHMETIC_TYPE_P (type)
32262 && (orig_reduc_id == NULL_TREE
32263 || (TREE_CODE (type) != COMPLEX_TYPE
32264 && (strcmp (IDENTIFIER_POINTER (orig_reduc_id),
32266 || strcmp (IDENTIFIER_POINTER (orig_reduc_id),
32268 error_at (loc, "predeclared arithmetic type %qT in "
32269 "%<#pragma omp declare reduction%>", type);
32270 else if (TREE_CODE (type) == FUNCTION_TYPE
32271 || TREE_CODE (type) == METHOD_TYPE
32272 || TREE_CODE (type) == ARRAY_TYPE)
32273 error_at (loc, "function or array type %qT in "
32274 "%<#pragma omp declare reduction%>", type);
32275 else if (TREE_CODE (type) == REFERENCE_TYPE)
32276 error_at (loc, "reference type %qT in "
32277 "%<#pragma omp declare reduction%>", type);
32278 else if (TYPE_QUALS_NO_ADDR_SPACE (type))
32279 error_at (loc, "const, volatile or __restrict qualified type %qT in "
32280 "%<#pragma omp declare reduction%>", type);
32282 types.safe_push (type);
32284 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
32285 cp_lexer_consume_token (parser->lexer);
32290 /* Restore the saved message. */
32291 parser->type_definition_forbidden_message = saved_message;
32292 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
32293 parser->colon_doesnt_start_class_def_p
32294 = saved_colon_doesnt_start_class_def_p;
32296 if (!cp_parser_require (parser, CPP_COLON, RT_COLON)
32297 || types.is_empty ())
32300 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
32304 first_token = cp_lexer_peek_token (parser->lexer);
32307 FOR_EACH_VEC_ELT (types, i, type)
32310 = build_function_type_list (void_type_node,
32311 cp_build_reference_type (type, false),
32313 tree this_reduc_id = reduc_id;
32314 if (!dependent_type_p (type))
32315 this_reduc_id = omp_reduction_id (ERROR_MARK, reduc_id, type);
32316 tree fndecl = build_lang_decl (FUNCTION_DECL, this_reduc_id, fntype);
32317 DECL_SOURCE_LOCATION (fndecl) = pragma_tok->location;
32318 DECL_ARTIFICIAL (fndecl) = 1;
32319 DECL_EXTERNAL (fndecl) = 1;
32320 DECL_DECLARED_INLINE_P (fndecl) = 1;
32321 DECL_IGNORED_P (fndecl) = 1;
32322 DECL_OMP_DECLARE_REDUCTION_P (fndecl) = 1;
32323 DECL_ATTRIBUTES (fndecl)
32324 = tree_cons (get_identifier ("gnu_inline"), NULL_TREE,
32325 DECL_ATTRIBUTES (fndecl));
32326 if (processing_template_decl)
32327 fndecl = push_template_decl (fndecl);
32328 bool block_scope = false;
32329 tree block = NULL_TREE;
32330 if (current_function_decl)
32332 block_scope = true;
32333 DECL_CONTEXT (fndecl) = global_namespace;
32334 if (!processing_template_decl)
32337 else if (current_class_type)
32341 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)
32342 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
32343 cp_lexer_consume_token (parser->lexer);
32344 if (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
32346 cp = cp_token_cache_new (first_token,
32347 cp_lexer_peek_nth_token (parser->lexer,
32350 DECL_STATIC_FUNCTION_P (fndecl) = 1;
32351 finish_member_declaration (fndecl);
32352 DECL_PENDING_INLINE_INFO (fndecl) = cp;
32353 DECL_PENDING_INLINE_P (fndecl) = 1;
32354 vec_safe_push (unparsed_funs_with_definitions, fndecl);
32359 DECL_CONTEXT (fndecl) = current_namespace;
32363 start_preparsed_function (fndecl, NULL_TREE, SF_PRE_PARSED);
32365 block = begin_omp_structured_block ();
32368 cp_parser_push_lexer_for_tokens (parser, cp);
32369 parser->lexer->in_pragma = true;
32371 if (!cp_parser_omp_declare_reduction_exprs (fndecl, parser))
32374 finish_function (0);
32376 DECL_CONTEXT (fndecl) = current_function_decl;
32378 cp_parser_pop_lexer (parser);
32382 cp_parser_pop_lexer (parser);
32384 finish_function (0);
32387 DECL_CONTEXT (fndecl) = current_function_decl;
32388 block = finish_omp_structured_block (block);
32389 if (TREE_CODE (block) == BIND_EXPR)
32390 DECL_SAVED_TREE (fndecl) = BIND_EXPR_BODY (block);
32391 else if (TREE_CODE (block) == STATEMENT_LIST)
32392 DECL_SAVED_TREE (fndecl) = block;
32393 if (processing_template_decl)
32394 add_decl_expr (fndecl);
32396 cp_check_omp_declare_reduction (fndecl);
32397 if (cp == NULL && types.length () > 1)
32398 cp = cp_token_cache_new (first_token,
32399 cp_lexer_peek_nth_token (parser->lexer, 2));
32400 if (errs != errorcount)
32404 cp_parser_require_pragma_eol (parser, pragma_tok);
32407 /* Free any declarators allocated. */
32408 obstack_free (&declarator_obstack, p);
32412 #pragma omp declare simd declare-simd-clauses[optseq] new-line
32413 #pragma omp declare reduction (reduction-id : typename-list : expression) \
32414 initializer-clause[opt] new-line
32415 #pragma omp declare target new-line */
32418 cp_parser_omp_declare (cp_parser *parser, cp_token *pragma_tok,
32419 enum pragma_context context)
32421 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
32423 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
32424 const char *p = IDENTIFIER_POINTER (id);
32426 if (strcmp (p, "simd") == 0)
32428 cp_lexer_consume_token (parser->lexer);
32429 cp_parser_omp_declare_simd (parser, pragma_tok,
32433 cp_ensure_no_omp_declare_simd (parser);
32434 if (strcmp (p, "reduction") == 0)
32436 cp_lexer_consume_token (parser->lexer);
32437 cp_parser_omp_declare_reduction (parser, pragma_tok,
32441 if (!flag_openmp) /* flag_openmp_simd */
32443 cp_parser_require_pragma_eol (parser, pragma_tok);
32446 if (strcmp (p, "target") == 0)
32448 cp_lexer_consume_token (parser->lexer);
32449 cp_parser_omp_declare_target (parser, pragma_tok);
32453 cp_parser_error (parser, "expected %<simd%> or %<reduction%> "
32455 cp_parser_require_pragma_eol (parser, pragma_tok);
32458 /* Main entry point to OpenMP statement pragmas. */
32461 cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok)
32464 char p_name[sizeof "#pragma omp teams distribute parallel for simd"];
32465 omp_clause_mask mask (0);
32467 switch (pragma_tok->pragma_kind)
32469 case PRAGMA_OACC_CACHE:
32470 stmt = cp_parser_oacc_cache (parser, pragma_tok);
32472 case PRAGMA_OACC_DATA:
32473 stmt = cp_parser_oacc_data (parser, pragma_tok);
32475 case PRAGMA_OACC_ENTER_DATA:
32476 stmt = cp_parser_oacc_enter_exit_data (parser, pragma_tok, true);
32478 case PRAGMA_OACC_EXIT_DATA:
32479 stmt = cp_parser_oacc_enter_exit_data (parser, pragma_tok, false);
32481 case PRAGMA_OACC_KERNELS:
32482 stmt = cp_parser_oacc_kernels (parser, pragma_tok);
32484 case PRAGMA_OACC_LOOP:
32485 stmt = cp_parser_oacc_loop (parser, pragma_tok);
32487 case PRAGMA_OACC_PARALLEL:
32488 stmt = cp_parser_oacc_parallel (parser, pragma_tok);
32490 case PRAGMA_OACC_UPDATE:
32491 stmt = cp_parser_oacc_update (parser, pragma_tok);
32493 case PRAGMA_OACC_WAIT:
32494 stmt = cp_parser_oacc_wait (parser, pragma_tok);
32496 case PRAGMA_OMP_ATOMIC:
32497 cp_parser_omp_atomic (parser, pragma_tok);
32499 case PRAGMA_OMP_CRITICAL:
32500 stmt = cp_parser_omp_critical (parser, pragma_tok);
32502 case PRAGMA_OMP_DISTRIBUTE:
32503 strcpy (p_name, "#pragma omp");
32504 stmt = cp_parser_omp_distribute (parser, pragma_tok, p_name, mask, NULL);
32506 case PRAGMA_OMP_FOR:
32507 strcpy (p_name, "#pragma omp");
32508 stmt = cp_parser_omp_for (parser, pragma_tok, p_name, mask, NULL);
32510 case PRAGMA_OMP_MASTER:
32511 stmt = cp_parser_omp_master (parser, pragma_tok);
32513 case PRAGMA_OMP_ORDERED:
32514 stmt = cp_parser_omp_ordered (parser, pragma_tok);
32516 case PRAGMA_OMP_PARALLEL:
32517 strcpy (p_name, "#pragma omp");
32518 stmt = cp_parser_omp_parallel (parser, pragma_tok, p_name, mask, NULL);
32520 case PRAGMA_OMP_SECTIONS:
32521 strcpy (p_name, "#pragma omp");
32522 stmt = cp_parser_omp_sections (parser, pragma_tok, p_name, mask, NULL);
32524 case PRAGMA_OMP_SIMD:
32525 strcpy (p_name, "#pragma omp");
32526 stmt = cp_parser_omp_simd (parser, pragma_tok, p_name, mask, NULL);
32528 case PRAGMA_OMP_SINGLE:
32529 stmt = cp_parser_omp_single (parser, pragma_tok);
32531 case PRAGMA_OMP_TASK:
32532 stmt = cp_parser_omp_task (parser, pragma_tok);
32534 case PRAGMA_OMP_TASKGROUP:
32535 stmt = cp_parser_omp_taskgroup (parser, pragma_tok);
32537 case PRAGMA_OMP_TEAMS:
32538 strcpy (p_name, "#pragma omp");
32539 stmt = cp_parser_omp_teams (parser, pragma_tok, p_name, mask, NULL);
32542 gcc_unreachable ();
32546 SET_EXPR_LOCATION (stmt, pragma_tok->location);
32549 /* Transactional Memory parsing routines. */
32551 /* Parse a transaction attribute.
32557 ??? Simplify this when C++0x bracket attributes are
32558 implemented properly. */
32561 cp_parser_txn_attribute_opt (cp_parser *parser)
32564 tree attr_name, attr = NULL;
32566 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
32567 return cp_parser_attributes_opt (parser);
32569 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
32571 cp_lexer_consume_token (parser->lexer);
32572 if (!cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE))
32575 token = cp_lexer_peek_token (parser->lexer);
32576 if (token->type == CPP_NAME || token->type == CPP_KEYWORD)
32578 token = cp_lexer_consume_token (parser->lexer);
32580 attr_name = (token->type == CPP_KEYWORD
32581 /* For keywords, use the canonical spelling,
32582 not the parsed identifier. */
32583 ? ridpointers[(int) token->keyword]
32585 attr = build_tree_list (attr_name, NULL_TREE);
32588 cp_parser_error (parser, "expected identifier");
32590 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
32592 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
32596 /* Parse a __transaction_atomic or __transaction_relaxed statement.
32598 transaction-statement:
32599 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
32601 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
32605 cp_parser_transaction (cp_parser *parser, enum rid keyword)
32607 unsigned char old_in = parser->in_transaction;
32608 unsigned char this_in = 1, new_in;
32610 tree stmt, attrs, noex;
32612 gcc_assert (keyword == RID_TRANSACTION_ATOMIC
32613 || keyword == RID_TRANSACTION_RELAXED);
32614 token = cp_parser_require_keyword (parser, keyword,
32615 (keyword == RID_TRANSACTION_ATOMIC ? RT_TRANSACTION_ATOMIC
32616 : RT_TRANSACTION_RELAXED));
32617 gcc_assert (token != NULL);
32619 if (keyword == RID_TRANSACTION_RELAXED)
32620 this_in |= TM_STMT_ATTR_RELAXED;
32623 attrs = cp_parser_txn_attribute_opt (parser);
32625 this_in |= parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER);
32628 /* Parse a noexcept specification. */
32629 noex = cp_parser_noexcept_specification_opt (parser, true, NULL, true);
32631 /* Keep track if we're in the lexical scope of an outer transaction. */
32632 new_in = this_in | (old_in & TM_STMT_ATTR_OUTER);
32634 stmt = begin_transaction_stmt (token->location, NULL, this_in);
32636 parser->in_transaction = new_in;
32637 cp_parser_compound_statement (parser, NULL, false, false);
32638 parser->in_transaction = old_in;
32640 finish_transaction_stmt (stmt, NULL, this_in, noex);
32645 /* Parse a __transaction_atomic or __transaction_relaxed expression.
32647 transaction-expression:
32648 __transaction_atomic txn-noexcept-spec[opt] ( expression )
32649 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
32653 cp_parser_transaction_expression (cp_parser *parser, enum rid keyword)
32655 unsigned char old_in = parser->in_transaction;
32656 unsigned char this_in = 1;
32661 gcc_assert (keyword == RID_TRANSACTION_ATOMIC
32662 || keyword == RID_TRANSACTION_RELAXED);
32665 error (keyword == RID_TRANSACTION_RELAXED
32666 ? G_("%<__transaction_relaxed%> without transactional memory "
32668 : G_("%<__transaction_atomic%> without transactional memory "
32669 "support enabled"));
32671 token = cp_parser_require_keyword (parser, keyword,
32672 (keyword == RID_TRANSACTION_ATOMIC ? RT_TRANSACTION_ATOMIC
32673 : RT_TRANSACTION_RELAXED));
32674 gcc_assert (token != NULL);
32676 if (keyword == RID_TRANSACTION_RELAXED)
32677 this_in |= TM_STMT_ATTR_RELAXED;
32679 /* Set this early. This might mean that we allow transaction_cancel in
32680 an expression that we find out later actually has to be a constexpr.
32681 However, we expect that cxx_constant_value will be able to deal with
32682 this; also, if the noexcept has no constexpr, then what we parse next
32683 really is a transaction's body. */
32684 parser->in_transaction = this_in;
32686 /* Parse a noexcept specification. */
32687 noex = cp_parser_noexcept_specification_opt (parser, false, &noex_expr,
32690 if (!noex || !noex_expr
32691 || cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
32693 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
32695 expr = cp_parser_expression (parser);
32696 expr = finish_parenthesized_expr (expr);
32698 cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN);
32702 /* The only expression that is available got parsed for the noexcept
32703 already. noexcept is true then. */
32705 noex = boolean_true_node;
32708 expr = build_transaction_expr (token->location, expr, this_in, noex);
32709 parser->in_transaction = old_in;
32711 if (cp_parser_non_integral_constant_expression (parser, NIC_TRANSACTION))
32712 return error_mark_node;
32714 return (flag_tm ? expr : error_mark_node);
32717 /* Parse a function-transaction-block.
32719 function-transaction-block:
32720 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
32722 __transaction_atomic txn-attribute[opt] function-try-block
32723 __transaction_relaxed ctor-initializer[opt] function-body
32724 __transaction_relaxed function-try-block
32728 cp_parser_function_transaction (cp_parser *parser, enum rid keyword)
32730 unsigned char old_in = parser->in_transaction;
32731 unsigned char new_in = 1;
32732 tree compound_stmt, stmt, attrs;
32733 bool ctor_initializer_p;
32736 gcc_assert (keyword == RID_TRANSACTION_ATOMIC
32737 || keyword == RID_TRANSACTION_RELAXED);
32738 token = cp_parser_require_keyword (parser, keyword,
32739 (keyword == RID_TRANSACTION_ATOMIC ? RT_TRANSACTION_ATOMIC
32740 : RT_TRANSACTION_RELAXED));
32741 gcc_assert (token != NULL);
32743 if (keyword == RID_TRANSACTION_RELAXED)
32744 new_in |= TM_STMT_ATTR_RELAXED;
32747 attrs = cp_parser_txn_attribute_opt (parser);
32749 new_in |= parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER);
32752 stmt = begin_transaction_stmt (token->location, &compound_stmt, new_in);
32754 parser->in_transaction = new_in;
32756 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
32757 ctor_initializer_p = cp_parser_function_try_block (parser);
32759 ctor_initializer_p = cp_parser_ctor_initializer_opt_and_function_body
32760 (parser, /*in_function_try_block=*/false);
32762 parser->in_transaction = old_in;
32764 finish_transaction_stmt (stmt, compound_stmt, new_in, NULL_TREE);
32766 return ctor_initializer_p;
32769 /* Parse a __transaction_cancel statement.
32772 __transaction_cancel txn-attribute[opt] ;
32773 __transaction_cancel txn-attribute[opt] throw-expression ;
32775 ??? Cancel and throw is not yet implemented. */
32778 cp_parser_transaction_cancel (cp_parser *parser)
32781 bool is_outer = false;
32784 token = cp_parser_require_keyword (parser, RID_TRANSACTION_CANCEL,
32785 RT_TRANSACTION_CANCEL);
32786 gcc_assert (token != NULL);
32788 attrs = cp_parser_txn_attribute_opt (parser);
32790 is_outer = (parse_tm_stmt_attr (attrs, TM_STMT_ATTR_OUTER) != 0);
32792 /* ??? Parse cancel-and-throw here. */
32794 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
32798 error_at (token->location, "%<__transaction_cancel%> without "
32799 "transactional memory support enabled");
32800 return error_mark_node;
32802 else if (parser->in_transaction & TM_STMT_ATTR_RELAXED)
32804 error_at (token->location, "%<__transaction_cancel%> within a "
32805 "%<__transaction_relaxed%>");
32806 return error_mark_node;
32810 if ((parser->in_transaction & TM_STMT_ATTR_OUTER) == 0
32811 && !is_tm_may_cancel_outer (current_function_decl))
32813 error_at (token->location, "outer %<__transaction_cancel%> not "
32814 "within outer %<__transaction_atomic%>");
32815 error_at (token->location,
32816 " or a %<transaction_may_cancel_outer%> function");
32817 return error_mark_node;
32820 else if (parser->in_transaction == 0)
32822 error_at (token->location, "%<__transaction_cancel%> not within "
32823 "%<__transaction_atomic%>");
32824 return error_mark_node;
32827 stmt = build_tm_abort_call (token->location, is_outer);
32835 static GTY (()) cp_parser *the_parser;
32838 /* Special handling for the first token or line in the file. The first
32839 thing in the file might be #pragma GCC pch_preprocess, which loads a
32840 PCH file, which is a GC collection point. So we need to handle this
32841 first pragma without benefit of an existing lexer structure.
32843 Always returns one token to the caller in *FIRST_TOKEN. This is
32844 either the true first token of the file, or the first token after
32845 the initial pragma. */
32848 cp_parser_initial_pragma (cp_token *first_token)
32852 cp_lexer_get_preprocessor_token (NULL, first_token);
32853 if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS)
32856 cp_lexer_get_preprocessor_token (NULL, first_token);
32857 if (first_token->type == CPP_STRING)
32859 name = first_token->u.value;
32861 cp_lexer_get_preprocessor_token (NULL, first_token);
32862 if (first_token->type != CPP_PRAGMA_EOL)
32863 error_at (first_token->location,
32864 "junk at end of %<#pragma GCC pch_preprocess%>");
32867 error_at (first_token->location, "expected string literal");
32869 /* Skip to the end of the pragma. */
32870 while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF)
32871 cp_lexer_get_preprocessor_token (NULL, first_token);
32873 /* Now actually load the PCH file. */
32875 c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name));
32877 /* Read one more token to return to our caller. We have to do this
32878 after reading the PCH file in, since its pointers have to be
32880 cp_lexer_get_preprocessor_token (NULL, first_token);
32883 /* Parses the grainsize pragma for the _Cilk_for statement.
32885 #pragma cilk grainsize = <VALUE>. */
32888 cp_parser_cilk_grainsize (cp_parser *parser, cp_token *pragma_tok)
32890 if (cp_parser_require (parser, CPP_EQ, RT_EQ))
32892 tree exp = cp_parser_binary_expression (parser, false, false,
32893 PREC_NOT_OPERATOR, NULL);
32894 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
32895 if (!exp || exp == error_mark_node)
32897 error_at (pragma_tok->location, "invalid grainsize for _Cilk_for");
32901 /* Make sure the next token is _Cilk_for, it is invalid otherwise. */
32902 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CILK_FOR))
32903 cp_parser_cilk_for (parser, exp);
32905 warning_at (cp_lexer_peek_token (parser->lexer)->location, 0,
32906 "%<#pragma cilk grainsize%> is not followed by "
32910 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
32913 /* Normal parsing of a pragma token. Here we can (and must) use the
32917 cp_parser_pragma (cp_parser *parser, enum pragma_context context)
32919 cp_token *pragma_tok;
32922 pragma_tok = cp_lexer_consume_token (parser->lexer);
32923 gcc_assert (pragma_tok->type == CPP_PRAGMA);
32924 parser->lexer->in_pragma = true;
32926 id = pragma_tok->pragma_kind;
32927 if (id != PRAGMA_OMP_DECLARE_REDUCTION)
32928 cp_ensure_no_omp_declare_simd (parser);
32931 case PRAGMA_GCC_PCH_PREPROCESS:
32932 error_at (pragma_tok->location,
32933 "%<#pragma GCC pch_preprocess%> must be first");
32936 case PRAGMA_OMP_BARRIER:
32939 case pragma_compound:
32940 cp_parser_omp_barrier (parser, pragma_tok);
32943 error_at (pragma_tok->location, "%<#pragma omp barrier%> may only be "
32944 "used in compound statements");
32951 case PRAGMA_OMP_FLUSH:
32954 case pragma_compound:
32955 cp_parser_omp_flush (parser, pragma_tok);
32958 error_at (pragma_tok->location, "%<#pragma omp flush%> may only be "
32959 "used in compound statements");
32966 case PRAGMA_OMP_TASKWAIT:
32969 case pragma_compound:
32970 cp_parser_omp_taskwait (parser, pragma_tok);
32973 error_at (pragma_tok->location,
32974 "%<#pragma omp taskwait%> may only be "
32975 "used in compound statements");
32982 case PRAGMA_OMP_TASKYIELD:
32985 case pragma_compound:
32986 cp_parser_omp_taskyield (parser, pragma_tok);
32989 error_at (pragma_tok->location,
32990 "%<#pragma omp taskyield%> may only be "
32991 "used in compound statements");
32998 case PRAGMA_OMP_CANCEL:
33001 case pragma_compound:
33002 cp_parser_omp_cancel (parser, pragma_tok);
33005 error_at (pragma_tok->location,
33006 "%<#pragma omp cancel%> may only be "
33007 "used in compound statements");
33014 case PRAGMA_OMP_CANCELLATION_POINT:
33017 case pragma_compound:
33018 cp_parser_omp_cancellation_point (parser, pragma_tok);
33021 error_at (pragma_tok->location,
33022 "%<#pragma omp cancellation point%> may only be "
33023 "used in compound statements");
33030 case PRAGMA_OMP_THREADPRIVATE:
33031 cp_parser_omp_threadprivate (parser, pragma_tok);
33034 case PRAGMA_OMP_DECLARE_REDUCTION:
33035 cp_parser_omp_declare (parser, pragma_tok, context);
33038 case PRAGMA_OACC_CACHE:
33039 case PRAGMA_OACC_DATA:
33040 case PRAGMA_OACC_ENTER_DATA:
33041 case PRAGMA_OACC_EXIT_DATA:
33042 case PRAGMA_OACC_KERNELS:
33043 case PRAGMA_OACC_PARALLEL:
33044 case PRAGMA_OACC_LOOP:
33045 case PRAGMA_OACC_UPDATE:
33046 case PRAGMA_OACC_WAIT:
33047 case PRAGMA_OMP_ATOMIC:
33048 case PRAGMA_OMP_CRITICAL:
33049 case PRAGMA_OMP_DISTRIBUTE:
33050 case PRAGMA_OMP_FOR:
33051 case PRAGMA_OMP_MASTER:
33052 case PRAGMA_OMP_ORDERED:
33053 case PRAGMA_OMP_PARALLEL:
33054 case PRAGMA_OMP_SECTIONS:
33055 case PRAGMA_OMP_SIMD:
33056 case PRAGMA_OMP_SINGLE:
33057 case PRAGMA_OMP_TASK:
33058 case PRAGMA_OMP_TASKGROUP:
33059 case PRAGMA_OMP_TEAMS:
33060 if (context != pragma_stmt && context != pragma_compound)
33062 cp_parser_omp_construct (parser, pragma_tok);
33065 case PRAGMA_OMP_TARGET:
33066 return cp_parser_omp_target (parser, pragma_tok, context);
33068 case PRAGMA_OMP_END_DECLARE_TARGET:
33069 cp_parser_omp_end_declare_target (parser, pragma_tok);
33072 case PRAGMA_OMP_SECTION:
33073 error_at (pragma_tok->location,
33074 "%<#pragma omp section%> may only be used in "
33075 "%<#pragma omp sections%> construct");
33080 if (context == pragma_external)
33082 error_at (pragma_tok->location,
33083 "%<#pragma GCC ivdep%> must be inside a function");
33086 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
33088 tok = cp_lexer_peek_token (the_parser->lexer);
33089 if (tok->type != CPP_KEYWORD
33090 || (tok->keyword != RID_FOR && tok->keyword != RID_WHILE
33091 && tok->keyword != RID_DO))
33093 cp_parser_error (parser, "for, while or do statement expected");
33096 cp_parser_iteration_statement (parser, true);
33100 case PRAGMA_CILK_SIMD:
33101 if (context == pragma_external)
33103 error_at (pragma_tok->location,
33104 "%<#pragma simd%> must be inside a function");
33107 cp_parser_cilk_simd (parser, pragma_tok);
33110 case PRAGMA_CILK_GRAINSIZE:
33111 if (context == pragma_external)
33113 error_at (pragma_tok->location,
33114 "%<#pragma cilk grainsize%> must be inside a function");
33118 /* Ignore the pragma if Cilk Plus is not enabled. */
33121 cp_parser_cilk_grainsize (parser, pragma_tok);
33126 error_at (pragma_tok->location, "-fcilkplus must be enabled to use "
33127 "%<#pragma cilk grainsize%>");
33132 gcc_assert (id >= PRAGMA_FIRST_EXTERNAL);
33133 c_invoke_pragma_handler (id);
33137 cp_parser_error (parser, "expected declaration specifiers");
33141 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
33145 /* The interface the pragma parsers have to the lexer. */
33148 pragma_lex (tree *value)
33151 enum cpp_ttype ret;
33153 tok = cp_lexer_peek_token (the_parser->lexer);
33156 *value = tok->u.value;
33158 if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF)
33160 else if (ret == CPP_STRING)
33161 *value = cp_parser_string_literal (the_parser, false, false);
33164 cp_lexer_consume_token (the_parser->lexer);
33165 if (ret == CPP_KEYWORD)
33173 /* External interface. */
33175 /* Parse one entire translation unit. */
33178 c_parse_file (void)
33180 static bool already_called = false;
33182 if (already_called)
33183 fatal_error (input_location,
33184 "inter-module optimizations not implemented for C++");
33185 already_called = true;
33187 the_parser = cp_parser_new ();
33188 push_deferring_access_checks (flag_access_control
33189 ? dk_no_deferred : dk_no_check);
33190 cp_parser_translation_unit (the_parser);
33194 /* Parses the Cilk Plus #pragma simd and SIMD-enabled function attribute's
33195 vectorlength clause:
33197 vectorlength ( constant-expression ) */
33200 cp_parser_cilk_simd_vectorlength (cp_parser *parser, tree clauses,
33203 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
33205 /* The vectorlength clause in #pragma simd behaves exactly like OpenMP's
33206 safelen clause. Thus, vectorlength is represented as OMP 4.0
33207 safelen. For SIMD-enabled function it is represented by OMP 4.0
33210 check_no_duplicate_clause (clauses, OMP_CLAUSE_SAFELEN, "vectorlength",
33213 check_no_duplicate_clause (clauses, OMP_CLAUSE_SIMDLEN, "vectorlength",
33216 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
33217 return error_mark_node;
33219 expr = cp_parser_constant_expression (parser);
33220 expr = maybe_constant_value (expr);
33222 /* If expr == error_mark_node, then don't emit any errors nor
33223 create a clause. if any of the above functions returns
33224 error mark node then they would have emitted an error message. */
33225 if (expr == error_mark_node)
33227 else if (!TREE_TYPE (expr)
33228 || !TREE_CONSTANT (expr)
33229 || !INTEGRAL_TYPE_P (TREE_TYPE (expr)))
33230 error_at (loc, "vectorlength must be an integer constant");
33231 else if (TREE_CONSTANT (expr)
33232 && exact_log2 (TREE_INT_CST_LOW (expr)) == -1)
33233 error_at (loc, "vectorlength must be a power of 2");
33239 c = build_omp_clause (loc, OMP_CLAUSE_SAFELEN);
33240 OMP_CLAUSE_SAFELEN_EXPR (c) = expr;
33241 OMP_CLAUSE_CHAIN (c) = clauses;
33246 c = build_omp_clause (loc, OMP_CLAUSE_SIMDLEN);
33247 OMP_CLAUSE_SIMDLEN_EXPR (c) = expr;
33248 OMP_CLAUSE_CHAIN (c) = clauses;
33253 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
33254 return error_mark_node;
33258 /* Handles the Cilk Plus #pragma simd linear clause.
33260 linear ( simd-linear-variable-list )
33262 simd-linear-variable-list:
33263 simd-linear-variable
33264 simd-linear-variable-list , simd-linear-variable
33266 simd-linear-variable:
33268 id-expression : simd-linear-step
33271 conditional-expression */
33274 cp_parser_cilk_simd_linear (cp_parser *parser, tree clauses)
33276 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
33278 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
33280 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
33282 cp_parser_error (parser, "expected identifier");
33283 cp_parser_skip_to_closing_parenthesis (parser, false, false, true);
33284 return error_mark_node;
33287 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
33288 parser->colon_corrects_to_scope_p = false;
33291 cp_token *token = cp_lexer_peek_token (parser->lexer);
33292 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
33294 cp_parser_error (parser, "expected variable-name");
33295 clauses = error_mark_node;
33299 tree var_name = cp_parser_id_expression (parser, false, true, NULL,
33301 tree decl = cp_parser_lookup_name_simple (parser, var_name,
33303 if (decl == error_mark_node)
33305 cp_parser_name_lookup_error (parser, var_name, decl, NLE_NULL,
33307 clauses = error_mark_node;
33311 tree e = NULL_TREE;
33312 tree step_size = integer_one_node;
33314 /* If present, parse the linear step. Otherwise, assume the default
33316 if (cp_lexer_peek_token (parser->lexer)->type == CPP_COLON)
33318 cp_lexer_consume_token (parser->lexer);
33320 e = cp_parser_assignment_expression (parser);
33321 e = maybe_constant_value (e);
33323 if (e == error_mark_node)
33325 /* If an error has occurred, then the whole pragma is
33326 considered ill-formed. Thus, no reason to keep
33328 clauses = error_mark_node;
33331 else if (type_dependent_expression_p (e)
33332 || value_dependent_expression_p (e)
33334 && INTEGRAL_TYPE_P (TREE_TYPE (e))
33335 && (TREE_CONSTANT (e)
33339 cp_parser_error (parser,
33340 "step size must be an integer constant "
33341 "expression or an integer variable");
33344 /* Use the OMP_CLAUSE_LINEAR, which has the same semantics. */
33345 tree l = build_omp_clause (loc, OMP_CLAUSE_LINEAR);
33346 OMP_CLAUSE_DECL (l) = decl;
33347 OMP_CLAUSE_LINEAR_STEP (l) = step_size;
33348 OMP_CLAUSE_CHAIN (l) = clauses;
33351 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
33352 cp_lexer_consume_token (parser->lexer);
33353 else if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
33357 error_at (cp_lexer_peek_token (parser->lexer)->location,
33358 "expected %<,%> or %<)%> after %qE", decl);
33359 clauses = error_mark_node;
33363 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
33364 cp_parser_skip_to_closing_parenthesis (parser, false, false, true);
33368 /* Returns the name of the next clause. If the clause is not
33369 recognized, then PRAGMA_CILK_CLAUSE_NONE is returned and the next
33370 token is not consumed. Otherwise, the appropriate enum from the
33371 pragma_simd_clause is returned and the token is consumed. */
33373 static pragma_omp_clause
33374 cp_parser_cilk_simd_clause_name (cp_parser *parser)
33376 pragma_omp_clause clause_type;
33377 cp_token *token = cp_lexer_peek_token (parser->lexer);
33379 if (token->keyword == RID_PRIVATE)
33380 clause_type = PRAGMA_CILK_CLAUSE_PRIVATE;
33381 else if (!token->u.value || token->type != CPP_NAME)
33382 return PRAGMA_CILK_CLAUSE_NONE;
33383 else if (!strcmp (IDENTIFIER_POINTER (token->u.value), "vectorlength"))
33384 clause_type = PRAGMA_CILK_CLAUSE_VECTORLENGTH;
33385 else if (!strcmp (IDENTIFIER_POINTER (token->u.value), "linear"))
33386 clause_type = PRAGMA_CILK_CLAUSE_LINEAR;
33387 else if (!strcmp (IDENTIFIER_POINTER (token->u.value), "firstprivate"))
33388 clause_type = PRAGMA_CILK_CLAUSE_FIRSTPRIVATE;
33389 else if (!strcmp (IDENTIFIER_POINTER (token->u.value), "lastprivate"))
33390 clause_type = PRAGMA_CILK_CLAUSE_LASTPRIVATE;
33391 else if (!strcmp (IDENTIFIER_POINTER (token->u.value), "reduction"))
33392 clause_type = PRAGMA_CILK_CLAUSE_REDUCTION;
33394 return PRAGMA_CILK_CLAUSE_NONE;
33396 cp_lexer_consume_token (parser->lexer);
33397 return clause_type;
33400 /* Parses all the #pragma simd clauses. Returns a list of clauses found. */
33403 cp_parser_cilk_simd_all_clauses (cp_parser *parser, cp_token *pragma_token)
33405 tree clauses = NULL_TREE;
33407 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)
33408 && clauses != error_mark_node)
33410 pragma_omp_clause c_kind;
33411 c_kind = cp_parser_cilk_simd_clause_name (parser);
33412 if (c_kind == PRAGMA_CILK_CLAUSE_VECTORLENGTH)
33413 clauses = cp_parser_cilk_simd_vectorlength (parser, clauses, false);
33414 else if (c_kind == PRAGMA_CILK_CLAUSE_LINEAR)
33415 clauses = cp_parser_cilk_simd_linear (parser, clauses);
33416 else if (c_kind == PRAGMA_CILK_CLAUSE_PRIVATE)
33417 /* Use the OpenMP 4.0 equivalent function. */
33418 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE, clauses);
33419 else if (c_kind == PRAGMA_CILK_CLAUSE_FIRSTPRIVATE)
33420 /* Use the OpenMP 4.0 equivalent function. */
33421 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
33423 else if (c_kind == PRAGMA_CILK_CLAUSE_LASTPRIVATE)
33424 /* Use the OMP 4.0 equivalent function. */
33425 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE,
33427 else if (c_kind == PRAGMA_CILK_CLAUSE_REDUCTION)
33428 /* Use the OMP 4.0 equivalent function. */
33429 clauses = cp_parser_omp_clause_reduction (parser, clauses);
33432 clauses = error_mark_node;
33433 cp_parser_error (parser, "expected %<#pragma simd%> clause");
33438 cp_parser_skip_to_pragma_eol (parser, pragma_token);
33440 if (clauses == error_mark_node)
33441 return error_mark_node;
33443 return c_finish_cilk_clauses (clauses);
33446 /* Main entry-point for parsing Cilk Plus <#pragma simd> for loops. */
33449 cp_parser_cilk_simd (cp_parser *parser, cp_token *pragma_token)
33451 tree clauses = cp_parser_cilk_simd_all_clauses (parser, pragma_token);
33453 if (clauses == error_mark_node)
33456 if (cp_lexer_next_token_is_not_keyword (parser->lexer, RID_FOR))
33458 error_at (cp_lexer_peek_token (parser->lexer)->location,
33459 "for statement expected");
33463 tree sb = begin_omp_structured_block ();
33464 int save = cp_parser_begin_omp_structured_block (parser);
33465 tree ret = cp_parser_omp_for_loop (parser, CILK_SIMD, clauses, NULL);
33467 cpp_validate_cilk_plus_loop (OMP_FOR_BODY (ret));
33468 cp_parser_end_omp_structured_block (parser, save);
33469 add_stmt (finish_omp_structured_block (sb));
33472 /* Main entry-point for parsing Cilk Plus _Cilk_for
33473 loops. The return value is error_mark_node
33474 when errors happen and CILK_FOR tree on success. */
33477 cp_parser_cilk_for (cp_parser *parser, tree grain)
33479 if (cp_lexer_next_token_is_not_keyword (parser->lexer, RID_CILK_FOR))
33480 gcc_unreachable ();
33482 tree sb = begin_omp_structured_block ();
33483 int save = cp_parser_begin_omp_structured_block (parser);
33485 tree clauses = build_omp_clause (EXPR_LOCATION (grain), OMP_CLAUSE_SCHEDULE);
33486 OMP_CLAUSE_SCHEDULE_KIND (clauses) = OMP_CLAUSE_SCHEDULE_CILKFOR;
33487 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clauses) = grain;
33488 clauses = finish_omp_clauses (clauses);
33490 tree ret = cp_parser_omp_for_loop (parser, CILK_FOR, clauses, NULL);
33492 cpp_validate_cilk_plus_loop (ret);
33494 ret = error_mark_node;
33496 cp_parser_end_omp_structured_block (parser, save);
33497 add_stmt (finish_omp_structured_block (sb));
33501 /* Create an identifier for a generic parameter type (a synthesized
33502 template parameter implied by `auto' or a concept identifier). */
33504 static GTY(()) int generic_parm_count;
33506 make_generic_type_name ()
33509 sprintf (buf, "auto:%d", ++generic_parm_count);
33510 return get_identifier (buf);
33513 /* Predicate that behaves as is_auto_or_concept but matches the parent
33514 node of the generic type rather than the generic type itself. This
33515 allows for type transformation in add_implicit_template_parms. */
33518 tree_type_is_auto_or_concept (const_tree t)
33520 return TREE_TYPE (t) && is_auto_or_concept (TREE_TYPE (t));
33523 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
33524 (creating a new template parameter list if necessary). Returns the newly
33525 created template type parm. */
33528 synthesize_implicit_template_parm (cp_parser *parser)
33530 gcc_assert (current_binding_level->kind == sk_function_parms);
33532 /* We are either continuing a function template that already contains implicit
33533 template parameters, creating a new fully-implicit function template, or
33534 extending an existing explicit function template with implicit template
33537 cp_binding_level *const entry_scope = current_binding_level;
33539 bool become_template = false;
33540 cp_binding_level *parent_scope = 0;
33542 if (parser->implicit_template_scope)
33544 gcc_assert (parser->implicit_template_parms);
33546 current_binding_level = parser->implicit_template_scope;
33550 /* Roll back to the existing template parameter scope (in the case of
33551 extending an explicit function template) or introduce a new template
33552 parameter scope ahead of the function parameter scope (or class scope
33553 in the case of out-of-line member definitions). The function scope is
33554 added back after template parameter synthesis below. */
33556 cp_binding_level *scope = entry_scope;
33558 while (scope->kind == sk_function_parms)
33560 parent_scope = scope;
33561 scope = scope->level_chain;
33563 if (current_class_type && !LAMBDA_TYPE_P (current_class_type))
33565 /* If not defining a class, then any class scope is a scope level in
33566 an out-of-line member definition. In this case simply wind back
33567 beyond the first such scope to inject the template parameter list.
33568 Otherwise wind back to the class being defined. The latter can
33569 occur in class member friend declarations such as:
33575 friend void A::foo (auto);
33578 The template parameter list synthesized for the friend declaration
33579 must be injected in the scope of 'B'. This can also occur in
33580 erroneous cases such as:
33586 void B::foo (auto) {}
33589 Here the attempted definition of 'B::foo' within 'A' is ill-formed
33590 but, nevertheless, the template parameter list synthesized for the
33591 declarator should be injected into the scope of 'A' as if the
33592 ill-formed template was specified explicitly. */
33594 while (scope->kind == sk_class && !scope->defining_class_p)
33596 parent_scope = scope;
33597 scope = scope->level_chain;
33601 current_binding_level = scope;
33603 if (scope->kind != sk_template_parms
33604 || !function_being_declared_is_template_p (parser))
33606 /* Introduce a new template parameter list for implicit template
33609 become_template = true;
33611 parser->implicit_template_scope
33612 = begin_scope (sk_template_parms, NULL);
33614 ++processing_template_decl;
33616 parser->fully_implicit_function_template_p = true;
33617 ++parser->num_template_parameter_lists;
33621 /* Synthesize implicit template parameters at the end of the explicit
33622 template parameter list. */
33624 gcc_assert (current_template_parms);
33626 parser->implicit_template_scope = scope;
33628 tree v = INNERMOST_TEMPLATE_PARMS (current_template_parms);
33629 parser->implicit_template_parms
33630 = TREE_VEC_ELT (v, TREE_VEC_LENGTH (v) - 1);
33634 /* Synthesize a new template parameter and track the current template
33635 parameter chain with implicit_template_parms. */
33637 tree synth_id = make_generic_type_name ();
33638 tree synth_tmpl_parm = finish_template_type_parm (class_type_node,
33641 = process_template_parm (parser->implicit_template_parms,
33643 build_tree_list (NULL_TREE, synth_tmpl_parm),
33644 /*non_type=*/false,
33645 /*param_pack=*/false);
33648 if (parser->implicit_template_parms)
33649 parser->implicit_template_parms
33650 = TREE_CHAIN (parser->implicit_template_parms);
33652 parser->implicit_template_parms = new_parm;
33654 tree new_type = TREE_TYPE (getdecls ());
33656 /* If creating a fully implicit function template, start the new implicit
33657 template parameter list with this synthesized type, otherwise grow the
33658 current template parameter list. */
33660 if (become_template)
33662 parent_scope->level_chain = current_binding_level;
33664 tree new_parms = make_tree_vec (1);
33665 TREE_VEC_ELT (new_parms, 0) = parser->implicit_template_parms;
33666 current_template_parms = tree_cons (size_int (processing_template_decl),
33667 new_parms, current_template_parms);
33671 tree& new_parms = INNERMOST_TEMPLATE_PARMS (current_template_parms);
33672 int new_parm_idx = TREE_VEC_LENGTH (new_parms);
33673 new_parms = grow_tree_vec (new_parms, new_parm_idx + 1);
33674 TREE_VEC_ELT (new_parms, new_parm_idx) = parser->implicit_template_parms;
33677 current_binding_level = entry_scope;
33682 /* Finish the declaration of a fully implicit function template. Such a
33683 template has no explicit template parameter list so has not been through the
33684 normal template head and tail processing. synthesize_implicit_template_parm
33685 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
33686 provided if the declaration is a class member such that its template
33687 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
33688 form is returned. Otherwise NULL_TREE is returned. */
33691 finish_fully_implicit_template (cp_parser *parser, tree member_decl_opt)
33693 gcc_assert (parser->fully_implicit_function_template_p);
33695 if (member_decl_opt && member_decl_opt != error_mark_node
33696 && DECL_VIRTUAL_P (member_decl_opt))
33698 error_at (DECL_SOURCE_LOCATION (member_decl_opt),
33699 "implicit templates may not be %<virtual%>");
33700 DECL_VIRTUAL_P (member_decl_opt) = false;
33703 if (member_decl_opt)
33704 member_decl_opt = finish_member_template_decl (member_decl_opt);
33705 end_template_decl ();
33707 parser->fully_implicit_function_template_p = false;
33708 --parser->num_template_parameter_lists;
33710 return member_decl_opt;
33713 #include "gt-cp-parser.h"