Lines Matching refs:parser
38 #include "parser.h"
54 and c-lex.c) and the C++ parser. */
186 /* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
191 cp_parser *parser;
194 type_id_in_expr_sentinel (cp_parser *parser, bool set = true)
195 : parser (parser),
196 saved (parser->in_type_id_in_expr_p)
197 { parser->in_type_id_in_expr_p = set; }
199 { parser->in_type_id_in_expr_p = saved; }
388 /* Dump parser context C to FILE. */
490 cp_debug_parser_tokens (FILE *file, cp_parser *parser, int window_size)
497 next_token = parser->lexer->next_token;
498 first_token = parser->lexer->buffer->address ();
502 cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
511 cp_debug_parser (FILE *file, cp_parser *parser)
522 vec_safe_length (parser->lexer->buffer));
523 cp_debug_print_tree_if_set (file, "Lookup scope", parser->scope);
525 parser->object_scope);
527 parser->qualifying_scope);
528 cp_debug_print_context_stack (file, parser->context);
530 parser->allow_gnu_extensions_p);
532 parser->greater_than_is_operator_p);
534 "parameter list", parser->default_arg_ok_p);
536 parser->integral_constant_expression_p);
539 parser->allow_non_integral_constant_expression_p);
541 parser->non_integral_constant_expression_p);
543 (parser->local_variables_forbidden_p
546 (parser->local_variables_forbidden_p
549 parser->in_unbraced_linkage_specification_p);
551 parser->in_declarator_p);
553 parser->in_template_argument_list_p);
555 parser->in_statement & IN_ITERATION_STMT);
557 parser->in_statement & IN_SWITCH_STMT);
559 parser->in_statement & IN_OMP_BLOCK);
561 parser->in_statement & IN_OMP_FOR);
563 parser->in_statement & IN_IF_STMT);
565 "context", parser->in_type_id_in_expr_p);
568 parser->translate_strings_p);
570 "local class", parser->in_function_body);
572 parser->colon_corrects_to_scope_p);
574 parser->colon_doesnt_start_class_def_p);
576 parser->objective_c_message_context_p);
577 if (parser->type_definition_forbidden_message)
579 parser->type_definition_forbidden_message,
580 parser->type_definition_forbidden_message_arg
581 ? parser->type_definition_forbidden_message_arg : "<none>");
582 cp_debug_print_unparsed_queues (file, parser->unparsed_queues);
584 parser->num_classes_being_defined);
586 "declaration: %u\n", parser->num_template_parameter_lists);
587 cp_debug_parser_tokens (file, parser, window_size);
588 token = parser->lexer->next_token;
1253 /* We don't use cpp_type2name here because the parser defines
1262 /* C++ parser token types - see "Manifest constants", above. */
1362 cp_ensure_no_omp_declare_simd (cp_parser *parser)
1364 if (parser->omp_declare_simd && !parser->omp_declare_simd->error_seen)
1368 parser->omp_declare_simd->variant_p ? "variant" : "simd");
1369 parser->omp_declare_simd = NULL;
1377 cp_finalize_omp_declare_simd (cp_parser *parser, tree fndecl)
1379 if (__builtin_expect (parser->omp_declare_simd != NULL, 0))
1383 parser->omp_declare_simd = NULL;
1388 cp_ensure_no_omp_declare_simd (parser);
1398 cp_ensure_no_oacc_routine (cp_parser *parser)
1400 if (parser->oacc_routine && !parser->oacc_routine->error_seen)
1402 error_at (parser->oacc_routine->loc,
1405 parser->oacc_routine = NULL;
1422 /* Nothing other than the parser should be creating declarators;
1744 /* The parser. */
1751 example, the parser breaks the token stream into declarators,
1757 The parser invokes routines elsewhere in the compiler to perform
1761 The parser (and the template instantiation code, which is, in a
1764 related functions. The parser (and template instantiation code)
1773 The parser is of the standard recursive-descent variety. Upcoming
1779 Therefore, the parser is capable of "parsing tentatively." When the
1780 parser is not sure what construct comes next, it enters this mode.
1781 Then, while we attempt to parse the construct, the parser queues up
1784 parser "commits", i.e., it issues any queued error messages and
1786 If, however, the construct is not parsed successfully, the parser
1793 The performance of the parser could probably be improved substantially.
1997 parser->unparsed_queues->last ().funs_with_default_args
1999 parser->unparsed_queues->last ().funs_with_definitions
2001 parser->unparsed_queues->last ().nsdmis
2003 parser->unparsed_queues->last ().noexcepts
2006 push_unparsed_function_queues (cp_parser *parser)
2009 vec_safe_push (parser->unparsed_queues, e);
2013 pop_unparsed_function_queues (cp_parser *parser)
2016 parser->unparsed_queues->pop ();
2197 (cp_parser* parser);
2314 (cp_parser* parser);
2626 (cp_parser *parser, bool nsdmi);
2719 cp_parser_parsing_tentatively (cp_parser* parser)
2721 return parser->context->next != NULL;
2881 cp_parser_error_1 (cp_parser* parser, const char* gmsgid,
2885 cp_token *token = cp_lexer_peek_token (parser->lexer);
2894 cp_parser_skip_to_pragma_eol (parser, token);
2904 if (cp_lexer_peek_conflict_marker (parser->lexer, token->type, &loc))
2911 cp_lexer_consume_token (parser->lexer);
2912 cp_token *next = cp_lexer_peek_token (parser->lexer);
2940 = cp_lexer_previous_token (parser->lexer)->location;
2977 cp_parser_error (cp_parser* parser, const char* gmsgid)
2979 if (!cp_parser_simulate_error (parser))
2980 cp_parser_error_1 (parser, gmsgid, RT_NONE, UNKNOWN_LOCATION);
2989 cp_parser_name_lookup_error (cp_parser* parser,
2999 if (parser->scope && parser->scope != global_namespace)
3001 parser->scope, name);
3002 else if (parser->scope == global_namespace)
3004 else if (parser->object_scope
3005 && !CLASS_TYPE_P (parser->object_scope))
3007 name, parser->object_scope);
3008 else if (parser->object_scope)
3010 parser->object_scope, name);
3014 else if (parser->scope && parser->scope != global_namespace)
3020 parser->scope, name);
3024 parser->scope, name);
3029 parser->scope, name);
3036 else if (parser->scope == global_namespace)
3080 cp_parser_simulate_error (cp_parser* parser)
3082 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3084 parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
3095 cp_parser_check_type_definition (cp_parser* parser)
3098 if (parser->type_definition_forbidden_message)
3102 error (parser->type_definition_forbidden_message,
3103 parser->type_definition_forbidden_message_arg);
3145 cp_parser_check_for_invalid_template_id (cp_parser* parser,
3152 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3168 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
3169 start = cp_lexer_token_position (parser->lexer, true);
3171 cp_lexer_consume_token (parser->lexer);
3173 cp_parser_enclosed_template_argument_list (parser);
3177 cp_lexer_purge_tokens_after (parser->lexer, start);
3187 cp_parser_non_integral_constant_expression (cp_parser *parser,
3190 parser->non_integral_constant_expression_p = true;
3191 if (parser->integral_constant_expression_p)
3193 if (!parser->allow_non_integral_constant_expression_p)
3311 cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id,
3315 cp_parser_commit_to_tentative_parse (parser);
3317 decl = cp_parser_lookup_name (parser, id, none_type,
3344 else if (!parser->scope)
3425 else if (parser->scope != error_mark_node)
3427 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
3433 parser->scope);
3438 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3444 id, parser->scope, suggestion);
3448 id, parser->scope);
3456 TREE_OPERAND (id, 0), parser->scope, suggestion);
3461 TREE_OPERAND (id, 0), parser->scope);
3469 id, parser->scope, suggestion);
3473 id, parser->scope);
3478 else if (CLASS_TYPE_P (parser->scope)
3479 && constructor_name_p (id, parser->scope))
3484 " the type", parser->scope, id);
3485 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3487 parser->scope);
3489 else if (TYPE_P (parser->scope)
3490 && dependent_scope_p (parser->scope))
3494 if (TREE_CODE (parser->scope) == TYPENAME_TYPE)
3498 TYPE_CONTEXT (parser->scope),
3499 TYPENAME_TYPE_FULLNAME (parser->scope),
3501 TYPE_CONTEXT (parser->scope),
3502 TYPENAME_TYPE_FULLNAME (parser->scope));
3506 parser->scope, id, parser->scope);
3508 else if (TYPE_P (parser->scope))
3511 if (!COMPLETE_TYPE_P (parser->scope))
3513 parser->scope);
3514 else if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
3517 id, parser->scope);
3521 TREE_OPERAND (id, 0), parser->scope);
3525 id, parser->scope);
3545 cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
3548 cp_token *token = cp_lexer_peek_token (parser->lexer);
3553 cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
3558 cp_parser_parse_tentatively (parser);
3559 id = cp_parser_id_expression (parser,
3567 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
3570 cp_parser_abort_tentative_parse (parser);
3573 if (!cp_parser_parse_definitely (parser))
3577 cp_parser_diagnose_invalid_type_name (parser, id, token->location);
3582 if (!parser->in_declarator_p)
3583 cp_parser_skip_to_end_of_block_or_statement (parser);
3593 cp_parser_skip_to_closing_parenthesis_1 (cp_parser *parser,
3604 && cp_parser_uncommitted_to_tentative_parse_p (parser))
3609 cp_token * token = cp_lexer_peek_token (parser->lexer);
3619 if (!parser->lexer->in_pragma)
3658 cp_lexer_consume_token (parser->lexer);
3678 cp_lexer_consume_token (parser->lexer);
3688 cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
3694 return cp_parser_skip_to_closing_parenthesis_1 (parser, recovering,
3703 cp_parser_skip_to_end_of_statement (cp_parser* parser)
3708 if (parser->fully_implicit_function_template_p)
3709 abort_fully_implicit_template (parser);
3713 cp_token *token = cp_lexer_peek_token (parser->lexer);
3718 if (!parser->lexer->in_pragma)
3755 cp_lexer_consume_token (parser->lexer);
3769 cp_lexer_consume_token (parser->lexer);
3778 cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
3781 if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
3785 cp_parser_skip_to_end_of_statement (parser);
3787 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
3788 cp_lexer_consume_token (parser->lexer);
3796 cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
3801 if (parser->fully_implicit_function_template_p)
3802 abort_fully_implicit_template (parser);
3806 cp_token *token = cp_lexer_peek_token (parser->lexer);
3811 if (!parser->lexer->in_pragma)
3844 cp_lexer_consume_token (parser->lexer);
3853 cp_parser_skip_to_closing_brace (cp_parser *parser)
3859 cp_token *token = cp_lexer_peek_token (parser->lexer);
3864 if (!parser->lexer->in_pragma)
3889 cp_lexer_consume_token (parser->lexer);
3898 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
3902 parser->lexer->in_pragma = false;
3905 token = cp_lexer_consume_token (parser->lexer);
3909 cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
3916 cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
3918 parser->lexer->in_pragma = false;
3919 if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
3920 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
3928 cp_parser_make_typename_type (cp_parser *parser, tree id,
3934 result = make_typename_type (parser->scope, id, typename_type,
3937 cp_parser_diagnose_invalid_type_name (parser, id, id_location);
3940 return make_typename_type (parser->scope, id, typename_type, tf_error);
3974 /* Create a new C++ parser. */
3979 cp_parser *parser;
3992 parser = ggc_cleared_alloc<cp_parser> ();
3993 parser->lexer = lexer;
3994 parser->context = cp_parser_context_new (NULL);
3997 parser->allow_gnu_extensions_p = 1;
4001 parser->greater_than_is_operator_p = true;
4003 parser->default_arg_ok_p = true;
4006 parser->integral_constant_expression_p = false;
4007 parser->allow_non_integral_constant_expression_p = false;
4008 parser->non_integral_constant_expression_p = false;
4011 parser->local_variables_forbidden_p = 0;
4014 parser->in_unbraced_linkage_specification_p = false;
4017 parser->in_declarator_p = false;
4020 parser->in_template_argument_list_p = false;
4023 parser->in_statement = 0;
4026 parser->in_switch_statement_p = false;
4029 parser->in_type_id_in_expr_p = false;
4032 parser->translate_strings_p = true;
4035 parser->in_function_body = false;
4038 parser->colon_corrects_to_scope_p = true;
4041 push_unparsed_function_queues (parser);
4044 parser->num_classes_being_defined = 0;
4047 parser->num_template_parameter_lists = 0;
4050 parser->omp_declare_simd = NULL;
4051 parser->oacc_routine = NULL;
4054 parser->auto_is_implicit_function_template_parm_p = false;
4055 parser->fully_implicit_function_template_p = false;
4056 parser->implicit_template_parms = 0;
4057 parser->implicit_template_scope = 0;
4060 parser->prevent_constrained_type_specifiers = 0;
4063 parser->innermost_linkage_specification_location = UNKNOWN_LOCATION;
4065 return parser;
4069 and push it onto the parser's lexer stack. This is used for delayed
4073 cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
4076 lexer->next = parser->lexer;
4077 parser->lexer = lexer;
4084 /* Pop the top lexer off the parser stack. This is never used for the
4087 cp_parser_pop_lexer (cp_parser *parser)
4089 cp_lexer *lexer = parser->lexer;
4090 parser->lexer = lexer->next;
4095 cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4104 cp_parser_identifier (cp_parser* parser)
4109 token = cp_parser_require (parser, CPP_NAME, RT_NAME);
4132 cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
4147 tok = cp_lexer_peek_token (parser->lexer);
4150 cp_parser_error (parser, "expected string-literal");
4172 (cp_lexer_peek_nth_token (parser->lexer, 2)))
4174 cp_lexer_consume_token (parser->lexer);
4200 cp_lexer_consume_token (parser->lexer);
4245 tok = cp_lexer_peek_token (parser->lexer);
4271 cp_parser_error (parser, "a wide string is invalid in this context");
4386 cp_parser_userdef_char_literal (cp_parser *parser)
4388 cp_token *token = cp_lexer_consume_token (parser->lexer);
4483 cp_parser_userdef_numeric_literal (cp_parser *parser)
4485 cp_token *token = cp_lexer_consume_token (parser->lexer);
4621 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
4694 cp_parser_translation_unit (cp_parser* parser)
4712 cp_token *token = cp_lexer_peek_token (parser->lexer);
4717 != cp_lexer_peek_token (parser->lexer)->implicit_extern_c)
4731 cp_parser_error (parser, "expected declaration");
4732 cp_lexer_consume_token (parser->lexer);
4734 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
4735 cp_lexer_consume_token (parser->lexer);
4738 cp_parser_toplevel_declaration (parser);
4742 cp_lexer_destroy (parser->lexer);
4743 parser->lexer = NULL;
4770 cp_parser_start_tentative_firewall (cp_parser *parser)
4772 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
4775 cp_parser_parse_tentatively (parser);
4776 cp_parser_commit_to_topmost_tentative_parse (parser);
4777 return cp_lexer_token_position (parser->lexer, false);
4784 cp_parser_end_tentative_firewall (cp_parser *parser, cp_token_position start,
4791 cp_parser_parse_definitely (parser);
4793 cp_token *token = cp_lexer_token_at (parser->lexer, start);
4797 cp_lexer_purge_tokens_after (parser->lexer, start);
4807 cp_parser *parser;
4810 tentative_firewall (cp_parser *p): parser(p)
4814 if ((set = cp_parser_uncommitted_to_tentative_parse_p (parser)))
4816 cp_parser_parse_tentatively (parser);
4817 cp_parser_commit_to_topmost_tentative_parse (parser);
4818 cp_parser_parse_tentatively (parser);
4828 bool err = cp_parser_error_occurred (parser);
4829 cp_parser_parse_definitely (parser);
4830 cp_parser_parse_definitely (parser);
4832 cp_parser_simulate_error (parser);
4856 bool require_open (cp_parser *parser)
4858 m_open_loc = cp_lexer_peek_token (parser->lexer)->location;
4859 return cp_parser_require (parser, traits_t::open_token_type,
4866 cp_token * consume_open (cp_parser *parser)
4868 cp_token *tok = cp_lexer_consume_token (parser->lexer);
4879 cp_token *require_close (cp_parser *parser) const
4881 return cp_parser_require (parser, traits_t::close_token_type,
4927 cp_parser_statement_expr (cp_parser *parser)
4929 cp_token_position start = cp_parser_start_tentative_firewall (parser);
4932 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
4934 parens.consume_open (parser);
4938 cp_parser_compound_statement (parser, expr, BCS_NORMAL, false);
4942 location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
4943 if (!parens.require_close (parser))
4944 cp_parser_skip_to_end_of_statement (parser);
4946 cp_parser_end_tentative_firewall (parser, start, expr);
5060 cp_parser_fold_operator (cp_parser *parser)
5062 cp_token* token = cp_lexer_peek_token (parser->lexer);
5065 cp_lexer_consume_token (parser->lexer);
5079 cp_parser_fold_expression (cp_parser *parser, tree expr1)
5084 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5086 cp_lexer_consume_token (parser->lexer);
5087 int op = cp_parser_fold_operator (parser);
5090 cp_parser_error (parser, "expected binary operator");
5094 tree expr = cp_parser_cast_expression (parser, false, false,
5101 const cp_token* token = cp_lexer_peek_token (parser->lexer);
5102 int op = cp_parser_fold_operator (parser);
5105 cp_parser_error (parser, "expected binary operator");
5109 if (cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS))
5111 cp_parser_error (parser, "expected ...");
5114 cp_lexer_consume_token (parser->lexer);
5131 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5134 if (cp_lexer_next_token_is_not (parser->lexer, token->type))
5136 cp_parser_error (parser, "mismatched operator in fold-expression");
5139 cp_lexer_consume_token (parser->lexer);
5142 tree expr2 = cp_parser_cast_expression (parser, false, false, false, &pidk);
5203 cp_parser_primary_expression (cp_parser *parser,
5216 token = cp_lexer_peek_token (parser->lexer);
5235 return cp_parser_userdef_numeric_literal (parser);
5236 token = cp_lexer_consume_token (parser->lexer);
5247 && parser->integral_constant_expression_p
5257 next_token = cp_lexer_peek_token (parser->lexer);
5271 || parser->greater_than_is_operator_p)
5276 || parser->greater_than_is_operator_p))
5285 cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
5295 return cp_parser_userdef_char_literal (parser);
5307 /* ??? Should wide strings be allowed when parser->translate_strings_p
5310 return (cp_parser_string_literal (parser,
5311 parser->translate_strings_p,
5318 if (cp_parser_allow_gnu_extensions_p (parser)
5319 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_BRACE))
5331 if (!parser->in_function_body
5332 || parser->in_template_argument_list_p)
5337 cp_parser_skip_to_end_of_block_or_statement (parser);
5338 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
5339 cp_lexer_consume_token (parser->lexer);
5343 return cp_parser_statement_expr (parser);
5354 parens.consume_open (parser);
5358 = parser->greater_than_is_operator_p;
5359 parser->greater_than_is_operator_p = true;
5361 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
5366 expr = cp_parser_expression (parser, idk, cast_p, decltype_p);
5368 token = cp_lexer_peek_token (parser->lexer);
5371 expr = cp_parser_fold_expression (parser, expr);
5394 parser->greater_than_is_operator_p
5398 token = cp_lexer_peek_token (parser->lexer);
5401 if (!parens.require_close (parser)
5402 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
5403 cp_parser_skip_to_end_of_statement (parser);
5413 cp_parser_parse_tentatively (parser);
5414 tree msg = cp_parser_objc_message_expression (parser);
5416 if (cp_parser_parse_definitely (parser))
5420 cp_expr lam = cp_parser_lambda_expression (parser);
5422 if (cp_parser_error_occurred (parser))
5431 return cp_parser_objc_expression (parser);
5432 cp_parser_error (parser, "expected primary-expression");
5440 cp_lexer_consume_token (parser->lexer);
5443 cp_lexer_consume_token (parser->lexer);
5448 cp_lexer_consume_token (parser->lexer);
5453 cp_lexer_consume_token (parser->lexer);
5458 cp_lexer_consume_token (parser->lexer);
5459 if (parser->local_variables_forbidden_p & THIS_FORBIDDEN)
5466 if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
5488 token = cp_lexer_consume_token (parser->lexer);
5505 if (cp_parser_non_integral_constant_expression (parser, name))
5518 = cp_lexer_peek_token (parser->lexer)->location;
5521 cp_lexer_consume_token (parser->lexer);
5524 parens.require_open (parser);
5526 expression = cp_parser_assignment_expression (parser);
5528 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
5529 type_location = cp_lexer_peek_token (parser->lexer)->location;
5532 type_id_in_expr_sentinel s (parser);
5533 type = cp_parser_type_id (parser);
5537 = cp_lexer_peek_token (parser->lexer)->location;
5538 parens.require_close (parser);
5541 if (cp_parser_non_integral_constant_expression (parser,
5555 return cp_parser_builtin_offsetof (parser);
5585 return cp_parser_trait_expr (parser, token->keyword);
5589 return cp_parser_requires_expression (parser);
5595 return cp_parser_objc_expression (parser);
5598 if (parser->in_function_body
5599 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
5604 cp_parser_skip_to_end_of_block_or_statement (parser);
5609 cp_parser_error (parser, "expected primary-expression");
5631 = cp_parser_id_expression (parser,
5640 token = cp_lexer_peek_token (parser->lexer);
5664 cp_parser_simulate_error (parser);
5668 decl = cp_parser_lookup_name (parser, id_expression,
5683 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
5688 cp_lexer_consume_token (parser->lexer);
5689 component = cp_parser_identifier (parser);
5742 if ((parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN)
5753 (id_expression, decl, parser->scope,
5755 parser->integral_constant_expression_p,
5756 parser->allow_non_integral_constant_expression_p,
5757 &parser->non_integral_constant_expression_p,
5763 cp_parser_error (parser, error_msg);
5784 cp_parser_error (parser, "expected primary-expression");
5790 cp_parser_primary_expression (cp_parser *parser,
5796 return cp_parser_primary_expression (parser, address_p, cast_p, template_arg_p,
5835 cp_parser_id_expression (cp_parser *parser,
5852 && (cp_parser_global_scope_opt (parser,
5858 = (cp_parser_nested_name_specifier_opt (parser,
5879 *template_p = cp_parser_optional_template_keyword (parser);
5882 saved_scope = parser->scope;
5883 saved_object_scope = parser->object_scope;
5884 saved_qualifying_scope = parser->qualifying_scope;
5886 unqualified_id = cp_parser_unqualified_id (parser, *template_p,
5891 parser->scope = saved_scope;
5892 parser->object_scope = saved_object_scope;
5893 parser->qualifying_scope = saved_qualifying_scope;
5905 token = cp_lexer_peek_token (parser->lexer);
5912 (parser, 2))
5913 return cp_parser_identifier (parser);
5915 cp_parser_parse_tentatively (parser);
5917 id = cp_parser_template_id_expr (parser,
5922 if (cp_parser_parse_definitely (parser))
5927 token = cp_lexer_peek_token (parser->lexer);
5932 return cp_parser_identifier (parser);
5936 return cp_parser_operator_function_id (parser);
5940 cp_parser_error (parser, "expected id-expression");
5945 return cp_parser_unqualified_id (parser, template_keyword_p,
5974 cp_parser_unqualified_id (cp_parser* parser,
5983 token = cp_lexer_peek_token (parser->lexer);
5993 cp_parser_parse_tentatively (parser);
5995 id = cp_parser_template_id_expr (parser, template_keyword_p,
5999 if (cp_parser_parse_definitely (parser))
6002 return cp_parser_identifier (parser);
6006 return cp_parser_template_id_expr (parser, template_keyword_p,
6020 cp_lexer_consume_token (parser->lexer);
6056 scope = parser->scope;
6057 object_scope = parser->object_scope;
6058 qualifying_scope = parser->qualifying_scope;
6063 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6064 cp_lexer_consume_token (parser->lexer);
6069 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6073 cp_parser_simulate_error (parser);
6074 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
6075 cp_lexer_consume_token (parser->lexer);
6080 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6083 cp_parser_simulate_error (parser);
6089 token = cp_lexer_peek_token (parser->lexer);
6103 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6109 cp_lexer_consume_token (parser->lexer);
6120 cp_lexer_consume_token (parser->lexer);
6134 cp_parser_parse_tentatively (parser);
6135 type_decl = cp_parser_class_name (parser,
6142 if (cp_parser_parse_definitely (parser))
6148 cp_parser_parse_tentatively (parser);
6149 parser->scope = qualifying_scope;
6150 parser->object_scope = NULL_TREE;
6151 parser->qualifying_scope = NULL_TREE;
6153 = cp_parser_class_name (parser,
6160 if (cp_parser_parse_definitely (parser))
6166 cp_parser_parse_tentatively (parser);
6167 parser->scope = object_scope;
6168 parser->object_scope = NULL_TREE;
6169 parser->qualifying_scope = NULL_TREE;
6171 = cp_parser_class_name (parser,
6178 if (cp_parser_parse_definitely (parser))
6184 parser->scope = NULL_TREE;
6185 parser->object_scope = NULL_TREE;
6186 parser->qualifying_scope = NULL_TREE;
6188 cp_parser_parse_tentatively (parser);
6190 = cp_parser_class_name (parser,
6198 && ! cp_parser_parse_definitely (parser))
6202 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
6204 cp_parser_simulate_error (parser);
6209 type_decl = cp_parser_identifier (parser);
6227 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
6231 cp_parser_simulate_error (parser);
6242 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
6256 cp_parser_parse_tentatively (parser);
6258 id = cp_parser_template_id_expr (parser, template_keyword_p,
6262 if (cp_parser_parse_definitely (parser))
6266 cp_parser_parse_tentatively (parser);
6268 id = cp_parser_operator_function_id (parser);
6270 if (!cp_parser_parse_definitely (parser))
6271 id = cp_parser_conversion_function_id (parser);
6280 cp_parser_error (parser, "expected unqualified-id");
6337 cp_parser_nested_name_specifier_opt (cp_parser *parser,
6349 if (cp_parser_uncommitted_to_tentative_parse_p (parser)
6350 && cp_lexer_next_token_is_not (parser->lexer, CPP_NESTED_NAME_SPECIFIER))
6352 start = cp_lexer_token_position (parser->lexer, false);
6364 token = cp_lexer_peek_token (parser->lexer);
6371 cp_parser_pre_parsed_nested_name_specifier (parser);
6376 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
6378 new_scope = resolve_typename_type (parser->scope,
6381 parser->scope = new_scope;
6407 token = cp_lexer_peek_nth_token (parser->lexer, 2);
6410 && parser->colon_corrects_to_scope_p
6411 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_NAME
6413 && !parser->objective_c_message_context_p)
6425 (parser, 2))
6431 cp_parser_parse_tentatively (parser);
6437 template_keyword_p = cp_parser_optional_template_keyword (parser);
6444 && cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
6450 old_scope = parser->scope;
6451 saved_qualifying_scope = parser->qualifying_scope;
6458 && parser->scope
6459 && TREE_CODE (parser->scope) == TYPENAME_TYPE)
6460 parser->scope = resolve_typename_type (parser->scope,
6464 = cp_parser_qualifying_entity (parser,
6471 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
6475 if (!cp_parser_parse_definitely (parser))
6482 parser->scope = old_scope;
6483 parser->qualifying_scope = saved_qualifying_scope;
6491 if (cp_lexer_next_token_is (parser->lexer, CPP_DECLTYPE)
6492 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6495 token = cp_lexer_consume_token (parser->lexer);
6501 parser->scope = error_mark_node;
6505 cp_lexer_consume_token (parser->lexer);
6508 if (cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID)
6509 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_SCOPE))
6513 token = cp_lexer_peek_token (parser->lexer);
6550 parser->scope = error_mark_node;
6554 cp_lexer_consume_token (parser->lexer);
6555 cp_lexer_consume_token (parser->lexer);
6559 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
6564 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
6565 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
6567 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
6570 token = cp_lexer_consume_token (parser->lexer);
6578 decl = cp_parser_lookup_name (parser, token->u.value,
6594 (parser))
6607 (parser, token->u.value, decl, NLE_NOT_CXX98,
6611 (parser, token->u.value, decl, NLE_CXX98,
6615 parser->scope = error_mark_node;
6627 cp_lexer_consume_token (parser->lexer);
6658 parser->scope = new_scope;
6670 token = cp_lexer_token_at (parser->lexer, start);
6677 token->u.tree_check_value->value = parser->scope;
6680 parser->qualifying_scope;
6684 cp_lexer_purge_tokens_after (parser->lexer, start);
6690 return success ? parser->scope : NULL_TREE;
6699 cp_parser_nested_name_specifier (cp_parser *parser,
6708 scope = cp_parser_nested_name_specifier_opt (parser,
6716 cp_parser_error (parser, "expected nested-name-specifier");
6717 parser->scope = NULL_TREE;
6741 cp_parser_qualifying_entity (cp_parser *parser,
6756 if (cp_lexer_next_token_is_decltype (parser->lexer))
6758 scope = cp_parser_decltype (parser);
6762 cp_parser_simulate_error (parser);
6773 saved_scope = parser->scope;
6774 saved_qualifying_scope = parser->qualifying_scope;
6775 saved_object_scope = parser->object_scope;
6781 cp_parser_parse_tentatively (parser);
6782 scope = cp_parser_class_name (parser,
6790 successful_parse_p = only_class_p || cp_parser_parse_definitely (parser);
6795 parser->scope = saved_scope;
6796 parser->qualifying_scope = saved_qualifying_scope;
6797 parser->object_scope = saved_object_scope;
6802 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)
6803 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
6805 scope = cp_parser_namespace_name (parser);
6814 cp_parser_compound_literal_p (cp_parser *parser)
6816 cp_lexer_save_tokens (parser->lexer);
6822 = (cp_parser_skip_to_closing_parenthesis (parser, false, false,
6824 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE));
6827 cp_lexer_rollback_tokens (parser->lexer);
6885 cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
6897 token = cp_lexer_peek_token (parser->lexer);
6918 cp_lexer_consume_token (parser->lexer);
6921 saved_message = parser->type_definition_forbidden_message;
6922 parser->type_definition_forbidden_message
6926 cp_parser_require (parser, CPP_LESS, RT_LESS);
6928 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
6929 parser->in_type_id_in_expr_p = true;
6930 type = cp_parser_type_id (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
6932 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
6934 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
6936 parser->type_definition_forbidden_message = saved_message;
6939 = parser->greater_than_is_operator_p;
6940 parser->greater_than_is_operator_p = true;
6944 parens.require_open (parser);
6945 expression = cp_parser_expression (parser, & idk, /*cast_p=*/true);
6946 cp_token *close_paren = cp_parser_require (parser, CPP_CLOSE_PAREN,
6951 parser->greater_than_is_operator_p
6957 && cp_parser_non_integral_constant_expression (parser, NIC_CAST))
7005 cp_lexer_consume_token (parser->lexer);
7008 parens.require_open (parser);
7010 saved_message = parser->type_definition_forbidden_message;
7011 parser->type_definition_forbidden_message
7015 cp_parser_parse_tentatively (parser);
7017 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
7018 parser->in_type_id_in_expr_p = true;
7019 type = cp_parser_type_id (parser);
7020 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
7024 cp_token *close_paren = parens.require_close (parser);
7026 if (cp_parser_parse_definitely (parser))
7034 expression = cp_parser_expression (parser, & idk);
7038 close_paren = parens.require_close (parser);
7041 parser->type_definition_forbidden_message = saved_message;
7043 if (cp_parser_non_integral_constant_expression (parser, NIC_TYPEID))
7066 ++parser->prevent_constrained_type_specifiers;
7067 type = cp_parser_elaborated_type_specifier (parser,
7070 --parser->prevent_constrained_type_specifiers;
7071 postfix_expression = cp_parser_functional_cast (parser, type);
7083 cp_lexer_consume_token (parser->lexer);
7084 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
7150 cp_lexer_consume_token (parser->lexer);
7153 parens.require_open (parser);
7155 expression = cp_parser_assignment_expression (parser);
7157 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
7159 = cp_lexer_peek_token (parser->lexer)->location;
7162 type_id_in_expr_sentinel s (parser);
7163 type = cp_parser_type_id (parser);
7166 parens.require_close (parser);
7181 cp_parser_parse_tentatively (parser);
7183 ++parser->prevent_constrained_type_specifiers;
7184 type = cp_parser_simple_type_specifier (parser,
7187 --parser->prevent_constrained_type_specifiers;
7189 if (!cp_parser_error_occurred (parser))
7191 = cp_parser_functional_cast (parser, type);
7193 if (cp_parser_parse_definitely (parser))
7198 if (cp_parser_allow_gnu_extensions_p (parser)
7199 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
7203 cp_parser_parse_tentatively (parser);
7206 parens.consume_open (parser);
7210 if (!cp_parser_compound_literal_p (parser))
7211 cp_parser_simulate_error (parser);
7215 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
7216 parser->in_type_id_in_expr_p = true;
7217 type = cp_parser_type_id (parser);
7218 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
7219 parens.require_close (parser);
7224 if (!cp_parser_error_occurred (parser))
7228 initializer = cp_parser_braced_list (parser,
7233 if (cp_parser_parse_definitely (parser))
7248 if (cp_parser_non_integral_constant_expression (parser,
7265 = cp_parser_primary_expression (parser, address_p, cast_p,
7283 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
7289 token = cp_lexer_peek_token (parser->lexer);
7294 if (cp_next_tokens_can_be_std_attribute_p (parser))
7296 cp_parser_error (parser,
7302 = cp_parser_postfix_open_square_expression (parser,
7335 = parser->integral_constant_expression_p;
7337 = parser->non_integral_constant_expression_p;
7338 parser->integral_constant_expression_p = false;
7341 (parser, non_attr,
7348 parser->integral_constant_expression_p
7350 parser->non_integral_constant_expression_p
7363 && cp_parser_non_integral_constant_expression (parser,
7501 cp_lexer_consume_token (parser->lexer);
7504 = cp_parser_postfix_dot_deref_expression (parser, token->type,
7514 cp_lexer_consume_token (parser->lexer);
7520 if (cp_parser_non_integral_constant_expression (parser, NIC_INC))
7529 cp_lexer_consume_token (parser->lexer);
7535 if (cp_parser_non_integral_constant_expression (parser, NIC_DEC))
7568 cp_parser_postfix_open_square_expression (cp_parser *parser,
7574 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
7578 cp_lexer_consume_token (parser->lexer);
7580 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
7581 parser->greater_than_is_operator_p = true;
7592 index = cp_parser_constant_expression (parser);
7595 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7598 cp_lexer_set_source_position (parser->lexer);
7600 index = cp_parser_braced_list (parser, &expr_nonconst_p);
7603 index = cp_parser_expression (parser, NULL, /*cast_p=*/false,
7608 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
7611 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
7620 && (cp_parser_non_integral_constant_expression (parser, NIC_ARRAY_REF)))
7694 cp_parser_postfix_dot_deref_expression (cp_parser *parser,
7714 parser->scope = NULL_TREE;
7715 parser->qualifying_scope = NULL_TREE;
7716 parser->object_scope = NULL_TREE;
7750 parser->context->object_type = scope;
7767 parser->context->object_type = unknown_type_node;
7781 cp_parser_parse_tentatively (parser);
7784 cp_parser_pseudo_destructor_name (parser, postfix_expression,
7787 && (cp_parser_error_occurred (parser)
7789 cp_parser_abort_tentative_parse (parser);
7790 else if (cp_parser_parse_definitely (parser))
7805 cp_token *token = cp_lexer_peek_token (parser->lexer);
7808 (parser,
7809 cp_parser_optional_template_keyword (parser),
7826 if (parser->scope)
7838 if (name != error_mark_node && !BASELINK_P (name) && parser->scope)
7840 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
7843 parser->scope, name);
7848 parser->scope,
7851 parser->scope = NULL_TREE;
7852 parser->qualifying_scope = NULL_TREE;
7853 parser->object_scope = NULL_TREE;
7855 if (parser->scope && name && BASELINK_P (name))
7857 (name, parser->scope, scope);
7868 = make_location (input_location, start_loc, parser->lexer);
7875 parser->context->object_type = NULL_TREE;
7881 (parser, token_type == CPP_DEREF ? NIC_ARROW : NIC_POINT)))
7921 cp_parser_parenthesized_expression_list (cp_parser* parser,
7939 if (!parens.require_open (parser))
7947 = parser->greater_than_is_operator_p;
7948 parser->greater_than_is_operator_p = true;
7953 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
7959 && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME)
7964 token = cp_lexer_consume_token (parser->lexer);
7973 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
7976 cp_lexer_set_source_position (parser->lexer);
7978 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
7985 (parser, /*allow_non_constant_p=*/true,
7991 expr = cp_parser_assignment_expression (parser, /*pidk=*/NULL,
8000 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
8003 cp_lexer_consume_token (parser->lexer);
8028 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
8032 cp_lexer_consume_token (parser->lexer);
8036 *close_paren_loc = cp_lexer_peek_token (parser->lexer)->location;
8038 if (!parens.require_close (parser))
8045 ending = cp_parser_skip_to_closing_parenthesis (parser,
8053 parser->greater_than_is_operator_p
8059 parser->greater_than_is_operator_p
8081 cp_parser_pseudo_destructor_name (cp_parser* parser,
8089 if (cp_lexer_next_token_is (parser->lexer, CPP_COMPL)
8090 && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_AUTO)
8097 cp_lexer_consume_token (parser->lexer);
8098 cp_lexer_consume_token (parser->lexer);
8108 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true);
8111 = (cp_parser_nested_name_specifier_opt (parser,
8120 && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
8123 cp_lexer_consume_token (parser->lexer);
8125 cp_parser_template_id (parser,
8131 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
8135 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL))
8143 if (cp_lexer_peek_token (parser->lexer)->type != CPP_NAME
8144 || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE
8145 || cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_COMPL)
8147 cp_parser_error (parser, "non-scalar type");
8152 *scope = TREE_TYPE (cp_parser_nonclass_name (parser));
8157 cp_parser_require (parser, CPP_SCOPE, RT_SCOPE);
8163 cp_parser_require (parser, CPP_COMPL, RT_COMPL);
8166 if (!processing_template_decl && !cp_parser_error_occurred (parser))
8167 cp_parser_commit_to_topmost_tentative_parse (parser);
8171 *type = TREE_TYPE (cp_parser_nonclass_name (parser));
8209 cp_parser_unary_expression (cp_parser *parser, cp_id_kind * pidk,
8216 token = cp_lexer_peek_token (parser->lexer);
8235 cp_lexer_consume_token (parser->lexer);
8237 operand = cp_parser_sizeof_operand (parser, keyword);
8245 = make_location (start_loc, start_loc, parser->lexer);
8290 return cp_parser_has_attribute_expression (parser);
8293 return cp_parser_new_expression (parser);
8296 return cp_parser_delete_expression (parser);
8305 cp_parser_extension_opt (parser, &saved_pedantic);
8307 expr = cp_parser_simple_cast_expression (parser);
8320 cp_lexer_consume_token (parser->lexer);
8322 expression = cp_parser_simple_cast_expression (parser);
8334 return cp_parser_transaction_expression (parser, keyword);
8346 cp_lexer_consume_token (parser->lexer);
8348 parens.require_open (parser);
8350 saved_message = parser->type_definition_forbidden_message;
8351 parser->type_definition_forbidden_message
8355 = parser->integral_constant_expression_p;
8357 = parser->non_integral_constant_expression_p;
8358 parser->integral_constant_expression_p = false;
8361 = parser->greater_than_is_operator_p;
8362 parser->greater_than_is_operator_p = true;
8367 expr = cp_parser_expression (parser);
8372 parser->greater_than_is_operator_p
8375 parser->integral_constant_expression_p
8377 parser->non_integral_constant_expression_p
8380 parser->type_definition_forbidden_message = saved_message;
8382 parens.require_close (parser);
8389 = make_location (start_loc, start_loc, parser->lexer);
8401 cp_lexer_consume_token (parser->lexer);
8403 expr = cp_parser_simple_cast_expression (parser);
8420 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
8426 keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword;
8429 return cp_parser_new_expression (parser);
8432 return cp_parser_delete_expression (parser);
8446 else if (cp_parser_allow_gnu_extensions_p (parser)
8454 cp_lexer_consume_token (parser->lexer);
8456 identifier = cp_parser_identifier (parser);
8462 = make_location (start_loc, start_loc, parser->lexer);
8465 if (cp_parser_non_integral_constant_expression (parser,
8480 token = cp_lexer_consume_token (parser->lexer);
8481 enum cpp_ttype op_ttype = cp_lexer_peek_token (parser->lexer)->type;
8485 = cp_parser_cast_expression (parser,
8561 && cp_parser_non_integral_constant_expression (parser,
8568 return cp_parser_postfix_expression (parser, address_p, cast_p,
8609 cp_parser_has_attribute_expression (cp_parser *parser)
8611 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
8614 cp_lexer_consume_token (parser->lexer);
8617 if (!parens.require_open (parser))
8622 const char *saved_message = parser->type_definition_forbidden_message;
8624 = parser->type_definition_forbidden_message_arg;
8625 parser->type_definition_forbidden_message
8627 parser->type_definition_forbidden_message_arg
8633 = parser->integral_constant_expression_p;
8635 = parser->non_integral_constant_expression_p;
8636 parser->integral_constant_expression_p = false;
8646 cp_parser_parse_tentatively (parser);
8648 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
8649 parser->in_type_id_in_expr_p = true;
8651 oper = cp_parser_type_id (parser);
8652 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
8654 cp_parser_parse_definitely (parser);
8659 oper = cp_parser_assignment_expression (parser);
8668 parser->type_definition_forbidden_message = saved_message;
8669 parser->type_definition_forbidden_message_arg = saved_message_arg;
8670 parser->integral_constant_expression_p
8672 parser->non_integral_constant_expression_p
8676 if (!cp_parser_require (parser, CPP_COMMA, RT_COMMA))
8678 cp_parser_skip_to_closing_parenthesis (parser, false, false,
8685 location_t atloc = cp_lexer_peek_token (parser->lexer)->location;
8686 if (tree attr = cp_parser_gnu_attribute_list (parser, /*exactly_one=*/true))
8702 parens.require_close (parser);
8707 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
8716 = make_location (start_loc, start_loc, parser->lexer);
8733 cp_parser_new_expression (cp_parser* parser)
8742 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
8746 = (cp_parser_global_scope_opt (parser,
8750 cp_parser_require_keyword (parser, RID_NEW, RT_NEW);
8753 cp_parser_parse_tentatively (parser);
8755 placement = cp_parser_new_placement (parser);
8757 if (!cp_parser_parse_definitely (parser))
8766 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
8769 const char *saved_message = parser->type_definition_forbidden_message;
8773 parens.consume_open (parser);
8776 parser->type_definition_forbidden_message
8779 type_id_in_expr_sentinel s (parser);
8780 type = cp_parser_type_id (parser);
8782 parser->type_definition_forbidden_message = saved_message;
8785 parens.require_close (parser);
8786 token = cp_lexer_peek_token (parser->lexer);
8790 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
8796 cp_parser_direct_new_declarator (parser);
8801 type = cp_parser_new_type_id (parser, &nelts);
8804 cp_token *token = cp_lexer_peek_token (parser->lexer);
8807 initializer = cp_parser_new_initializer (parser);
8813 if (cp_parser_non_integral_constant_expression (parser, NIC_NEW))
8839 parser->lexer);
8861 cp_parser_new_placement (cp_parser* parser)
8867 (parser, non_attr, /*cast_p=*/false,
8887 cp_parser_new_type_id (cp_parser* parser, tree *nelts)
8899 saved_message = parser->type_definition_forbidden_message;
8900 parser->type_definition_forbidden_message
8903 cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
8908 parser->type_definition_forbidden_message = saved_message;
8914 new_declarator = cp_parser_new_declarator_opt (parser);
8961 cp_parser_new_declarator_opt (cp_parser* parser)
8968 cp_parser_parse_tentatively (parser);
8970 code = cp_parser_ptr_operator (parser, &type, &cv_quals, &std_attributes);
8972 if (cp_parser_parse_definitely (parser))
8977 declarator = cp_parser_new_declarator_opt (parser);
8986 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
8987 return cp_parser_direct_new_declarator (parser);
9001 cp_parser_direct_new_declarator (cp_parser* parser)
9011 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
9013 token = cp_lexer_peek_token (parser->lexer);
9014 expression = cp_parser_expression (parser);
9037 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
9044 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
9060 cp_parser_new_initializer (cp_parser* parser)
9064 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
9068 cp_lexer_set_source_position (parser->lexer);
9070 t = cp_parser_braced_list (parser, &expr_non_constant_p);
9076 (parser, non_attr, /*cast_p=*/false,
9092 cp_parser_delete_expression (cp_parser* parser)
9097 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
9101 = (cp_parser_global_scope_opt (parser,
9105 cp_parser_require_keyword (parser, RID_DELETE, RT_DELETE);
9107 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
9110 cp_lexer_consume_token (parser->lexer);
9112 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
9120 expression = cp_parser_simple_cast_expression (parser);
9124 if (cp_parser_non_integral_constant_expression (parser, NIC_DEL))
9133 parser->lexer);
9145 cp_parser_tokens_start_cast_expression (cp_parser *parser)
9147 cp_token *token = cp_lexer_peek_token (parser->lexer);
9193 return cp_lexer_peek_nth_token (parser->lexer, 2)->type
9233 /* Reuse the parser logic by attempting to build the various kinds of
9314 cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p,
9318 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
9328 cp_parser_parse_tentatively (parser);
9330 saved_message = parser->type_definition_forbidden_message;
9331 parser->type_definition_forbidden_message
9335 cp_token *open_paren = parens.consume_open (parser);
9379 cp_lexer_save_tokens (parser->lexer);
9382 if (cp_parser_skip_to_closing_parenthesis (parser, false, false,
9385 = cp_parser_tokens_start_cast_expression (parser);
9388 cp_lexer_rollback_tokens (parser->lexer);
9392 cp_parser_simulate_error (parser);
9395 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
9396 parser->in_type_id_in_expr_p = true;
9398 type = cp_parser_type_id (parser);
9400 cp_token *close_paren = parens.require_close (parser);
9403 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
9407 parser->type_definition_forbidden_message = saved_message;
9412 if (!cp_parser_error_occurred (parser))
9417 cp_parser_commit_to_topmost_tentative_parse (parser);
9419 expr = cp_parser_cast_expression (parser,
9425 if (cp_parser_parse_definitely (parser))
9443 && cp_parser_non_integral_constant_expression (parser,
9461 cp_parser_abort_tentative_parse (parser);
9466 return cp_parser_unary_expression (parser, pidk, address_p,
9545 && !parser->greater_than_is_operator_p) \
9550 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
9567 current.lhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
9569 current.lhs = cp_parser_cast_expression (parser, /*address_p=*/false,
9573 if (cp_parser_error_occurred (parser))
9579 token = cp_lexer_peek_token (parser->lexer);
9583 && !parser->greater_than_is_operator_p)
9594 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
9618 cp_lexer_consume_token (parser->lexer);
9633 rhs_type = (cp_lexer_next_token_is (parser->lexer, CPP_NOT)
9635 rhs = cp_parser_simple_cast_expression (parser);
9640 token = cp_lexer_peek_token (parser->lexer);
9643 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
9754 && cp_parser_non_integral_constant_expression (parser,
9763 cp_parser_binary_expression (cp_parser* parser, bool cast_p,
9768 return cp_parser_binary_expression (parser, cast_p, no_toplevel_fold_p,
9786 cp_parser_question_colon_clause (cp_parser* parser, cp_expr logical_or_expr)
9791 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
9794 cp_lexer_consume_token (parser->lexer);
9795 token = cp_lexer_peek_token (parser->lexer);
9796 if (cp_parser_allow_gnu_extensions_p (parser)
9809 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
9810 parser->colon_corrects_to_scope_p = false;
9814 expr = cp_parser_expression (parser);
9818 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
9822 cp_parser_require (parser, CPP_COLON, RT_COLON);
9824 assignment_expr = cp_parser_assignment_expression (parser);
9858 cp_parser_assignment_expression (cp_parser* parser, cp_id_kind * pidk,
9865 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW))
9866 expr = cp_parser_throw_expression (parser);
9869 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CO_YIELD))
9870 expr = cp_parser_yield_expression (parser);
9876 expr = cp_parser_binary_expression (parser, cast_p, false,
9881 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
9882 return cp_parser_question_colon_clause (parser, expr);
9885 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
9890 = cp_parser_assignment_operator_opt (parser);
9896 cp_expr rhs = cp_parser_initializer_clause (parser,
9904 if (cp_parser_non_integral_constant_expression (parser,
9949 cp_parser_assignment_operator_opt (cp_parser* parser)
9955 token = cp_lexer_peek_token (parser->lexer);
10010 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10015 cp_lexer_consume_token (parser->lexer);
10034 cp_parser_expression (cp_parser* parser, cp_id_kind * pidk,
10046 = cp_parser_assignment_expression (parser, pidk, cast_p, decltype_p);
10054 && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
10077 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
10078 || cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS))
10081 loc = cp_lexer_peek_token (parser->lexer)->location;
10093 cp_lexer_consume_token (parser->lexer);
10095 if (cp_parser_non_integral_constant_expression (parser, NIC_COMMA))
10115 cp_parser_constant_expression (cp_parser* parser,
10143 saved_integral_constant_expression_p = parser->integral_constant_expression_p;
10145 = parser->allow_non_integral_constant_expression_p;
10146 saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p;
10148 parser->integral_constant_expression_p = true;
10149 parser->allow_non_integral_constant_expression_p
10151 parser->non_integral_constant_expression_p = false;
10164 expression = cp_parser_binary_expression (parser, false, false, false,
10168 if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY))
10169 expression = cp_parser_question_colon_clause (parser, expression);
10172 expression = cp_parser_assignment_expression (parser);
10174 parser->integral_constant_expression_p
10176 parser->allow_non_integral_constant_expression_p
10188 parser->non_integral_constant_expression_p = !is_const;
10193 *non_constant_p = parser->non_integral_constant_expression_p;
10194 parser->non_integral_constant_expression_p
10212 cp_parser_builtin_offsetof (cp_parser *parser)
10224 save_ice_p = parser->integral_constant_expression_p;
10225 save_non_ice_p = parser->non_integral_constant_expression_p;
10227 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
10230 cp_lexer_consume_token (parser->lexer);
10233 parens.require_open (parser);
10235 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10237 const char *saved_message = parser->type_definition_forbidden_message;
10238 parser->type_definition_forbidden_message
10240 type = cp_parser_type_id (parser);
10241 parser->type_definition_forbidden_message = saved_message;
10244 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
10245 token = cp_lexer_peek_token (parser->lexer);
10253 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, object_ptr,
10257 token = cp_lexer_peek_token (parser->lexer);
10262 expr = cp_parser_postfix_open_square_expression (parser, expr,
10274 cp_lexer_consume_token (parser->lexer);
10275 expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT,
10282 finish_loc = cp_lexer_peek_token (parser->lexer)->location;
10283 cp_lexer_consume_token (parser->lexer);
10289 parens.require_close (parser);
10290 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
10308 parser->integral_constant_expression_p = save_ice_p;
10309 parser->non_integral_constant_expression_p = save_non_ice_p;
10321 cp_parser_trait_expr (cp_parser* parser, enum rid keyword)
10434 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
10437 cp_lexer_consume_token (parser->lexer);
10440 parens.require_open (parser);
10443 type_id_in_expr_sentinel s (parser);
10444 type1 = cp_parser_type_id (parser);
10452 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
10455 type_id_in_expr_sentinel s (parser);
10456 type2 = cp_parser_type_id (parser);
10464 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
10466 cp_lexer_consume_token (parser->lexer);
10467 tree elt = cp_parser_type_id (parser);
10468 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10470 cp_lexer_consume_token (parser->lexer);
10479 location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
10480 parens.require_close (parser);
10511 cp_parser_lambda_expression (cp_parser* parser)
10516 cp_token *token = cp_lexer_peek_token (parser->lexer);
10534 else if (parser->in_template_argument_list_p || processing_template_parmlist)
10549 cp_parser_lambda_introducer (parser, lambda_expr);
10550 if (cp_parser_error_occurred (parser))
10569 = parser->num_template_parameter_lists;
10570 unsigned char in_statement = parser->in_statement;
10571 bool in_switch_statement_p = parser->in_switch_statement_p;
10573 = parser->fully_implicit_function_template_p;
10574 tree implicit_template_parms = parser->implicit_template_parms;
10575 cp_binding_level* implicit_template_scope = parser->implicit_template_scope;
10577 = parser->auto_is_implicit_function_template_parm_p;
10579 parser->num_template_parameter_lists = 0;
10580 parser->in_statement = 0;
10581 parser->in_switch_statement_p = false;
10582 parser->fully_implicit_function_template_p = false;
10583 parser->implicit_template_parms = 0;
10584 parser->implicit_template_scope = 0;
10585 parser->auto_is_implicit_function_template_parm_p = false;
10594 if (cp_parser_start_tentative_firewall (parser))
10597 ok &= cp_parser_lambda_declarator_opt (parser, lambda_expr);
10599 if (ok && cp_parser_error_occurred (parser))
10604 cp_parser_lambda_body (parser, lambda_expr);
10606 else if (cp_parser_require (parser, CPP_OPEN_BRACE, RT_OPEN_BRACE))
10608 if (cp_parser_skip_to_closing_brace (parser))
10609 cp_lexer_consume_token (parser->lexer);
10623 parser->num_template_parameter_lists = saved_num_template_parameter_lists;
10624 parser->in_statement = in_statement;
10625 parser->in_switch_statement_p = in_switch_statement_p;
10626 parser->fully_implicit_function_template_p
10628 parser->implicit_template_parms = implicit_template_parms;
10629 parser->implicit_template_scope = implicit_template_scope;
10630 parser->auto_is_implicit_function_template_parm_p
10645 parser->lexer);
10652 cp_parser_end_tentative_firewall (parser, start, lambda_expr);
10667 cp_parser_lambda_introducer (cp_parser* parser, tree lambda_expr)
10673 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
10676 if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
10677 && !cp_lexer_nth_token_is (parser->lexer, 2, CPP_ELLIPSIS)
10678 && !cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME)
10679 && !cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
10681 else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
10686 cp_lexer_consume_token (parser->lexer);
10695 while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_SQUARE))
10710 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
10719 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
10722 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THIS))
10724 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10729 cp_lexer_consume_token (parser->lexer);
10742 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)
10743 && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
10745 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10749 cp_lexer_consume_token (parser->lexer);
10750 cp_lexer_consume_token (parser->lexer);
10763 if (cp_lexer_next_token_is (parser->lexer, CPP_AND)
10764 && cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_THIS))
10766 error_at (cp_lexer_peek_token (parser->lexer)->location,
10768 cp_lexer_consume_token (parser->lexer);
10769 cp_lexer_consume_token (parser->lexer);
10774 if (cp_lexer_next_token_is (parser->lexer, CPP_AND))
10777 cp_lexer_consume_token (parser->lexer);
10782 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10784 ellipsis_loc = cp_lexer_peek_token (parser->lexer)->location;
10788 cp_lexer_consume_token (parser->lexer);
10794 && cp_lexer_next_token_is (parser->lexer, CPP_AND))
10796 pedwarn (cp_lexer_peek_token (parser->lexer)->location,
10799 cp_lexer_consume_token (parser->lexer);
10803 capture_token = cp_lexer_peek_token (parser->lexer);
10804 capture_id = cp_parser_identifier (parser);
10812 cp_parser_skip_to_closing_parenthesis (parser,
10820 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
10821 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
10822 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10830 capture_init_expr = cp_parser_initializer (parser, &direct,
10847 = cp_parser_lookup_name_simple (parser, capture_id,
10881 parser->scope,
10893 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
10895 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
10896 cp_lexer_consume_token (parser->lexer);
10903 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
10904 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
10905 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
10953 parser->scope = NULL_TREE;
10954 parser->qualifying_scope = NULL_TREE;
10955 parser->object_scope = NULL_TREE;
10958 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
10976 cp_parser_lambda_declarator_opt (cp_parser* parser, tree lambda_expr)
10998 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
11001 pedwarn (parser->lexer->next_token->location, 0,
11005 pedwarn (parser->lexer->next_token->location, OPT_Wpedantic,
11009 cp_lexer_consume_token (parser->lexer);
11011 template_param_list = cp_parser_template_parameter_list (parser);
11012 cp_parser_skip_to_end_of_template_parameter_list (parser);
11017 tree dreqs = cp_parser_requires_clause_opt (parser, true);
11027 ++parser->num_template_parameter_lists;
11031 lambda_specs.attributes = cp_parser_attributes_opt (parser);
11036 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
11043 for (size_t n = cp_parser_skip_balanced_tokens (parser, 1);
11044 cp_lexer_nth_token_is (parser->lexer, n, CPP_KEYWORD); n++)
11046 if (cp_lexer_peek_nth_token (parser->lexer, n)->keyword
11056 parens.consume_open (parser);
11066 (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL);
11076 parens.require_close (parser);
11081 if (cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer)
11082 && !cp_next_tokens_can_be_gnu_attribute_p (parser))
11083 cp_parser_decl_specifier_seq (parser,
11095 tx_qual = cp_parser_tx_qualifier_opt (parser);
11099 = cp_parser_exception_specification_opt (parser, CP_PARSER_FLAGS_NONE,
11104 if (cp_next_tokens_can_be_gnu_attribute_p (parser))
11105 gnu_attrs = cp_parser_gnu_attributes_opt (parser);
11107 std_attrs = cp_parser_std_attribute_spec_seq (parser);
11110 if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
11112 cp_lexer_consume_token (parser->lexer);
11113 return_type = cp_parser_trailing_type_id (parser);
11118 if (cp_next_tokens_can_be_gnu_attribute_p (parser))
11119 gnu_attrs = chainon (gnu_attrs, cp_parser_gnu_attributes_opt (parser));
11122 trailing_requires_clause = cp_parser_requires_clause_opt (parser, false);
11129 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
11188 --parser->num_template_parameter_lists;
11190 else if (parser->fully_implicit_function_template_p)
11191 fco = finish_fully_implicit_template (parser, fco);
11209 cp_parser_lambda_body (cp_parser* parser, tree lambda_expr)
11213 = parser->local_variables_forbidden_p;
11214 bool in_function_body = parser->in_function_body;
11230 parser->local_variables_forbidden_p = 0;
11231 parser->in_function_body = true;
11241 cp_parser_function_body (parser, false);
11247 parser->local_variables_forbidden_p = local_variables_forbidden_p;
11248 parser->in_function_body = in_function_body;
11316 cp_parser_statement (cp_parser* parser, tree in_statement_expr,
11330 saved_token_sentinel saved_tokens (parser->lexer);
11331 attrs_loc = cp_lexer_peek_token (parser->lexer)->location;
11336 cp_parser_parse_tentatively (parser);
11337 std_attrs = cp_parser_std_attribute_spec_seq (parser);
11339 attrs_loc = make_location (attrs_loc, attrs_loc, parser->lexer);
11342 if (!cp_parser_parse_definitely (parser))
11347 token = cp_lexer_peek_token (parser->lexer);
11365 cp_parser_label_for_labeled_statement (parser, std_attrs);
11372 statement = cp_parser_selection_statement (parser, if_p, chain);
11379 statement = cp_parser_iteration_statement (parser, if_p, false, 0);
11388 statement = cp_parser_jump_statement (parser);
11398 statement = cp_parser_objc_statement (parser);
11403 statement = cp_parser_try_block (parser);
11415 cp_parser_declaration_statement (parser);
11424 statement = cp_parser_transaction (parser, token);
11428 statement = cp_parser_transaction_cancel (parser);
11441 token = cp_lexer_peek_nth_token (parser->lexer, 2);
11448 cp_parser_label_for_labeled_statement (parser, std_attrs);
11457 statement = cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
11469 cp_parser_pragma (parser, pragma_compound, if_p);
11470 else if (!cp_parser_pragma (parser, pragma_stmt, if_p))
11476 cp_parser_error (parser, "expected statement");
11486 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
11493 cp_parser_parse_tentatively (parser);
11495 cp_parser_declaration_statement (parser);
11497 if (cp_parser_parse_definitely (parser))
11501 cp_lexer_set_token_position (parser->lexer, statement_token);
11510 statement = cp_parser_expression_statement (parser, in_statement_expr);
11568 cp_parser_label_for_labeled_statement (cp_parser* parser, tree attributes)
11572 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
11575 token = cp_lexer_peek_token (parser->lexer);
11579 cp_parser_error (parser, "expected labeled-statement");
11587 parser->colon_corrects_to_scope_p = false;
11596 cp_lexer_consume_token (parser->lexer);
11598 expr = cp_parser_constant_expression (parser);
11602 ellipsis = cp_lexer_peek_token (parser->lexer);
11606 cp_lexer_consume_token (parser->lexer);
11607 expr_hi = cp_parser_constant_expression (parser);
11617 if (parser->in_switch_statement_p)
11635 cp_lexer_consume_token (parser->lexer);
11637 if (parser->in_switch_statement_p)
11652 label = finish_label_stmt (cp_parser_identifier (parser));
11659 cp_parser_require (parser, CPP_COLON, RT_COLON);
11668 && cp_next_tokens_can_be_gnu_attribute_p (parser))
11671 cp_parser_parse_tentatively (parser);
11672 attrs = cp_parser_gnu_attributes_opt (parser);
11676 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
11677 cp_parser_abort_tentative_parse (parser);
11678 else if (!cp_parser_parse_definitely (parser))
11687 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
11701 cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr)
11704 cp_token *token = cp_lexer_peek_token (parser->lexer);
11708 tree attr = cp_parser_gnu_attributes_opt (parser);
11712 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
11714 statement = cp_parser_expression (parser);
11716 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
11718 cp_parser_skip_to_end_of_block_or_statement (parser);
11743 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
11744 && !cp_parser_uncommitted_to_tentative_parse_p (parser))
11762 cp_parser_consume_semicolon_at_end_of_statement (parser);
11765 && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
11792 cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr,
11799 if (!braces.require_open (parser))
11808 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
11809 cp_parser_label_declaration (parser);
11811 cp_parser_statement_seq_opt (parser, in_statement_expr);
11819 braces.require_close (parser);
11831 cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr)
11836 cp_token *token = cp_lexer_peek_token (parser->lexer);
11851 if (parser->in_statement & IN_IF_STMT)
11855 token = cp_lexer_consume_token (parser->lexer);
11861 cp_parser_statement (parser, in_statement_expr, true, NULL);
11869 cp_parser_range_based_for_with_init_p (cp_parser *parser)
11874 cp_lexer_save_tokens (parser->lexer);
11877 if (cp_parser_skip_to_closing_parenthesis_1 (parser,
11884 cp_lexer_consume_token (parser->lexer);
11887 r = (cp_parser_skip_to_closing_parenthesis_1 (parser,
11894 cp_lexer_rollback_tokens (parser->lexer);
11902 cp_parser_init_statement_p (cp_parser *parser)
11905 cp_lexer_save_tokens (parser->lexer);
11908 int ret = cp_parser_skip_to_closing_parenthesis_1 (parser,
11914 cp_lexer_rollback_tokens (parser->lexer);
11937 cp_parser_selection_statement (cp_parser* parser, bool *if_p,
11948 token = cp_parser_require (parser, CPP_KEYWORD, RT_SELECT);
11963 && cp_lexer_next_token_is_keyword (parser->lexer,
11967 cp_token *tok = cp_lexer_consume_token (parser->lexer);
11975 if (!parens.require_open (parser))
11977 cp_parser_skip_to_end_of_statement (parser);
11991 if (cp_parser_init_statement_p (parser))
11995 pedwarn (cp_lexer_peek_token (parser->lexer)->location, 0,
11998 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12005 cp_parser_init_statement (parser, &decl);
12009 condition = cp_parser_condition (parser);
12011 if (!parens.require_close (parser))
12012 cp_parser_skip_to_closing_parenthesis (parser, true, false,
12028 in_statement = parser->in_statement;
12029 parser->in_statement |= IN_IF_STMT;
12042 cp_parser_implicitly_scoped_statement (parser, &nested_if,
12045 parser->in_statement = in_statement;
12057 if (cp_lexer_next_token_is_keyword (parser->lexer,
12069 = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
12071 cp_lexer_consume_token (parser->lexer);
12074 if (cp_lexer_next_token_is_keyword (parser->lexer,
12093 else if (!cp_lexer_next_token_is_keyword (parser->lexer,
12105 cp_parser_implicitly_scoped_statement (parser, NULL,
12155 in_switch_statement_p = parser->in_switch_statement_p;
12156 in_statement = parser->in_statement;
12157 parser->in_switch_statement_p = true;
12158 parser->in_statement |= IN_SWITCH_STMT;
12159 cp_parser_implicitly_scoped_statement (parser, if_p,
12161 parser->in_switch_statement_p = in_switch_statement_p;
12162 parser->in_statement = in_statement;
12173 cp_parser_error (parser, "expected selection-statement");
12185 cp_parser_maybe_commit_to_declaration (cp_parser* parser,
12189 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)
12190 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
12191 && !cp_parser_error_occurred (parser)
12195 cp_parser_commit_to_tentative_parse (parser);
12203 cp_parser_check_condition_declarator (cp_parser* parser,
12217 if (parser->fully_implicit_function_template_p)
12218 abort_fully_implicit_template (parser);
12219 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
12244 cp_parser_condition (cp_parser* parser)
12251 cp_parser_parse_tentatively (parser);
12254 saved_message = parser->type_definition_forbidden_message;
12255 parser->type_definition_forbidden_message
12258 cp_parser_decl_specifier_seq (parser,
12263 parser->type_definition_forbidden_message = saved_message;
12269 cp_parser_maybe_commit_to_declaration (parser, &type_specifiers);
12272 if (!cp_parser_error_occurred (parser))
12279 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
12282 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
12290 attributes = cp_parser_attributes_opt (parser);
12292 asm_specification = cp_parser_asm_specification_opt (parser);
12300 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
12301 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
12302 cp_parser_simulate_error (parser);
12306 if (cp_parser_parse_definitely (parser))
12312 if (!cp_parser_check_condition_declarator (parser, declarator, loc))
12322 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
12324 initializer = cp_parser_braced_list (parser, &non_constant_p);
12328 else if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
12331 cp_lexer_consume_token (parser->lexer);
12332 initializer = cp_parser_initializer_clause (parser,
12337 cp_parser_error (parser, "expected initializer");
12358 cp_parser_abort_tentative_parse (parser);
12361 return cp_parser_expression (parser);
12368 cp_parser_for (cp_parser *parser, bool ivdep, unsigned short unroll)
12377 is_range_for = cp_parser_init_statement (parser, &decl);
12380 return cp_parser_range_for (parser, scope, init, decl, ivdep, unroll,
12383 return cp_parser_c_for (parser, scope, init, ivdep, unroll);
12387 cp_parser_c_for (cp_parser *parser, tree scope, tree init, bool ivdep,
12401 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12402 condition = cp_parser_condition (parser);
12405 cp_parser_error (parser, "missing loop condition in loop with "
12411 cp_parser_error (parser, "missing loop condition in loop with "
12417 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
12420 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
12421 expression = cp_parser_expression (parser);
12438 cp_parser_range_for (cp_parser *parser, tree scope, tree init, tree range_decl,
12483 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
12486 range_expr = cp_parser_braced_list (parser, &expr_non_constant_p);
12489 range_expr = cp_parser_expression (parser);
12844 cp_parser_iteration_statement (cp_parser* parser, bool *if_p, bool ivdep,
12854 token = cp_parser_require (parser, CPP_KEYWORD, RT_ITERATION);
12862 in_statement = parser->in_statement;
12876 parens.require_open (parser);
12878 condition = cp_parser_condition (parser);
12881 parens.require_close (parser);
12883 parser->in_statement = IN_ITERATION_STMT;
12885 cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
12887 parser->in_statement = in_statement;
12900 parser->in_statement = IN_ITERATION_STMT;
12902 cp_parser_implicitly_scoped_statement (parser, NULL, guard_tinfo);
12904 parser->in_statement = in_statement;
12907 cp_parser_require_keyword (parser, RID_WHILE, RT_WHILE);
12910 parens.require_open (parser);
12912 expression = cp_parser_expression (parser);
12916 parens.require_close (parser);
12918 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
12926 parens.require_open (parser);
12928 statement = cp_parser_for (parser, ivdep, unroll);
12931 parens.require_close (parser);
12934 parser->in_statement = IN_ITERATION_STMT;
12936 cp_parser_already_scoped_statement (parser, if_p, guard_tinfo);
12938 parser->in_statement = in_statement;
12946 cp_parser_error (parser, "expected iteration-statement");
12962 cp_parser_init_statement (cp_parser *parser, tree *decl)
12970 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
12973 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
12976 if (cp_parser_range_based_for_with_init_p (parser))
12979 cp_parser_parse_tentatively (parser);
12981 cp_parser_simple_declaration (parser,
12984 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
12985 if (!cp_parser_parse_definitely (parser))
12987 cp_parser_expression_statement (parser, NULL_TREE);
12991 pedwarn (cp_lexer_peek_token (parser->lexer)->location, 0,
12999 parser->colon_corrects_to_scope_p = false;
13003 cp_parser_parse_tentatively (parser);
13005 cp_parser_simple_declaration (parser,
13008 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
13009 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
13012 cp_lexer_consume_token (parser->lexer);
13015 pedwarn (cp_lexer_peek_token (parser->lexer)->location, 0,
13022 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13024 if (cp_parser_parse_definitely (parser))
13030 cp_parser_expression_statement (parser, NULL_TREE);
13052 cp_parser_jump_statement (cp_parser* parser)
13060 token = cp_parser_require (parser, CPP_KEYWORD, RT_JUMP);
13069 in_statement = parser->in_statement & ~IN_IF_STMT;
13089 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13093 switch (parser->in_statement & ~(IN_SWITCH_STMT | IN_IF_STMT))
13109 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13118 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13120 cp_lexer_set_source_position (parser->lexer);
13122 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
13124 else if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
13125 expr = cp_parser_expression (parser);
13139 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13144 if (parser->in_function_body
13152 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT))
13157 cp_lexer_consume_token (parser->lexer);
13159 finish_goto_stmt (cp_parser_expression (parser));
13162 finish_goto_stmt (cp_parser_identifier (parser));
13164 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13168 cp_parser_error (parser, "expected jump-statement");
13181 cp_parser_declaration_statement (cp_parser* parser)
13189 cp_parser_block_declaration (parser, /*statement_p=*/true);
13215 cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p,
13220 location_t body_loc = cp_lexer_peek_token (parser->lexer)->location;
13223 = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
13229 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13231 cp_lexer_consume_token (parser->lexer);
13235 && !cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE))
13243 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
13244 statement = cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
13251 cp_parser_statement (parser, NULL_TREE, false, if_p, chain,
13258 = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
13276 cp_parser_already_scoped_statement (cp_parser* parser, bool *if_p,
13280 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
13283 = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
13286 cp_parser_statement (parser, NULL_TREE, false, if_p, NULL,
13289 = get_token_indent_info (cp_lexer_peek_token (parser->lexer));
13303 braces.require_open (parser);
13305 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_LABEL))
13306 cp_parser_label_declaration (parser);
13308 cp_parser_statement_seq_opt (parser, NULL_TREE);
13309 braces.require_close (parser);
13322 cp_parser_declaration_seq_opt (cp_parser* parser)
13326 cp_token *token = cp_lexer_peek_token (parser->lexer);
13332 cp_parser_toplevel_declaration (parser);
13356 cp_parser_declaration (cp_parser* parser)
13365 if (cp_parser_extension_opt (parser, &saved_pedantic))
13368 cp_parser_declaration (parser);
13376 token1 = *cp_lexer_peek_token (parser->lexer);
13379 token2 = *cp_lexer_peek_nth_token (parser->lexer, 2);
13393 cp_parser_linkage_specification (parser);
13401 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
13402 cp_parser_explicit_specialization (parser);
13405 cp_parser_template_declaration (parser, /*member_p=*/false);
13408 cp_parser_explicit_instantiation (parser);
13413 cp_parser_template_declaration (parser, /*member_p=*/false);
13417 else if (cp_parser_allow_gnu_extensions_p (parser)
13422 cp_parser_explicit_instantiation (parser);
13428 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type
13431 && cp_lexer_peek_nth_token (parser->lexer, 3)->type
13436 cp_parser_namespace_definition (parser);
13440 cp_parser_namespace_definition (parser);
13443 cp_parser_objc_declaration (parser, NULL_TREE);
13446 && cp_parser_objc_valid_prefix_attributes (parser, &attributes))
13447 cp_parser_objc_declaration (parser, attributes);
13451 && cp_parser_template_declaration_after_export (parser,
13456 cp_parser_block_declaration (parser, /*statement_p=*/false);
13465 cp_parser_toplevel_declaration (cp_parser* parser)
13467 cp_token *token = cp_lexer_peek_token (parser->lexer);
13474 cp_parser_pragma (parser, pragma_external, NULL);
13479 cp_lexer_consume_token (parser->lexer);
13484 cp_parser_declaration (parser);
13510 cp_parser_block_declaration (cp_parser *parser,
13517 if (cp_parser_extension_opt (parser, &saved_pedantic))
13520 cp_parser_block_declaration (parser, statement_p);
13529 token1 = cp_lexer_peek_token (parser->lexer);
13535 cp_parser_commit_to_tentative_parse (parser);
13536 cp_parser_asm_definition (parser);
13541 cp_parser_namespace_alias_definition (parser);
13549 cp_parser_commit_to_tentative_parse (parser);
13552 token2 = cp_lexer_peek_nth_token (parser->lexer, 2);
13554 cp_parser_using_directive (parser);
13559 && ((cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ)
13560 || (cp_nth_tokens_can_be_attribute_p (parser, 3))))
13561 cp_parser_alias_declaration (parser);
13564 cp_parser_using_declaration (parser,
13571 cp_lexer_consume_token (parser->lexer);
13573 cp_parser_skip_to_end_of_statement (parser);
13575 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13576 cp_lexer_consume_token (parser->lexer);
13580 cp_parser_static_assert (parser, /*member_p=*/false);
13583 cp_parser_simple_declaration (parser, !statement_p,
13607 cp_parser_simple_declaration (cp_parser* parser,
13636 cp_parser_decl_specifier_seq (parser,
13649 cp_parser_error (parser, "expected declaration");
13660 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
13664 cp_parser_commit_to_tentative_parse (parser);
13669 cp_parser_maybe_commit_to_declaration (parser, &decl_specifiers);
13673 if (cp_lexer_nth_token_is (parser->lexer, n, CPP_AND)
13674 || cp_lexer_nth_token_is (parser->lexer, n, CPP_AND_AND))
13676 else if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
13677 && !cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_SQUARE)
13681 = cp_parser_decomposition_declaration (parser, &decl_specifiers,
13686 cp_token *token = cp_lexer_peek_token (parser->lexer);
13703 || cp_parser_uncommitted_to_tentative_parse_p (parser))
13704 cp_parser_error (parser, "expected %<;%>");
13706 cp_parser_skip_to_end_of_statement (parser);
13708 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13709 cp_lexer_consume_token (parser->lexer);
13732 while (cp_lexer_next_token_is_not (parser->lexer,
13743 token = cp_lexer_peek_token (parser->lexer);
13745 cp_lexer_consume_token (parser->lexer);
13757 decl = cp_parser_init_declarator (parser,
13772 if (cp_parser_error_occurred (parser))
13824 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
13826 cp_token *token = cp_lexer_peek_token (parser->lexer);
13841 token = cp_lexer_peek_token (parser->lexer);
13862 || cp_parser_uncommitted_to_tentative_parse_p (parser))
13863 cp_parser_error (parser, "expected %<,%> or %<;%>");
13865 cp_parser_skip_to_end_of_statement (parser);
13867 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
13868 cp_lexer_consume_token (parser->lexer);
13885 if (cp_parser_declares_only_class_p (parser))
13903 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
13904 else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
13922 cp_parser_decomposition_declaration (cp_parser *parser,
13927 cp_ref_qualifier ref_qual = cp_parser_ref_qualifier_opt (parser);
13928 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
13929 cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE);
13933 if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
13936 cp_expr e = cp_parser_identifier (parser);
13940 if (!cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
13942 cp_lexer_consume_token (parser->lexer);
13945 location_t end_loc = cp_lexer_peek_token (parser->lexer)->location;
13946 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
13949 cp_parser_skip_to_closing_parenthesis_1 (parser, true, CPP_CLOSE_SQUARE,
13951 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
13952 cp_lexer_consume_token (parser->lexer);
13955 cp_parser_skip_to_end_of_statement (parser);
14018 || cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
14021 *init_loc = cp_lexer_peek_token (parser->lexer)->location;
14022 tree initializer = cp_parser_initializer (parser, &is_direct_init,
14092 The parser flags FLAGS is used to control type-specifier parsing.
14105 cp_parser_decl_specifier_seq (cp_parser* parser,
14110 bool constructor_possible_p = !parser->in_declarator_p;
14129 token = cp_lexer_peek_token (parser->lexer);
14137 && cp_next_tokens_can_be_attribute_p (parser))
14140 tree attrs = cp_parser_attributes_opt (parser);
14204 cp_lexer_purge_token (parser->lexer);
14210 cp_lexer_consume_token (parser->lexer);
14216 cp_lexer_consume_token (parser->lexer);
14221 cp_lexer_consume_token (parser->lexer);
14226 cp_lexer_consume_token (parser->lexer);
14231 cp_lexer_consume_token (parser->lexer);
14240 cp_token *next = cp_lexer_peek_token (parser->lexer);
14252 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
14253 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_EQ)
14269 cp_parser_function_specifier_opt (parser, decl_specs);
14277 cp_lexer_consume_token (parser->lexer);
14286 cp_parser_commit_to_tentative_parse (parser);
14305 cp_lexer_consume_token (parser->lexer);
14316 cp_parser_set_storage_class (parser, decl_specs, RID_AUTO,
14329 cp_lexer_consume_token (parser->lexer);
14330 cp_parser_set_storage_class (parser, decl_specs, token->keyword,
14336 cp_lexer_consume_token (parser->lexer);
14367 (parser, flags, decl_spec_seq_has_spec_p (decl_specs,
14382 = cp_parser_type_specifier (parser, flags,
14475 cp_parser_storage_class_specifier_opt (cp_parser* parser)
14477 switch (cp_lexer_peek_token (parser->lexer)->keyword)
14491 return cp_lexer_consume_token (parser->lexer)->u.value;
14512 cp_parser_function_specifier_opt (cp_parser* parser,
14515 cp_token *token = cp_lexer_peek_token (parser->lexer);
14535 tree id = cp_lexer_consume_token (parser->lexer)->u.value;
14538 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
14541 parens.consume_open (parser);
14545 = parser->type_definition_forbidden_message;
14546 parser->type_definition_forbidden_message
14555 expr = cp_parser_constant_expression (parser);
14558 parser->type_definition_forbidden_message = saved_message;
14559 parens.require_close (parser);
14587 return cp_lexer_consume_token (parser->lexer)->u.value;
14597 cp_parser_linkage_specification (cp_parser* parser)
14603 = cp_parser_require_keyword (parser, RID_EXTERN, RT_EXTERN);
14606 cp_token *string_token = cp_lexer_peek_token (parser->lexer);
14607 linkage = cp_parser_string_literal (parser, false, false);
14615 cp_parser_error (parser, "invalid linkage-specification");
14628 = parser->innermost_linkage_specification_location;
14634 parser->innermost_linkage_specification_location
14641 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
14643 cp_ensure_no_omp_declare_simd (parser);
14644 cp_ensure_no_oacc_routine (parser);
14648 braces.consume_open (parser);
14650 cp_parser_declaration_seq_opt (parser);
14652 braces.require_close (parser);
14660 = parser->in_unbraced_linkage_specification_p;
14661 parser->in_unbraced_linkage_specification_p = true;
14662 cp_parser_declaration (parser);
14663 parser->in_unbraced_linkage_specification_p
14671 parser->innermost_linkage_specification_location = saved_location;
14683 cp_parser_static_assert(cp_parser *parser, bool member_p)
14692 token_loc = cp_lexer_peek_token (parser->lexer)->location;
14695 if (!cp_parser_require_keyword (parser, RID_STATIC_ASSERT,
14701 if (cp_parser_parsing_tentatively (parser))
14702 cp_parser_commit_to_tentative_parse (parser);
14706 parens.require_open (parser);
14711 cp_parser_constant_expression (parser,
14715 if (cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
14722 cp_lexer_consume_token (parser->lexer);
14730 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
14733 message = cp_parser_string_literal (parser,
14738 if (!parens.require_close (parser))
14739 cp_parser_skip_to_closing_parenthesis (parser,
14746 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
14763 cp_parser_decltype_expr (cp_parser *parser,
14770 id_expr_start_token = cp_lexer_peek_token (parser->lexer);
14771 cp_parser_parse_tentatively (parser);
14772 expr = cp_parser_id_expression (parser,
14779 if (!cp_parser_error_occurred (parser) && expr != error_mark_node)
14788 expr = cp_parser_lookup_name_simple (parser, expr,
14800 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
14804 (id_expression, expr, parser->scope, &idk,
14826 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
14834 cp_parser_abort_tentative_parse (parser);
14837 cp_parser_parse_tentatively (parser);
14840 expr = cp_parser_postfix_expression (parser, /*address_p=*/false,
14846 && cp_lexer_peek_token (parser->lexer)->type == CPP_CLOSE_PAREN)
14853 cp_parser_parse_definitely (parser);
14858 cp_parser_abort_tentative_parse (parser);
14861 expr = cp_parser_expression (parser, /*pidk=*/NULL, /*cast_p=*/false,
14876 cp_parser_decltype (cp_parser *parser)
14879 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
14884 cp_lexer_consume_token (parser->lexer);
14889 if (!cp_parser_require_keyword (parser, RID_DECLTYPE, RT_DECLTYPE))
14894 if (!parens.require_open (parser))
14900 tentative_firewall firewall (parser);
14904 if (cp_parser_uncommitted_to_tentative_parse_p (parser)
14905 && !parser->in_declarator_p)
14906 cp_parser_commit_to_topmost_tentative_parse (parser);
14913 && cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
14915 cp_lexer_consume_token (parser->lexer);
14922 const char *saved_message = parser->type_definition_forbidden_message;
14923 parser->type_definition_forbidden_message
14929 = parser->integral_constant_expression_p;
14931 = parser->non_integral_constant_expression_p;
14932 parser->integral_constant_expression_p = false;
14937 = parser->greater_than_is_operator_p;
14938 parser->greater_than_is_operator_p = true;
14946 expr = cp_parser_decltype_expr (parser, id_expression_or_member_access_p);
14955 parser->greater_than_is_operator_p
14960 parser->type_definition_forbidden_message = saved_message;
14961 parser->integral_constant_expression_p
14963 parser->non_integral_constant_expression_p
14968 if (expr == error_mark_node || !parens.require_close (parser))
14970 cp_parser_skip_to_closing_parenthesis (parser, true, false,
14976 if (cp_parser_error_occurred (parser))
14999 loc = make_location (loc, loc, parser->lexer);
15002 cp_lexer_purge_tokens_after (parser->lexer, start_token);
15019 cp_parser_conversion_function_id (cp_parser* parser)
15028 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
15033 saved_scope = parser->scope;
15034 saved_qualifying_scope = parser->qualifying_scope;
15035 saved_object_scope = parser->object_scope;
15052 type = cp_parser_conversion_type_id (parser);
15057 parser->scope = saved_scope;
15058 parser->qualifying_scope = saved_qualifying_scope;
15059 parser->object_scope = saved_object_scope;
15074 cp_parser_conversion_type_id (cp_parser* parser)
15083 attributes = cp_parser_attributes_opt (parser);
15085 saved_message = parser->type_definition_forbidden_message;
15086 parser->type_definition_forbidden_message
15091 cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
15096 parser->type_definition_forbidden_message = saved_message;
15102 declarator = cp_parser_conversion_declarator_opt (parser);
15111 if (! cp_parser_uncommitted_to_tentative_parse_p (parser)
15135 cp_parser_conversion_declarator_opt (cp_parser* parser)
15142 cp_parser_parse_tentatively (parser);
15144 code = cp_parser_ptr_operator (parser, &class_type, &cv_quals,
15147 if (cp_parser_parse_definitely (parser))
15152 declarator = cp_parser_conversion_declarator_opt (parser);
15169 cp_parser_ctor_initializer_opt (cp_parser* parser)
15173 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
15182 cp_lexer_consume_token (parser->lexer);
15184 cp_parser_mem_initializer_list (parser);
15194 cp_parser_mem_initializer_list (cp_parser* parser)
15198 cp_token *token = cp_lexer_peek_token (parser->lexer);
15211 token = cp_lexer_peek_token (parser->lexer);
15213 mem_initializer = cp_parser_mem_initializer (parser);
15215 bool ellipsis = cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS);
15223 cp_lexer_consume_token (parser->lexer);
15268 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
15271 cp_lexer_consume_token (parser->lexer);
15296 cp_parser_mem_initializer (cp_parser* parser)
15301 cp_token *token = cp_lexer_peek_token (parser->lexer);
15304 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
15312 mem_initializer_id = cp_parser_mem_initializer_id (parser);
15320 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
15323 cp_lexer_set_source_position (parser->lexer);
15325 expression_list = cp_parser_braced_list (parser, &expr_non_constant_p);
15332 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
15366 cp_parser_mem_initializer_id (cp_parser* parser)
15373 cp_token *token = cp_lexer_peek_token (parser->lexer);
15376 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
15381 cp_lexer_consume_token (parser->lexer);
15385 = (cp_parser_global_scope_opt (parser,
15401 = (cp_parser_nested_name_specifier_opt (parser,
15408 template_p = cp_parser_optional_template_keyword (parser);
15412 return cp_parser_class_name (parser,
15420 cp_parser_parse_tentatively (parser);
15421 if (cp_lexer_next_token_is_decltype (parser->lexer))
15423 id = cp_parser_decltype (parser);
15426 id = cp_parser_class_name (parser,
15434 if (cp_parser_parse_definitely (parser))
15437 return cp_parser_identifier (parser);
15451 cp_parser_operator_function_id (cp_parser* parser)
15453 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
15455 if (!cp_parser_require_keyword (parser, RID_OPERATOR, RT_OPERATOR))
15458 return cp_parser_operator (parser, start_loc);
15493 cp_parser_operator (cp_parser* parser, location_t start_loc)
15500 token = cp_lexer_peek_token (parser->lexer);
15523 end_loc = cp_lexer_consume_token (parser->lexer)->location;
15526 token = cp_lexer_peek_token (parser->lexer);
15533 cp_lexer_consume_token (parser->lexer);
15536 = cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
15706 cp_lexer_consume_token (parser->lexer);
15708 cp_parser_require (parser, CPP_COLON, RT_COLON);
15716 parens.consume_open (parser);
15718 token = parens.require_close (parser);
15728 cp_lexer_consume_token (parser->lexer);
15730 token = cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
15758 str = cp_parser_string_literal (parser, /*translate=*/true,
15772 token = cp_lexer_peek_token (parser->lexer);
15775 id = cp_parser_identifier (parser);
15815 = make_location (start_loc, start_loc, parser->lexer);
15830 cp_lexer_consume_token (parser->lexer);
15835 cp_parser_error (parser, "expected operator");
15873 cp_parser_template_declaration (cp_parser* parser, bool member_p)
15876 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT))
15879 cp_lexer_consume_token (parser->lexer);
15884 cp_parser_template_declaration_after_export (parser, member_p);
15897 cp_parser_template_parameter_list (cp_parser* parser)
15922 parm_loc = cp_lexer_peek_token (parser->lexer)->location;
15923 parameter = cp_parser_template_parameter (parser,
15940 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
15943 cp_lexer_consume_token (parser->lexer);
15964 cp_parser_introduction_list (cp_parser *parser)
15970 bool is_pack = cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS);
15972 cp_lexer_consume_token (parser->lexer);
15974 tree identifier = cp_parser_identifier (parser);
15981 = cp_lexer_peek_token (parser->lexer)->location;
15987 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
15990 cp_lexer_consume_token (parser->lexer);
16052 cp_parser_check_constrained_type_parm (cp_parser *parser,
16060 cp_parser_error (parser, "invalid constrained type parameter");
16068 cp_parser_error (parser, "cv-qualified type parameter");
16079 cp_parser_constrained_type_template_parm (cp_parser *parser,
16083 if (cp_parser_check_constrained_type_parm (parser, parmdecl))
16109 cp_parser_constrained_template_template_parm (cp_parser *parser,
16114 if (!cp_parser_check_constrained_type_parm (parser, parmdecl))
16139 finish_constrained_parameter (cp_parser *parser,
16151 parm = cp_parser_constrained_type_template_parm (parser, id, parmdecl);
16153 parm = cp_parser_constrained_template_template_parm (parser, proto, id,
16192 cp_parser_default_type_template_argument (cp_parser *parser)
16194 gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_EQ));
16197 cp_lexer_consume_token (parser->lexer);
16199 cp_token *token = cp_lexer_peek_token (parser->lexer);
16203 tree default_argument = cp_parser_type_id (parser,
16221 cp_parser_default_template_template_argument (cp_parser *parser)
16223 gcc_assert (cp_lexer_next_token_is (parser->lexer, CPP_EQ));
16228 cp_lexer_consume_token (parser->lexer);
16233 const cp_token* token = cp_lexer_peek_token (parser->lexer);
16235 = cp_parser_id_expression (parser,
16249 = cp_parser_lookup_name (parser, default_argument,
16275 cp_parser_template_parameter (cp_parser* parser, bool *is_non_type,
16287 token = cp_lexer_peek_token (parser->lexer);
16290 return cp_parser_type_parameter (parser, is_parameter_pack);
16307 token = cp_lexer_peek_nth_token (parser->lexer, 2);
16311 return cp_parser_type_parameter (parser, is_parameter_pack);
16314 token = cp_lexer_peek_nth_token (parser->lexer, 3);
16320 return cp_parser_type_parameter (parser, is_parameter_pack);
16332 = cp_parser_parameter_declaration (parser,
16348 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16350 cp_lexer_consume_token (parser->lexer);
16355 return finish_constrained_parameter (parser,
16396 cp_parser_type_parameter (cp_parser* parser, bool *is_parameter_pack)
16402 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_TYPENAME_TEMPLATE);
16416 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16419 cp_lexer_consume_token (parser->lexer);
16427 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
16428 identifier = cp_parser_identifier (parser);
16436 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
16439 = cp_parser_default_type_template_argument (parser);
16473 cp_parser_require (parser, CPP_LESS, RT_LESS);
16475 cp_parser_template_parameter_list (parser);
16477 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
16483 if (tree dreqs = cp_parser_requires_clause_opt (parser, false))
16489 cp_parser_type_parameter_key (parser);
16492 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
16495 cp_lexer_consume_token (parser->lexer);
16504 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
16505 && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER)
16506 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
16508 identifier = cp_parser_identifier (parser);
16522 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
16525 = cp_parser_default_template_template_argument (parser);
16574 cp_parser_template_id (cp_parser *parser,
16589 cp_token *token = cp_lexer_peek_token (parser->lexer);
16593 cp_lexer_consume_token (parser->lexer);
16602 (parser, 2)))
16604 cp_parser_error (parser, "expected template-id");
16609 if (cp_parser_uncommitted_to_tentative_parse_p (parser))
16610 start_of_id = cp_lexer_token_position (parser->lexer, false);
16616 templ = cp_parser_template_name (parser, template_keyword_p,
16631 tentative_firewall firewall (parser);
16637 if (((next_token = cp_lexer_peek_token (parser->lexer))->type
16640 && ((next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2))->type
16644 cp_parser_parse_tentatively (parser);
16649 cp_lexer_consume_token (parser->lexer);
16652 arguments = cp_parser_enclosed_template_argument_list (parser);
16653 if (!cp_parser_parse_definitely (parser))
16659 cp_parser_error (parser, "expected %<<%>");
16684 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
16690 arguments = cp_parser_enclosed_template_argument_list (parser);
16695 && (cp_parser_error_occurred (parser)
16696 || cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)))
16702 if (cp_parser_error_occurred (parser))
16711 error_at (cp_lexer_peek_token (parser->lexer)->location,
16715 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
16718 cp_parser_simulate_error (parser);
16730 = make_location (token->location, token->location, parser->lexer);
16755 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE));
16792 && !(cp_parser_error_occurred (parser)
16793 && cp_parser_parsing_tentatively (parser)
16794 && parser->in_declarator_p))
16809 cp_lexer_purge_tokens_after (parser->lexer, start_of_id);
16815 if (cp_parser_error_occurred (parser) && template_id != error_mark_node)
16826 cp_parser_template_id_expr (cp_parser *parser,
16831 tree x = cp_parser_template_id (parser, template_keyword_p, check_dependency_p,
16878 cp_parser_template_name (cp_parser* parser,
16887 cp_token *token = cp_lexer_peek_token (parser->lexer);
16891 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR))
16895 cp_parser_parse_tentatively (parser);
16897 identifier = cp_parser_operator_function_id (parser);
16899 if (!cp_parser_parse_definitely (parser))
16901 cp_parser_error (parser, "expected template-name");
16907 identifier = cp_parser_identifier (parser);
16926 && cp_parser_nth_token_starts_template_argument_list_p (parser, 1))
16937 && parser->scope && TYPE_P (parser->scope)
16939 && dependent_scope_p (parser->scope)
16942 && !constructor_name_p (identifier, parser->scope))
16950 parser->scope, identifier);
16952 if (cp_parser_simulate_error (parser))
16953 start = cp_lexer_token_position (parser->lexer, true);
16956 cp_lexer_consume_token (parser->lexer);
16957 cp_parser_enclosed_template_argument_list (parser);
16960 cp_parser_skip_to_closing_parenthesis (parser,
16969 cp_lexer_purge_tokens_after (parser->lexer, start);
16972 parser->context->object_type = NULL_TREE;
16982 tree scope = (parser->scope ? parser->scope
16983 : parser->context->object_type);
16990 parser->context->object_type = NULL_TREE;
16997 const bool scoped_p = ((parser->scope ? parser->scope
16998 : parser->context->object_type) != NULL_TREE);
17001 decl = cp_parser_lookup_name (parser, identifier,
17045 && cp_lexer_next_token_is (parser->lexer, CPP_LESS)
17067 cp_parser_error (parser, "expected template-name");
17084 cp_parser_template_argument_list (cp_parser* parser)
17098 saved_in_template_argument_list_p = parser->in_template_argument_list_p;
17099 parser->in_template_argument_list_p = true;
17103 saved_ice_p = parser->integral_constant_expression_p;
17104 parser->integral_constant_expression_p = false;
17105 saved_non_ice_p = parser->non_integral_constant_expression_p;
17106 parser->non_integral_constant_expression_p = false;
17115 cp_lexer_consume_token (parser->lexer);
17118 argument = cp_parser_template_argument (parser);
17122 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
17126 cp_token *token = cp_lexer_peek_token (parser->lexer);
17131 cp_lexer_consume_token (parser->lexer);
17152 while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
17161 parser->non_integral_constant_expression_p = saved_non_ice_p;
17162 parser->integral_constant_expression_p = saved_ice_p;
17163 parser->in_template_argument_list_p = saved_in_template_argument_list_p;
17186 cp_parser_template_argument (cp_parser* parser)
17206 cp_parser_parse_tentatively (parser);
17207 argument = cp_parser_template_type_arg (parser);
17224 if (!cp_parser_error_occurred (parser)
17226 && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
17229 cp_parser_abort_tentative_parse (parser);
17236 if (!cp_parser_next_token_ends_template_argument_p (parser))
17237 cp_parser_error (parser, "expected template-argument");
17239 if (cp_parser_parse_definitely (parser))
17243 cp_parser_parse_tentatively (parser);
17245 argument_start_token = cp_lexer_peek_token (parser->lexer);
17246 argument = cp_parser_id_expression (parser,
17254 if (!cp_parser_next_token_ends_template_argument_p (parser))
17255 cp_parser_error (parser, "expected template-argument");
17256 if (!cp_parser_error_occurred (parser))
17263 argument = cp_parser_lookup_name (parser, argument,
17272 cp_parser_error (parser, "expected template-name");
17274 if (cp_parser_parse_definitely (parser))
17298 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
17300 cp_parser_parse_tentatively (parser);
17301 argument = cp_parser_primary_expression (parser,
17307 || !cp_parser_next_token_ends_template_argument_p (parser))
17308 cp_parser_simulate_error (parser);
17309 if (cp_parser_parse_definitely (parser))
17315 address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND);
17318 loc = cp_lexer_peek_token (parser->lexer)->location;
17319 cp_lexer_consume_token (parser->lexer);
17322 token = cp_lexer_peek_token (parser->lexer);
17329 cp_parser_parse_tentatively (parser);
17330 argument = cp_parser_primary_expression (parser,
17335 if (cp_parser_error_occurred (parser)
17336 || !cp_parser_next_token_ends_template_argument_p (parser))
17337 cp_parser_abort_tentative_parse (parser);
17361 cp_parser_simulate_error (parser);
17376 cp_parser_simulate_error (parser);
17378 if (cp_parser_parse_definitely (parser))
17393 cp_parser_error (parser, "invalid non-type template argument");
17403 cp_parser_parse_tentatively (parser);
17406 argument = cp_parser_constant_expression (parser);
17411 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
17414 return cp_parser_braced_list (parser, &expr_non_constant_p);
17419 argument = cp_parser_assignment_expression (parser);
17425 if (!cp_parser_next_token_ends_template_argument_p (parser))
17426 cp_parser_error (parser, "expected template-argument");
17427 if (cp_parser_parse_definitely (parser))
17433 return cp_parser_template_type_arg (parser);
17459 cp_parser_explicit_instantiation (cp_parser* parser)
17469 if (cp_parser_allow_gnu_extensions_p (parser))
17472 = cp_parser_storage_class_specifier_opt (parser);
17475 = cp_parser_function_specifier_opt (parser,
17480 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
17488 cp_parser_decl_specifier_seq (parser,
17495 if (declares_class_or_enum && cp_parser_declares_only_class_p (parser))
17515 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
17553 cp_parser_skip_to_end_of_statement (parser);
17559 cp_parser_consume_semicolon_at_end_of_statement (parser);
17578 cp_parser_explicit_specialization (cp_parser* parser)
17581 cp_token *token = cp_lexer_peek_token (parser->lexer);
17584 cp_parser_require_keyword (parser, RID_TEMPLATE, RT_TEMPLATE);
17586 cp_parser_require (parser, CPP_LESS, RT_LESS);
17588 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
17590 ++parser->num_template_parameter_lists;
17615 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
17617 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
17618 && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER)
17619 cp_parser_template_declaration_after_export (parser,
17622 cp_parser_explicit_specialization (parser);
17626 cp_parser_single_declaration (parser,
17638 --parser->num_template_parameter_lists;
17664 The parser flags FLAGS is used to control type-specifier parsing.
17680 cp_parser_type_specifier (cp_parser* parser,
17699 token = cp_lexer_peek_token (parser->lexer);
17711 type_spec = cp_parser_enum_specifier (parser);
17737 cp_parser_parse_tentatively (parser);
17741 type_spec = cp_parser_class_specifier (parser);
17746 if (cp_parser_parse_definitely (parser))
17769 (parser,
17814 return cp_lexer_consume_token (parser->lexer)->u.value;
17819 type_spec = cp_parser_simple_type_specifier (parser,
17827 cp_parser_error (parser, "expected type specifier");
17881 cp_parser_simple_type_specifier (cp_parser* parser,
17890 token = cp_lexer_peek_token (parser->lexer);
17969 if (parser->auto_is_implicit_function_template_parm_p)
17975 cp_parser_parse_tentatively (parser);
17976 cp_lexer_consume_token (parser->lexer);
17977 while (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ)
17978 && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
17979 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
17980 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
17982 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
17984 cp_lexer_consume_token (parser->lexer);
17985 cp_parser_skip_to_closing_parenthesis (parser,
17992 if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
17998 cp_lexer_consume_token (parser->lexer);
18000 cp_parser_abort_tentative_parse (parser);
18010 type = synthesize_implicit_template_parm (parser, NULL_TREE);
18043 cp_parser_decltype (parser);
18044 cp_lexer_set_token_position (parser->lexer, token);
18049 cp_lexer_consume_token (parser->lexer);
18051 type = cp_parser_sizeof_operand (parser, RID_TYPEOF);
18064 type = cp_parser_trait_expr (parser, RID_UNDERLYING_TYPE);
18074 type = cp_parser_trait_expr (parser, token->keyword);
18087 && cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE)
18100 cp_lexer_consume_token (parser->lexer);
18121 cp_lexer_consume_token (parser->lexer);
18129 cp_parser_check_for_invalid_template_id (parser, type, none_type,
18146 cp_parser_parse_tentatively (parser);
18150 bool tent = cp_parser_parsing_tentatively (parser);
18152 token = cp_lexer_peek_token (parser->lexer);
18156 = (cp_parser_global_scope_opt (parser,
18161 = (cp_parser_nested_name_specifier_opt (parser,
18169 if (parser->scope
18170 && cp_parser_optional_template_keyword (parser))
18173 type = cp_parser_template_id (parser,
18184 type = cp_parser_make_typename_type (parser, type,
18188 cp_parser_error (parser, "expected template-id for type");
18196 else if (parser->scope
18199 && cp_lexer_next_token_is (parser->lexer, CPP_TEMPLATE_ID))
18201 cp_parser_parse_tentatively (parser);
18203 type = cp_parser_template_id (parser,
18210 cp_parser_simulate_error (parser);
18212 if (!cp_parser_parse_definitely (parser))
18215 type = make_typename_type (parser->scope, type, typename_type,
18225 cp_parser_parse_tentatively (parser);
18227 type = cp_parser_type_name (parser, (qualified_p && typename_p));
18229 if (cxx_dialect >= cxx17 && !cp_parser_parse_definitely (parser))
18238 cp_parser_parse_tentatively (parser);
18240 type = cp_parser_template_id (parser,
18248 type = cp_parser_placeholder_type_specifier (parser, loc,
18252 cp_parser_simulate_error (parser);
18255 cp_parser_simulate_error (parser);
18257 if (!cp_parser_parse_definitely (parser))
18265 tree name = cp_parser_identifier (parser);
18267 && parser->scope != error_mark_node)
18270 = cp_lexer_previous_token (parser->lexer)->location;
18271 tree tmpl = cp_parser_lookup_name (parser, name,
18282 type = cp_parser_placeholder_type_specifier (parser, loc,
18287 if (!cp_parser_simulate_error (parser))
18288 cp_parser_name_lookup_error (parser, name, tmpl,
18298 && !cp_parser_parse_definitely (parser))
18318 cp_parser_error (parser, "expected type-name");
18330 if (c_dialect_objc () && !parser->scope
18333 tree protos = cp_parser_objc_protocol_refs_opt (parser);
18347 cp_parser_check_for_invalid_template_id (parser, type,
18375 cp_parser_placeholder_type_specifier (cp_parser *parser, location_t loc,
18408 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
18409 placeholder = cp_lexer_consume_token (parser->lexer);
18410 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DECLTYPE))
18412 placeholder = cp_lexer_consume_token (parser->lexer);
18414 parens.require_open (parser);
18415 cp_parser_require_keyword (parser, RID_AUTO, RT_AUTO);
18416 close_paren = parens.require_close (parser);
18441 && !parser->in_result_type_constraint_p
18454 else if (parser->in_result_type_constraint_p && placeholder)
18463 if (parser->auto_is_implicit_function_template_parm_p)
18474 return synthesize_implicit_template_parm (parser, parm);
18482 : parser->in_result_type_constraint_p;
18517 cp_parser_type_name (cp_parser* parser, bool typename_keyword_p)
18522 cp_parser_parse_tentatively (parser);
18524 type_decl = cp_parser_class_name (parser,
18532 if (!cp_parser_parse_definitely (parser))
18536 return cp_parser_nonclass_name (parser);
18538 cp_parser_parse_tentatively (parser);
18541 type_decl = cp_parser_template_id (parser,
18564 cp_parser_simulate_error (parser);
18566 if (!cp_parser_parse_definitely (parser))
18568 return cp_parser_nonclass_name (parser);
18589 cp_parser_nonclass_name (cp_parser* parser)
18594 cp_token *token = cp_lexer_peek_token (parser->lexer);
18595 identifier = cp_parser_identifier (parser);
18600 type_decl = cp_parser_lookup_name_simple (parser, identifier, token->location);
18608 tree protos = cp_parser_objc_protocol_refs_opt (parser);
18623 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT))
18625 if (!cp_parser_simulate_error (parser))
18626 cp_parser_name_lookup_error (parser, identifier, type_decl,
18635 && !parser->scope)
18668 cp_parser_elaborated_type_specifier (cp_parser* parser,
18680 location_t key_loc = cp_lexer_peek_token (parser->lexer)->location;
18685 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM))
18688 cp_lexer_consume_token (parser->lexer);
18693 cp_token *token = cp_lexer_peek_token (parser->lexer);
18705 cp_lexer_consume_token (parser->lexer);
18713 attributes = cp_parser_attributes_opt (parser);
18716 else if (cp_lexer_next_token_is_keyword (parser->lexer,
18720 cp_lexer_consume_token (parser->lexer);
18727 key_loc = cp_lexer_peek_token (parser->lexer)->location;
18728 tag_type = cp_parser_class_key (parser);
18732 attributes = cp_parser_attributes_opt (parser);
18736 globalscope = cp_parser_global_scope_opt (parser,
18743 = cp_parser_nested_name_specifier (parser,
18756 = cp_parser_nested_name_specifier_opt (parser,
18769 template_p = cp_parser_optional_template_keyword (parser);
18773 cp_parser_parse_tentatively (parser);
18777 cp_parser_error (parser, "%<template%> must follow a nested-"
18783 token = cp_lexer_peek_token (parser->lexer);
18784 decl = cp_parser_template_id (parser, template_p,
18790 if (!template_p && !cp_parser_parse_definitely (parser))
18800 cp_parser_diagnose_invalid_type_name (parser, decl, token->location);
18808 type = make_typename_type (parser->scope, decl,
18825 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
18834 token = cp_lexer_peek_token (parser->lexer);
18835 identifier = cp_parser_identifier (parser);
18839 parser->scope = NULL_TREE;
18845 && TREE_CODE (parser->scope) != NAMESPACE_DECL)
18846 return cp_parser_make_typename_type (parser, identifier,
18852 = parser->num_template_parameter_lists;
18861 if (parser->scope)
18866 decl = cp_parser_lookup_name (parser, identifier,
18906 cp_parser_diagnose_invalid_type_name (parser,
18936 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
18994 && cp_lexer_next_token_is (parser->lexer,
19003 && (cp_parser_next_token_starts_class_definition_p (parser)
19004 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)));
19008 && !cp_parser_check_template_parameters (parser,
19033 else if (is_declaration && cp_parser_declares_only_class_p (parser))
19041 cp_parser_maybe_warn_enum_key (parser, key_loc, type, scoped_key);
19047 && cp_parser_declares_only_class_p (parser));
19048 cp_parser_check_class_key (parser, key_loc, tag_type, type, false,
19059 cp_parser_check_for_invalid_template_id (parser, type, tag_type,
19096 cp_parser_enum_specifier (cp_parser* parser)
19111 temp_override<bool> cleanup (parser->colon_corrects_to_scope_p, false);
19115 cp_parser_parse_tentatively (parser);
19121 cp_lexer_consume_token (parser->lexer);
19125 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_CLASS)
19126 || cp_lexer_next_token_is_keyword (parser->lexer, RID_STRUCT))
19132 cp_lexer_consume_token (parser->lexer);
19137 attributes = cp_parser_attributes_opt (parser);
19140 parser->scope = NULL_TREE;
19141 parser->qualifying_scope = NULL_TREE;
19142 parser->object_scope = NULL_TREE;
19147 type_start_token = cp_lexer_peek_token (parser->lexer);
19151 = cp_parser_nested_name_specifier_opt (parser,
19161 identifier = cp_parser_identifier (parser);
19162 name = cp_parser_lookup_name (parser, identifier,
19195 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19196 identifier = cp_parser_identifier (parser);
19210 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
19215 cp_lexer_consume_token (parser->lexer);
19218 cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_NONE,
19224 if (!cp_parser_parse_definitely (parser))
19244 if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
19249 cp_parser_commit_to_tentative_parse (parser);
19250 cp_parser_error (parser, "expected %<{%>");
19256 && cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
19259 cp_parser_commit_to_tentative_parse (parser);
19260 cp_parser_error (parser, "expected %<;%> or %<{%>");
19266 if (!has_underlying_type && !cp_parser_parse_definitely (parser))
19282 if (!cp_parser_check_type_definition (parser))
19293 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
19357 braces.consume_open (parser);
19378 cp_parser_skip_to_end_of_block_or_statement (parser);
19380 else if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
19390 cp_parser_commit_to_tentative_parse (parser);
19391 cp_parser_enumerator_list (parser, type);
19395 braces.require_close (parser);
19405 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
19418 if (cp_parser_allow_gnu_extensions_p (parser))
19420 tree trailing_attr = cp_parser_gnu_attributes_opt (parser);
19456 cp_parser_enumerator_list (cp_parser* parser, tree type)
19461 cp_parser_enumerator_definition (parser, type);
19465 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
19468 cp_lexer_consume_token (parser->lexer);
19470 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
19497 cp_parser_enumerator_definition (cp_parser* parser, tree type)
19505 loc = cp_lexer_peek_token (parser->lexer)->location;
19508 identifier = cp_parser_identifier (parser);
19513 tree attrs = cp_parser_attributes_opt (parser);
19516 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
19519 cp_lexer_consume_token (parser->lexer);
19521 value = cp_parser_constant_expression (parser);
19544 cp_parser_namespace_name (cp_parser* parser)
19549 cp_token *token = cp_lexer_peek_token (parser->lexer);
19552 identifier = cp_parser_identifier (parser);
19574 namespace_decl = cp_parser_lookup_name (parser, identifier,
19585 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
19590 && parser->scope && TREE_CODE (parser->scope) == NAMESPACE_DECL)
19593 parser->scope);
19607 cp_parser_error (parser, "expected namespace-name");
19634 cp_parser_namespace_definition (cp_parser* parser)
19639 cp_ensure_no_omp_declare_simd (parser);
19640 cp_ensure_no_oacc_routine (parser);
19642 bool is_inline = cp_lexer_next_token_is_keyword (parser->lexer, RID_INLINE);
19648 cp_lexer_consume_token (parser->lexer);
19653 = cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
19656 tree attribs = cp_parser_attributes_opt (parser);
19662 bool nested_inline_p = cp_lexer_next_token_is_keyword (parser->lexer,
19667 pedwarn (cp_lexer_peek_token (parser->lexer)->location,
19670 cp_lexer_consume_token (parser->lexer);
19673 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
19675 identifier = cp_parser_identifier (parser);
19677 if (cp_next_tokens_can_be_std_attribute_p (parser))
19683 attribs = attr_chainon (attribs, cp_parser_attributes_opt (parser));
19686 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
19708 cp_parser_error (parser, "nested namespace name required");
19709 cp_lexer_consume_token (parser->lexer);
19713 cp_parser_error (parser, "namespace name required");
19731 if (braces.require_open (parser))
19734 cp_parser_namespace_body (parser);
19737 braces.require_close (parser);
19754 cp_parser_namespace_body (cp_parser* parser)
19756 cp_parser_declaration_seq_opt (parser);
19765 cp_parser_namespace_alias_definition (cp_parser* parser)
19770 cp_token *token = cp_lexer_peek_token (parser->lexer);
19773 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
19775 identifier = cp_parser_identifier (parser);
19779 if (!cp_parser_uncommitted_to_tentative_parse_p (parser)
19780 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
19784 cp_lexer_consume_token (parser->lexer);
19785 if (cp_parser_skip_to_closing_brace (parser))
19786 cp_lexer_consume_token (parser->lexer);
19789 cp_parser_require (parser, CPP_EQ, RT_EQ);
19792 = cp_parser_qualified_namespace_specifier (parser);
19795 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
19810 cp_parser_qualified_namespace_specifier (cp_parser* parser)
19813 cp_parser_global_scope_opt (parser,
19817 cp_parser_nested_name_specifier_opt (parser,
19823 return cp_parser_namespace_name (parser);
19839 cp_parser_using_declaration (cp_parser* parser,
19853 diag_token = cp_lexer_peek_token (parser->lexer);
19854 cp_parser_parse_tentatively (parser);
19859 cp_parser_require_keyword (parser, RID_USING, RT_USING);
19863 token = cp_lexer_peek_token (parser->lexer);
19870 cp_lexer_consume_token (parser->lexer);
19876 = (cp_parser_global_scope_opt (parser,
19884 qscope = cp_parser_nested_name_specifier (parser, typename_p,
19888 if (!qscope && !cp_parser_uncommitted_to_tentative_parse_p (parser))
19890 cp_parser_skip_to_end_of_block_or_statement (parser);
19897 qscope = cp_parser_nested_name_specifier_opt (parser,
19910 if (access_declaration_p && cp_parser_error_occurred (parser))
19914 return cp_parser_parse_definitely (parser);
19916 token = cp_lexer_peek_token (parser->lexer);
19918 identifier = cp_parser_unqualified_id (parser,
19926 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
19927 cp_parser_simulate_error (parser);
19928 if (!cp_parser_parse_definitely (parser))
19931 else if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
19933 cp_token *ell = cp_lexer_consume_token (parser->lexer);
19964 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
19976 && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
19978 cp_token *comma = cp_lexer_consume_token (parser->lexer);
19987 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
20004 cp_parser_alias_declaration (cp_parser* parser)
20015 = cp_parser_require_keyword (parser, RID_USING, RT_USING);
20019 id_location = cp_lexer_peek_token (parser->lexer)->location;
20020 id = cp_parser_identifier (parser);
20024 cp_token *attrs_token = cp_lexer_peek_token (parser->lexer);
20025 attributes = cp_parser_attributes_opt (parser);
20029 cp_parser_require (parser, CPP_EQ, RT_EQ);
20031 if (cp_parser_error_occurred (parser))
20034 cp_parser_commit_to_tentative_parse (parser);
20048 So let's set parser->type_definition_forbidden_message in that
20052 if (parser->num_template_parameter_lists)
20054 saved_message = parser->type_definition_forbidden_message;
20055 parser->type_definition_forbidden_message =
20059 type = cp_parser_type_id (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
20063 if (parser->num_template_parameter_lists)
20064 parser->type_definition_forbidden_message = saved_message;
20067 || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
20069 cp_parser_skip_to_end_of_block_or_statement (parser);
20096 if (parser->num_template_parameter_lists
20097 && !cp_parser_check_template_parameters (parser,
20142 cp_parser_using_directive (cp_parser* parser)
20148 cp_parser_require_keyword (parser, RID_USING, RT_USING);
20150 cp_parser_require_keyword (parser, RID_NAMESPACE, RT_NAMESPACE);
20152 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
20154 cp_parser_nested_name_specifier_opt (parser,
20160 namespace_decl = cp_parser_namespace_name (parser);
20163 attribs = cp_parser_attributes_opt (parser);
20169 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
20205 cp_parser_asm_definition (cp_parser* parser)
20217 location_t asm_loc = cp_lexer_peek_token (parser->lexer)->location;
20220 cp_parser_require_keyword (parser, RID_ASM, RT_ASM);
20224 if (parser->in_function_body
20236 if (cp_parser_allow_gnu_extensions_p (parser))
20239 cp_token *token = cp_lexer_peek_token (parser->lexer);
20241 switch (cp_lexer_peek_token (parser->lexer)->keyword)
20252 if (!parser->in_function_body)
20257 cp_lexer_consume_token (parser->lexer);
20271 cp_lexer_consume_token (parser->lexer);
20285 cp_lexer_consume_token (parser->lexer);
20291 cp_lexer_consume_token (parser->lexer);
20304 if (!parser->in_function_body && (inline_p || goto_p))
20311 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
20314 string = cp_parser_string_literal (parser, false, false);
20317 cp_parser_skip_to_closing_parenthesis (parser, true, false,
20327 if (cp_parser_allow_gnu_extensions_p (parser)
20328 && parser->in_function_body
20329 && (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
20330 || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)))
20340 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20343 cp_lexer_consume_token (parser->lexer);
20345 if (cp_lexer_next_token_is_not (parser->lexer,
20347 && cp_lexer_next_token_is_not (parser->lexer,
20349 && cp_lexer_next_token_is_not (parser->lexer,
20353 outputs = cp_parser_asm_operand_list (parser);
20360 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
20366 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20369 cp_lexer_consume_token (parser->lexer);
20371 if (cp_lexer_next_token_is_not (parser->lexer,
20373 && cp_lexer_next_token_is_not (parser->lexer,
20375 && cp_lexer_next_token_is_not (parser->lexer,
20378 inputs = cp_parser_asm_operand_list (parser);
20383 else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
20389 || cp_lexer_next_token_is (parser->lexer, CPP_COLON))
20393 cp_lexer_consume_token (parser->lexer);
20395 if (cp_lexer_next_token_is_not (parser->lexer,
20397 && cp_lexer_next_token_is_not (parser->lexer,
20399 clobbers = cp_parser_asm_clobber_list (parser);
20401 else if (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
20407 || (goto_p && cp_lexer_next_token_is (parser->lexer, CPP_COLON)))
20411 cp_lexer_consume_token (parser->lexer);
20413 labels = cp_parser_asm_label_list (parser);
20423 if (!cp_parser_require (parser, missing ? CPP_COLON : CPP_CLOSE_PAREN,
20425 cp_parser_skip_to_closing_parenthesis (parser, true, false,
20427 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
20432 if (parser->in_function_body)
20504 The parser flags FLAGS is used to control type-specifier parsing.
20536 cp_parser_init_declarator (cp_parser* parser,
20568 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
20585 parser->default_arg_ok_p = false;
20592 token = cp_lexer_peek_token (parser->lexer);
20596 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
20603 parser->default_arg_ok_p = saved_default_arg_ok_p;
20611 if (!cp_parser_check_declarator_template_parameters (parser, declarator,
20632 if (cp_parser_allow_gnu_extensions_p (parser))
20635 asm_spec_start_token = cp_lexer_peek_token (parser->lexer);
20636 asm_specification = cp_parser_asm_specification_opt (parser);
20642 attributes_start_token = cp_lexer_peek_token (parser->lexer);
20643 attributes = cp_parser_attributes_opt (parser);
20646 token = cp_lexer_peek_token (parser->lexer);
20660 parser->scope = id->u.id.qualifying_scope;
20661 tree tmpl = cp_parser_lookup_name_simple (parser, name, id->id_loc);
20680 cp_parser_error (parser,
20686 = cp_lexer_peek_token (parser->lexer)->location;
20703 decl = cp_parser_save_member_function_body (parser,
20710 (parser, decl_specifiers, prefix_attributes, declarator));
20722 else if (parser->fully_implicit_function_template_p)
20733 finish_fully_implicit_template (parser, NULL_TREE);
20746 cp_parser_error (parser,
20767 cp_token *t2 = cp_lexer_peek_nth_token (parser->lexer, 2);
20786 cp_parser_error (parser, "expected initializer");
20797 cp_parser_commit_to_tentative_parse (parser);
20804 if (parser->in_unbraced_linkage_specification_p)
20809 cp_finalize_omp_declare_simd (parser, decl);
20810 cp_finalize_oacc_routine (parser, decl, false);
20860 initializer = cp_parser_pure_specifier (parser);
20868 cp_parser_skip_to_closing_parenthesis (parser,
20891 initializer = cp_parser_initializer (parser,
20897 cp_parser_skip_to_end_of_statement (parser);
20901 /* The old parser allows attributes to appear after a parenthesized
20903 on the GCC mailing lists on 2002-08-13. This parser accepts the
20905 if (cp_parser_allow_gnu_extensions_p (parser)
20907 && cp_parser_attributes_opt (parser)
20939 cp_parser_save_default_args (parser, decl);
20940 cp_finalize_omp_declare_simd (parser, decl);
20941 cp_finalize_oacc_routine (parser, decl, false);
20972 && parser->fully_implicit_function_template_p)
20975 decl = finish_fully_implicit_template (parser, decl);
20977 finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
21007 The parser flags FLAGS is used to control type-specifier parsing.
21033 cp_parser_declarator (cp_parser* parser,
21051 if (cp_parser_allow_gnu_extensions_p (parser))
21052 gnu_attributes = cp_parser_gnu_attributes_opt (parser);
21055 cp_parser_parse_tentatively (parser);
21057 code = cp_parser_ptr_operator (parser,
21063 if (cp_parser_parse_definitely (parser))
21072 cp_parser_parse_tentatively (parser);
21075 declarator = cp_parser_declarator (parser, dcl_kind,
21085 && !cp_parser_parse_definitely (parser))
21095 *parenthesized_p = cp_lexer_next_token_is (parser->lexer,
21097 declarator = cp_parser_direct_declarator (parser, dcl_kind,
21134 The parser flags FLAGS is used to control type-specifier parsing.
21139 cp_parser_direct_declarator (cp_parser* parser,
21148 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
21149 bool saved_in_declarator_p = parser->in_declarator_p;
21157 token = cp_lexer_peek_token (parser->lexer);
21212 cp_parser_parse_tentatively (parser);
21216 parens.consume_open (parser);
21221 parser->default_arg_ok_p = false;
21222 parser->in_declarator_p = true;
21233 = cp_parser_parameter_declaration_clause (parser, flags);
21236 parens.require_close (parser);
21240 if (member_p || cp_parser_parse_definitely (parser))
21251 = parser->local_variables_forbidden_p;
21254 parser->local_variables_forbidden_p |= THIS_FORBIDDEN;
21263 cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
21265 ref_qual = cp_parser_ref_qualifier_opt (parser);
21267 tree tx_qual = cp_parser_tx_qualifier_opt (parser);
21276 = cp_parser_exception_specification_opt (parser,
21280 attrs = cp_parser_std_attribute_spec_seq (parser);
21288 (parser, declarator, requires_clause,
21292 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
21309 parser->default_arg_ok_p = false;
21312 parser->local_variables_forbidden_p
21330 parser->default_arg_ok_p = saved_default_arg_ok_p;
21331 parser->in_declarator_p = saved_in_declarator_p;
21336 parens.consume_open (parser);
21338 saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
21339 parser->in_type_id_in_expr_p = true;
21341 = cp_parser_declarator (parser, dcl_kind, flags,
21346 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
21349 close_paren = cp_lexer_peek_token (parser->lexer);
21350 if (!parens.require_close (parser))
21363 && !cp_next_tokens_can_be_attribute_p (parser))
21373 parser->default_arg_ok_p = false;
21374 parser->in_declarator_p = true;
21376 cp_lexer_consume_token (parser->lexer);
21378 token = cp_lexer_peek_token (parser->lexer);
21385 = cp_parser_constant_expression (parser,
21392 else if (!parser->in_function_body
21399 cp_parser_error (parser,
21414 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
21420 attrs = cp_parser_std_attribute_spec_seq (parser);
21439 cp_parser_parse_tentatively (parser);
21446 cp_lexer_consume_token (parser->lexer);
21452 declarator_id_start_token = cp_lexer_peek_token (parser->lexer);
21454 = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok);
21455 qualifying_scope = parser->scope;
21463 okay = !cp_parser_error_occurred (parser);
21469 cp_parser_abort_tentative_parse (parser);
21472 okay = cp_parser_parse_definitely (parser);
21480 cp_parser_error (parser, "expected unqualified-id");
21495 attrs = cp_parser_std_attribute_spec_seq (parser);
21559 cp_parser_error (parser, "invalid declarator");
21638 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
21654 = cp_parser_lookup_name_simple (parser, unqualified_name,
21678 cp_parser_error (parser, "qualified-id in declaration");
21684 parser->in_declarator_p = true;
21689 parser->default_arg_ok_p = saved_default_arg_ok_p;
21691 parser->default_arg_ok_p = false;
21703 cp_parser_error (parser, "expected declarator");
21725 parser->default_arg_ok_p = saved_default_arg_ok_p;
21726 parser->in_declarator_p = saved_in_declarator_p;
21756 cp_parser_ptr_operator (cp_parser* parser,
21771 token = cp_lexer_peek_token (parser->lexer);
21785 cp_lexer_consume_token (parser->lexer);
21792 || cp_parser_allow_gnu_extensions_p (parser))
21793 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
21795 attrs = cp_parser_std_attribute_spec_seq (parser);
21802 cp_parser_parse_tentatively (parser);
21804 cp_parser_global_scope_opt (parser,
21807 token = cp_lexer_peek_token (parser->lexer);
21808 cp_parser_nested_name_specifier (parser,
21815 if (!cp_parser_error_occurred (parser)
21816 && cp_parser_require (parser, CPP_MULT, RT_MULT))
21821 if (TREE_CODE (parser->scope) == NAMESPACE_DECL)
21822 error_at (token->location, "%qD is a namespace", parser->scope);
21823 else if (TREE_CODE (parser->scope) == ENUMERAL_TYPE)
21825 "non-class %q#T", parser->scope);
21830 *type = parser->scope;
21832 parser->scope = NULL_TREE;
21833 parser->qualifying_scope = NULL_TREE;
21834 parser->object_scope = NULL_TREE;
21836 attrs = cp_parser_std_attribute_spec_seq (parser);
21840 *cv_quals = cp_parser_cv_qualifier_seq_opt (parser);
21844 if (!cp_parser_parse_definitely (parser))
21845 cp_parser_error (parser, "expected ptr-operator");
21868 cp_parser_cv_qualifier_seq_opt (cp_parser* parser)
21878 token = cp_lexer_peek_token (parser->lexer);
21907 cp_lexer_purge_token (parser->lexer);
21911 cp_lexer_consume_token (parser->lexer);
21928 cp_parser_ref_qualifier_opt (cp_parser* parser)
21933 if (cxx_dialect < cxx11 && cp_parser_parsing_tentatively (parser))
21939 cp_token *token = cp_lexer_peek_token (parser->lexer);
21961 cp_lexer_purge_token (parser->lexer);
21966 cp_lexer_consume_token (parser->lexer);
21980 cp_parser_tx_qualifier_opt (cp_parser *parser)
21982 cp_token *token = cp_lexer_peek_token (parser->lexer);
21994 cp_lexer_consume_token (parser->lexer);
22020 cp_parser_virt_specifier_seq_opt (cp_parser* parser)
22030 token = cp_lexer_peek_token (parser->lexer);
22056 cp_lexer_purge_token (parser->lexer);
22060 cp_lexer_consume_token (parser->lexer);
22123 cp_parser_late_return_type_opt (cp_parser* parser, cp_declarator *declarator,
22128 bool declare_simd_p = (parser->omp_declare_simd
22132 bool oacc_routine_p = (parser->oacc_routine
22137 token = cp_lexer_peek_token (parser->lexer);
22157 cp_lexer_consume_token (parser->lexer);
22159 type = cp_parser_trailing_type_id (parser);
22164 requires_clause = cp_parser_requires_clause_opt (parser, false);
22168 = cp_parser_late_parsing_omp_declare_simd (parser,
22172 = cp_parser_late_parsing_oacc_routine (parser,
22198 cp_parser_declarator_id (cp_parser* parser, bool optional_p)
22215 id = cp_parser_id_expression (parser,
22231 The parser flags FLAGS is used to control type-specifier parsing.
22241 cp_parser_type_id_1 (cp_parser *parser, cp_parser_flags flags,
22249 cp_parser_type_specifier_seq (parser, flags,
22262 gcc_assert (cp_parser_uncommitted_to_tentative_parse_p (parser));
22263 cp_parser_simulate_error (parser);
22270 cp_parser_parse_tentatively (parser);
22273 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT,
22280 if (!cp_parser_parse_definitely (parser))
22285 && (!flag_concepts || parser->in_type_id_in_expr_p)
22300 else if (parser->in_result_type_constraint_p)
22325 cp_parser_type_id (cp_parser *parser, cp_parser_flags flags,
22328 return cp_parser_type_id_1 (parser, flags, false, false, type_location);
22334 cp_parser_template_type_arg (cp_parser *parser)
22337 const char *saved_message = parser->type_definition_forbidden_message;
22338 parser->type_definition_forbidden_message
22340 r = cp_parser_type_id_1 (parser, CP_PARSER_FLAGS_NONE, true, false, NULL);
22341 parser->type_definition_forbidden_message = saved_message;
22353 cp_parser_trailing_type_id (cp_parser *parser)
22355 return cp_parser_type_id_1 (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
22369 The parser flags FLAGS is used to control type-specifier parsing.
22380 cp_parser_type_specifier_seq (cp_parser* parser,
22406 if (cp_next_tokens_can_be_attribute_p (parser))
22412 && cp_next_tokens_can_be_gnu_attribute_p (parser))
22414 size_t n = cp_parser_skip_attributes_opt (parser, 1);
22415 cp_token *tok = cp_lexer_peek_nth_token (parser->lexer, n);
22422 cp_parser_attributes_opt (parser));
22429 start_token = cp_lexer_peek_token (parser->lexer);
22432 type_specifier = cp_parser_type_specifier (parser,
22445 int in_decl = parser->in_declarator_p;
22446 parser->in_declarator_p = true;
22448 if (cp_parser_uncommitted_to_tentative_parse_p (parser)
22449 || !cp_parser_parse_and_diagnose_invalid_type_name (parser))
22450 cp_parser_error (parser, "expected type-specifier");
22452 parser->in_declarator_p = in_decl;
22488 function_being_declared_is_template_p (cp_parser* parser)
22493 if (parser->implicit_template_scope)
22498 return parser->num_template_parameter_lists != 0;
22500 return ((int) parser->num_template_parameter_lists > template_class_depth
22510 The parser flags FLAGS is used to control type-specifier parsing.
22517 cp_parser_parameter_declaration_clause (cp_parser* parser,
22525 (parser->auto_is_implicit_function_template_parm_p);
22532 && parser->default_arg_ok_p)
22535 parser->auto_is_implicit_function_template_parm_p = true;
22538 token = cp_lexer_peek_token (parser->lexer);
22543 cp_lexer_consume_token (parser->lexer);
22551 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
22555 cp_lexer_consume_token (parser->lexer);
22561 parameters = cp_parser_parameter_declaration_list (parser, flags);
22569 token = cp_lexer_peek_token (parser->lexer);
22574 cp_lexer_consume_token (parser->lexer);
22577 = (cp_parser_require (parser, CPP_ELLIPSIS, RT_ELLIPSIS) != NULL);
22584 cp_lexer_consume_token (parser->lexer);
22604 The parser flags FLAGS is used to control type-specifier parsing.
22611 cp_parser_parameter_declaration_list (cp_parser* parser, cp_parser_flags flags)
22622 = parser->in_unbraced_linkage_specification_p;
22623 parser->in_unbraced_linkage_specification_p = false;
22634 = cp_parser_parameter_declaration (parser, flags,
22682 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
22683 || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)
22685 || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
22686 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
22689 else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
22694 token = cp_lexer_peek_nth_token (parser->lexer, 2);
22700 cp_lexer_consume_token (parser->lexer);
22713 if (!parser->in_template_argument_list_p
22714 && !parser->in_type_id_in_expr_p
22715 && cp_parser_uncommitted_to_tentative_parse_p (parser)
22721 cp_parser_commit_to_tentative_parse (parser);
22725 cp_parser_error (parser, "expected %<,%> or %<...%>");
22726 if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
22727 cp_parser_skip_to_closing_parenthesis (parser,
22735 parser->in_unbraced_linkage_specification_p
22743 if (cp_binding_level *its = parser->implicit_template_scope)
22750 parser->implicit_template_parms = 0;
22751 parser->implicit_template_scope = 0;
22766 The parser flags FLAGS is used to control type-specifier parsing.
22778 cp_parser_parameter_declaration (cp_parser *parser,
22801 saved_message = parser->type_definition_forbidden_message;
22802 parser->type_definition_forbidden_message
22805 int template_parm_idx = (function_being_declared_is_template_p (parser) ?
22810 cp_token *decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
22811 cp_parser_decl_specifier_seq (parser,
22818 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
22823 if (cp_parser_error_occurred (parser))
22825 parser->type_definition_forbidden_message = saved_message;
22830 token = cp_lexer_peek_token (parser->lexer);
22847 bool saved_default_arg_ok_p = parser->default_arg_ok_p;
22848 parser->default_arg_ok_p = false;
22854 if (!parser->in_template_argument_list_p
22862 && !parser->in_type_id_in_expr_p
22863 && cp_parser_uncommitted_to_tentative_parse_p (parser)
22864 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)
22865 && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN))
22866 cp_parser_commit_to_tentative_parse (parser);
22869 declarator = cp_parser_declarator (parser,
22877 parser->default_arg_ok_p = saved_default_arg_ok_p;
22881 cp_parser_attributes_opt (parser));
22899 token = cp_lexer_peek_token (parser->lexer);
22904 if (parser->implicit_template_parms
22918 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
22932 cp_lexer_consume_token (parser->lexer);
22947 parser->type_definition_forbidden_message = saved_message;
22950 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
22953 token = cp_lexer_peek_token (parser->lexer);
22959 default_argument = cp_parser_cache_defarg (parser, /*nsdmi=*/false);
22965 = cp_parser_default_type_template_argument (parser);
22971 = cp_parser_default_template_template_argument (parser);
22977 = cp_parser_default_argument (parser, template_parm_p);
22979 if (!parser->default_arg_ok_p)
23055 cp_parser_default_argument (cp_parser *parser, bool template_parm_p)
23064 saved_greater_than_is_operator_p = parser->greater_than_is_operator_p;
23065 parser->greater_than_is_operator_p = !template_parm_p;
23068 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
23069 parser->local_variables_forbidden_p = LOCAL_VARS_AND_THIS_FORBIDDEN;
23084 = cp_parser_initializer (parser, &is_direct_init, &non_constant_p);
23095 parser->greater_than_is_operator_p = saved_greater_than_is_operator_p;
23096 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
23107 cp_parser_function_body (cp_parser *parser, bool in_function_try_block)
23109 cp_parser_compound_statement (parser, NULL, (in_function_try_block
23119 cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser,
23145 cp_parser_ctor_initializer_opt (parser);
23160 cp_parser_function_body (parser, in_function_try_block);
23183 cp_parser_initializer (cp_parser* parser, bool* is_direct_init,
23190 token = cp_lexer_peek_token (parser->lexer);
23201 cp_lexer_consume_token (parser->lexer);
23203 init = cp_parser_initializer_clause (parser, non_constant_p);
23208 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
23219 cp_lexer_set_source_position (parser->lexer);
23221 init = cp_parser_braced_list (parser, non_constant_p);
23227 cp_parser_error (parser, "expected initializer");
23251 cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p)
23260 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
23263 = cp_parser_constant_expression (parser,
23268 initializer = cp_parser_braced_list (parser, non_constant_p);
23288 cp_parser_braced_list (cp_parser* parser, bool* non_constant_p)
23291 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
23295 braces.require_open (parser);
23299 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE))
23304 = cp_parser_initializer_list (parser, non_constant_p, &designated);
23307 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
23308 cp_lexer_consume_token (parser->lexer);
23313 location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
23314 braces.require_close (parser);
23331 cp_parser_skip_to_closing_square_bracket (cp_parser *parser)
23337 cp_token * token = cp_lexer_peek_token (parser->lexer);
23342 if (!parser->lexer->in_pragma)
23356 cp_lexer_consume_token (parser->lexer);
23366 cp_lexer_consume_token (parser->lexer);
23373 cp_parser_array_designator_p (cp_parser *parser)
23376 cp_lexer_consume_token (parser->lexer);
23378 cp_lexer_save_tokens (parser->lexer);
23384 = (cp_parser_skip_to_closing_square_bracket (parser)
23385 && cp_lexer_next_token_is (parser->lexer, CPP_EQ));
23388 cp_lexer_rollback_tokens (parser->lexer);
23429 cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p,
23449 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
23453 || cp_parser_allow_gnu_extensions_p (parser))
23454 && cp_lexer_next_token_is (parser->lexer, CPP_DOT)
23455 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_NAME
23456 && (cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_EQ
23457 || (cp_lexer_peek_nth_token (parser->lexer, 3)->type
23465 cp_lexer_consume_token (parser->lexer);
23467 designator = cp_lexer_consume_token (parser->lexer)->u.value;
23468 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
23470 cp_lexer_consume_token (parser->lexer);
23475 else if (cp_parser_allow_gnu_extensions_p (parser)
23476 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
23477 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
23484 designator = cp_lexer_consume_token (parser->lexer)->u.value;
23486 cp_lexer_consume_token (parser->lexer);
23489 else if (cp_parser_allow_gnu_extensions_p (parser)
23491 && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
23496 cp_parser_parse_tentatively (parser);
23498 if (!cp_parser_array_designator_p (parser))
23500 cp_parser_simulate_error (parser);
23505 designator = cp_parser_constant_expression (parser, true,
23507 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
23508 cp_parser_require (parser, CPP_EQ, RT_EQ);
23511 if (!cp_parser_parse_definitely (parser))
23542 initializer = cp_parser_initializer_clause (parser,
23550 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
23552 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
23555 cp_lexer_consume_token (parser->lexer);
23570 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
23574 token = cp_lexer_peek_nth_token (parser->lexer, 2);
23595 cp_lexer_consume_token (parser->lexer);
23650 cp_parser_class_name (cp_parser *parser,
23666 token = cp_lexer_peek_token (parser->lexer);
23669 cp_parser_error (parser, "expected class-name");
23675 scope = parser->scope;
23686 && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2))
23692 identifier_token = cp_lexer_peek_token (parser->lexer);
23694 identifier = cp_parser_identifier (parser);
23711 cp_parser_simulate_error (parser);
23722 if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
23725 decl = cp_parser_lookup_name (parser, identifier,
23734 if (cp_parser_parsing_tentatively (parser))
23735 cp_parser_simulate_error (parser);
23743 decl = cp_parser_template_id (parser, template_keyword_p,
23769 && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
23792 && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
23797 cp_parser_error (parser, "expected class-name");
23798 else if (identifier && !parser->scope)
23840 cp_parser_class_specifier_1 (cp_parser* parser)
23857 type = cp_parser_class_head (parser,
23863 cp_parser_skip_to_end_of_block_or_statement (parser);
23870 if (!braces.require_open (parser))
23876 cp_ensure_no_omp_declare_simd (parser);
23877 cp_ensure_no_oacc_routine (parser);
23880 bool type_definition_ok_p = cp_parser_check_type_definition (parser);
23882 ++parser->num_classes_being_defined;
23886 = parser->num_template_parameter_lists;
23887 parser->num_template_parameter_lists = 0;
23889 saved_in_function_body = parser->in_function_body;
23890 parser->in_function_body = false;
23892 in_statement = parser->in_statement;
23893 parser->in_statement = 0;
23895 in_switch_statement_p = parser->in_switch_statement_p;
23896 parser->in_switch_statement_p = false;
23899 = parser->in_unbraced_linkage_specification_p;
23900 parser->in_unbraced_linkage_specification_p = false;
23912 cp_parser_skip_to_closing_brace (parser);
23915 cp_parser_member_specification_opt (parser);
23918 closing_brace = braces.require_close (parser);
23920 if (cp_parser_allow_gnu_extensions_p (parser))
23921 attributes = cp_parser_gnu_attributes_opt (parser);
23939 cp_token *token = cp_lexer_peek_token (parser->lexer);
23942 if (cp_next_tokens_can_be_std_attribute_p (parser))
23985 cp_token *lookahead = cp_lexer_peek_nth_token (parser->lexer, 2);
24005 = cp_lexer_previous_token_position (parser->lexer);
24006 cp_token *prev_token = cp_lexer_token_at (parser->lexer, prev);
24035 cp_lexer_set_token_position (parser->lexer, prev);
24036 token = cp_lexer_peek_token (parser->lexer);
24062 if (--parser->num_classes_being_defined == 0)
24105 cp_parser_late_parsing_default_args (parser, decl);
24136 = parser->local_variables_forbidden_p;
24138 parser->local_variables_forbidden_p |= THIS_FORBIDDEN;
24141 spec = cp_parser_late_noexcept_specifier (parser, spec, decl);
24147 parser->local_variables_forbidden_p = local_variables_forbidden_p;
24175 cp_parser_late_parsing_nsdmi (parser, decl);
24189 cp_parser_late_parsing_for_member (parser, decl);
24192 cp_parser_late_parsing_for_member (parser, decl);
24196 cp_parser_late_parsing_for_member (parser, decl);
24204 parser->in_switch_statement_p = in_switch_statement_p;
24205 parser->in_statement = in_statement;
24206 parser->in_function_body = saved_in_function_body;
24207 parser->num_template_parameter_lists
24209 parser->in_unbraced_linkage_specification_p
24216 cp_parser_class_specifier (cp_parser* parser)
24220 ret = cp_parser_class_specifier_1 (parser);
24257 cp_parser_class_head (cp_parser* parser,
24271 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
24280 parser->colon_corrects_to_scope_p = false;
24283 class_key = cp_parser_class_key (parser);
24290 attributes = cp_parser_attributes_opt (parser);
24301 if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false))
24308 nested_name_specifier_token_start = cp_lexer_peek_token (parser->lexer);
24310 = cp_parser_nested_name_specifier_opt (parser,
24322 type_start_token = cp_lexer_peek_token (parser->lexer);
24340 cp_parser_parse_tentatively (parser);
24341 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
24342 bad_template_keyword = cp_lexer_consume_token (parser->lexer);
24343 type = cp_parser_class_name (parser,
24351 if (!cp_parser_parse_definitely (parser))
24354 type_start_token = cp_lexer_peek_token (parser->lexer);
24355 id = cp_parser_identifier (parser);
24373 cp_parser_parse_tentatively (parser);
24375 type_start_token = cp_lexer_peek_token (parser->lexer);
24376 id = cp_parser_template_id (parser,
24382 if (!cp_parser_parse_definitely (parser))
24384 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
24386 type_start_token = cp_lexer_peek_token (parser->lexer);
24387 id = cp_parser_identifier (parser);
24403 cp_parser_check_for_invalid_template_id (parser, id,
24407 virt_specifiers = cp_parser_virt_specifier_seq_opt (parser);
24413 if (!cp_parser_next_token_starts_class_definition_p (parser))
24415 cp_parser_error (parser, "expected %<{%> or %<:%>");
24422 cp_parser_commit_to_tentative_parse (parser);
24425 cp_parser_error (parser,
24433 cp_parser_error (parser,
24440 cp_parser_error (parser,
24496 && parser->num_template_parameter_lists == 0
24518 ++parser->num_template_parameter_lists;
24526 if (!cp_parser_check_template_parameters (parser, num_templates,
24581 cp_parser_error (parser, "could not resolve typename type");
24621 tag_scope tag_scope = (parser->in_type_id_in_expr_p
24625 parser->num_template_parameter_lists);
24629 cp_parser_check_class_key (parser, UNKNOWN_LOCATION, class_key, type,
24675 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
24681 bases = cp_parser_base_clause (parser);
24692 if (type && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
24704 --parser->num_template_parameter_lists;
24712 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
24727 cp_parser_class_key (cp_parser* parser)
24733 token = cp_parser_require (parser, CPP_KEYWORD, RT_CLASS_KEY);
24740 cp_parser_error (parser, "expected class-key");
24752 cp_parser_type_parameter_key (cp_parser* parser)
24756 cp_token *token = cp_lexer_peek_token (parser->lexer);
24759 cp_lexer_consume_token (parser->lexer);
24768 cp_parser_error (parser, "expected %<class%> or %<typename%>");
24780 cp_parser_member_specification_opt (cp_parser* parser)
24788 token = cp_lexer_peek_token (parser->lexer);
24803 cp_lexer_consume_token (parser->lexer);
24807 cp_parser_require (parser, CPP_COLON, RT_COLON);
24814 cp_parser_pragma (parser, pragma_member, NULL);
24820 cp_parser_member_declaration (parser);
24860 cp_parser_member_declaration (cp_parser* parser)
24871 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
24874 if (cp_parser_extension_opt (parser, &saved_pedantic))
24877 cp_parser_member_declaration (parser);
24885 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
24889 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS
24890 && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER)
24891 cp_parser_explicit_specialization (parser);
24893 cp_parser_template_declaration (parser, /*member_p=*/true);
24898 else if (cp_parser_template_declaration_after_export (parser, true))
24902 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
24907 cp_parser_using_declaration (parser,
24915 cp_parser_parse_tentatively (parser);
24916 decl = cp_parser_alias_declaration (parser);
24923 !cp_parser_uncommitted_to_tentative_parse_p (parser);
24924 cp_parser_parse_definitely (parser);
24929 cp_parser_using_declaration (parser,
24936 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS))
24939 tree ivar_chains = cp_parser_objc_defs_expression (parser);
24952 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC_ASSERT))
24954 cp_parser_static_assert (parser, /*member_p=*/true);
24958 parser->colon_corrects_to_scope_p = false;
24960 if (cp_parser_using_declaration (parser, /*access_declaration=*/true))
24964 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
24965 cp_parser_decl_specifier_seq (parser,
24972 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
24976 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
24989 cp_token *token = cp_lexer_peek_token (parser->lexer);
25084 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
25092 token = cp_lexer_peek_token (parser->lexer);
25098 if (cp_next_tokens_can_be_attribute_p (parser)
25100 && cp_nth_tokens_can_be_attribute_p (parser, 2)
25104 = cp_parser_skip_attributes_opt (parser, 1 + named_bitfld);
25105 token = cp_lexer_peek_nth_token (parser->lexer, n);
25111 && token == cp_lexer_peek_token (parser->lexer)
25112 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON)
25119 = cp_lexer_peek_token (parser->lexer)->location;
25122 identifier = cp_parser_identifier (parser);
25127 attributes = cp_parser_attributes_opt (parser);
25130 cp_lexer_consume_token (parser->lexer);
25133 width = cp_parser_constant_expression (parser, false, NULL,
25140 && (cp_lexer_next_token_is (parser->lexer, CPP_EQ)
25141 || cp_lexer_next_token_is (parser->lexer,
25145 = cp_lexer_peek_token (parser->lexer)->location;
25153 initializer = cp_parser_save_nsdmi (parser);
25167 if (cp_next_tokens_can_be_std_attribute_p (parser))
25172 late_attributes = cp_parser_attributes_opt (parser);
25207 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
25219 cp_parser_skip_to_end_of_statement (parser);
25225 if (cp_lexer_next_token_is (parser->lexer,
25227 cp_lexer_consume_token (parser->lexer);
25237 asm_specification = cp_parser_asm_specification_opt (parser);
25239 attributes = cp_parser_attributes_opt (parser);
25253 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
25268 initializer_token_start = cp_lexer_peek_token (parser->lexer);
25275 initializer = cp_parser_pure_specifier (parser);
25277 initializer = cp_parser_save_nsdmi (parser);
25284 cp_lexer_consume_token (parser->lexer);
25286 initializer = cp_parser_initializer_clause (parser,
25291 initializer = cp_parser_constant_initializer (parser);
25293 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)
25298 initializer = cp_parser_save_nsdmi (parser);
25300 initializer = cp_parser_initializer (parser, &x, &x);
25308 else if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)
25321 cp_parser_skip_to_end_of_statement (parser);
25323 if (cp_lexer_next_token_is (parser->lexer,
25325 cp_lexer_consume_token (parser->lexer);
25338 (cp_lexer_peek_token (parser->lexer)))
25348 decl = cp_parser_save_member_function_body (parser,
25352 if (parser->fully_implicit_function_template_p)
25353 decl = finish_fully_implicit_template (parser, decl);
25358 token = cp_lexer_peek_token (parser->lexer);
25363 = cp_lexer_consume_token (parser->lexer)->location;
25379 if (parser->fully_implicit_function_template_p)
25382 finish_fully_implicit_template (parser, 0);
25384 decl = finish_fully_implicit_template (parser, decl);
25388 cp_finalize_omp_declare_simd (parser, decl);
25389 cp_finalize_oacc_routine (parser, decl, false);
25402 parser->scope = NULL_TREE;
25403 parser->qualifying_scope = NULL_TREE;
25404 parser->object_scope = NULL_TREE;
25406 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
25408 cp_lexer_consume_token (parser->lexer);
25409 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
25411 cp_token *token = cp_lexer_previous_token (parser->lexer);
25419 else if (cp_lexer_next_token_is_not (parser->lexer,
25425 cp_token *token = cp_lexer_previous_token (parser->lexer);
25448 cp_parser_save_default_args (parser, STRIP_TEMPLATE (decl));
25460 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
25462 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
25474 cp_parser_pure_specifier (cp_parser* parser)
25479 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
25482 token = cp_lexer_peek_token (parser->lexer);
25488 cp_lexer_consume_token (parser->lexer);
25501 cp_parser_error (parser,
25503 cp_parser_skip_to_end_of_statement (parser);
25523 cp_parser_constant_initializer (cp_parser* parser)
25526 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
25534 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
25536 cp_parser_error (parser,
25540 braces.consume_open (parser);
25542 cp_parser_skip_to_closing_brace (parser);
25544 braces.require_close (parser);
25549 return cp_parser_constant_expression (parser);
25571 cp_parser_base_clause (cp_parser* parser)
25576 cp_parser_require (parser, CPP_COLON, RT_COLON);
25586 base = cp_parser_base_specifier (parser);
25588 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
25591 cp_lexer_consume_token (parser->lexer);
25610 token = cp_lexer_peek_token (parser->lexer);
25615 cp_lexer_consume_token (parser->lexer);
25621 parser->scope = NULL_TREE;
25622 parser->qualifying_scope = NULL_TREE;
25623 parser->object_scope = NULL_TREE;
25643 cp_parser_base_specifier (cp_parser* parser)
25658 token = cp_lexer_peek_token (parser->lexer);
25666 cp_parser_error (parser,
25674 cp_lexer_consume_token (parser->lexer);
25686 cp_parser_error (parser,
25694 cp_lexer_consume_token (parser->lexer);
25706 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
25708 token = cp_lexer_peek_token (parser->lexer);
25716 cp_lexer_consume_token (parser->lexer);
25720 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
25733 cp_parser_nested_name_specifier_opt (parser,
25740 class_scope_p = (parser->scope && TYPE_P (parser->scope));
25741 template_p = class_scope_p && cp_parser_optional_template_keyword (parser);
25743 if (!parser->scope
25744 && cp_lexer_next_token_is_decltype (parser->lexer))
25746 type = cp_parser_decltype (parser);
25750 type = cp_parser_class_name (parser,
25772 cp_parser_save_noexcept (cp_parser *parser)
25774 cp_token *first = parser->lexer->next_token;
25776 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0);
25777 cp_token *last = parser->lexer->next_token;
25795 cp_parser_late_noexcept_specifier (cp_parser *parser, tree default_arg,
25801 push_unparsed_function_queues (parser);
25803 /* Push the saved tokens for the noexcept-specifier onto the parser's
25806 cp_parser_push_lexer_for_tokens (parser, tokens);
25813 = cp_parser_noexcept_specification_opt (parser,
25820 cp_parser_pop_lexer (parser);
25823 pop_unparsed_function_queues (parser);
25866 in which case a boolean condition is returned instead. The parser flags
25871 cp_parser_noexcept_specification_opt (cp_parser* parser,
25882 token = cp_lexer_peek_token (parser->lexer);
25895 = ((cp_lexer_nth_token_is (parser->lexer, 3, CPP_NUMBER)
25896 || cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
25897 && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_PAREN));
25899 if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN)
25909 return cp_parser_save_noexcept (parser);
25911 cp_lexer_consume_token (parser->lexer);
25913 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
25916 parens.consume_open (parser);
25927 saved_message = parser->type_definition_forbidden_message;
25928 parser->type_definition_forbidden_message
25933 = cp_parser_constant_expression (parser,
25944 parser->type_definition_forbidden_message = saved_message;
25948 expr = cp_parser_expression (parser);
25952 parens.require_close (parser);
25981 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
25986 cp_parser_exception_specification_opt (cp_parser* parser,
25995 token = cp_lexer_peek_token (parser->lexer);
25999 = cp_parser_noexcept_specification_opt (parser, flags,
26013 cp_lexer_consume_token (parser->lexer);
26017 parens.require_open (parser);
26020 token = cp_lexer_peek_token (parser->lexer);
26025 saved_message = parser->type_definition_forbidden_message;
26026 parser->type_definition_forbidden_message
26029 type_id_list = cp_parser_type_id_list (parser);
26031 parser->type_definition_forbidden_message = saved_message;
26053 parens.require_close (parser);
26068 cp_parser_type_id_list (cp_parser* parser)
26077 token = cp_lexer_peek_token (parser->lexer);
26080 type = cp_parser_type_id (parser);
26089 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
26092 cp_lexer_consume_token (parser->lexer);
26100 token = cp_lexer_peek_token (parser->lexer);
26105 cp_lexer_consume_token (parser->lexer);
26117 cp_parser_try_block (cp_parser* parser)
26121 cp_parser_require_keyword (parser, RID_TRY, RT_TRY);
26122 if (parser->in_function_body
26130 cp_parser_compound_statement (parser, NULL, BCS_TRY_BLOCK, false);
26132 cp_parser_handler_seq (parser);
26144 cp_parser_function_try_block (cp_parser* parser)
26150 if (!cp_parser_require_keyword (parser, RID_TRY, RT_TRY))
26156 (parser, /*in_function_try_block=*/true);
26160 cp_parser_handler_seq (parser);
26171 cp_parser_handler_seq (cp_parser* parser)
26178 cp_parser_handler (parser);
26180 token = cp_lexer_peek_token (parser->lexer);
26193 cp_parser_handler (cp_parser* parser)
26198 cp_parser_require_keyword (parser, RID_CATCH, RT_CATCH);
26201 parens.require_open (parser);
26202 declaration = cp_parser_exception_declaration (parser);
26204 parens.require_close (parser);
26205 cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
26221 cp_parser_exception_declaration (cp_parser* parser)
26228 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
26231 cp_lexer_consume_token (parser->lexer);
26236 saved_message = parser->type_definition_forbidden_message;
26237 parser->type_definition_forbidden_message
26241 cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_NONE,
26246 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
26249 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER,
26258 parser->type_definition_forbidden_message = saved_message;
26274 cp_parser_throw_expression (cp_parser* parser)
26278 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
26280 cp_parser_require_keyword (parser, RID_THROW, RT_THROW);
26281 token = cp_lexer_peek_token (parser->lexer);
26292 expression = cp_parser_assignment_expression (parser);
26300 parser->lexer);
26315 cp_parser_yield_expression (cp_parser* parser)
26319 cp_token *token = cp_lexer_peek_token (parser->lexer);
26322 cp_parser_require_keyword (parser, RID_CO_YIELD, RT_CO_YIELD);
26324 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
26327 cp_lexer_set_source_position (parser->lexer);
26330 expr = cp_parser_braced_list (parser, &expr_non_constant_p);
26333 expr = cp_parser_assignment_expression (parser);
26353 cp_parser_asm_specification_opt (cp_parser* parser)
26359 token = cp_lexer_peek_token (parser->lexer);
26366 cp_lexer_consume_token (parser->lexer);
26369 parens.require_open (parser);
26372 asm_specification = cp_parser_string_literal (parser, false, false);
26375 parens.require_close (parser);
26398 cp_parser_asm_operand_list (cp_parser* parser)
26409 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
26412 cp_lexer_consume_token (parser->lexer);
26414 name = cp_parser_identifier (parser);
26419 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
26424 string_literal = cp_parser_string_literal (parser, false, false);
26428 parens.require_open (parser);
26430 expression = cp_parser_expression (parser);
26432 parens.require_close (parser);
26445 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
26448 cp_lexer_consume_token (parser->lexer);
26464 cp_parser_asm_clobber_list (cp_parser* parser)
26473 string_literal = cp_parser_string_literal (parser, false, false);
26478 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
26481 cp_lexer_consume_token (parser->lexer);
26497 cp_parser_asm_label_list (cp_parser* parser)
26506 identifier = cp_parser_identifier (parser);
26521 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
26524 cp_lexer_consume_token (parser->lexer);
26534 cp_next_tokens_can_be_gnu_attribute_p (cp_parser *parser)
26536 return cp_nth_tokens_can_be_gnu_attribute_p (parser, 1);
26543 cp_next_tokens_can_be_std_attribute_p (cp_parser *parser)
26545 return cp_nth_tokens_can_be_std_attribute_p (parser, 1);
26552 cp_nth_tokens_can_be_std_attribute_p (cp_parser *parser, size_t n)
26554 cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
26559 && (token = cp_lexer_peek_nth_token (parser->lexer, n + 1))
26567 cp_nth_tokens_can_be_gnu_attribute_p (cp_parser *parser, size_t n)
26569 cp_token *token = cp_lexer_peek_nth_token (parser->lexer, n);
26578 cp_next_tokens_can_be_attribute_p (cp_parser *parser)
26580 return (cp_next_tokens_can_be_gnu_attribute_p (parser)
26581 || cp_next_tokens_can_be_std_attribute_p (parser));
26588 cp_nth_tokens_can_be_attribute_p (cp_parser *parser, size_t n)
26590 return (cp_nth_tokens_can_be_gnu_attribute_p (parser, n)
26591 || cp_nth_tokens_can_be_std_attribute_p (parser, n));
26598 cp_parser_attributes_opt (cp_parser *parser)
26600 if (cp_next_tokens_can_be_gnu_attribute_p (parser))
26601 return cp_parser_gnu_attributes_opt (parser);
26602 return cp_parser_std_attribute_spec_seq (parser);
26616 cp_parser_gnu_attributes_opt (cp_parser* parser)
26621 (parser->auto_is_implicit_function_template_parm_p, false);
26630 token = cp_lexer_peek_token (parser->lexer);
26636 cp_lexer_consume_token (parser->lexer);
26639 if (!outer_parens.require_open (parser))
26642 if (!inner_parens.require_open (parser))
26646 token = cp_lexer_peek_token (parser->lexer);
26649 attribute_list = cp_parser_gnu_attribute_list (parser);
26656 if (!inner_parens.require_close (parser))
26658 if (!outer_parens.require_close (parser))
26661 cp_parser_skip_to_end_of_statement (parser);
26688 cp_parser_gnu_attribute_list (cp_parser* parser, bool exactly_one /* = false */)
26691 bool save_translate_strings_p = parser->translate_strings_p;
26697 parser->translate_strings_p = false;
26706 token = cp_lexer_peek_token (parser->lexer);
26714 cp_token *id_token = cp_lexer_consume_token (parser->lexer);
26728 token = cp_lexer_peek_token (parser->lexer);
26736 (parser, attr_flag, /*cast_p=*/false,
26757 token = cp_lexer_peek_token (parser->lexer);
26765 cp_lexer_consume_token (parser->lexer);
26767 parser->translate_strings_p = save_translate_strings_p;
26815 cp_parser_std_attribute (cp_parser *parser, tree attr_ns)
26821 (parser->auto_is_implicit_function_template_parm_p, false);
26825 token = cp_lexer_peek_token (parser->lexer);
26836 cp_lexer_consume_token (parser->lexer);
26838 token = cp_lexer_peek_token (parser->lexer);
26843 cp_lexer_consume_token (parser->lexer);
26849 token = cp_lexer_peek_token (parser->lexer);
26862 cp_lexer_consume_token (parser->lexer);
26868 token = cp_lexer_peek_token (parser->lexer);
26917 cp_parser_skip_to_closing_parenthesis (parser,
26933 for (size_t n = cp_parser_skip_balanced_tokens (parser, 1) - 1; n; --n)
26934 cp_lexer_consume_token (parser->lexer);
26939 (parser, attr_flag, /*cast_p=*/false,
27000 cp_parser_std_attribute_list (cp_parser *parser, tree attr_ns)
27007 attribute = cp_parser_std_attribute (parser, attr_ns);
27016 token = cp_lexer_peek_token (parser->lexer);
27019 cp_lexer_consume_token (parser->lexer);
27030 token = cp_lexer_peek_token (parser->lexer);
27034 cp_lexer_consume_token (parser->lexer);
27054 cp_parser_std_attribute_spec (cp_parser *parser)
27057 cp_token *token = cp_lexer_peek_token (parser->lexer);
27060 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_OPEN_SQUARE)
27064 cp_lexer_consume_token (parser->lexer);
27065 cp_lexer_consume_token (parser->lexer);
27067 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
27069 token = cp_lexer_peek_nth_token (parser->lexer, 2);
27078 && cp_lexer_nth_token_is (parser->lexer, 3, CPP_COLON))
27085 cp_lexer_consume_token (parser->lexer);
27086 cp_lexer_consume_token (parser->lexer);
27087 cp_lexer_consume_token (parser->lexer);
27093 attributes = cp_parser_std_attribute_list (parser, attr_ns);
27095 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE)
27096 || !cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
27097 cp_parser_skip_to_end_of_statement (parser);
27109 token = cp_lexer_peek_token (parser->lexer);
27115 cp_lexer_consume_token (parser->lexer);
27119 if (!parens.require_open (parser))
27122 cp_parser_parse_tentatively (parser);
27123 alignas_expr = cp_parser_type_id (parser);
27125 if (!cp_parser_parse_definitely (parser))
27127 alignas_expr = cp_parser_assignment_expression (parser);
27129 cp_parser_skip_to_end_of_statement (parser);
27139 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
27141 cp_lexer_consume_token (parser->lexer);
27151 if (cp_parser_uncommitted_to_tentative_parse_p (parser)
27152 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
27153 cp_parser_commit_to_tentative_parse (parser);
27155 if (!parens.require_close (parser))
27175 cp_parser_std_attribute_spec_seq (cp_parser *parser)
27186 tree attr_spec = cp_parser_std_attribute_spec (parser);
27206 cp_parser_skip_balanced_tokens (cp_parser *parser, size_t n)
27211 switch (cp_lexer_peek_nth_token (parser->lexer, n++)->type)
27214 if (!parser->lexer->in_pragma)
27250 cp_parser_skip_gnu_attributes_opt (cp_parser *parser, size_t n)
27254 if (!cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_ATTRIBUTE)
27255 || !cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_PAREN)
27256 || !cp_lexer_nth_token_is (parser->lexer, n + 2, CPP_OPEN_PAREN))
27259 size_t n2 = cp_parser_skip_balanced_tokens (parser, n + 2);
27262 if (!cp_lexer_nth_token_is (parser->lexer, n2, CPP_CLOSE_PAREN))
27274 cp_parser_skip_std_attribute_spec_seq (cp_parser *parser, size_t n)
27278 if (cp_lexer_nth_token_is (parser->lexer, n, CPP_OPEN_SQUARE)
27279 && cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_SQUARE))
27281 size_t n2 = cp_parser_skip_balanced_tokens (parser, n + 1);
27284 if (!cp_lexer_nth_token_is (parser->lexer, n2, CPP_CLOSE_SQUARE))
27288 else if (cp_lexer_nth_token_is_keyword (parser->lexer, n, RID_ALIGNAS)
27289 && cp_lexer_nth_token_is (parser->lexer, n + 1, CPP_OPEN_PAREN))
27291 size_t n2 = cp_parser_skip_balanced_tokens (parser, n + 1);
27307 cp_parser_skip_attributes_opt (cp_parser *parser, size_t n)
27309 if (cp_nth_tokens_can_be_gnu_attribute_p (parser, n))
27310 return cp_parser_skip_gnu_attributes_opt (parser, n);
27311 return cp_parser_skip_std_attribute_spec_seq (parser, n);
27321 cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic)
27326 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION))
27329 cp_lexer_consume_token (parser->lexer);
27350 cp_parser_label_declaration (cp_parser* parser)
27353 cp_parser_require_keyword (parser, RID_LABEL, RT_LABEL);
27360 identifier = cp_parser_identifier (parser);
27367 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
27370 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
27374 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
27381 cp_parser_concept_definition (cp_parser *parser)
27383 gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT));
27384 cp_lexer_consume_token (parser->lexer);
27386 cp_expr id = cp_parser_identifier (parser);
27389 cp_parser_skip_to_end_of_statement (parser);
27390 cp_parser_consume_semicolon_at_end_of_statement (parser);
27394 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
27396 cp_parser_skip_to_end_of_statement (parser);
27397 cp_parser_consume_semicolon_at_end_of_statement (parser);
27402 tree init = cp_parser_constraint_expression (parser);
27404 cp_parser_skip_to_end_of_statement (parser);
27408 cp_parser_consume_semicolon_at_end_of_statement (parser);
27447 cp_parser_constraint_requires_parens (cp_parser *parser, bool lambda_p)
27449 cp_token *token = cp_lexer_peek_token (parser->lexer);
27467 if (cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_DELETE)
27468 || cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_DEFAULT))
27530 if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE))
27548 cp_parser_unary_constraint_requires_parens (cp_parser *parser)
27550 cp_token *token = cp_lexer_peek_token (parser->lexer);
27594 cp_parser_constraint_primary_expression (cp_parser *parser, bool lambda_p)
27598 if (cp_parser_unary_constraint_requires_parens (parser))
27600 cp_expr e = cp_parser_assignment_expression (parser, NULL, false, false);
27605 cp_lexer_save_tokens (parser->lexer);
27608 cp_expr expr = cp_parser_primary_expression (parser,
27620 pce = cp_parser_constraint_requires_parens (parser, lambda_p);
27624 cp_lexer_commit_tokens (parser->lexer);
27630 cp_lexer_rollback_tokens (parser->lexer);
27631 cp_parser_parse_tentatively (parser);
27633 expr = cp_parser_assignment_expression (parser, NULL, false, false);
27635 expr = cp_parser_simple_cast_expression (parser);
27636 if (cp_parser_parse_definitely (parser))
27655 cp_parser_constraint_logical_and_expression (cp_parser *parser, bool lambda_p)
27657 cp_expr lhs = cp_parser_constraint_primary_expression (parser, lambda_p);
27658 while (cp_lexer_next_token_is (parser->lexer, CPP_AND_AND))
27660 cp_token *op = cp_lexer_consume_token (parser->lexer);
27661 tree rhs = cp_parser_constraint_primary_expression (parser, lambda_p);
27674 cp_parser_constraint_logical_or_expression (cp_parser *parser, bool lambda_p)
27676 cp_expr lhs = cp_parser_constraint_logical_and_expression (parser, lambda_p);
27677 while (cp_lexer_next_token_is (parser->lexer, CPP_OR_OR))
27679 cp_token *op = cp_lexer_consume_token (parser->lexer);
27680 cp_expr rhs = cp_parser_constraint_logical_and_expression (parser, lambda_p);
27690 cp_parser_requires_clause_expression (cp_parser *parser, bool lambda_p)
27700 cp_expr expr = cp_parser_constraint_logical_or_expression (parser, lambda_p);
27716 cp_parser_constraint_expression (cp_parser *parser)
27723 cp_expr expr = cp_parser_binary_expression (parser, false, true,
27742 cp_parser_requires_clause_opt (cp_parser *parser, bool lambda_p)
27744 cp_token *tok = cp_lexer_peek_token (parser->lexer);
27750 error_at (cp_lexer_peek_token (parser->lexer)->location,
27754 cp_lexer_consume_token (parser->lexer);
27755 cp_parser_constraint_expression (parser);
27760 cp_token *tok2 = cp_lexer_peek_nth_token (parser->lexer, 2);
27774 cp_lexer_consume_token (parser->lexer);
27777 return cp_parser_requires_clause_expression (parser, lambda_p);
27779 return cp_parser_constraint_expression (parser);
27792 cp_parser_requires_expression (cp_parser *parser)
27794 gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES));
27795 location_t loc = cp_lexer_consume_token (parser->lexer)->location;
27798 tentative_firewall firewall (parser);
27801 cp_parser_commit_to_tentative_parse (parser);
27825 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
27827 parms = cp_parser_requirement_parameter_list (parser);
27839 reqs = cp_parser_requirement_body (parser);
27847 loc = make_location (loc, loc, parser->lexer);
27867 cp_parser_requirement_parameter_list (cp_parser *parser)
27870 if (!parens.require_open (parser))
27874 (parser, CP_PARSER_FLAGS_TYPENAME_OPTIONAL));
27876 if (!parens.require_close (parser))
27887 cp_parser_requirement_body (cp_parser *parser)
27890 if (!braces.require_open (parser))
27893 tree reqs = cp_parser_requirement_seq (parser);
27895 if (!braces.require_close (parser))
27908 cp_parser_requirement_seq (cp_parser *parser)
27913 tree req = cp_parser_requirement (parser);
27917 while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE)
27918 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF));
27937 cp_parser_requirement (cp_parser *parser)
27939 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
27940 return cp_parser_compound_requirement (parser);
27941 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME))
27942 return cp_parser_type_requirement (parser);
27943 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES))
27944 return cp_parser_nested_requirement (parser);
27946 return cp_parser_simple_requirement (parser);
27955 cp_parser_simple_requirement (cp_parser *parser)
27957 location_t start = cp_lexer_peek_token (parser->lexer)->location;
27958 cp_expr expr = cp_parser_expression (parser, NULL, false, false);
27960 cp_parser_skip_to_end_of_statement (parser);
27962 cp_parser_consume_semicolon_at_end_of_statement (parser);
27985 cp_parser_type_requirement (cp_parser *parser)
27987 cp_token *start_tok = cp_lexer_consume_token (parser->lexer);
27988 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
27991 tree saved_scope = parser->scope;
27992 tree saved_object_scope = parser->object_scope;
27993 tree saved_qualifying_scope = parser->qualifying_scope;
27994 cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
27995 cp_parser_nested_name_specifier_opt (parser,
28002 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
28004 cp_lexer_consume_token (parser->lexer);
28005 type = cp_parser_template_id (parser,
28010 type = make_typename_type (parser->scope, type, typename_type,
28014 type = cp_parser_type_name (parser, /*typename_keyword_p=*/true);
28019 parser->scope = saved_scope;
28020 parser->object_scope = saved_object_scope;
28021 parser->qualifying_scope = saved_qualifying_scope;
28024 cp_parser_skip_to_end_of_statement (parser);
28026 cp_parser_consume_semicolon_at_end_of_statement (parser);
28031 loc = make_location (loc, start_tok->location, parser->lexer);
28041 cp_parser_compound_requirement (cp_parser *parser)
28045 if (!braces.require_open (parser))
28048 cp_token *expr_token = cp_lexer_peek_token (parser->lexer);
28050 tree expr = cp_parser_expression (parser, NULL, false, false);
28052 cp_parser_skip_to_closing_brace (parser);
28054 if (!braces.require_close (parser))
28056 cp_parser_skip_to_end_of_statement (parser);
28057 cp_parser_consume_semicolon_at_end_of_statement (parser);
28064 cp_parser_skip_to_end_of_statement (parser);
28065 cp_parser_consume_semicolon_at_end_of_statement (parser);
28071 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_NOEXCEPT))
28073 cp_lexer_consume_token (parser->lexer);
28079 if (cp_lexer_next_token_is (parser->lexer, CPP_DEREF))
28081 cp_lexer_consume_token (parser->lexer);
28082 cp_token *tok = cp_lexer_peek_token (parser->lexer);
28084 bool saved_result_type_constraint_p = parser->in_result_type_constraint_p;
28085 parser->in_result_type_constraint_p = true;
28089 type = cp_parser_trailing_type_id (parser);
28090 parser->in_result_type_constraint_p = saved_result_type_constraint_p;
28095 parser->lexer);
28104 cp_parser_consume_semicolon_at_end_of_statement (parser);
28116 parser->lexer);
28118 cp_parser_consume_semicolon_at_end_of_statement (parser);
28132 cp_parser_nested_requirement (cp_parser *parser)
28134 gcc_assert (cp_lexer_next_token_is_keyword (parser->lexer, RID_REQUIRES));
28135 cp_token *tok = cp_lexer_consume_token (parser->lexer);
28136 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
28137 tree req = cp_parser_constraint_expression (parser);
28139 cp_parser_skip_to_end_of_statement (parser);
28140 loc = make_location (loc, tok->location, parser->lexer);
28141 cp_parser_consume_semicolon_at_end_of_statement (parser);
28203 cp_parser_lookup_name (cp_parser *parser, tree name,
28212 tree object_type = parser->context->object_type;
28221 parser->context->object_type = NULL_TREE;
28245 if (parser->scope)
28246 type = parser->scope;
28257 return lookup_destructor (current_class_ref, parser->scope, name,
28275 if (parser->scope)
28279 if (parser->scope == error_mark_node)
28287 dependent_p = (TYPE_P (parser->scope)
28288 && dependent_scope_p (parser->scope));
28289 if ((check_dependency || !CLASS_TYPE_P (parser->scope))
28303 pushed_scope = push_scope (parser->scope);
28309 decl = lookup_qualified_name (parser->scope, name,
28329 && same_type_p (DECL_CONTEXT (decl), parser->scope))
28330 decl = lookup_qualified_name (parser->scope, ctor_identifier,
28345 if (decl == error_mark_node && TYPE_P (parser->scope)
28346 && dependent_type_p (parser->scope))
28355 type = make_typename_type (parser->scope, name, tag_type,
28361 && (cp_parser_next_token_ends_template_argument_p (parser)
28362 || cp_lexer_next_token_is (parser->lexer,
28364 decl = make_unbound_class_template (parser->scope,
28369 parser->scope, name,
28372 parser->qualifying_scope = parser->scope;
28373 parser->object_scope = NULL_TREE;
28402 parser->object_scope = object_type;
28403 parser->qualifying_scope = NULL_TREE;
28410 parser->qualifying_scope = NULL_TREE;
28411 parser->object_scope = NULL_TREE;
28429 if (!cp_parser_simulate_error (parser))
28452 check_accessibility_of_qualified_id (decl, object_type, parser->scope);
28464 cp_parser_lookup_name_simple (cp_parser* parser, tree name, location_t location)
28466 return cp_parser_lookup_name (parser, name,
28524 cp_parser_check_declarator_template_parameters (cp_parser* parser,
28548 (parser, num_templates, template_id_p, declarator_location,
28558 (parser, declarator->declarator, declarator_location));
28576 cp_parser_check_template_parameters (cp_parser* parser,
28584 if (parser->num_template_parameter_lists == num_templates)
28589 && parser->num_template_parameter_lists == num_templates + 1)
28592 if (cp_parser_simulate_error (parser))
28599 if (parser->num_template_parameter_lists < num_templates)
28630 cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p)
28635 token = cp_lexer_peek_token (parser->lexer);
28641 cp_lexer_consume_token (parser->lexer);
28643 parser->scope = global_namespace;
28644 parser->qualifying_scope = global_namespace;
28645 parser->object_scope = NULL_TREE;
28647 return parser->scope;
28651 parser->scope = NULL_TREE;
28652 parser->qualifying_scope = NULL_TREE;
28653 parser->object_scope = NULL_TREE;
28661 declarator is preceded by the `friend' specifier. The parser flags FLAGS
28665 cp_parser_constructor_declarator_p (cp_parser *parser, cp_parser_flags flags,
28676 if (parser->in_function_body)
28679 next_token = cp_lexer_peek_token (parser->lexer);
28688 cp_parser_parse_tentatively (parser);
28693 cp_parser_global_scope_opt (parser,
28697 = (cp_parser_nested_name_specifier_opt (parser,
28731 tree id = cp_parser_unqualified_id (parser,
28753 cp_parser_parse_tentatively (parser);
28756 type_decl = cp_parser_class_name (parser,
28765 && !cp_parser_parse_definitely (parser))
28768 tree tmpl = cp_parser_template_name (parser,
28778 cp_parser_simulate_error (parser);
28786 constructor_p = (!cp_parser_error_occurred (parser)
28804 && !cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
28808 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
28809 && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS)
28813 && (!cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer)
28820 || (cp_parser_allow_gnu_extensions_p (parser)
28821 && cp_next_tokens_can_be_gnu_attribute_p (parser)))
28823 && !cp_next_tokens_can_be_std_attribute_p (parser))
28829 if (cp_next_tokens_can_be_gnu_attribute_p (parser))
28831 unsigned int n = cp_parser_skip_gnu_attributes_opt (parser, 1);
28833 cp_lexer_consume_token (parser->lexer);
28849 cp_parser_abort_tentative_parse (parser);
28859 = parser->num_template_parameter_lists;
28860 parser->num_template_parameter_lists = 0;
28881 cp_parser_type_specifier (parser,
28889 parser->num_template_parameter_lists
28896 constructor_p = !cp_parser_error_occurred (parser);
28901 cp_parser_abort_tentative_parse (parser);
28914 (cp_parser* parser,
28937 cp_finalize_omp_declare_simd (parser, current_function_decl);
28938 parser->omp_declare_simd = NULL;
28939 cp_finalize_oacc_routine (parser, current_function_decl, true);
28940 parser->oacc_routine = NULL;
28946 cp_parser_skip_to_end_of_block_or_statement (parser);
28952 cp_parser_skip_to_end_of_block_or_statement (parser);
28967 fn = cp_parser_function_definition_after_declarator (parser,
28982 cp_parser_function_definition_after_declarator (cp_parser* parser,
28991 = parser->fully_implicit_function_template_p;
28992 parser->fully_implicit_function_template_p = false;
28994 = parser->implicit_template_parms;
28995 parser->implicit_template_parms = 0;
28997 = parser->implicit_template_scope;
28998 parser->implicit_template_scope = 0;
29000 saved_in_function_body = parser->in_function_body;
29001 parser->in_function_body = true;
29005 token = cp_lexer_peek_token (parser->lexer);
29006 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN))
29009 cp_lexer_consume_token (parser->lexer);
29012 cp_parser_identifier (parser);
29019 cp_token *token = cp_lexer_peek_token (parser->lexer);
29024 cp_lexer_consume_token (parser->lexer);
29030 = parser->in_unbraced_linkage_specification_p;
29031 parser->in_unbraced_linkage_specification_p = false;
29035 = parser->num_template_parameter_lists;
29036 parser->num_template_parameter_lists = 0;
29042 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_ATOMIC))
29043 cp_parser_function_transaction (parser, RID_TRANSACTION_ATOMIC);
29044 else if (cp_lexer_next_token_is_keyword (parser->lexer,
29046 cp_parser_function_transaction (parser, RID_TRANSACTION_RELAXED);
29047 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
29048 cp_parser_function_try_block (parser);
29051 (parser, /*in_function_try_block=*/false);
29058 parser->in_unbraced_linkage_specification_p
29060 parser->num_template_parameter_lists
29062 parser->in_function_body = saved_in_function_body;
29064 parser->fully_implicit_function_template_p
29066 parser->implicit_template_parms
29068 parser->implicit_template_scope
29071 if (parser->fully_implicit_function_template_p)
29072 finish_fully_implicit_template (parser, /*member_decl_opt=*/0);
29080 cp_parser_template_declaration_after_parameters (cp_parser* parser,
29088 ++parser->num_template_parameter_lists;
29098 if (cp_parser_template_declaration_after_export (parser, member_p))
29101 && cp_lexer_next_token_is_keyword (parser->lexer, RID_USING))
29102 decl = cp_parser_alias_declaration (parser);
29104 && cp_lexer_next_token_is_keyword (parser->lexer, RID_CONCEPT)
29105 && !cp_lexer_nth_token_is_keyword (parser->lexer, 2, RID_BOOL))
29107 decl = cp_parser_concept_definition (parser);
29113 cp_token *token = cp_lexer_peek_token (parser->lexer);
29114 decl = cp_parser_single_declaration (parser,
29136 --parser->num_template_parameter_lists;
29219 cp_parser_template_introduction (cp_parser* parser, bool member_p)
29221 cp_parser_parse_tentatively (parser);
29223 tree saved_scope = parser->scope;
29224 tree saved_object_scope = parser->object_scope;
29225 tree saved_qualifying_scope = parser->qualifying_scope;
29226 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
29228 cp_token *start_token = cp_lexer_peek_token (parser->lexer);
29233 parser->colon_corrects_to_scope_p = false;
29236 cp_parser_global_scope_opt (parser,
29239 cp_parser_nested_name_specifier_opt (parser,
29245 cp_token *token = cp_lexer_peek_token (parser->lexer);
29246 tree concept_name = cp_parser_identifier (parser);
29250 tree tmpl_decl = cp_parser_lookup_name_simple (parser, concept_name,
29252 parser->scope = saved_scope;
29253 parser->object_scope = saved_object_scope;
29254 parser->qualifying_scope = saved_qualifying_scope;
29255 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
29259 cp_parser_simulate_error (parser);
29263 braces.require_open (parser);
29266 if (!cp_parser_parse_definitely (parser))
29273 tree introduction_list = cp_parser_introduction_list (parser);
29276 if (!braces.require_close (parser))
29289 cp_parser_name_lookup_error (parser, concept_name, tmpl_decl, NLE_NULL,
29297 parser->lexer);
29307 cp_parser_template_declaration_after_parameters (parser, parms,
29321 cp_parser_explicit_template_declaration (cp_parser* parser, bool member_p)
29328 if (!cp_parser_require (parser, CPP_LESS, RT_LESS))
29337 cp_parser_skip_to_end_of_block_or_statement (parser);
29363 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER))
29365 cp_parser_error (parser, "invalid explicit specialization");
29372 parameter_list = cp_parser_template_parameter_list (parser);
29376 cp_parser_skip_to_end_of_template_parameter_list (parser);
29382 if (tree treqs = cp_parser_requires_clause_opt (parser, false))
29387 cp_parser_template_declaration_after_parameters (parser, parameter_list,
29401 cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p)
29403 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
29405 cp_lexer_consume_token (parser->lexer);
29406 cp_parser_explicit_template_declaration (parser, member_p);
29410 return cp_parser_template_introduction (parser, member_p);
29435 cp_parser_single_declaration (cp_parser* parser,
29457 decl_spec_token_start = cp_lexer_peek_token (parser->lexer);
29458 cp_parser_decl_specifier_seq (parser,
29481 if (cp_parser_declares_only_class_p (parser)
29517 if (!cp_parser_declares_only_class_p (parser)
29520 error_at (cp_lexer_peek_token (parser->lexer)->location,
29523 cp_parser_skip_to_end_of_block_or_statement (parser);
29531 && cp_parser_parse_and_diagnose_invalid_type_name (parser))
29546 && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)
29549 decl = cp_parser_init_declarator (parser,
29579 || !cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON)))
29580 cp_parser_skip_to_end_of_block_or_statement (parser);
29587 parser->scope = NULL_TREE;
29588 parser->qualifying_scope = NULL_TREE;
29589 parser->object_scope = NULL_TREE;
29597 cp_parser_simple_cast_expression (cp_parser *parser)
29599 return cp_parser_cast_expression (parser, /*address_p=*/false,
29607 cp_parser_functional_cast (cp_parser* parser, tree type)
29619 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
29621 cp_lexer_set_source_position (parser->lexer);
29623 expression_list = cp_parser_braced_list (parser, &nonconst_p);
29636 parser->lexer);
29642 vec = cp_parser_parenthesized_expression_list (parser, non_attr,
29660 parser->lexer);
29670 && cp_parser_non_integral_constant_expression (parser,
29684 cp_parser_save_member_function_body (cp_parser* parser,
29696 cp_finalize_omp_declare_simd (parser, fn);
29697 cp_finalize_oacc_routine (parser, fn, true);
29703 (cp_lexer_peek_token (parser->lexer)))
29704 cp_parser_skip_to_end_of_block_or_statement (parser);
29709 cp_parser_save_default_args (parser, fn);
29713 first = parser->lexer->next_token;
29715 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRANSACTION_RELAXED))
29716 cp_lexer_consume_token (parser->lexer);
29717 else if (cp_lexer_next_token_is_keyword (parser->lexer,
29720 cp_lexer_consume_token (parser->lexer);
29722 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)
29723 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_SQUARE)
29724 && (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME)
29725 || cp_lexer_nth_token_is (parser->lexer, 3, CPP_KEYWORD))
29726 && cp_lexer_nth_token_is (parser->lexer, 4, CPP_CLOSE_SQUARE)
29727 && cp_lexer_nth_token_is (parser->lexer, 5, CPP_CLOSE_SQUARE))
29729 cp_lexer_consume_token (parser->lexer);
29730 cp_lexer_consume_token (parser->lexer);
29731 cp_lexer_consume_token (parser->lexer);
29732 cp_lexer_consume_token (parser->lexer);
29733 cp_lexer_consume_token (parser->lexer);
29736 while (cp_next_tokens_can_be_gnu_attribute_p (parser)
29737 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
29739 cp_lexer_consume_token (parser->lexer);
29740 if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
29746 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
29748 cp_lexer_consume_token (parser->lexer);
29752 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
29754 cp_lexer_consume_token (parser->lexer);
29755 while (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE))
29758 if (cp_parser_cache_group (parser, CPP_CLOSE_PAREN, /*depth=*/0))
29762 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
29763 cp_lexer_consume_token (parser->lexer);
29766 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
29769 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH))
29770 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
29771 last = parser->lexer->next_token;
29792 cp_parser_save_nsdmi (cp_parser* parser)
29794 return cp_parser_cache_defarg (parser, /*nsdmi=*/true);
29802 cp_parser_enclosed_template_argument_list (cp_parser* parser)
29816 = parser->greater_than_is_operator_p;
29817 parser->greater_than_is_operator_p = false;
29820 saved_scope = parser->scope;
29821 saved_qualifying_scope = parser->qualifying_scope;
29822 saved_object_scope = parser->object_scope;
29827 if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)
29828 || cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
29831 arguments = cp_parser_template_argument_list (parser);
29834 if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT))
29854 cp_token *token = cp_lexer_peek_token (parser->lexer);
29865 cp_token *token = cp_lexer_peek_token (parser->lexer);
29879 cp_token *token = cp_lexer_consume_token (parser->lexer);
29886 cp_parser_skip_to_end_of_template_parameter_list (parser);
29888 parser->greater_than_is_operator_p
29891 parser->scope = saved_scope;
29892 parser->qualifying_scope = saved_qualifying_scope;
29893 parser->object_scope = saved_object_scope;
29903 cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function)
29914 gcc_assert (parser->num_classes_being_defined == 0);
29919 push_unparsed_function_queues (parser);
29943 cp_parser_push_lexer_for_tokens (parser, tokens);
29957 parser->lexer->in_pragma = true;
29958 cp_parser_omp_declare_reduction_exprs (member_function, parser);
29964 cp_parser_function_definition_after_declarator (parser,
29973 cp_parser_pop_lexer (parser);
29980 pop_unparsed_function_queues (parser);
29988 cp_parser_save_default_args (cp_parser* parser, tree decl)
30014 cp_parser_late_parse_one_default_arg (cp_parser *parser, tree decl,
30024 /* Push the saved tokens for the default argument onto the parser's
30027 cp_parser_push_lexer_for_tokens (parser, tokens);
30032 parsed_arg = cp_parser_initializer (parser, &dummy, &dummy);
30039 cp_parser_skip_to_end_of_statement (parser);
30057 if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF))
30060 cp_parser_error (parser, "expected %<,%>");
30062 cp_parser_error (parser, "expected %<;%>");
30066 cp_parser_pop_lexer (parser);
30075 cp_parser_late_parsing_nsdmi (cp_parser *parser, tree field)
30081 push_unparsed_function_queues (parser);
30082 def = cp_parser_late_parse_one_default_arg (parser, field,
30085 pop_unparsed_function_queues (parser);
30098 cp_parser_late_parsing_default_args (cp_parser *parser, tree fn)
30107 push_unparsed_function_queues (parser);
30111 saved_local_variables_forbidden_p = parser->local_variables_forbidden_p;
30112 parser->local_variables_forbidden_p = LOCAL_VARS_AND_THIS_FORBIDDEN;
30137 = cp_parser_late_parse_one_default_arg (parser, parmdecl,
30154 parser->local_variables_forbidden_p = saved_local_variables_forbidden_p;
30157 pop_unparsed_function_queues (parser);
30167 cp_parser_sizeof_pack (cp_parser *parser)
30170 cp_lexer_consume_token (parser->lexer);
30174 bool paren = cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN);
30176 parens.consume_open (parser);
30178 permerror (cp_lexer_peek_token (parser->lexer)->location,
30181 cp_token *token = cp_lexer_peek_token (parser->lexer);
30182 tree name = cp_parser_identifier (parser);
30186 parser->scope = NULL_TREE;
30187 parser->qualifying_scope = NULL_TREE;
30188 parser->object_scope = NULL_TREE;
30189 tree expr = cp_parser_lookup_name_simple (parser, name, token->location);
30191 cp_parser_name_lookup_error (parser, name, expr, NLE_NULL,
30201 parens.require_close (parser);
30212 cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword)
30223 && cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
30224 return cp_parser_sizeof_pack (parser);
30228 saved_message = parser->type_definition_forbidden_message;
30229 saved_message_arg = parser->type_definition_forbidden_message_arg;
30230 parser->type_definition_forbidden_message
30232 parser->type_definition_forbidden_message_arg
30238 = parser->integral_constant_expression_p;
30240 = parser->non_integral_constant_expression_p;
30241 parser->integral_constant_expression_p = false;
30248 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
30252 tentative_firewall firewall (parser);
30256 cp_parser_parse_tentatively (parser);
30259 parens.consume_open (parser);
30265 if (cp_parser_compound_literal_p (parser))
30266 cp_parser_simulate_error (parser);
30269 bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p;
30270 parser->in_type_id_in_expr_p = true;
30272 type = cp_parser_type_id (parser);
30274 parens.require_close (parser);
30275 parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p;
30279 if (cp_parser_parse_definitely (parser))
30284 cp_parser_commit_to_tentative_parse (parser);
30286 expr = cp_parser_unary_expression (parser);
30290 expr = cp_parser_unary_expression (parser);
30297 parser->type_definition_forbidden_message = saved_message;
30298 parser->type_definition_forbidden_message_arg = saved_message_arg;
30299 parser->integral_constant_expression_p
30301 parser->non_integral_constant_expression_p
30310 cp_parser_declares_only_class_p (cp_parser *parser)
30314 return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
30315 || cp_lexer_next_token_is (parser->lexer, CPP_COMMA));
30322 cp_parser_set_storage_class (cp_parser *parser,
30329 if (parser->in_unbraced_linkage_specification_p)
30563 cp_parser_required_error (cp_parser *parser,
30568 if (cp_parser_simulate_error (parser))
30735 cp_parser_error_1 (parser, gmsgid, token_desc, matching_location);
30751 cp_parser_require (cp_parser* parser,
30756 if (cp_lexer_next_token_is (parser->lexer, type))
30757 return cp_lexer_consume_token (parser->lexer);
30761 if (!cp_parser_simulate_error (parser))
30762 cp_parser_required_error (parser, token_desc, /*keyword=*/false,
30773 cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser)
30781 if (cp_parser_require (parser, CPP_GREATER, RT_GREATER))
30788 switch (cp_lexer_peek_token (parser->lexer)->type)
30806 cp_lexer_consume_token (parser->lexer);
30817 cp_lexer_consume_token (parser->lexer);
30846 cp_lexer_consume_token (parser->lexer);
30857 cp_parser_require_keyword (cp_parser* parser,
30861 cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc);
30865 cp_parser_required_error (parser, token_desc, /*keyword=*/true,
30897 cp_parser_next_token_starts_class_definition_p (cp_parser *parser)
30901 token = cp_lexer_peek_token (parser->lexer);
30904 && !parser->colon_doesnt_start_class_def_p));
30911 cp_parser_next_token_ends_template_argument_p (cp_parser *parser)
30915 token = cp_lexer_peek_token (parser->lexer);
30926 cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser,
30931 token = cp_lexer_peek_nth_token (parser->lexer, n);
30940 token2 = cp_lexer_peek_nth_token (parser->lexer, n+1);
30991 cp_parser_maybe_warn_enum_key (cp_parser *parser, location_t key_loc,
31001 tree decl = cp_parser_lookup_name_simple (parser, name, input_location);
31170 cp_parser_check_class_key (cp_parser *parser, location_t key_loc,
31199 class_decl_loc_t::add (parser, key_loc, class_key, type, def_p, decl_p);
31230 class_decl_loc_t::add (cp_parser *parser, location_t key_loc,
31238 tree decl = cp_parser_lookup_name_simple (parser, name, input_location);
31551 cp_parser_optional_template_keyword (cp_parser *parser)
31553 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE))
31556 outside templates the parser can always figure out what is a
31562 cp_token *token = cp_lexer_peek_token (parser->lexer);
31569 cp_lexer_purge_token (parser->lexer);
31575 cp_lexer_consume_token (parser->lexer);
31586 cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser)
31591 check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value;
31593 parser->scope = saved_checks_value (check_value);
31594 parser->qualifying_scope = check_value->qualifying_scope;
31595 parser->object_scope = NULL_TREE;
31602 cp_parser_cache_group (cp_parser *parser,
31608 cp_token *token = cp_lexer_peek_token (parser->lexer);
31625 cp_lexer_consume_token (parser->lexer);
31629 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1);
31638 cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1);
31643 cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1);
31658 cp_parser_cache_defarg (cp_parser *parser, bool nsdmi)
31668 first_token = cp_lexer_peek_token (parser->lexer);
31672 cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0);
31673 token = cp_lexer_peek_token (parser->lexer);
31680 token = cp_lexer_peek_token (parser->lexer);
31702 bool saved_italp = parser->in_template_argument_list_p;
31703 parser->in_template_argument_list_p = true;
31705 cp_parser_parse_tentatively (parser);
31719 cp_lexer_consume_token (parser->lexer);
31720 cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
31727 peek = cp_lexer_peek_token (parser->lexer);
31728 if (cp_parser_error_occurred (parser))
31740 cp_lexer_consume_token (parser->lexer);
31743 (parser, CP_PARSER_FLAGS_NONE);
31748 if (!cp_parser_error_occurred (parser) && !error)
31750 cp_parser_abort_tentative_parse (parser);
31752 parser->in_template_argument_list_p = saved_italp;
31835 token = cp_lexer_consume_token (parser->lexer);
31864 cp_parser_parse_tentatively (cp_parser* parser)
31867 parser->context = cp_parser_context_new (parser->context);
31869 cp_lexer_save_tokens (parser->lexer);
31879 cp_parser_commit_to_tentative_parse (cp_parser* parser)
31885 lexer = parser->lexer;
31886 for (context = parser->context; context->next; context = context->next)
31906 cp_parser_commit_to_topmost_tentative_parse (cp_parser* parser)
31908 cp_parser_context *context = parser->context;
31909 cp_lexer *lexer = parser->lexer;
31927 cp_parser_abort_tentative_parse (cp_parser* parser)
31929 gcc_assert (parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED
31931 cp_parser_simulate_error (parser);
31934 cp_parser_parse_definitely (parser);
31942 cp_parser_parse_definitely (cp_parser* parser)
31949 error_occurred = cp_parser_error_occurred (parser);
31951 context = parser->context;
31952 parser->context = context->next;
31959 cp_lexer_commit_tokens (parser->lexer);
31967 cp_lexer_rollback_tokens (parser->lexer);
31981 cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser)
31983 return (cp_parser_parsing_tentatively (parser)
31984 && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED);
31991 cp_parser_error_occurred (cp_parser* parser)
31993 return (cp_parser_parsing_tentatively (parser)
31994 && parser->context->status == CP_PARSER_STATUS_KIND_ERROR);
32000 cp_parser_allow_gnu_extensions_p (cp_parser* parser)
32002 return parser->allow_gnu_extensions_p;
32022 cp_parser_objc_expression (cp_parser* parser)
32025 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
32030 return cp_parser_objc_message_expression (parser);
32033 kwd = cp_lexer_consume_token (parser->lexer);
32040 return cp_parser_objc_encode_expression (parser);
32043 return cp_parser_objc_protocol_expression (parser);
32046 return cp_parser_objc_selector_expression (parser);
32056 cp_parser_skip_to_end_of_block_or_statement (parser);
32070 cp_parser_objc_message_expression (cp_parser* parser)
32074 parser->objective_c_message_context_p = true;
32075 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
32076 cp_lexer_consume_token (parser->lexer); /* Eat '['. */
32077 receiver = cp_parser_objc_message_receiver (parser);
32078 messageargs = cp_parser_objc_message_args (parser);
32079 location_t end_loc = cp_lexer_peek_token (parser->lexer)->location;
32080 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
32091 parser->objective_c_message_context_p = false;
32104 cp_parser_objc_message_receiver (cp_parser* parser)
32110 cp_parser_parse_tentatively (parser);
32111 rcv = cp_parser_expression (parser);
32114 if (cp_parser_parse_definitely (parser))
32117 cp_parser_parse_tentatively (parser);
32118 rcv = cp_parser_simple_type_specifier (parser,
32122 if (cp_parser_parse_definitely (parser))
32125 cp_parser_error (parser, "objective-c++ message receiver expected");
32149 cp_parser_objc_message_args (cp_parser* parser)
32153 cp_token *token = cp_lexer_peek_token (parser->lexer);
32160 selector = cp_parser_objc_selector (parser);
32164 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
32168 cp_parser_require (parser, CPP_COLON, RT_COLON);
32169 arg = cp_parser_assignment_expression (parser);
32175 token = cp_lexer_peek_token (parser->lexer);
32183 cp_lexer_consume_token (parser->lexer);
32184 arg = cp_parser_assignment_expression (parser);
32190 token = cp_lexer_peek_token (parser->lexer);
32195 cp_parser_error (parser, "objective-c++ message argument(s) are expected");
32210 cp_parser_objc_encode_expression (cp_parser* parser)
32214 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
32216 cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */
32218 parens.require_open (parser);
32219 token = cp_lexer_peek_token (parser->lexer);
32220 type = complete_type (cp_parser_type_id (parser));
32221 parens.require_close (parser);
32248 location_t combined_loc = make_location (start_loc, start_loc, parser->lexer);
32256 cp_parser_objc_defs_expression (cp_parser *parser)
32260 cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */
32262 parens.require_open (parser);
32263 name = cp_parser_identifier (parser);
32264 parens.require_close (parser);
32277 cp_parser_objc_protocol_expression (cp_parser* parser)
32280 location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
32282 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
32284 parens.require_open (parser);
32285 proto = cp_parser_identifier (parser);
32286 parens.require_close (parser);
32292 location_t combined_loc = make_location (start_loc, start_loc, parser->lexer);
32314 cp_parser_objc_selector_expression (cp_parser* parser)
32319 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
32321 cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */
32323 parens.require_open (parser);
32324 token = cp_lexer_peek_token (parser->lexer);
32333 selector = cp_parser_objc_selector (parser);
32335 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)
32336 && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE))
32346 cp_parser_error (parser, "expected %<:%>");
32350 token = cp_lexer_consume_token (parser->lexer);
32366 token = cp_lexer_peek_token (parser->lexer);
32370 parens.require_close (parser);
32377 location_t combined_loc = make_location (loc, loc, parser->lexer);
32393 cp_parser_objc_identifier_list (cp_parser* parser)
32399 identifier = cp_parser_identifier (parser);
32404 sep = cp_lexer_peek_token (parser->lexer);
32408 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
32409 identifier = cp_parser_identifier (parser);
32415 sep = cp_lexer_peek_token (parser->lexer);
32430 cp_parser_objc_alias_declaration (cp_parser* parser)
32434 cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */
32435 alias = cp_parser_identifier (parser);
32436 orig = cp_parser_identifier (parser);
32438 cp_parser_consume_semicolon_at_end_of_statement (parser);
32450 cp_parser_objc_class_declaration (cp_parser* parser)
32452 cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */
32457 id = cp_parser_identifier (parser);
32463 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
32464 cp_lexer_consume_token (parser->lexer);
32468 cp_parser_consume_semicolon_at_end_of_statement (parser);
32482 cp_parser_objc_protocol_refs_opt (cp_parser* parser)
32486 if(cp_lexer_next_token_is (parser->lexer, CPP_LESS))
32488 cp_lexer_consume_token (parser->lexer); /* Eat '<'. */
32489 protorefs = cp_parser_objc_identifier_list (parser);
32490 cp_parser_require (parser, CPP_GREATER, RT_GREATER);
32499 cp_parser_objc_visibility_spec (cp_parser* parser)
32501 cp_token *vis = cp_lexer_peek_token (parser->lexer);
32522 cp_lexer_consume_token (parser->lexer);
32529 cp_parser_objc_method_type (cp_parser* parser)
32531 if (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS)
32540 cp_parser_objc_protocol_qualifiers (cp_parser* parser)
32543 cp_token *token = cp_lexer_peek_token (parser->lexer);
32556 cp_lexer_consume_token (parser->lexer);
32557 token = cp_lexer_peek_token (parser->lexer);
32567 cp_parser_objc_typename (cp_parser* parser)
32571 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
32576 parens.consume_open (parser); /* Eat '('. */
32577 proto_quals = cp_parser_objc_protocol_qualifiers (parser);
32581 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
32583 cp_type = cp_parser_type_id (parser);
32595 cp_parser_skip_to_closing_parenthesis (parser,
32602 parens.require_close (parser);
32624 cp_parser_objc_selector (cp_parser* parser)
32626 cp_token *token = cp_lexer_consume_token (parser->lexer);
32655 cp_parser_objc_method_keyword_params (cp_parser* parser, tree* attributes)
32659 cp_token *token = cp_lexer_peek_token (parser->lexer);
32670 selector = cp_parser_objc_selector (parser);
32674 && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
32681 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
32687 type_name = cp_parser_objc_typename (parser);
32689 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
32690 parm_attr = cp_parser_attributes_opt (parser);
32691 identifier = cp_parser_identifier (parser);
32700 token = cp_lexer_peek_token (parser->lexer);
32705 cp_parser_error (parser, "objective-c++ method declaration is expected");
32712 *attributes = cp_parser_attributes_opt (parser);
32713 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
32714 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
32716 cp_parser_error (parser,
32723 cp_parser_error (parser, "objective-c++ method declaration is expected");
32732 cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp,
32736 cp_token *token = cp_lexer_peek_token (parser->lexer);
32744 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
32745 token = cp_lexer_peek_token (parser->lexer);
32749 cp_lexer_consume_token (parser->lexer); /* Eat '...'. */
32751 token = cp_lexer_peek_token (parser->lexer);
32756 parmdecl = cp_parser_parameter_declaration (parser, CP_PARSER_FLAGS_NONE,
32764 token = cp_lexer_peek_token (parser->lexer);
32772 *attributes = cp_parser_attributes_opt (parser);
32773 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)
32774 || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
32780 *attributes = cp_parser_attributes_opt (parser);
32782 cp_parser_error (parser,
32793 cp_parser_objc_interstitial_code (cp_parser* parser)
32795 cp_token *token = cp_lexer_peek_token (parser->lexer);
32801 (cp_lexer_peek_nth_token (parser->lexer, 2)))
32802 cp_parser_linkage_specification (parser);
32805 cp_parser_pragma (parser, pragma_objc_icode, NULL);
32808 cp_lexer_consume_token (parser->lexer);
32812 cp_lexer_consume_token (parser->lexer);
32817 cp_lexer_consume_token (parser->lexer);
32821 cp_parser_namespace_definition (parser);
32825 cp_lexer_consume_token (parser->lexer);
32831 cp_parser_block_declaration (parser, /*statement_p=*/false);
32837 cp_parser_objc_method_signature (cp_parser* parser, tree* attributes)
32843 is_class_method = cp_parser_objc_method_type (parser);
32844 rettype = cp_parser_objc_typename (parser);
32846 kwdparms = cp_parser_objc_method_keyword_params (parser, attributes);
32849 optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis, attributes);
32857 cp_parser_objc_method_maybe_bad_prefix_attributes (cp_parser* parser)
32860 cp_lexer_save_tokens (parser->lexer);
32861 tattr = cp_parser_attributes_opt (parser);
32866 if (cp_lexer_next_token_is (parser->lexer, CPP_PLUS)
32867 || cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
32872 cp_lexer_rollback_tokens (parser->lexer);
32879 cp_parser_objc_method_prototype_list (cp_parser* parser)
32881 cp_token *token = cp_lexer_peek_token (parser->lexer);
32893 sig = cp_parser_objc_method_signature (parser, &attributes);
32896 cp_parser_skip_to_end_of_block_or_statement (parser);
32897 token = cp_lexer_peek_token (parser->lexer);
32901 cp_parser_consume_semicolon_at_end_of_statement (parser);
32904 cp_parser_objc_at_property_declaration (parser);
32906 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
32907 warning_at (cp_lexer_peek_token (parser->lexer)->location,
32912 cp_parser_objc_interstitial_code (parser);
32914 token = cp_lexer_peek_token (parser->lexer);
32918 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
32920 cp_parser_error (parser, "expected %<@end%>");
32928 cp_parser_objc_method_definition_list (cp_parser* parser)
32930 cp_token *token = cp_lexer_peek_token (parser->lexer);
32946 sig = cp_parser_objc_method_signature (parser, &attribute);
32949 cp_parser_skip_to_end_of_block_or_statement (parser);
32950 token = cp_lexer_peek_token (parser->lexer);
32957 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
32958 cp_lexer_consume_token (parser->lexer);
32960 ptk = cp_lexer_peek_token (parser->lexer);
32966 meth = cp_parser_function_definition_after_declarator (parser,
32975 cp_parser_objc_at_property_declaration (parser);
32977 cp_parser_objc_at_synthesize_declaration (parser);
32979 cp_parser_objc_at_dynamic_declaration (parser);
32981 && cp_parser_objc_method_maybe_bad_prefix_attributes(parser))
32986 cp_parser_objc_interstitial_code (parser);
32988 token = cp_lexer_peek_token (parser->lexer);
32992 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
32994 cp_parser_error (parser, "expected %<@end%>");
33002 cp_parser_objc_class_ivars (cp_parser* parser)
33004 cp_token *token = cp_lexer_peek_token (parser->lexer);
33009 cp_lexer_consume_token (parser->lexer); /* Eat '{'. */
33010 token = cp_lexer_peek_token (parser->lexer);
33019 cp_parser_objc_visibility_spec (parser);
33021 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
33024 cp_parser_decl_specifier_seq (parser,
33032 cp_parser_error (parser, "invalid type for instance variable");
33039 cp_parser_error (parser, "invalid type for instance variable");
33046 cp_parser_error (parser, "invalid type for instance variable");
33055 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
33062 token = cp_lexer_peek_token (parser->lexer);
33067 && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
33072 cp_parser_identifier (parser),
33076 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
33079 = cp_parser_constant_expression (parser);
33085 = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
33095 attributes = cp_parser_attributes_opt (parser);
33124 token = cp_lexer_peek_token (parser->lexer);
33128 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
33134 cp_parser_consume_semicolon_at_end_of_statement (parser);
33135 token = cp_lexer_peek_token (parser->lexer);
33139 cp_parser_error (parser, "expected %<}%>");
33144 cp_lexer_consume_token (parser->lexer); /* Eat '}'. */
33147 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
33148 cp_lexer_consume_token (parser->lexer);
33154 cp_parser_objc_protocol_declaration (cp_parser* parser, tree attributes)
33159 cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */
33160 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
33162 tok = cp_lexer_peek_token (parser->lexer);
33164 cp_parser_consume_semicolon_at_end_of_statement (parser);
33169 tok = cp_lexer_peek_nth_token (parser->lexer, 2);
33178 id = cp_parser_identifier (parser);
33184 if(cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
33185 cp_lexer_consume_token (parser->lexer);
33189 cp_parser_consume_semicolon_at_end_of_statement (parser);
33195 proto = cp_parser_identifier (parser);
33196 protorefs = cp_parser_objc_protocol_refs_opt (parser);
33198 cp_parser_objc_method_prototype_list (parser);
33205 cp_parser_objc_superclass_or_category (cp_parser *parser,
33210 cp_token *next = cp_lexer_peek_token (parser->lexer);
33216 cp_lexer_consume_token (parser->lexer); /* Eat ':'. */
33217 *super = cp_parser_identifier (parser);
33222 parens.consume_open (parser); /* Eat '('. */
33226 if (iface_p && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
33232 *categ = cp_parser_identifier (parser);
33234 parens.require_close (parser);
33241 cp_parser_objc_class_interface (cp_parser* parser, tree attributes)
33246 cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */
33247 name = cp_parser_identifier (parser);
33257 cp_parser_objc_superclass_or_category (parser, true, &super, &categ,
33259 protos = cp_parser_objc_protocol_refs_opt (parser);
33268 cp_parser_objc_class_ivars (parser);
33272 cp_parser_objc_method_prototype_list (parser);
33278 cp_parser_objc_class_implementation (cp_parser* parser)
33283 cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */
33284 name = cp_parser_identifier (parser);
33295 cp_parser_objc_superclass_or_category (parser, false, &super, &categ,
33305 cp_parser_objc_class_ivars (parser);
33309 cp_parser_objc_method_definition_list (parser);
33315 cp_parser_objc_end_implementation (cp_parser* parser)
33317 cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */
33324 cp_parser_objc_declaration (cp_parser* parser, tree attributes)
33327 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
33352 cp_parser_objc_alias_declaration (parser);
33355 cp_parser_objc_class_declaration (parser);
33358 cp_parser_objc_protocol_declaration (parser, attributes);
33361 cp_parser_objc_class_interface (parser, attributes);
33364 cp_parser_objc_class_implementation (parser);
33367 cp_parser_objc_end_implementation (parser);
33372 cp_parser_skip_to_end_of_block_or_statement (parser);
33403 cp_parser_objc_try_catch_finally_statement (cp_parser *parser)
33408 cp_parser_require_keyword (parser, RID_AT_TRY, RT_AT_TRY);
33409 location = cp_lexer_peek_token (parser->lexer)->location;
33414 cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
33417 while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH))
33424 cp_lexer_consume_token (parser->lexer);
33425 if (parens.require_open (parser))
33427 if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
33434 cp_lexer_consume_token (parser->lexer);
33441 parm = cp_parser_parameter_declaration (parser, CP_PARSER_FLAGS_NONE,
33452 parens.require_close (parser);
33463 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
33464 cp_lexer_consume_token (parser->lexer);
33472 cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
33475 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY))
33477 cp_lexer_consume_token (parser->lexer);
33478 location = cp_lexer_peek_token (parser->lexer)->location;
33482 cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
33497 cp_parser_objc_synchronized_statement (cp_parser *parser)
33502 cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, RT_AT_SYNCHRONIZED);
33504 location = cp_lexer_peek_token (parser->lexer)->location;
33507 parens.require_open (parser);
33508 lock = cp_parser_expression (parser);
33509 parens.require_close (parser);
33514 cp_parser_compound_statement (parser, NULL, BCS_NORMAL, false);
33527 cp_parser_objc_throw_statement (cp_parser *parser)
33530 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
33532 cp_parser_require_keyword (parser, RID_AT_THROW, RT_AT_THROW);
33534 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
33535 expr = cp_parser_expression (parser);
33537 cp_parser_consume_semicolon_at_end_of_statement (parser);
33545 cp_parser_objc_statement (cp_parser * parser)
33548 cp_token *kwd = cp_lexer_peek_token (parser->lexer);
33553 return cp_parser_objc_try_catch_finally_statement (parser);
33555 return cp_parser_objc_synchronized_statement (parser);
33557 return cp_parser_objc_throw_statement (parser);
33561 cp_parser_skip_to_end_of_block_or_statement (parser);
33573 cp_parser_objc_valid_prefix_attributes (cp_parser* parser, tree *attrib)
33575 cp_lexer_save_tokens (parser->lexer);
33576 *attrib = cp_parser_attributes_opt (parser);
33578 if (OBJC_IS_AT_KEYWORD (cp_lexer_peek_token (parser->lexer)->keyword))
33580 cp_lexer_commit_tokens (parser->lexer);
33583 cp_lexer_rollback_tokens (parser->lexer);
33600 cp_parser_objc_struct_declaration (cp_parser *parser)
33607 cp_parser_decl_specifier_seq (parser,
33618 cp_parser_error (parser, "invalid type for property");
33625 cp_parser_error (parser, "invalid type for property");
33632 cp_parser_error (parser, "invalid type for property");
33640 while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
33647 declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED,
33652 attributes = cp_parser_attributes_opt (parser);
33678 token = cp_lexer_peek_token (parser->lexer);
33681 cp_lexer_consume_token (parser->lexer); /* Eat ','. */
33721 cp_parser_objc_at_property_declaration (cp_parser *parser)
33727 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
33729 cp_lexer_consume_token (parser->lexer); /* Eat '@property'. */
33732 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
33736 location_t attr_start = cp_lexer_peek_token (parser->lexer)->location;
33737 parens.consume_open (parser);
33741 location_t attr_end = cp_lexer_peek_token (parser->lexer)->location;
33743 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
33752 cp_token *token = cp_lexer_peek_token (parser->lexer);
33763 cp_lexer_consume_token (parser->lexer);
33776 cp_lexer_consume_token (parser->lexer);
33799 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
33808 token = cp_lexer_peek_token (parser->lexer);
33810 cp_lexer_consume_token (parser->lexer); /* eat the = */
33813 (cp_lexer_peek_token (parser->lexer)->type))
33823 token = cp_lexer_peek_token (parser->lexer);
33827 meth_name = cp_parser_objc_selector (parser);
33831 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON))
33842 (parser->lexer)->location);
33843 cp_lexer_consume_token (parser->lexer);
33863 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
33864 cp_lexer_consume_token (parser->lexer);
33869 if (syntax_error || !parens.require_close (parser))
33870 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
33881 tree properties = cp_parser_objc_struct_declaration (parser);
33884 cp_parser_skip_to_end_of_statement (parser);
33886 cp_parser_error (parser, "expected identifier");
33897 cp_parser_consume_semicolon_at_end_of_statement (parser);
33925 cp_parser_objc_at_synthesize_declaration (cp_parser *parser)
33929 loc = cp_lexer_peek_token (parser->lexer)->location;
33931 cp_lexer_consume_token (parser->lexer); /* Eat '@synthesize'. */
33935 property = cp_parser_identifier (parser);
33938 cp_parser_consume_semicolon_at_end_of_statement (parser);
33941 if (cp_lexer_next_token_is (parser->lexer, CPP_EQ))
33943 cp_lexer_consume_token (parser->lexer);
33944 ivar = cp_parser_identifier (parser);
33947 cp_parser_consume_semicolon_at_end_of_statement (parser);
33954 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
33955 cp_lexer_consume_token (parser->lexer);
33959 cp_parser_consume_semicolon_at_end_of_statement (parser);
33976 cp_parser_objc_at_dynamic_declaration (cp_parser *parser)
33980 loc = cp_lexer_peek_token (parser->lexer)->location;
33982 cp_lexer_consume_token (parser->lexer); /* Eat '@dynamic'. */
33986 property = cp_parser_identifier (parser);
33989 cp_parser_consume_semicolon_at_end_of_statement (parser);
33993 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
33994 cp_lexer_consume_token (parser->lexer);
33998 cp_parser_consume_semicolon_at_end_of_statement (parser);
34012 cp_parser_omp_clause_name (cp_parser *parser)
34016 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
34018 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF))
34020 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
34022 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE))
34024 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE))
34026 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
34028 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
34030 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
34241 cp_lexer_consume_token (parser->lexer);
34278 cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
34283 bool saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
34286 parser->colon_corrects_to_scope_p = false;
34294 cp_parser_parse_tentatively (parser);
34295 token = cp_lexer_peek_token (parser->lexer);
34304 cp_lexer_consume_token (parser->lexer);
34311 decl = cp_parser_primary_expression (parser, false, false, false,
34316 name = cp_parser_id_expression (parser, /*template_p=*/false,
34324 && cp_parser_simulate_error (parser))
34330 decl = cp_parser_lookup_name_simple (parser, name, token->location);
34336 && cp_parser_simulate_error (parser))
34338 cp_parser_name_lookup_error (parser, name, decl, NLE_NULL,
34353 if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_SQUARE)
34363 while (cp_lexer_next_token_is (parser->lexer, CPP_DOT)
34365 && cp_lexer_next_token_is (parser->lexer, CPP_DEREF)))
34368 = cp_lexer_next_token_is (parser->lexer, CPP_DOT)
34371 = cp_lexer_peek_token (parser->lexer)->location;
34373 cp_lexer_consume_token (parser->lexer);
34376 = cp_parser_postfix_dot_deref_expression (parser, ttype,
34385 while (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE))
34389 parser->colon_corrects_to_scope_p = false;
34390 cp_lexer_consume_token (parser->lexer);
34391 if (!cp_lexer_next_token_is (parser->lexer, CPP_COLON))
34393 low_bound = cp_parser_expression (parser);
34398 parser->colon_corrects_to_scope_p
34400 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_SQUARE))
34405 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
34408 && cp_parser_simulate_error (parser))
34413 cp_parser_commit_to_tentative_parse (parser);
34414 if (!cp_lexer_next_token_is (parser->lexer,
34417 length = cp_parser_expression (parser);
34423 if (!cp_parser_require (parser, CPP_CLOSE_SQUARE,
34427 && cp_parser_simulate_error (parser))
34441 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)
34442 && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)
34443 && cp_parser_simulate_error (parser))
34446 cp_parser_abort_tentative_parse (parser);
34447 decl = cp_parser_assignment_expression (parser, NULL,
34451 cp_parser_parse_definitely (parser);
34463 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
34465 cp_lexer_consume_token (parser->lexer);
34469 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
34471 if (colon != NULL && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
34474 cp_parser_require (parser, CPP_COLON, RT_COLON);
34478 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
34486 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
34487 ending = cp_parser_skip_to_closing_parenthesis (parser,
34502 cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list,
34505 if (cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
34506 return cp_parser_omp_var_list_no_open (parser, kind, list, NULL,
34525 cp_parser_oacc_data_clause (cp_parser *parser, pragma_omp_clause c_kind,
34574 nl = cp_parser_omp_var_list (parser, OMP_CLAUSE_MAP, list, true);
34586 cp_parser_oacc_data_clause_deviceptr (cp_parser *parser, tree list)
34588 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
34594 vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
34633 cp_parser_oacc_single_int_clause (cp_parser *parser, omp_clause_code code,
34636 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
34639 if (!parens.require_open (parser))
34642 tree t = cp_parser_assignment_expression (parser, NULL, false, false);
34645 || !parens.require_close (parser))
34647 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
34679 cp_parser_oacc_shape_clause (cp_parser *parser, location_t loc,
34684 cp_lexer *lexer = parser->lexer;
34693 parens.consume_open (parser);
34706 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
34712 cp_parser_error (parser, "too many %<static%> arguments");
34718 && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
34719 || cp_lexer_nth_token_is (parser->lexer, 2,
34745 cp_parser_error (parser, "unexpected argument");
34749 tree expr = cp_parser_assignment_expression (parser, NULL, false,
34767 if (!parens.require_close (parser))
34784 cp_parser_skip_to_closing_parenthesis (parser, false, false, true);
34792 cp_parser_oacc_clause_tile (cp_parser *parser, location_t clause_loc, tree list)
34805 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
34810 if (tile && !cp_parser_require (parser, CPP_COMMA, RT_COMMA))
34813 if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)
34814 && (cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA)
34815 || cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN)))
34817 cp_lexer_consume_token (parser->lexer);
34821 expr = cp_parser_constant_expression (parser);
34825 while (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN));
34828 cp_lexer_consume_token (parser->lexer);
34841 cp_parser_oacc_wait_list (cp_parser *parser, location_t clause_loc, tree list)
34846 args = cp_parser_parenthesized_expression_list (parser, non_attr,
34855 cp_parser_error (parser, "expected integer expression list");
34892 cp_parser_oacc_clause_wait (cp_parser *parser, tree list)
34894 location_t location = cp_lexer_peek_token (parser->lexer)->location;
34896 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
34897 list = cp_parser_oacc_wait_list (parser, location, list);
34914 cp_parser_omp_clause_collapse (cp_parser *parser, tree list, location_t location)
34920 loc = cp_lexer_peek_token (parser->lexer)->location;
34922 if (!parens.require_open (parser))
34925 num = cp_parser_constant_expression (parser);
34927 if (!parens.require_close (parser))
34928 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
34960 cp_parser_omp_clause_default (cp_parser *parser, tree list,
34967 if (!parens.require_open (parser))
34969 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
34971 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
34998 cp_lexer_consume_token (parser->lexer);
35004 cp_parser_error (parser, "expected %<none%> or %<present%>");
35006 cp_parser_error (parser, "expected %<none%> or %<shared%>");
35010 || !parens.require_close (parser))
35011 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35030 cp_parser_omp_clause_final (cp_parser *parser, tree list, location_t location)
35035 if (!parens.require_open (parser))
35038 t = cp_parser_assignment_expression (parser);
35041 || !parens.require_close (parser))
35042 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35070 cp_parser_omp_clause_if (cp_parser *parser, tree list, location_t location,
35077 if (!parens.require_open (parser))
35080 if (is_omp && cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35082 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
35099 if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
35101 id = cp_lexer_peek_nth_token (parser->lexer, 2)->u.value;
35116 = cp_lexer_peek_nth_token (parser->lexer, 2)->location;
35124 if (cp_lexer_nth_token_is (parser->lexer, 3, CPP_NAME))
35126 id = cp_lexer_peek_nth_token (parser->lexer, 3)->u.value;
35134 = cp_lexer_peek_nth_token (parser->lexer, 3)->location;
35143 if (cp_lexer_nth_token_is (parser->lexer, n, CPP_COLON))
35146 cp_lexer_consume_token (parser->lexer);
35153 = cp_lexer_peek_nth_token (parser->lexer, n)->location;
35161 t = cp_parser_assignment_expression (parser);
35164 || !parens.require_close (parser))
35165 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35223 cp_parser_omp_clause_mergeable (cp_parser * /*parser*/,
35240 cp_parser_omp_clause_nowait (cp_parser * /*parser*/,
35256 cp_parser_omp_clause_num_threads (cp_parser *parser, tree list,
35262 if (!parens.require_open (parser))
35265 t = cp_parser_assignment_expression (parser);
35268 || !parens.require_close (parser))
35269 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35287 cp_parser_omp_clause_num_tasks (cp_parser *parser, tree list,
35293 if (!parens.require_open (parser))
35296 t = cp_parser_assignment_expression (parser);
35299 || !parens.require_close (parser))
35300 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35318 cp_parser_omp_clause_grainsize (cp_parser *parser, tree list,
35324 if (!parens.require_open (parser))
35327 t = cp_parser_assignment_expression (parser);
35330 || !parens.require_close (parser))
35331 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35349 cp_parser_omp_clause_priority (cp_parser *parser, tree list,
35355 if (!parens.require_open (parser))
35358 t = cp_parser_assignment_expression (parser);
35361 || !parens.require_close (parser))
35362 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35380 cp_parser_omp_clause_hint (cp_parser *parser, tree list, location_t location)
35385 if (!parens.require_open (parser))
35388 t = cp_parser_assignment_expression (parser);
35391 || !parens.require_close (parser))
35392 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35412 cp_parser_omp_clause_defaultmap (cp_parser *parser, tree list,
35422 if (!parens.require_open (parser))
35425 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT))
35427 else if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35430 cp_parser_error (parser, "expected %<alloc%>, %<to%>, %<from%>, "
35437 id = cp_lexer_peek_token (parser->lexer)->u.value;
35485 cp_lexer_consume_token (parser->lexer);
35487 if (!cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
35489 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
35492 if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35495 cp_parser_error (parser, "expected %<scalar%>, %<aggregate%> or "
35499 id = cp_lexer_peek_token (parser->lexer)->u.value;
35529 cp_lexer_consume_token (parser->lexer);
35531 if (!parens.require_close (parser))
35578 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35588 cp_parser_omp_clause_order (cp_parser *parser, tree list, location_t location)
35594 if (!parens.require_open (parser))
35597 if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35599 cp_parser_error (parser, "expected %<concurrent%>");
35604 id = cp_lexer_peek_token (parser->lexer)->u.value;
35609 cp_parser_error (parser, "expected %<concurrent%>");
35612 cp_lexer_consume_token (parser->lexer);
35613 if (!parens.require_close (parser))
35622 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35632 cp_parser_omp_clause_bind (cp_parser *parser, tree list,
35640 if (!parens.require_open (parser))
35643 if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35646 cp_parser_error (parser,
35652 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
35661 cp_lexer_consume_token (parser->lexer);
35662 if (!parens.require_close (parser))
35672 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35685 cp_parser_omp_clause_ordered (cp_parser *parser,
35694 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
35697 parens.consume_open (parser);
35699 num = cp_parser_constant_expression (parser);
35701 if (!parens.require_close (parser))
35702 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35750 cp_parser_omp_clause_reduction (cp_parser *parser, enum omp_clause_code kind,
35758 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
35763 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT)
35764 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
35766 cp_lexer_consume_token (parser->lexer);
35767 cp_lexer_consume_token (parser->lexer);
35769 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
35770 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COMMA))
35772 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
35780 cp_lexer_consume_token (parser->lexer);
35781 cp_lexer_consume_token (parser->lexer);
35786 switch (cp_lexer_peek_token (parser->lexer)->type)
35800 cp_lexer_consume_token (parser->lexer);
35804 saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
35805 parser->colon_corrects_to_scope_p = false;
35806 id = cp_parser_id_expression (parser, /*template_p=*/false,
35811 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
35837 tree scope = parser->scope;
35840 parser->scope = NULL_TREE;
35841 parser->qualifying_scope = NULL_TREE;
35842 parser->object_scope = NULL_TREE;
35848 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
35855 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
35858 nlist = cp_parser_omp_var_list_no_open (parser, kind, list,
35890 cp_parser_omp_clause_schedule (cp_parser *parser, tree list, location_t location)
35896 if (!parens.require_open (parser))
35901 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35903 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
35913 cp_lexer_consume_token (parser->lexer);
35915 && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
35916 cp_lexer_consume_token (parser->lexer);
35919 cp_parser_require (parser, CPP_COLON, RT_COLON);
35924 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
35926 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
35953 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
35955 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AUTO))
35959 cp_lexer_consume_token (parser->lexer);
35971 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
35974 cp_lexer_consume_token (parser->lexer);
35976 token = cp_lexer_peek_token (parser->lexer);
35977 t = cp_parser_assignment_expression (parser);
35990 if (!parens.require_close (parser))
35993 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
36005 cp_parser_error (parser, "invalid schedule kind");
36007 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36017 cp_parser_omp_clause_untied (cp_parser * /*parser*/,
36034 cp_parser_omp_clause_branch (cp_parser * /*parser*/, enum omp_clause_code code,
36050 cp_parser_omp_clause_cancelkind (cp_parser * /*parser*/,
36063 cp_parser_omp_clause_nogroup (cp_parser * /*parser*/,
36077 cp_parser_omp_clause_orderedkind (cp_parser * /*parser*/,
36091 cp_parser_omp_clause_num_teams (cp_parser *parser, tree list,
36097 if (!parens.require_open (parser))
36100 t = cp_parser_assignment_expression (parser);
36103 || !parens.require_close (parser))
36104 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36122 cp_parser_omp_clause_thread_limit (cp_parser *parser, tree list,
36128 if (!parens.require_open (parser))
36131 t = cp_parser_assignment_expression (parser);
36134 || !parens.require_close (parser))
36135 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36154 cp_parser_omp_clause_aligned (cp_parser *parser, tree list)
36160 if (!parens.require_open (parser))
36163 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_ALIGNED, list,
36168 alignment = cp_parser_constant_expression (parser);
36170 if (!parens.require_close (parser))
36171 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36192 cp_parser_omp_clause_lastprivate (cp_parser *parser, tree list)
36196 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
36199 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
36200 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_COLON))
36202 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36208 cp_lexer_consume_token (parser->lexer);
36209 cp_lexer_consume_token (parser->lexer);
36213 tree nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_LASTPRIVATE,
36231 cp_parser_omp_clause_linear (cp_parser *parser, tree list,
36239 if (!parens.require_open (parser))
36242 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
36244 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36253 if (cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
36254 cp_lexer_consume_token (parser->lexer);
36260 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_LINEAR, list,
36264 nlist = cp_parser_omp_var_list (parser, OMP_CLAUSE_LINEAR, list);
36265 colon = cp_lexer_next_token_is (parser->lexer, CPP_COLON);
36267 cp_parser_require (parser, CPP_COLON, RT_COLON);
36268 else if (!parens.require_close (parser))
36269 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36278 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
36279 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_CLOSE_PAREN))
36281 cp_token *token = cp_lexer_peek_token (parser->lexer);
36282 cp_parser_parse_tentatively (parser);
36283 step = cp_parser_id_expression (parser, /*template_p=*/false,
36289 step = cp_parser_lookup_name_simple (parser, step, token->location);
36293 cp_parser_abort_tentative_parse (parser);
36295 else if (!cp_parser_parse_definitely (parser))
36299 step = cp_parser_assignment_expression (parser);
36301 if (!parens.require_close (parser))
36302 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36323 cp_parser_omp_clause_safelen (cp_parser *parser, tree list,
36329 if (!parens.require_open (parser))
36332 t = cp_parser_constant_expression (parser);
36335 || !parens.require_close (parser))
36336 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36353 cp_parser_omp_clause_simdlen (cp_parser *parser, tree list,
36359 if (!parens.require_open (parser))
36362 t = cp_parser_constant_expression (parser);
36365 || !parens.require_close (parser))
36366 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36386 cp_parser_omp_clause_depend_sink (cp_parser *parser, location_t clause_loc,
36391 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
36393 cp_parser_error (parser, "expected identifier");
36397 while (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
36399 location_t id_loc = cp_lexer_peek_token (parser->lexer)->location;
36400 tree t, identifier = cp_parser_identifier (parser);
36408 (parser, identifier,
36409 cp_lexer_peek_token (parser->lexer)->location);
36411 cp_parser_name_lookup_error (parser, identifier, t, NLE_NULL,
36416 if (cp_lexer_next_token_is (parser->lexer, CPP_MINUS))
36418 else if (!cp_lexer_next_token_is (parser->lexer, CPP_PLUS))
36423 cp_lexer_consume_token (parser->lexer);
36425 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NUMBER))
36427 cp_parser_error (parser, "expected integer");
36431 addend = cp_lexer_peek_token (parser->lexer)->u.value;
36434 cp_parser_error (parser, "expected integer");
36437 cp_lexer_consume_token (parser->lexer);
36447 if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA))
36450 cp_lexer_consume_token (parser->lexer);
36453 if (cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN) && vec)
36480 cp_parser_omp_iterators (cp_parser *parser)
36483 cp_lexer_consume_token (parser->lexer);
36486 if (!parens.require_open (parser))
36490 = parser->colon_corrects_to_scope_p;
36492 = parser->colon_doesnt_start_class_def_p;
36497 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
36498 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_EQ))
36503 = parser->type_definition_forbidden_message;
36504 parser->type_definition_forbidden_message
36507 iter_type = cp_parser_type_id (parser);
36509 parser->type_definition_forbidden_message = saved_message;
36512 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
36513 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
36515 cp_parser_error (parser, "expected identifier");
36519 tree id = cp_parser_identifier (parser);
36523 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
36526 parser->colon_corrects_to_scope_p = false;
36527 parser->colon_doesnt_start_class_def_p = true;
36528 tree begin = cp_parser_assignment_expression (parser);
36530 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
36533 tree end = cp_parser_assignment_expression (parser);
36536 if (cp_lexer_next_token_is (parser->lexer, CPP_COLON))
36538 cp_lexer_consume_token (parser->lexer);
36539 step = cp_parser_assignment_expression (parser);
36554 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
36556 cp_lexer_consume_token (parser->lexer);
36563 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
36564 parser->colon_doesnt_start_class_def_p
36567 if (!parens.require_close (parser))
36568 cp_parser_skip_to_closing_parenthesis (parser,
36597 cp_parser_omp_clause_depend (cp_parser *parser, tree list, location_t loc)
36603 if (!parens.require_open (parser))
36608 if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME))
36611 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36617 iterators = cp_parser_omp_iterators (parser);
36618 cp_parser_require (parser, CPP_COMMA, RT_COMMA);
36641 cp_lexer_consume_token (parser->lexer);
36658 if (!parens.require_close (parser))
36659 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36665 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
36669 nlist = cp_parser_omp_clause_depend_sink (parser, loc, list);
36672 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_DEPEND,
36695 cp_parser_error (parser, "invalid depend kind");
36699 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36719 cp_parser_omp_clause_map (cp_parser *parser, tree list)
36725 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
36728 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
36730 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36736 if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COMMA)
36738 if ((cp_lexer_peek_nth_token (parser->lexer, nth)->type == CPP_NAME
36739 || (cp_lexer_peek_nth_token (parser->lexer, nth)->keyword
36741 && (cp_lexer_peek_nth_token (parser->lexer, nth + 1)->type
36745 cp_lexer_consume_token (parser->lexer);
36747 cp_lexer_consume_token (parser->lexer);
36752 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)
36753 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
36755 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36770 cp_parser_error (parser, "invalid map kind");
36771 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36776 cp_lexer_consume_token (parser->lexer);
36777 cp_lexer_consume_token (parser->lexer);
36779 else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DELETE)
36780 && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON)
36783 cp_lexer_consume_token (parser->lexer);
36784 cp_lexer_consume_token (parser->lexer);
36787 nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_MAP, list,
36800 cp_parser_omp_clause_device (cp_parser *parser, tree list,
36806 if (!parens.require_open (parser))
36809 t = cp_parser_assignment_expression (parser);
36812 || !parens.require_close (parser))
36813 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36832 cp_parser_omp_clause_dist_schedule (cp_parser *parser, tree list,
36838 if (!parens.require_open (parser))
36843 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC))
36845 cp_lexer_consume_token (parser->lexer);
36847 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
36849 cp_lexer_consume_token (parser->lexer);
36851 t = cp_parser_assignment_expression (parser);
36857 if (!parens.require_close (parser))
36860 else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
36871 cp_parser_error (parser, "invalid dist_schedule kind");
36873 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36886 cp_parser_omp_clause_proc_bind (cp_parser *parser, tree list,
36892 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
36895 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
36897 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36912 cp_lexer_consume_token (parser->lexer);
36913 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
36924 cp_parser_error (parser, "invalid depend kind");
36926 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36936 cp_parser_omp_clause_device_type (cp_parser *parser, tree list,
36942 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
36945 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
36947 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
36962 cp_lexer_consume_token (parser->lexer);
36963 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_COMMA_CLOSE_PAREN))
36974 cp_parser_error (parser, "invalid depend kind");
36976 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
36986 cp_parser_oacc_clause_async (cp_parser *parser, tree list)
36989 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
36993 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
36996 parens.consume_open (parser);
36998 t = cp_parser_assignment_expression (parser);
37000 || !parens.require_close (parser))
37001 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
37020 cp_parser_oacc_all_clauses (cp_parser *parser, omp_clause_mask mask,
37030 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
37038 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
37039 cp_lexer_consume_token (parser->lexer);
37041 here = cp_lexer_peek_token (parser->lexer)->location;
37042 c_kind = cp_parser_omp_clause_name (parser);
37047 clauses = cp_parser_oacc_clause_async (parser, clauses);
37056 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37060 clauses = cp_parser_omp_clause_collapse (parser, clauses, here);
37064 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37068 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37072 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37076 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37080 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37084 clauses = cp_parser_omp_clause_default (parser, clauses, here, true);
37088 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37092 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37096 clauses = cp_parser_oacc_data_clause_deviceptr (parser, clauses);
37100 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37109 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
37115 clauses = cp_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_GANG,
37119 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37123 clauses = cp_parser_omp_clause_if (parser, clauses, here, false);
37137 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37141 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37147 clauses = cp_parser_oacc_single_int_clause (parser, code, c_name,
37153 clauses = cp_parser_oacc_single_int_clause (parser, code, c_name,
37157 clauses = cp_parser_oacc_data_clause (parser, c_kind, clauses);
37161 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
37167 = cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
37177 clauses = cp_parser_oacc_clause_tile (parser, here, clauses);
37181 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE_DEVICE_PTR,
37187 clauses = cp_parser_oacc_shape_clause (parser, here,
37194 clauses = cp_parser_oacc_single_int_clause (parser, code, c_name,
37198 clauses = cp_parser_oacc_clause_wait (parser, clauses);
37203 clauses = cp_parser_oacc_shape_clause (parser, here,
37208 cp_parser_error (parser, "expected %<#pragma acc%> clause");
37224 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
37240 cp_parser_omp_all_clauses (cp_parser *parser, omp_clause_mask mask,
37251 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
37257 if (nested && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
37262 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
37263 cp_lexer_consume_token (parser->lexer);
37265 error_at (cp_lexer_peek_token (parser->lexer)->location,
37270 token = cp_lexer_peek_token (parser->lexer);
37271 c_kind = cp_parser_omp_clause_name (parser);
37276 clauses = cp_parser_omp_clause_bind (parser, clauses,
37281 clauses = cp_parser_omp_clause_collapse (parser, clauses,
37286 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses);
37290 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE,
37295 clauses = cp_parser_omp_clause_default (parser, clauses,
37300 clauses = cp_parser_omp_clause_final (parser, clauses, token->location);
37304 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE,
37309 clauses = cp_parser_omp_clause_grainsize (parser, clauses,
37314 clauses = cp_parser_omp_clause_hint (parser, clauses,
37319 clauses = cp_parser_omp_clause_defaultmap (parser, clauses,
37324 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE_DEVICE_PTR,
37329 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_USE_DEVICE_ADDR,
37334 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_IS_DEVICE_PTR,
37339 clauses = cp_parser_omp_clause_if (parser, clauses, token->location,
37345 = cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_IN_REDUCTION,
37350 clauses = cp_parser_omp_clause_lastprivate (parser, clauses);
37354 clauses = cp_parser_omp_clause_mergeable (parser, clauses,
37359 clauses = cp_parser_omp_clause_nowait (parser, clauses,
37364 clauses = cp_parser_omp_clause_num_tasks (parser, clauses,
37369 clauses = cp_parser_omp_clause_num_threads (parser, clauses,
37374 clauses = cp_parser_omp_clause_order (parser, clauses,
37379 clauses = cp_parser_omp_clause_ordered (parser, clauses,
37384 clauses = cp_parser_omp_clause_priority (parser, clauses,
37389 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE,
37395 = cp_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
37400 clauses = cp_parser_omp_clause_schedule (parser, clauses,
37405 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED,
37411 = cp_parser_omp_clause_reduction (parser,
37417 clauses = cp_parser_omp_clause_untied (parser, clauses,
37422 clauses = cp_parser_omp_clause_branch (parser, OMP_CLAUSE_INBRANCH,
37427 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_NONTEMPORAL,
37432 clauses = cp_parser_omp_clause_branch (parser,
37438 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_PARALLEL,
37450 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_FOR,
37457 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_SECTIONS,
37464 clauses = cp_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_TASKGROUP,
37471 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LINK, clauses);
37476 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_TO_DECLARE,
37479 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_TO, clauses);
37483 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FROM, clauses);
37487 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_UNIFORM,
37492 clauses = cp_parser_omp_clause_num_teams (parser, clauses,
37497 clauses = cp_parser_omp_clause_thread_limit (parser, clauses,
37502 clauses = cp_parser_omp_clause_aligned (parser, clauses);
37510 clauses = cp_parser_omp_clause_linear (parser, clauses, declare_simd);
37515 clauses = cp_parser_omp_clause_depend (parser, clauses,
37520 clauses = cp_parser_omp_clause_map (parser, clauses);
37524 clauses = cp_parser_omp_clause_device (parser, clauses,
37529 clauses = cp_parser_omp_clause_dist_schedule (parser, clauses,
37534 clauses = cp_parser_omp_clause_proc_bind (parser, clauses,
37539 clauses = cp_parser_omp_clause_device_type (parser, clauses,
37544 clauses = cp_parser_omp_clause_safelen (parser, clauses,
37549 clauses = cp_parser_omp_clause_simdlen (parser, clauses,
37554 clauses = cp_parser_omp_clause_nogroup (parser, clauses,
37560 = cp_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_THREADS,
37566 = cp_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_SIMD,
37571 cp_parser_error (parser, "expected %<#pragma omp%> clause");
37587 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
37607 cp_parser_begin_omp_structured_block (cp_parser *parser)
37609 unsigned save = parser->in_statement;
37619 if (parser->in_statement)
37620 parser->in_statement = IN_OMP_BLOCK;
37626 cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save)
37628 parser->in_statement = save;
37632 cp_parser_omp_structured_block (cp_parser *parser, bool *if_p)
37635 unsigned int save = cp_parser_begin_omp_structured_block (parser);
37637 cp_parser_statement (parser, NULL_TREE, false, if_p);
37639 cp_parser_end_omp_structured_block (parser, save);
37695 cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok)
37706 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
37708 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
37709 cp_lexer_consume_token (parser->lexer);
37713 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
37715 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
37716 location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
37742 cp_lexer_consume_token (parser->lexer);
37743 clauses = cp_parser_omp_clause_hint (parser, clauses, cloc);
37769 cp_lexer_consume_token (parser->lexer);
37775 cp_parser_require_pragma_eol (parser, pragma_tok);
37851 v = cp_parser_unary_expression (parser);
37854 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
37857 lhs = cp_parser_expression (parser);
37859 lhs = cp_parser_unary_expression (parser);
37873 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
37875 cp_lexer_consume_token (parser->lexer);
37880 v = cp_parser_unary_expression (parser);
37883 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
37891 lhs = cp_parser_unary_expression (parser);
37949 switch (cp_lexer_peek_token (parser->lexer)->type)
37981 cp_lexer_consume_token (parser->lexer);
37982 cp_parser_parse_tentatively (parser);
37983 rhs1 = cp_parser_simple_cast_expression (parser);
37986 cp_parser_abort_tentative_parse (parser);
37987 cp_parser_simple_cast_expression (parser);
37990 token = cp_lexer_peek_token (parser->lexer);
37993 cp_parser_abort_tentative_parse (parser);
37994 cp_parser_parse_tentatively (parser);
37995 rhs = cp_parser_binary_expression (parser, false, true,
37999 cp_parser_abort_tentative_parse (parser);
38000 cp_parser_binary_expression (parser, false, true,
38018 if (cp_parser_parse_definitely (parser))
38032 cp_parser_abort_tentative_parse (parser);
38035 rhs = cp_parser_expression (parser);
38042 cp_parser_error (parser,
38046 if (!cp_parser_parse_definitely (parser))
38058 cp_lexer_consume_token (parser->lexer);
38068 cp_parser_error (parser,
38099 cp_parser_error (parser,
38107 cp_lexer_consume_token (parser->lexer);
38108 rhs = cp_parser_binary_expression (parser, false, false,
38115 cp_parser_error (parser,
38119 cp_lexer_consume_token (parser->lexer);
38121 rhs = cp_parser_expression (parser);
38129 if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
38131 v = cp_parser_unary_expression (parser);
38134 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
38136 lhs1 = cp_parser_unary_expression (parser);
38142 cp_parser_consume_semicolon_at_end_of_statement (parser);
38143 cp_parser_require (parser, CPP_CLOSE_BRACE, RT_CLOSE_BRACE);
38150 cp_parser_consume_semicolon_at_end_of_statement (parser);
38154 cp_parser_skip_to_end_of_block_or_statement (parser);
38157 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
38158 cp_lexer_consume_token (parser->lexer);
38161 cp_parser_skip_to_end_of_block_or_statement (parser);
38162 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
38163 cp_lexer_consume_token (parser->lexer);
38173 cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok)
38175 cp_parser_require_pragma_eol (parser, pragma_tok);
38191 cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
38195 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
38198 parens.consume_open (parser);
38200 name = cp_parser_identifier (parser);
38203 || !parens.require_close (parser))
38204 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
38210 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
38211 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
38212 cp_lexer_consume_token (parser->lexer);
38214 clauses = cp_parser_omp_all_clauses (parser,
38219 cp_parser_require_pragma_eol (parser, pragma_tok);
38221 stmt = cp_parser_omp_structured_block (parser, if_p);
38240 cp_parser_omp_depobj (cp_parser *parser, cp_token *pragma_tok)
38244 if (!parens.require_open (parser))
38246 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
38250 tree depobj = cp_parser_assignment_expression (parser);
38252 if (!parens.require_close (parser))
38253 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
38259 location_t c_loc = cp_lexer_peek_token (parser->lexer)->location;
38260 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38262 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38265 cp_lexer_consume_token (parser->lexer);
38270 clause = cp_parser_omp_clause_depend (parser, NULL_TREE, c_loc);
38281 if (c_parens.require_open (parser))
38284 = cp_lexer_peek_token (parser->lexer)->location;
38285 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38287 tree id2 = cp_lexer_peek_token (parser->lexer)->u.value;
38290 cp_lexer_consume_token (parser->lexer);
38306 if (!c_parens.require_close (parser))
38307 cp_parser_skip_to_closing_parenthesis (parser,
38321 cp_parser_require_pragma_eol (parser, pragma_tok);
38337 cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok)
38340 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38342 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38351 error_at (cp_lexer_peek_token (parser->lexer)->location,
38353 cp_lexer_consume_token (parser->lexer);
38355 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
38358 error_at (cp_lexer_peek_token (parser->lexer)->location,
38361 (void) cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
38363 cp_parser_require_pragma_eol (parser, pragma_tok);
38371 cp_parser_omp_for_cond (cp_parser *parser, tree decl, enum tree_code code)
38373 tree cond = cp_parser_binary_expression (parser, false, true,
38376 || cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
38378 cp_parser_skip_to_end_of_statement (parser);
38414 cp_parser_omp_for_incr (cp_parser *parser, tree decl)
38416 cp_token *token = cp_lexer_peek_token (parser->lexer);
38426 cp_lexer_consume_token (parser->lexer);
38427 lhs = cp_parser_simple_cast_expression (parser);
38434 lhs = cp_parser_primary_expression (parser, false, false, false, &idk);
38439 token = cp_lexer_peek_token (parser->lexer);
38444 cp_lexer_consume_token (parser->lexer);
38448 op = cp_parser_assignment_operator_opt (parser);
38454 rhs = cp_parser_assignment_expression (parser);
38459 lhs = cp_parser_binary_expression (parser, false, false,
38461 token = cp_lexer_peek_token (parser->lexer);
38473 cp_lexer_consume_token (parser->lexer);
38474 rhs = cp_parser_binary_expression (parser, false, false,
38476 token = cp_lexer_peek_token (parser->lexer);
38514 cp_parser_omp_for_loop_init (cp_parser *parser,
38522 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
38540 cp_parser_parse_tentatively (parser);
38541 cp_parser_type_specifier_seq (parser, CP_PARSER_FLAGS_NONE,
38545 if (cp_parser_parse_definitely (parser))
38552 declarator = cp_parser_declarator (parser,
38560 attributes = cp_parser_attributes_opt (parser);
38561 asm_specification = cp_parser_asm_specification_opt (parser);
38564 cp_parser_skip_to_end_of_statement (parser);
38576 if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ))
38578 if (cp_lexer_next_token_is (parser->lexer,
38584 cp_parser_require (parser, CPP_EQ, RT_EQ);
38587 cp_parser_skip_to_end_of_statement (parser);
38595 init = cp_parser_initializer (parser,
38652 cp_lexer_consume_token (parser->lexer);
38653 init = cp_parser_assignment_expression (parser);
38674 cp_parser_parse_tentatively (parser);
38675 decl = cp_parser_primary_expression (parser, false, false,
38677 cp_token *last_tok = cp_lexer_peek_token (parser->lexer);
38678 if (!cp_parser_error_occurred (parser)
38683 cp_parser_abort_tentative_parse (parser);
38684 cp_parser_parse_tentatively (parser);
38685 cp_token *token = cp_lexer_peek_token (parser->lexer);
38686 tree name = cp_parser_id_expression (parser, /*template_p=*/false,
38692 && last_tok == cp_lexer_peek_token (parser->lexer))
38694 decl = cp_parser_lookup_name_simple (parser, name,
38699 cp_parser_abort_tentative_parse (parser);
38700 cp_parser_parse_tentatively (parser);
38701 decl = cp_parser_primary_expression (parser, false, false,
38704 if (!cp_parser_error_occurred (parser)
38711 cp_parser_parse_definitely (parser);
38712 cp_parser_require (parser, CPP_EQ, RT_EQ);
38713 rhs = cp_parser_assignment_expression (parser);
38725 cp_parser_abort_tentative_parse (parser);
38726 init = cp_parser_expression (parser);
38930 cp_parser_omp_scan_loop_body (cp_parser *parser)
38935 if (!braces.require_open (parser))
38938 substmt = cp_parser_omp_structured_block (parser, NULL);
38942 cp_token *tok = cp_lexer_peek_token (parser->lexer);
38947 cp_lexer_consume_token (parser->lexer);
38949 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
38951 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
38960 cp_lexer_consume_token (parser->lexer);
38961 clauses = cp_parser_omp_var_list (parser, clause, NULL_TREE);
38964 cp_parser_error (parser, "expected %<inclusive%> or "
38967 cp_parser_require_pragma_eol (parser, tok);
38973 substmt = cp_parser_omp_structured_block (parser, NULL);
38978 braces.require_close (parser);
38984 cp_parser_omp_for_loop (cp_parser *parser, enum tree_code code, tree clauses,
39049 loc_first = cp_lexer_peek_token (parser->lexer)->location;
39057 if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
39060 cp_parser_error (parser, "for statement expected");
39063 loc = cp_lexer_consume_token (parser->lexer)->location;
39070 if (!parens.require_open (parser))
39079 cp_lexer_save_tokens (parser->lexer);
39083 = (cp_parser_skip_to_closing_parenthesis_1 (parser,
39090 cp_lexer_rollback_tokens (parser->lexer);
39095 = parser->colon_corrects_to_scope_p;
39098 parser->colon_corrects_to_scope_p = false;
39101 cp_parser_simple_declaration (parser,
39104 parser->colon_corrects_to_scope_p
39107 cp_parser_require (parser, CPP_COLON, RT_COLON);
39109 init = cp_parser_range_for (parser, NULL_TREE, NULL_TREE, decl,
39139 = cp_parser_omp_for_loop_init (parser, this_pre_body, for_block,
39142 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
39244 if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
39245 cond = cp_parser_omp_for_cond (parser, decl, code);
39246 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
39249 if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
39258 incr = cp_parser_omp_for_incr (parser, real_decl);
39260 incr = cp_parser_expression (parser);
39265 if (!parens.require_close (parser))
39266 cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true,
39295 cp_parser_parse_tentatively (parser);
39298 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
39300 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE))
39302 cp_lexer_consume_token (parser->lexer);
39306 && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
39307 cp_lexer_consume_token (parser->lexer);
39310 loc = cp_lexer_peek_token (parser->lexer)->location;
39313 cp_parser_abort_tentative_parse (parser);
39321 cp_parser_parse_definitely (parser);
39331 parser->in_statement = IN_OMP_FOR;
39346 cp_parser_omp_scan_loop_body (parser);
39348 cp_parser_statement (parser, NULL_TREE, false, if_p);
39362 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE))
39364 cp_lexer_consume_token (parser->lexer);
39367 else if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
39368 cp_lexer_consume_token (parser->lexer);
39373 error_at (cp_lexer_peek_token (parser->lexer)->location,
39377 cp_parser_statement_seq_opt (parser, NULL);
39378 if (cp_lexer_next_token_is (parser->lexer, CPP_EOF))
39422 cp_parser_omp_loop (cp_parser *parser, cp_token *pragma_tok,
39428 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39433 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
39443 save = cp_parser_begin_omp_structured_block (parser);
39445 ret = cp_parser_omp_for_loop (parser, OMP_LOOP, clauses, cclauses, if_p);
39447 cp_parser_end_omp_structured_block (parser, save);
39471 cp_parser_omp_simd (cp_parser *parser, cp_token *pragma_tok,
39477 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39482 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
39501 save = cp_parser_begin_omp_structured_block (parser);
39503 ret = cp_parser_omp_for_loop (parser, OMP_SIMD, clauses, cclauses, if_p);
39505 cp_parser_end_omp_structured_block (parser, save);
39532 cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok,
39538 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39550 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39552 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39561 cp_lexer_consume_token (parser->lexer);
39563 return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
39566 save = cp_parser_begin_omp_structured_block (parser);
39567 ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
39569 cp_parser_end_omp_structured_block (parser, save);
39584 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39592 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
39602 save = cp_parser_begin_omp_structured_block (parser);
39604 ret = cp_parser_omp_for_loop (parser, OMP_FOR, clauses, cclauses, if_p);
39606 cp_parser_end_omp_structured_block (parser, save);
39620 cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok,
39626 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39630 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39632 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39641 cp_lexer_consume_token (parser->lexer);
39643 return cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask,
39646 save = cp_parser_begin_omp_structured_block (parser);
39647 ret = cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask,
39649 cp_parser_end_omp_structured_block (parser, save);
39658 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39664 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
39669 cp_parser_require_pragma_eol (parser, pragma_tok);
39672 cp_parser_omp_structured_block (parser, if_p));
39691 cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok,
39696 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39698 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39705 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39713 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39717 = cp_parser_omp_all_clauses (parser,
39726 = cp_parser_omp_all_clauses (parser, OMP_ORDERED_CLAUSE_MASK,
39734 cp_parser_omp_structured_block (parser, if_p));
39748 cp_parser_omp_sections_scope (cp_parser *parser)
39755 if (!braces.require_open (parser))
39760 if (cp_parser_pragma_kind (cp_lexer_peek_token (parser->lexer))
39763 substmt = cp_parser_omp_structured_block (parser, NULL);
39770 tok = cp_lexer_peek_token (parser->lexer);
39778 cp_lexer_consume_token (parser->lexer);
39779 cp_parser_require_pragma_eol (parser, tok);
39784 cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>");
39788 substmt = cp_parser_omp_structured_block (parser, NULL);
39792 braces.require_close (parser);
39816 cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok,
39820 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39827 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
39835 ret = cp_parser_omp_sections_scope (parser);
39866 cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok,
39872 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
39881 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR))
39887 cp_lexer_consume_token (parser->lexer);
39889 return cp_parser_omp_for (parser, pragma_tok, p_name, mask, cclauses,
39892 save = cp_parser_begin_omp_structured_block (parser);
39893 tree ret = cp_parser_omp_for (parser, pragma_tok, p_name, mask, cclauses,
39895 cp_parser_end_omp_structured_block (parser, save);
39910 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39913 else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
39915 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
39922 cp_lexer_consume_token (parser->lexer);
39924 return cp_parser_omp_master (parser, pragma_tok, p_name, mask,
39927 save = cp_parser_begin_omp_structured_block (parser);
39928 tree ret = cp_parser_omp_master (parser, pragma_tok, p_name, mask,
39930 cp_parser_end_omp_structured_block (parser, save);
39944 cp_lexer_consume_token (parser->lexer);
39946 return cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
39949 save = cp_parser_begin_omp_structured_block (parser);
39950 tree ret = cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
39952 cp_parser_end_omp_structured_block (parser, save);
39962 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39970 cp_lexer_consume_token (parser->lexer);
39972 save = cp_parser_begin_omp_structured_block (parser);
39973 cp_parser_omp_sections (parser, pragma_tok, p_name, mask, cclauses);
39974 cp_parser_end_omp_structured_block (parser, save);
39983 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
39987 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
39996 save = cp_parser_begin_omp_structured_block (parser);
39997 cp_parser_statement (parser, NULL_TREE, false, if_p);
39998 cp_parser_end_omp_structured_block (parser, save);
40014 cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
40021 = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
40023 OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
40046 cp_parser_omp_task (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
40051 clauses = cp_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
40054 save = cp_parser_begin_omp_structured_block (parser);
40055 cp_parser_statement (parser, NULL_TREE, false, if_p);
40056 cp_parser_end_omp_structured_block (parser, save);
40070 cp_parser_omp_taskwait (cp_parser *parser, cp_token *pragma_tok)
40073 = cp_parser_omp_all_clauses (parser, OMP_TASKWAIT_CLAUSE_MASK,
40093 cp_parser_omp_taskyield (cp_parser *parser, cp_token *pragma_tok)
40095 cp_parser_require_pragma_eol (parser, pragma_tok);
40110 cp_parser_omp_taskgroup (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
40113 = cp_parser_omp_all_clauses (parser, OMP_TASKGROUP_CLAUSE_MASK,
40116 cp_parser_omp_structured_block (parser,
40126 cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok)
40130 vars = cp_parser_omp_var_list (parser, OMP_CLAUSE_ERROR, NULL);
40131 cp_parser_require_pragma_eol (parser, pragma_tok);
40147 cp_parser_omp_cancel (cp_parser *parser, cp_token *pragma_tok)
40149 tree clauses = cp_parser_omp_all_clauses (parser, OMP_CANCEL_CLAUSE_MASK,
40164 cp_parser_omp_cancellation_point (cp_parser *parser, cp_token *pragma_tok,
40170 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40172 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40177 cp_lexer_consume_token (parser->lexer);
40183 cp_parser_error (parser, "expected %<point%>");
40184 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40195 cp_parser_error (parser, "expected declaration specifiers");
40196 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40200 clauses = cp_parser_omp_all_clauses (parser,
40219 cp_parser_omp_distribute (cp_parser *parser, cp_token *pragma_tok,
40225 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
40230 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40232 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40246 cp_lexer_consume_token (parser->lexer);
40250 return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
40253 return cp_parser_omp_parallel (parser, pragma_tok, p_name, mask,
40257 save = cp_parser_begin_omp_structured_block (parser);
40259 ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
40262 ret = cp_parser_omp_parallel (parser, pragma_tok, p_name, mask,
40264 cp_parser_end_omp_structured_block (parser, save);
40279 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40283 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
40293 save = cp_parser_begin_omp_structured_block (parser);
40295 ret = cp_parser_omp_for_loop (parser, OMP_DISTRIBUTE, clauses, NULL, if_p);
40297 cp_parser_end_omp_structured_block (parser, save);
40317 cp_parser_omp_teams (cp_parser *parser, cp_token *pragma_tok,
40323 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
40328 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40330 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40338 cp_lexer_consume_token (parser->lexer);
40340 return cp_parser_omp_distribute (parser, pragma_tok, p_name, mask,
40344 save = cp_parser_begin_omp_structured_block (parser);
40345 ret = cp_parser_omp_distribute (parser, pragma_tok, p_name, mask,
40347 cp_parser_end_omp_structured_block (parser, save);
40366 cp_lexer_consume_token (parser->lexer);
40368 return cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
40372 save = cp_parser_begin_omp_structured_block (parser);
40373 ret = cp_parser_omp_loop (parser, pragma_tok, p_name, mask,
40375 cp_parser_end_omp_structured_block (parser, save);
40391 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40395 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
40407 OMP_TEAMS_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
40425 cp_parser_omp_target_data (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
40428 = cp_parser_omp_all_clauses (parser, OMP_TARGET_DATA_CLAUSE_MASK,
40479 OMP_TARGET_DATA_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
40497 cp_parser_omp_target_enter_data (cp_parser *parser, cp_token *pragma_tok,
40501 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40503 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40508 cp_lexer_consume_token (parser->lexer);
40514 cp_parser_error (parser, "expected %<data%>");
40515 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40524 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40529 = cp_parser_omp_all_clauses (parser, OMP_TARGET_ENTER_DATA_CLAUSE_MASK,
40585 cp_parser_omp_target_exit_data (cp_parser *parser, cp_token *pragma_tok,
40589 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40591 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40596 cp_lexer_consume_token (parser->lexer);
40602 cp_parser_error (parser, "expected %<data%>");
40603 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40612 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40617 = cp_parser_omp_all_clauses (parser, OMP_TARGET_EXIT_DATA_CLAUSE_MASK,
40675 cp_parser_omp_target_update (cp_parser *parser, cp_token *pragma_tok,
40683 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40688 = cp_parser_omp_all_clauses (parser, OMP_TARGET_UPDATE_CLAUSE_MASK,
40723 cp_parser_omp_target (cp_parser *parser, cp_token *pragma_tok,
40732 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
40734 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
40750 cp_lexer_consume_token (parser->lexer);
40758 stmt = cp_parser_omp_teams (parser, pragma_tok, p_name,
40763 stmt = cp_parser_omp_parallel (parser, pragma_tok, p_name,
40768 stmt = cp_parser_omp_simd (parser, pragma_tok, p_name,
40779 unsigned save = cp_parser_begin_omp_structured_block (parser);
40783 ret = cp_parser_omp_teams (parser, pragma_tok, p_name,
40788 ret = cp_parser_omp_parallel (parser, pragma_tok, p_name,
40793 ret = cp_parser_omp_simd (parser, pragma_tok, p_name,
40800 cp_parser_end_omp_structured_block (parser, save);
40843 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40848 cp_lexer_consume_token (parser->lexer);
40849 cp_parser_omp_target_data (parser, pragma_tok, if_p);
40854 cp_lexer_consume_token (parser->lexer);
40855 cp_parser_omp_target_enter_data (parser, pragma_tok, context);
40860 cp_lexer_consume_token (parser->lexer);
40861 cp_parser_omp_target_exit_data (parser, pragma_tok, context);
40866 cp_lexer_consume_token (parser->lexer);
40867 return cp_parser_omp_target_update (parser, pragma_tok, context);
40872 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
40880 = cp_parser_omp_all_clauses (parser, OMP_TARGET_CLAUSE_MASK,
40884 OMP_TARGET_BODY (stmt) = cp_parser_omp_structured_block (parser, if_p);
40924 cp_parser_oacc_cache (cp_parser *parser, cp_token *pragma_tok)
40932 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE__CACHE_, NULL_TREE);
40935 cp_parser_require_pragma_eol (parser, cp_lexer_peek_token (parser->lexer));
40963 cp_parser_oacc_data (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
40968 clauses = cp_parser_oacc_all_clauses (parser, OACC_DATA_CLAUSE_MASK,
40972 save = cp_parser_begin_omp_structured_block (parser);
40973 cp_parser_statement (parser, NULL_TREE, false, if_p);
40974 cp_parser_end_omp_structured_block (parser, save);
40989 cp_parser_oacc_host_data (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
40994 clauses = cp_parser_oacc_all_clauses (parser, OACC_HOST_DATA_CLAUSE_MASK,
40998 save = cp_parser_begin_omp_structured_block (parser);
40999 cp_parser_statement (parser, NULL_TREE, false, if_p);
41000 cp_parser_end_omp_structured_block (parser, save);
41020 cp_parser_oacc_declare (cp_parser *parser, cp_token *pragma_tok)
41026 clauses = cp_parser_oacc_all_clauses (parser, OACC_DECLARE_CLAUSE_MASK,
41192 cp_parser_oacc_enter_exit_data (cp_parser *parser, cp_token *pragma_tok,
41199 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41200 p = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
41206 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
41210 cp_lexer_consume_token (parser->lexer);
41213 clauses = cp_parser_oacc_all_clauses (parser, OACC_ENTER_DATA_CLAUSE_MASK,
41216 clauses = cp_parser_oacc_all_clauses (parser, OACC_EXIT_DATA_CLAUSE_MASK,
41251 cp_parser_oacc_loop (cp_parser *parser, cp_token *pragma_tok, char *p_name,
41259 tree clauses = cp_parser_oacc_all_clauses (parser, mask, p_name, pragma_tok,
41271 int save = cp_parser_begin_omp_structured_block (parser);
41272 tree stmt = cp_parser_omp_for_loop (parser, OACC_LOOP, clauses, NULL, if_p);
41273 cp_parser_end_omp_structured_block (parser, save);
41348 cp_parser_oacc_compute (cp_parser *parser, cp_token *pragma_tok,
41374 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41377 = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
41380 cp_lexer_consume_token (parser->lexer);
41383 tree stmt = cp_parser_oacc_loop (parser, pragma_tok, p_name, mask,
41390 tree clauses = cp_parser_oacc_all_clauses (parser, mask, p_name, pragma_tok);
41393 unsigned int save = cp_parser_begin_omp_structured_block (parser);
41394 cp_parser_statement (parser, NULL_TREE, false, if_p);
41395 cp_parser_end_omp_structured_block (parser, save);
41412 cp_parser_oacc_update (cp_parser *parser, cp_token *pragma_tok)
41416 clauses = cp_parser_oacc_all_clauses (parser, OACC_UPDATE_CLAUSE_MASK,
41445 cp_parser_oacc_wait (cp_parser *parser, cp_token *pragma_tok)
41448 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
41450 if (cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
41451 list = cp_parser_oacc_wait_list (parser, loc, list);
41453 clauses = cp_parser_oacc_all_clauses (parser, OACC_WAIT_CLAUSE_MASK,
41474 cp_parser_omp_declare_simd (cp_parser *parser, cp_token *pragma_tok,
41478 bool first_p = parser->omp_declare_simd == NULL;
41489 parser->omp_declare_simd = &data;
41491 else if (parser->omp_declare_simd->variant_p != variant_p)
41496 parser->omp_declare_simd->variant_p ? "variant" : "simd",
41497 parser->omp_declare_simd->variant_p ? "simd" : "variant");
41498 parser->omp_declare_simd->error_seen = true;
41502 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)
41503 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
41504 cp_lexer_consume_token (parser->lexer);
41505 if (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
41506 parser->omp_declare_simd->error_seen = true;
41507 cp_parser_require_pragma_eol (parser, pragma_tok);
41509 = cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
41510 parser->omp_declare_simd->tokens.safe_push (cp);
41514 while (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
41515 cp_parser_pragma (parser, context, NULL);
41519 cp_parser_declaration (parser);
41522 cp_parser_member_declaration (parser);
41525 cp_parser_block_declaration (parser, /*statement_p=*/false);
41528 cp_parser_declaration_statement (parser);
41531 if (parser->omp_declare_simd
41532 && !parser->omp_declare_simd->error_seen
41533 && !parser->omp_declare_simd->fndecl_seen)
41537 parser->omp_declare_simd->variant_p ? "variant" : "simd");
41539 parser->omp_declare_simd = NULL;
41562 cp_parser_omp_context_selector (cp_parser *parser, tree set, bool has_parms_p)
41568 if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
41569 || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41570 selector = cp_lexer_peek_token (parser->lexer)->u.value;
41573 cp_parser_error (parser, "expected trait selector name");
41628 cp_lexer_consume_token (parser->lexer);
41643 cp_lexer_consume_token (parser->lexer);
41645 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
41655 parens.consume_open (parser);
41657 cp_token *token = cp_lexer_peek_token (parser->lexer);
41659 && cp_lexer_next_token_is (parser->lexer, CPP_NAME)
41661 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_PAREN))
41663 cp_lexer_save_tokens (parser->lexer);
41664 cp_lexer_consume_token (parser->lexer);
41665 cp_lexer_consume_token (parser->lexer);
41666 if (cp_parser_skip_to_closing_parenthesis (parser, false, false,
41668 && cp_lexer_next_token_is (parser->lexer, CPP_COLON))
41670 cp_lexer_rollback_tokens (parser->lexer);
41671 cp_lexer_consume_token (parser->lexer);
41674 parens2.require_open (parser);
41675 tree score = cp_parser_constant_expression (parser);
41676 if (!parens2.require_close (parser))
41677 cp_parser_skip_to_closing_parenthesis (parser, true,
41679 cp_parser_require (parser, CPP_COLON, RT_COLON);
41699 cp_lexer_rollback_tokens (parser->lexer);
41701 token = cp_lexer_peek_token (parser->lexer);
41710 t = cp_parser_constant_expression (parser);
41728 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41729 cp_lexer_consume_token (parser->lexer);
41736 if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
41737 || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41739 tree prop = cp_lexer_peek_token (parser->lexer)->u.value;
41740 cp_lexer_consume_token (parser->lexer);
41745 cp_parser_error (parser, "expected identifier");
41753 if (cp_lexer_next_token_is (parser->lexer, CPP_KEYWORD)
41754 || cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41756 prop = cp_lexer_peek_token (parser->lexer)->u.value;
41757 cp_lexer_consume_token (parser->lexer);
41759 else if (cp_lexer_next_token_is (parser->lexer, CPP_STRING))
41760 value = cp_parser_string_literal (parser, false, false);
41763 cp_parser_error (parser, "expected identifier or "
41770 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41771 cp_lexer_consume_token (parser->lexer);
41778 t = cp_parser_constant_expression (parser);
41802 = cp_parser_omp_all_clauses (parser,
41810 if (!parens.require_close (parser))
41811 cp_parser_skip_to_closing_parenthesis (parser, true, false, true);
41819 cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN);
41825 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41826 cp_lexer_consume_token (parser->lexer);
41849 cp_parser_omp_context_selector_specification (cp_parser *parser,
41856 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41858 = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
41882 cp_parser_error (parser, "expected %<construct%>, %<device%>, "
41887 tree set = cp_lexer_peek_token (parser->lexer)->u.value;
41888 cp_lexer_consume_token (parser->lexer);
41890 if (!cp_parser_require (parser, CPP_EQ, RT_EQ))
41894 if (!braces.require_open (parser))
41898 = cp_parser_omp_context_selector (parser, set, has_parms_p);
41901 cp_parser_skip_to_closing_brace (parser);
41907 braces.require_close (parser);
41909 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
41910 cp_lexer_consume_token (parser->lexer);
41925 cp_finish_omp_declare_variant (cp_parser *parser, cp_token *pragma_tok,
41929 if (!parens.require_open (parser))
41932 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
41938 cp_token *varid_token = cp_lexer_peek_token (parser->lexer);
41940 = cp_parser_id_expression (parser, /*template_keyword_p=*/false,
41945 parens.require_close (parser);
41957 variant = cp_parser_lookup_name (parser, varid, none_type,
41971 = finish_id_expression (varid, variant, parser->scope,
41973 &parser->non_integral_constant_expression_p,
41977 cp_parser_error (parser, error_msg);
41985 location_t match_loc = cp_lexer_peek_token (parser->lexer)->location;
41986 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
41987 clause = IDENTIFIER_POINTER (cp_lexer_peek_token (parser->lexer)->u.value);
41990 cp_parser_error (parser, "expected %<match%>");
41994 cp_lexer_consume_token (parser->lexer);
41996 if (!parens.require_open (parser))
41999 tree ctx = cp_parser_omp_context_selector_specification (parser, true);
42017 parens.require_close (parser);
42018 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42027 cp_parser_late_parsing_omp_declare_simd (cp_parser *parser, tree attrs)
42030 cp_omp_declare_simd_data *data = parser->omp_declare_simd;
42047 cp_parser_push_lexer_for_tokens (parser, ce);
42048 parser->lexer->in_pragma = true;
42049 gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
42050 cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
42051 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42053 cp_lexer_consume_token (parser->lexer);
42056 cl = cp_parser_omp_all_clauses (parser, OMP_DECLARE_SIMD_CLAUSE_MASK,
42070 attrs = cp_finish_omp_declare_variant (parser, pragma_tok, attrs);
42072 cp_parser_pop_lexer (parser);
42096 cp_parser_omp_declare_target (cp_parser *parser, cp_token *pragma_tok)
42101 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42103 = cp_parser_omp_all_clauses (parser, OMP_DECLARE_TARGET_CLAUSE_MASK,
42105 else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
42107 clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_TO_DECLARE,
42110 cp_parser_require_pragma_eol (parser, pragma_tok);
42114 cp_parser_require_pragma_eol (parser, pragma_tok);
42193 cp_parser_omp_end_declare_target (cp_parser *parser, cp_token *pragma_tok)
42196 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42198 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42203 cp_lexer_consume_token (parser->lexer);
42205 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42207 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42211 cp_lexer_consume_token (parser->lexer);
42214 cp_parser_error (parser, "expected %<target%>");
42215 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42221 cp_parser_error (parser, "expected %<declare%>");
42222 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42225 cp_parser_require_pragma_eol (parser, pragma_tok);
42252 cp_parser_omp_declare_reduction_exprs (tree fndecl, cp_parser *parser)
42270 combiner = cp_parser_expression (parser);
42277 if (!cp_parser_require (parser, CPP_CLOSE_PAREN, RT_CLOSE_PAREN))
42281 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42283 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42289 cp_lexer_consume_token (parser->lexer);
42291 if (!parens.require_open (parser))
42295 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42297 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42318 cp_lexer_consume_token (parser->lexer);
42320 if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)
42321 || (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
42322 && cp_lexer_peek_nth_token (parser->lexer, 2)->type
42324 && cp_lexer_peek_nth_token (parser->lexer, 3)->type
42331 initializer = cp_parser_initializer (parser, &is_direct_init,
42338 cp_parser_parse_tentatively (parser);
42341 tree fn_name = cp_parser_id_expression (parser, /*template_p=*/false,
42348 || cp_parser_error_occurred (parser)
42349 || !cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
42351 (parser, non_attr, /*cast_p=*/false,
42354 cp_parser_error_occurred (parser)))
42357 cp_parser_abort_tentative_parse (parser);
42358 cp_parser_error (parser, "expected id-expression (arguments)");
42368 cp_parser_abort_tentative_parse (parser);
42372 initializer = cp_parser_postfix_expression (parser, false, false, false,
42386 if (!parens.require_close (parser))
42390 if (!cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL))
42391 cp_parser_required_error (parser, RT_PRAGMA_EOL, /*keyword=*/false,
42406 cp_parser_omp_declare_reduction (cp_parser *parser, cp_token *pragma_tok,
42421 if (!cp_parser_require (parser, CPP_OPEN_PAREN, RT_OPEN_PAREN))
42424 switch (cp_lexer_peek_token (parser->lexer)->type)
42451 reduc_id = orig_reduc_id = cp_parser_identifier (parser);
42454 cp_parser_error (parser, "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, "
42460 cp_lexer_consume_token (parser->lexer);
42466 if (!cp_parser_require (parser, CPP_COLON, RT_COLON))
42471 saved_message = parser->type_definition_forbidden_message;
42472 parser->type_definition_forbidden_message
42475 saved_colon_corrects_to_scope_p = parser->colon_corrects_to_scope_p;
42476 parser->colon_corrects_to_scope_p = false;
42479 = parser->colon_doesnt_start_class_def_p;
42480 parser->colon_doesnt_start_class_def_p = true;
42484 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
42485 type = cp_parser_type_id (parser);
42508 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
42509 cp_lexer_consume_token (parser->lexer);
42515 parser->type_definition_forbidden_message = saved_message;
42516 parser->colon_corrects_to_scope_p = saved_colon_corrects_to_scope_p;
42517 parser->colon_doesnt_start_class_def_p
42520 if (!cp_parser_require (parser, CPP_COLON, RT_COLON)
42524 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42528 first_token = cp_lexer_peek_token (parser->lexer);
42566 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)
42567 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
42568 cp_lexer_consume_token (parser->lexer);
42569 if (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
42572 cp_lexer_peek_nth_token (parser->lexer,
42593 cp_parser_push_lexer_for_tokens (parser, cp);
42594 parser->lexer->in_pragma = true;
42596 if (!cp_parser_omp_declare_reduction_exprs (fndecl, parser))
42603 cp_parser_pop_lexer (parser);
42607 cp_parser_pop_lexer (parser);
42624 cp_lexer_peek_nth_token (parser->lexer, 2));
42629 cp_parser_require_pragma_eol (parser, pragma_tok);
42646 cp_parser_omp_declare (cp_parser *parser, cp_token *pragma_tok,
42649 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42651 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42656 cp_lexer_consume_token (parser->lexer);
42657 cp_parser_omp_declare_simd (parser, pragma_tok,
42663 cp_lexer_consume_token (parser->lexer);
42664 cp_parser_omp_declare_simd (parser, pragma_tok,
42668 cp_ensure_no_omp_declare_simd (parser);
42671 cp_lexer_consume_token (parser->lexer);
42672 cp_parser_omp_declare_reduction (parser, pragma_tok,
42678 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42683 cp_lexer_consume_token (parser->lexer);
42684 cp_parser_omp_declare_target (parser, pragma_tok);
42688 cp_parser_error (parser, "expected %<simd%>, %<reduction%>, "
42690 cp_parser_require_pragma_eol (parser, pragma_tok);
42698 cp_parser_omp_requires (cp_parser *parser, cp_token *pragma_tok)
42704 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
42706 if (!first && cp_lexer_next_token_is (parser->lexer, CPP_COMMA))
42707 cp_lexer_consume_token (parser->lexer);
42711 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42713 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42715 location_t cloc = cp_lexer_peek_token (parser->lexer)->location;
42728 cp_lexer_consume_token (parser->lexer);
42731 if (parens.require_open (parser))
42733 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42735 id = cp_lexer_peek_token (parser->lexer)->u.value;
42750 error_at (cp_lexer_peek_token (parser->lexer)->location,
42753 if (cp_lexer_nth_token_is (parser->lexer, 2,
42755 cp_lexer_consume_token (parser->lexer);
42758 cp_lexer_consume_token (parser->lexer);
42760 if (!parens.require_close (parser))
42761 cp_parser_skip_to_closing_parenthesis (parser,
42769 cp_parser_require_pragma_eol (parser, pragma_tok);
42782 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42789 cp_lexer_consume_token (parser->lexer);
42830 cp_parser_require_pragma_eol (parser, pragma_tok);
42864 cp_parser_omp_taskloop (cp_parser *parser, cp_token *pragma_tok,
42870 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
42879 if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
42881 tree id = cp_lexer_peek_token (parser->lexer)->u.value;
42890 cp_lexer_consume_token (parser->lexer);
42892 return cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
42895 save = cp_parser_begin_omp_structured_block (parser);
42896 ret = cp_parser_omp_simd (parser, pragma_tok, p_name, mask,
42898 cp_parser_end_omp_structured_block (parser, save);
42913 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
42917 clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
42927 save = cp_parser_begin_omp_structured_block (parser);
42929 ret = cp_parser_omp_for_loop (parser, OMP_TASKLOOP, clauses, cclauses,
42932 cp_parser_end_omp_structured_block (parser, save);
42960 cp_parser_oacc_routine (cp_parser *parser, cp_token *pragma_tok,
42966 gcc_checking_assert (parser->oacc_routine == NULL);
42976 parser->oacc_routine = &data;
42979 if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
42982 parens.consume_open (parser); /* '(' */
42987 location_t name_loc = cp_lexer_peek_token (parser->lexer)->location;
42988 tree name = cp_parser_id_expression (parser,
42995 ? cp_parser_lookup_name_simple (parser, name, name_loc)
42998 cp_parser_name_lookup_error (parser, name, decl, NLE_NULL, name_loc);
43001 || !parens.require_close (parser))
43003 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
43004 parser->oacc_routine = NULL;
43009 = cp_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
43011 cp_lexer_peek_token (parser->lexer));
43022 parser->oacc_routine = NULL;
43032 parser->oacc_routine = NULL;
43039 parser->oacc_routine = NULL;
43043 cp_finalize_oacc_routine (parser, decl, false);
43044 parser->oacc_routine = NULL;
43049 while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)
43050 && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))
43051 cp_lexer_consume_token (parser->lexer);
43052 if (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL))
43053 parser->oacc_routine->error_seen = true;
43054 cp_parser_require_pragma_eol (parser, pragma_tok);
43056 = cp_token_cache_new (pragma_tok, cp_lexer_peek_token (parser->lexer));
43057 parser->oacc_routine->tokens.safe_push (cp);
43061 if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA))
43063 cp_ensure_no_oacc_routine (parser);
43070 cp_parser_declaration (parser);
43071 if (parser->oacc_routine
43072 && !parser->oacc_routine->fndecl_seen)
43073 cp_ensure_no_oacc_routine (parser);
43075 parser->oacc_routine = NULL;
43084 cp_parser_late_parsing_oacc_routine (cp_parser *parser, tree attrs)
43087 cp_oacc_routine_data *data = parser->oacc_routine;
43102 cp_parser_push_lexer_for_tokens (parser, ce);
43103 parser->lexer->in_pragma = true;
43104 gcc_assert (cp_lexer_peek_token (parser->lexer)->type == CPP_PRAGMA);
43106 cp_token *pragma_tok = cp_lexer_consume_token (parser->lexer);
43107 gcc_checking_assert (parser->oacc_routine->clauses == NULL_TREE);
43108 parser->oacc_routine->clauses
43109 = cp_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
43113 parser->oacc_routine->clauses = nreverse (parser->oacc_routine->clauses);
43114 cp_parser_pop_lexer (parser);
43125 cp_finalize_oacc_routine (cp_parser *parser, tree fndecl, bool is_defn)
43127 if (__builtin_expect (parser->oacc_routine != NULL, 0))
43130 if (parser->oacc_routine->error_seen
43134 if (parser->oacc_routine->fndecl_seen)
43136 error_at (parser->oacc_routine->loc,
43139 parser->oacc_routine = NULL;
43144 cp_ensure_no_oacc_routine (parser);
43149 = oacc_verify_routine_clauses (fndecl, &parser->oacc_routine->clauses,
43150 parser->oacc_routine->loc,
43154 parser->oacc_routine = NULL;
43164 error_at (parser->oacc_routine->loc,
43170 parser->oacc_routine = NULL;
43175 tree dims = oacc_build_routine_dims (parser->oacc_routine->clauses);
43181 parser->oacc_routine->clauses,
43185 /* Don't unset parser->oacc_routine here: we may still need it to
43188 parser->oacc_routine->fndecl_seen = true;
43195 cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok, bool *if_p)
43204 cp_parser_omp_atomic (parser, pragma_tok);
43207 stmt = cp_parser_oacc_cache (parser, pragma_tok);
43210 stmt = cp_parser_oacc_data (parser, pragma_tok, if_p);
43213 stmt = cp_parser_oacc_enter_exit_data (parser, pragma_tok, true);
43216 stmt = cp_parser_oacc_enter_exit_data (parser, pragma_tok, false);
43219 stmt = cp_parser_oacc_host_data (parser, pragma_tok, if_p);
43225 stmt = cp_parser_oacc_compute (parser, pragma_tok, p_name, if_p);
43229 stmt = cp_parser_oacc_loop (parser, pragma_tok, p_name, mask, NULL,
43233 stmt = cp_parser_oacc_update (parser, pragma_tok);
43236 stmt = cp_parser_oacc_wait (parser, pragma_tok);
43239 cp_parser_omp_atomic (parser, pragma_tok);
43242 stmt = cp_parser_omp_critical (parser, pragma_tok, if_p);
43246 stmt = cp_parser_omp_distribute (parser, pragma_tok, p_name, mask, NULL,
43251 stmt = cp_parser_omp_for (parser, pragma_tok, p_name, mask, NULL,
43256 stmt = cp_parser_omp_loop (parser, pragma_tok, p_name, mask, NULL,
43261 stmt = cp_parser_omp_master (parser, pragma_tok, p_name, mask, NULL,
43266 stmt = cp_parser_omp_parallel (parser, pragma_tok, p_name, mask, NULL,
43271 stmt = cp_parser_omp_sections (parser, pragma_tok, p_name, mask, NULL);
43275 stmt = cp_parser_omp_simd (parser, pragma_tok, p_name, mask, NULL,
43279 stmt = cp_parser_omp_single (parser, pragma_tok, if_p);
43282 stmt = cp_parser_omp_task (parser, pragma_tok, if_p);
43285 stmt = cp_parser_omp_taskgroup (parser, pragma_tok, if_p);
43289 stmt = cp_parser_omp_taskloop (parser, pragma_tok, p_name, mask, NULL,
43294 stmt = cp_parser_omp_teams (parser, pragma_tok, p_name, mask, NULL,
43317 cp_parser_txn_attribute_opt (cp_parser *parser)
43322 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE))
43323 return cp_parser_attributes_opt (parser);
43325 if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE))
43327 cp_lexer_consume_token (parser->lexer);
43328 if (!cp_parser_require (parser, CPP_OPEN_SQUARE, RT_OPEN_SQUARE))
43331 token = cp_lexer_peek_token (parser->lexer);
43334 token = cp_lexer_consume_token (parser->lexer);
43344 cp_parser_error (parser, "expected identifier");
43346 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
43348 cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE);
43361 cp_parser_transaction (cp_parser *parser, cp_token *token)
43363 unsigned char old_in = parser->in_transaction;
43368 cp_lexer_consume_token (parser->lexer);
43375 attrs = cp_parser_txn_attribute_opt (parser);
43390 noex = cp_parser_noexcept_specification_opt (parser,
43402 parser->in_transaction = new_in;
43403 cp_parser_compound_statement (parser, NULL, BCS_TRANSACTION, false);
43404 parser->in_transaction = old_in;
43419 cp_parser_transaction_expression (cp_parser *parser, enum rid keyword)
43421 unsigned char old_in = parser->in_transaction;
43426 location_t loc = cp_lexer_peek_token (parser->lexer)->location;
43439 token = cp_parser_require_keyword (parser, keyword,
43452 parser->in_transaction = this_in;
43455 noex = cp_parser_noexcept_specification_opt (parser,
43463 || cp_lexer_peek_token (parser->lexer)->type == CPP_OPEN_PAREN)
43466 parens.require_open (parser);
43468 expr = cp_parser_expression (parser);
43471 parens.require_close (parser);
43482 parser->in_transaction = old_in;
43484 if (cp_parser_non_integral_constant_expression (parser, NIC_TRANSACTION))
43501 cp_parser_function_transaction (cp_parser *parser, enum rid keyword)
43503 unsigned char old_in = parser->in_transaction;
43510 token = cp_parser_require_keyword (parser, keyword,
43519 attrs = cp_parser_txn_attribute_opt (parser);
43526 parser->in_transaction = new_in;
43528 if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY))
43529 cp_parser_function_try_block (parser);
43532 (parser, /*in_function_try_block=*/false);
43534 parser->in_transaction = old_in;
43548 cp_parser_transaction_cancel (cp_parser *parser)
43554 token = cp_parser_require_keyword (parser, RID_TRANSACTION_CANCEL,
43558 attrs = cp_parser_txn_attribute_opt (parser);
43564 cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON);
43572 else if (parser->in_transaction & TM_STMT_ATTR_RELAXED)
43580 if ((parser->in_transaction & TM_STMT_ATTR_OUTER) == 0
43590 else if (parser->in_transaction == 0)
43604 /* The parser. */
43661 cp_parser_pragma_ivdep (cp_parser *parser, cp_token *pragma_tok)
43663 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
43670 cp_parser_pragma_unroll (cp_parser *parser, cp_token *pragma_tok)
43672 location_t location = cp_lexer_peek_token (parser->lexer)->location;
43673 tree expr = cp_parser_constant_expression (parser);
43693 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
43701 cp_parser_pragma (cp_parser *parser, enum pragma_context context, bool *if_p)
43708 pragma_tok = cp_lexer_consume_token (parser->lexer);
43710 parser->lexer->in_pragma = true;
43714 cp_ensure_no_omp_declare_simd (parser);
43726 cp_parser_omp_barrier (parser, pragma_tok);
43741 cp_parser_omp_depobj (parser, pragma_tok);
43756 cp_parser_omp_flush (parser, pragma_tok);
43771 cp_parser_omp_taskwait (parser, pragma_tok);
43787 cp_parser_omp_taskyield (parser, pragma_tok);
43803 cp_parser_omp_cancel (parser, pragma_tok);
43816 cp_parser_omp_cancellation_point (parser, pragma_tok, context);
43820 cp_parser_omp_threadprivate (parser, pragma_tok);
43824 return cp_parser_omp_declare (parser, pragma_tok, context);
43827 cp_parser_oacc_declare (parser, pragma_tok);
43840 cp_parser_omp_construct (parser, pragma_tok, if_p);
43853 cp_parser_omp_construct (parser, pragma_tok, if_p);
43863 cp_parser_oacc_routine (parser, pragma_tok, context);
43876 cp_parser_omp_construct (parser, pragma_tok, if_p);
43889 cp_parser_omp_construct (parser, pragma_tok, if_p);
43917 cp_parser_omp_construct (parser, pragma_tok, if_p);
43929 return cp_parser_omp_requires (parser, pragma_tok);
43935 ret = cp_parser_omp_ordered (parser, pragma_tok, context, if_p);
43943 ret = cp_parser_omp_target (parser, pragma_tok, context, if_p);
43948 cp_parser_omp_end_declare_target (parser, pragma_tok);
43971 const bool ivdep = cp_parser_pragma_ivdep (parser, pragma_tok);
43977 tok = cp_lexer_consume_token (parser->lexer);
43978 unroll = cp_parser_pragma_unroll (parser, tok);
43988 cp_parser_error (parser, "for, while or do statement expected");
43991 cp_parser_iteration_statement (parser, if_p, ivdep, unroll);
44004 = cp_parser_pragma_unroll (parser, pragma_tok);
44010 tok = cp_lexer_consume_token (parser->lexer);
44011 ivdep = cp_parser_pragma_ivdep (parser, tok);
44021 cp_parser_error (parser, "for, while or do statement expected");
44024 cp_parser_iteration_statement (parser, if_p, ivdep, unroll);
44034 cp_parser_error (parser, "expected declaration specifiers");
44038 cp_parser_skip_to_pragma_eol (parser, pragma_tok);
44112 synthesize_implicit_template_parm (cp_parser *parser, tree constr)
44133 if (parser->implicit_template_scope)
44135 gcc_assert (parser->implicit_template_parms);
44137 current_binding_level = parser->implicit_template_scope;
44195 || !function_being_declared_is_template_p (parser))
44202 parser->implicit_template_scope
44207 parser->fully_implicit_function_template_p = true;
44208 ++parser->num_template_parameter_lists;
44217 parser->implicit_template_scope = scope;
44220 parser->implicit_template_parms
44241 = process_template_parm (parser->implicit_template_parms,
44255 if (parser->implicit_template_parms)
44256 parser->implicit_template_parms
44257 = TREE_CHAIN (parser->implicit_template_parms);
44259 parser->implicit_template_parms = new_parm;
44275 TREE_VEC_ELT (new_parms, 0) = parser->implicit_template_parms;
44284 TREE_VEC_ELT (new_parms, new_parm_idx) = parser->implicit_template_parms;
44310 finish_fully_implicit_template (cp_parser *parser, tree member_decl_opt)
44312 gcc_assert (parser->fully_implicit_function_template_p);
44326 parser->fully_implicit_function_template_p = false;
44327 parser->implicit_template_parms = 0;
44328 parser->implicit_template_scope = 0;
44329 --parser->num_template_parameter_lists;
44340 abort_fully_implicit_template (cp_parser *parser)
44344 if (parser->implicit_template_scope
44345 && return_to_scope != parser->implicit_template_scope)
44349 scope != parser->implicit_template_scope;
44352 child->level_chain = parser->implicit_template_scope->level_chain;
44353 parser->implicit_template_scope->level_chain = return_to_scope;
44354 current_binding_level = parser->implicit_template_scope;
44359 finish_fully_implicit_template (parser, NULL);
44377 #include "gt-cp-parser.h"