Lines Matching refs:parser
4 Parser actions based on the old Bison parser; structure somewhat
5 influenced by and fragments based on the C++ parser.
26 actions, brought over from old parser. Verify exact correspondence
64 #include "c-parser.h"
65 #include "gimple-parser.h"
170 /* A parser structure recording information about the state and
197 initial #pragma pch_preprocess). Otherwise the parser is
201 /* True if, when the parser is concatenating string literals, it
206 /* Objective-C specific parser/lexer information. */
235 c_parser_tokens_buf (c_parser *parser, unsigned n)
237 return &parser->tokens_buf[n];
243 c_parser_error (c_parser *parser)
245 return parser->error;
251 c_parser_set_error (c_parser *parser, bool err)
253 parser->error = err;
257 /* The actual parser and external interface. ??? Does this need to be
266 c_lex_one_token (c_parser *parser, c_token *token, bool raw = false)
270 if (raw || vec_safe_length (parser->raw_tokens) == 0)
274 (parser->lex_joined_string
284 *token = (*parser->raw_tokens)[parser->raw_tokens_used];
285 ++parser->raw_tokens_used;
286 if (parser->raw_tokens_used == vec_safe_length (parser->raw_tokens))
288 vec_free (parser->raw_tokens);
289 parser->raw_tokens_used = 0;
302 bool objc_force_identifier = parser->objc_need_raw_identifier;
304 parser->objc_need_raw_identifier = false;
333 if (parser->objc_pq_context)
339 else if (parser->objc_could_be_foreach_context
367 if (parser->objc_property_attr_context)
454 parser->objc_need_raw_identifier = false;
472 c_parser_peek_token (c_parser *parser)
474 if (parser->tokens_avail == 0)
476 c_lex_one_token (parser, &parser->tokens[0]);
477 parser->tokens_avail = 1;
479 return &parser->tokens[0];
486 c_parser_peek_2nd_token (c_parser *parser)
488 if (parser->tokens_avail >= 2)
489 return &parser->tokens[1];
490 gcc_assert (parser->tokens_avail == 1);
491 gcc_assert (parser->tokens[0].type != CPP_EOF);
492 gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
493 c_lex_one_token (parser, &parser->tokens[1]);
494 parser->tokens_avail = 2;
495 return &parser->tokens[1];
502 c_parser_peek_nth_token (c_parser *parser, unsigned int n)
507 if (parser->tokens_avail >= n)
508 return &parser->tokens[n - 1];
509 gcc_assert (parser->tokens_avail == n - 1);
510 c_lex_one_token (parser, &parser->tokens[n - 1]);
511 parser->tokens_avail = n;
512 return &parser->tokens[n - 1];
521 c_parser_peek_nth_token_raw (c_parser *parser, unsigned int n)
526 if (parser->tokens_avail >= n)
527 return &parser->tokens[n - 1];
528 unsigned int raw_len = vec_safe_length (parser->raw_tokens);
530 = parser->tokens_avail + raw_len - parser->raw_tokens_used;
533 return &(*parser->raw_tokens)[parser->raw_tokens_used
534 + n - 1 - parser->tokens_avail];
535 vec_safe_reserve (parser->raw_tokens, 1);
536 parser->raw_tokens->quick_grow (raw_len + 1);
537 c_lex_one_token (parser, &(*parser->raw_tokens)[raw_len], true);
538 return &(*parser->raw_tokens)[raw_len];
623 c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la)
625 c_token *token = c_parser_peek_token (parser);
635 && !parser->objc_could_be_foreach_context
638 || c_parser_peek_2nd_token (parser)->type == CPP_NAME
639 || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
684 c_parser_next_token_is_qualifier (c_parser *parser)
686 c_token *token = c_parser_peek_token (parser);
787 c_parser_next_token_starts_declspecs (c_parser *parser)
789 c_token *token = c_parser_peek_token (parser);
800 && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
810 c_parser_next_tokens_start_declaration (c_parser *parser)
812 c_token *token = c_parser_peek_token (parser);
818 && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
823 && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
829 if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl))
838 c_parser_consume_token (c_parser *parser)
840 gcc_assert (parser->tokens_avail >= 1);
841 gcc_assert (parser->tokens[0].type != CPP_EOF);
842 gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL);
843 gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA);
844 parser->last_token_location = parser->tokens[0].location;
845 if (parser->tokens != &parser->tokens_buf[0])
846 parser->tokens++;
847 else if (parser->tokens_avail >= 2)
849 parser->tokens[0] = parser->tokens[1];
850 if (parser->tokens_avail >= 3)
852 parser->tokens[1] = parser->tokens[2];
853 if (parser->tokens_avail >= 4)
854 parser->tokens[2] = parser->tokens[3];
857 parser->tokens_avail--;
864 c_parser_consume_pragma (c_parser *parser)
866 gcc_assert (!parser->in_pragma);
867 gcc_assert (parser->tokens_avail >= 1);
868 gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
869 if (parser->tokens != &parser->tokens_buf[0])
870 parser->tokens++;
871 else if (parser->tokens_avail >= 2)
873 parser->tokens[0] = parser->tokens[1];
874 if (parser->tokens_avail >= 3)
875 parser->tokens[1] = parser->tokens[2];
877 parser->tokens_avail--;
878 parser->in_pragma = true;
903 c_parser_peek_conflict_marker (c_parser *parser, enum cpp_ttype tok1_kind,
906 c_token *token2 = c_parser_peek_2nd_token (parser);
909 c_token *token3 = c_parser_peek_nth_token (parser, 3);
912 c_token *token4 = c_parser_peek_nth_token (parser, 4);
917 location_t start_loc = c_parser_peek_token (parser)->location;
943 ??? This is taken from the C++ parser, but building up messages in
948 c_parser_error_richloc (c_parser *parser, const char *gmsgid,
951 c_token *token = c_parser_peek_token (parser);
952 if (parser->error)
954 parser->error = true;
964 if (c_parser_peek_conflict_marker (parser, token->type, &loc))
976 /* ??? The C parser does not save the cpp flags of a
989 c_parser_error (c_parser *parser, const char *gmsgid)
991 c_token *token = c_parser_peek_token (parser);
994 return c_parser_error_richloc (parser, gmsgid, &richloc);
1016 bool require_open (c_parser *parser)
1018 c_token *token = c_parser_peek_token (parser);
1022 return c_parser_require (parser, traits_t::open_token_type,
1029 void consume_open (c_parser *parser)
1031 c_token *token = c_parser_peek_token (parser);
1034 c_parser_consume_token (parser);
1042 bool require_close (c_parser *parser) const
1044 return c_parser_require (parser, traits_t::close_token_type,
1052 void skip_until_found_close (c_parser *parser) const
1054 c_parser_skip_until_found (parser, traits_t::close_token_type,
1134 c_parser_require (c_parser *parser,
1140 if (c_parser_next_token_is (parser, type))
1142 c_parser_consume_token (parser);
1147 location_t next_token_loc = c_parser_peek_token (parser)->location;
1153 if (!parser->error && type_is_unique)
1155 parser->last_token_location);
1165 if (c_parser_error_richloc (parser, msgid, &richloc))
1180 c_parser_require_keyword (c_parser *parser,
1184 if (c_parser_next_token_is_keyword (parser, keyword))
1186 c_parser_consume_token (parser);
1191 c_parser_error (parser, msgid);
1208 c_parser_skip_until_found (c_parser *parser,
1215 if (c_parser_require (parser, type, msgid, matching_location))
1222 c_token *token = c_parser_peek_token (parser);
1226 c_parser_consume_token (parser);
1233 if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
1247 c_parser_consume_token (parser);
1249 parser->error = false;
1256 c_parser_skip_to_end_of_parameter (c_parser *parser)
1262 c_token *token = c_parser_peek_token (parser);
1269 if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
1283 c_parser_consume_token (parser);
1285 parser->error = false;
1292 c_parser_skip_to_pragma_eol (c_parser *parser, bool error_if_not_eol = true)
1294 gcc_assert (parser->in_pragma);
1295 parser->in_pragma = false;
1297 if (error_if_not_eol && c_parser_peek_token (parser)->type != CPP_PRAGMA_EOL)
1298 c_parser_error (parser, "expected end of line");
1303 c_token *token = c_parser_peek_token (parser);
1307 c_parser_consume_token (parser);
1311 parser->error = false;
1318 c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
1321 bool save_error = parser->error;
1328 token = c_parser_peek_token (parser);
1336 if (parser->in_pragma)
1346 c_parser_consume_token (parser);
1356 c_parser_consume_token (parser);
1370 Normally, we'd expect to be here with parser->error set,
1372 here for secondary error recovery, after parser->error has
1374 c_parser_consume_pragma (parser);
1375 c_parser_skip_to_pragma_eol (parser);
1376 parser->error = save_error;
1383 c_parser_consume_token (parser);
1387 parser->error = false;
1562 /* These Objective-C parser functions are only ever called when
1606 c_parser_translation_unit (c_parser *parser)
1608 if (c_parser_next_token_is (parser, CPP_EOF))
1610 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
1620 c_parser_external_declaration (parser);
1623 while (c_parser_next_token_is_not (parser, CPP_EOF));
1666 c_parser_external_declaration (c_parser *parser)
1669 switch (c_parser_peek_token (parser)->type)
1672 switch (c_parser_peek_token (parser)->keyword)
1676 c_parser_consume_token (parser);
1677 c_parser_external_declaration (parser);
1681 c_parser_asm_definition (parser);
1686 c_parser_objc_class_definition (parser, NULL_TREE);
1690 c_parser_objc_class_declaration (parser);
1694 c_parser_objc_alias_declaration (parser);
1698 c_parser_objc_protocol_definition (parser, NULL_TREE);
1702 c_parser_objc_at_property_declaration (parser);
1706 c_parser_objc_at_synthesize_declaration (parser);
1710 c_parser_objc_at_dynamic_declaration (parser);
1714 c_parser_consume_token (parser);
1722 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
1724 c_parser_consume_token (parser);
1728 c_parser_pragma (parser, pragma_external, NULL);
1735 c_parser_objc_method_definition (parser);
1747 c_parser_declaration_or_fndef (parser, true, true, true, false, true,
1829 callers. ??? Following the old parser, __extension__ may start
1860 c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
1873 location_t here = c_parser_peek_token (parser)->location;
1875 add_debug_begin_stmt (c_parser_peek_token (parser)->location);
1878 && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
1880 c_parser_static_assert_declaration (parser);
1893 if (c_parser_peek_token (parser)->type == CPP_NAME
1894 && c_parser_peek_token (parser)->id_kind == C_ID_ID
1895 && (c_parser_peek_2nd_token (parser)->type == CPP_NAME
1896 || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
1897 && (!nested || !lookup_name (c_parser_peek_token (parser)->value)))
1899 tree name = c_parser_peek_token (parser)->value;
1950 c_parser_peek_token (parser)->type = CPP_KEYWORD;
1951 c_parser_peek_token (parser)->keyword = RID_VOID;
1952 c_parser_peek_token (parser)->value = error_mark_node;
1959 if (c_parser_nth_token_starts_std_attributes (parser, 1))
1962 c_parser_declspecs (parser, specs, true, true, start_attr_ok,
1964 if (parser->error)
1966 c_parser_skip_to_end_of_block_or_statement (parser);
1971 c_parser_error (parser, "expected declaration specifiers");
1972 c_parser_skip_to_end_of_block_or_statement (parser);
1978 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2005 c_parser_consume_token (parser);
2015 && c_parser_next_token_starts_declspecs (parser)
2016 && !c_parser_next_token_is (parser, CPP_NAME))
2018 c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
2019 parser->error = false;
2026 switch (c_parser_peek_token (parser)->type)
2030 if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2034 warning_at (c_parser_peek_token (parser)->location,
2040 c_parser_objc_method_definition (parser);
2042 c_parser_objc_methodproto (parser);
2053 switch (c_parser_peek_token (parser)->keyword)
2057 if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2059 c_parser_objc_class_definition (parser, specs->attrs);
2065 if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2069 warning_at (c_parser_peek_token (parser)->location,
2074 c_parser_objc_class_definition (parser, NULL_TREE);
2080 if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
2082 c_parser_objc_protocol_definition (parser, specs->attrs);
2092 c_parser_error (parser, "unexpected attribute");
2118 declarator = c_parser_declarator (parser,
2124 c_finish_omp_declare_simd (parser, NULL_TREE, NULL_TREE,
2128 c_parser_skip_to_end_of_block_or_statement (parser);
2136 c_parser_skip_to_end_of_block_or_statement (parser);
2139 if (c_parser_next_token_is (parser, CPP_EQ)
2140 || c_parser_next_token_is (parser, CPP_COMMA)
2141 || c_parser_next_token_is (parser, CPP_SEMICOLON)
2142 || c_parser_next_token_is_keyword (parser, RID_ASM)
2143 || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)
2144 || c_parser_next_token_is_keyword (parser, RID_IN))
2156 if (c_parser_next_token_is_keyword (parser, RID_ASM))
2157 asm_name = c_parser_simple_asm_expr (parser);
2158 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2160 postfix_attrs = c_parser_gnu_attributes (parser);
2161 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
2168 c_parser_skip_to_end_of_block_or_statement (parser);
2172 if (c_parser_next_token_is (parser, CPP_EQ))
2177 c_parser_consume_token (parser);
2180 init_loc = c_parser_peek_token (parser)->location;
2188 init = c_parser_expr_no_commas (parser, NULL);
2228 c_finish_omp_declare_simd (parser, d, NULL_TREE,
2240 c_finish_omp_declare_simd (parser, d, NULL_TREE,
2242 init_loc = c_parser_peek_token (parser)->location;
2250 init = c_parser_initializer (parser);
2270 c_parser_skip_to_end_of_block_or_statement (parser);
2330 c_finish_omp_declare_simd (parser, d, parms,
2341 if (c_parser_next_token_is_keyword (parser, RID_IN))
2349 if (c_parser_next_token_is (parser, CPP_COMMA))
2356 c_parser_skip_to_end_of_block_or_statement (parser);
2359 c_parser_consume_token (parser);
2360 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2361 all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
2367 else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2369 c_parser_consume_token (parser);
2372 else if (c_parser_next_token_is_keyword (parser, RID_IN))
2383 c_parser_error (parser, "expected %<,%> or %<;%>");
2384 c_parser_skip_to_end_of_block_or_statement (parser);
2392 c_parser_skip_to_end_of_block_or_statement (parser);
2397 c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
2399 c_parser_skip_to_end_of_block_or_statement (parser);
2418 gcc_assert (!c_parser_next_token_is (parser, CPP_SEMICOLON));
2419 if (c_parser_next_token_starts_declspecs (parser))
2430 c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>");
2431 parser->error = false;
2438 c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
2457 parser, they are not accepted on subsequent old-style
2464 while (c_parser_next_token_is_not (parser, CPP_EOF)
2465 && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
2466 c_parser_declaration_or_fndef (parser, false, false, false,
2470 c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE,
2474 location_t startloc = c_parser_peek_token (parser)->location;
2479 /* If the definition was marked with __RTL, use the RTL parser now,
2483 endloc = c_parser_parse_rtl_body (parser, specs->gimple_or_rtl_pass);
2501 c_parser_parse_gimple_body (parser, specs->gimple_or_rtl_pass,
2507 fnbody = c_parser_compound_statement (parser, &endloc);
2544 c_parser_asm_definition (c_parser *parser)
2546 tree asm_str = c_parser_simple_asm_expr (parser);
2549 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
2559 c_parser_static_assert_declaration (c_parser *parser)
2561 c_parser_static_assert_declaration_no_semi (parser);
2562 if (parser->error
2563 || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
2564 c_parser_skip_to_end_of_block_or_statement (parser);
2579 c_parser_static_assert_declaration_no_semi (c_parser *parser)
2585 gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT));
2586 assert_loc = c_parser_peek_token (parser)->location;
2593 c_parser_consume_token (parser);
2595 if (!parens.require_open (parser))
2597 location_t value_tok_loc = c_parser_peek_token (parser)->location;
2598 value = c_parser_expr_no_commas (parser, NULL).value;
2600 if (c_parser_next_token_is (parser, CPP_COMMA))
2602 c_parser_consume_token (parser);
2603 switch (c_parser_peek_token (parser)->type)
2610 string = c_parser_string_literal (parser, false, true).value;
2613 c_parser_error (parser, "expected string literal");
2624 parens.require_close (parser);
2772 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
2785 && c_parser_nth_token_starts_std_attributes (parser, 1))
2788 location_t loc = c_parser_peek_token (parser)->location;
2789 tree attrs = c_parser_std_attribute_specifier_sequence (parser);
2794 while (c_parser_next_token_is (parser, CPP_NAME)
2795 || c_parser_next_token_is (parser, CPP_KEYWORD)
2796 || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
2801 location_t loc = c_parser_peek_token (parser)->location;
2808 && c_parser_next_tokens_start_typename (parser, la)
2809 && !c_parser_next_token_is_qualifier (parser)
2810 && !c_parser_next_token_is_keyword (parser, RID_ALIGNAS))
2813 if (c_parser_next_token_is (parser, CPP_NAME))
2815 c_token *name_token = c_parser_peek_token (parser);
2824 c_parser_consume_token (parser);
2829 gcc_assert (!c_parser_next_token_is_qualifier (parser));
2835 if (seen_type || !c_parser_next_tokens_start_typename (parser, la))
2840 c_parser_consume_token (parser);
2851 || c_parser_next_token_is_not (parser, CPP_LESS)))
2863 if (c_parser_next_token_is (parser, CPP_LESS))
2864 proto = c_parser_objc_protocol_refs (parser);
2872 if (c_parser_next_token_is (parser, CPP_LESS))
2880 proto = c_parser_objc_protocol_refs (parser);
2888 gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
2889 switch (c_parser_peek_token (parser)->keyword)
2906 c_parser_peek_token (parser)->value);
2907 c_parser_consume_token (parser);
2940 parser->objc_need_raw_identifier = true;
2942 t.spec = c_parser_peek_token (parser)->value;
2946 c_parser_consume_token (parser);
2953 t = c_parser_enum_specifier (parser);
2963 t = c_parser_struct_or_union_specifier (parser);
2968 /* ??? The old parser rejected typeof after other type
2975 t = c_parser_typeof_specifier (parser);
2979 /* C parser handling of Objective-C constructs needs
2996 value = c_parser_peek_token (parser)->value;
2997 c_parser_consume_token (parser);
2998 if (typespec_ok && c_parser_next_token_is (parser, CPP_OPEN_PAREN))
3002 c_parser_consume_token (parser);
3003 struct c_type_name *type = c_parser_type_name (parser);
3011 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3033 declspecs_add_qual (loc, specs, c_parser_peek_token (parser)->value);
3034 c_parser_consume_token (parser);
3039 attrs = c_parser_gnu_attributes (parser);
3045 align = c_parser_alignas_specifier (parser);
3051 c_parser_consume_token (parser);
3054 c_parser_gimple_or_rtl_pass_list (parser, specs);
3057 c_parser_consume_token (parser);
3060 c_parser_gimple_or_rtl_pass_list (parser, specs);
3068 && c_parser_nth_token_starts_std_attributes (parser, 1))
3069 specs->postfix_attrs = c_parser_std_attribute_specifier_sequence (parser);
3106 c_parser_enum_specifier (c_parser *parser)
3115 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
3116 c_parser_consume_token (parser);
3117 have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
3119 std_attrs = c_parser_std_attribute_specifier_sequence (parser);
3120 attrs = c_parser_gnu_attributes (parser);
3121 enum_loc = c_parser_peek_token (parser)->location;
3123 c_parser_set_source_position_from_token (c_parser_peek_token (parser));
3124 if (c_parser_next_token_is (parser, CPP_NAME))
3126 ident = c_parser_peek_token (parser)->value;
3127 ident_loc = c_parser_peek_token (parser)->location;
3129 c_parser_consume_token (parser);
3131 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3143 c_parser_consume_token (parser);
3153 if (c_parser_next_token_is_not (parser, CPP_NAME))
3156 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
3157 && !parser->error)
3159 error_at (c_parser_peek_token (parser)->location,
3161 parser->error = true;
3164 c_parser_error (parser, "expected identifier");
3165 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
3169 token = c_parser_peek_token (parser);
3174 c_parser_consume_token (parser);
3177 if (c_parser_nth_token_starts_std_attributes (parser, 1))
3178 std_attrs = c_parser_std_attribute_specifier_sequence (parser);
3180 c_parser_gnu_attributes (parser));
3181 if (c_parser_next_token_is (parser, CPP_EQ))
3183 c_parser_consume_token (parser);
3184 value_loc = c_parser_peek_token (parser)->location;
3185 enum_value = c_parser_expr_no_commas (parser, NULL).value;
3196 if (c_parser_next_token_is (parser, CPP_COMMA))
3198 comma_loc = c_parser_peek_token (parser)->location;
3200 c_parser_consume_token (parser);
3202 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3207 c_parser_consume_token (parser);
3212 c_parser_error (parser, "expected %<,%> or %<}%>");
3213 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
3218 postfix_attrs = c_parser_gnu_attributes (parser);
3230 c_parser_error (parser, "expected %<{%>");
3241 if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
3242 c_parser_error (parser, "expected %<;%>");
3297 c_parser_struct_or_union_specifier (c_parser *parser)
3307 switch (c_parser_peek_token (parser)->keyword)
3318 struct_loc = c_parser_peek_token (parser)->location;
3319 c_parser_consume_token (parser);
3320 have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
3322 std_attrs = c_parser_std_attribute_specifier_sequence (parser);
3323 attrs = c_parser_gnu_attributes (parser);
3326 c_parser_set_source_position_from_token (c_parser_peek_token (parser));
3328 if (c_parser_next_token_is (parser, CPP_NAME))
3330 ident = c_parser_peek_token (parser)->value;
3331 ident_loc = c_parser_peek_token (parser)->location;
3333 c_parser_consume_token (parser);
3335 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3355 c_parser_consume_token (parser);
3358 if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
3362 c_parser_consume_token (parser);
3364 if (!parens.require_open (parser))
3366 if (c_parser_next_token_is (parser, CPP_NAME)
3367 && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
3369 name = c_parser_peek_token (parser)->value;
3370 c_parser_consume_token (parser);
3374 c_parser_error (parser, "expected class name");
3375 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3378 parens.skip_until_found_close (parser);
3389 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3392 = c_parser_peek_token (parser)->location;
3397 c_parser_consume_token (parser);
3401 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3403 c_parser_consume_token (parser);
3407 if (c_parser_next_token_is (parser, CPP_PRAGMA))
3409 c_parser_pragma (parser, pragma_struct, NULL);
3414 decls = c_parser_struct_declaration (parser);
3419 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3420 c_parser_consume_token (parser);
3423 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3424 pedwarn (c_parser_peek_token (parser)->location, 0,
3426 else if (parser->error
3427 || !c_parser_next_token_starts_declspecs (parser))
3429 c_parser_error (parser, "expected %<;%>");
3430 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
3439 postfix_attrs = c_parser_gnu_attributes (parser);
3452 c_parser_error (parser, "expected %<{%>");
3461 if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
3462 c_parser_error (parser, "expected %<;%>");
3504 c_parser_struct_declaration (c_parser *parser)
3511 if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3516 c_parser_consume_token (parser);
3517 decl = c_parser_struct_declaration (parser);
3521 if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
3523 c_parser_static_assert_declaration_no_semi (parser);
3527 decl_loc = c_parser_peek_token (parser)->location;
3533 c_parser_declspecs (parser, specs, false, true, true,
3535 if (parser->error)
3539 c_parser_error (parser, "expected specifier-qualifier-list");
3543 if (c_parser_next_token_is (parser, CPP_SEMICOLON)
3544 || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3561 ret = grokfield (c_parser_peek_token (parser)->location,
3574 && c_parser_next_token_starts_declspecs (parser)
3575 && !c_parser_next_token_is (parser, CPP_NAME))
3577 c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
3578 parser->error = false;
3592 if (c_parser_next_token_is (parser, CPP_COLON))
3595 declarator = c_parser_declarator (parser,
3600 c_parser_skip_to_end_of_block_or_statement (parser);
3603 if (c_parser_next_token_is (parser, CPP_COLON)
3604 || c_parser_next_token_is (parser, CPP_COMMA)
3605 || c_parser_next_token_is (parser, CPP_SEMICOLON)
3606 || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
3607 || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3612 if (c_parser_next_token_is (parser, CPP_COLON))
3614 c_parser_consume_token (parser);
3615 width = c_parser_expr_no_commas (parser, NULL).value;
3617 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3618 postfix_attrs = c_parser_gnu_attributes (parser);
3619 d = grokfield (c_parser_peek_token (parser)->location,
3625 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
3626 all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
3630 if (c_parser_next_token_is (parser, CPP_COMMA))
3631 c_parser_consume_token (parser);
3632 else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
3633 || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3640 c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
3646 c_parser_error (parser,
3663 c_parser_typeof_specifier (c_parser *parser)
3670 gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
3671 c_parser_consume_token (parser);
3675 if (!parens.require_open (parser))
3681 if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
3683 struct c_type_name *type = c_parser_type_name (parser);
3695 location_t here = c_parser_peek_token (parser)->location;
3696 struct c_expr expr = c_parser_expression (parser);
3716 parens.skip_until_found_close (parser);
3730 c_parser_alignas_specifier (c_parser * parser)
3733 location_t loc = c_parser_peek_token (parser)->location;
3734 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS));
3735 c_parser_consume_token (parser);
3743 if (!parens.require_open (parser))
3745 if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
3747 struct c_type_name *type = c_parser_type_name (parser);
3753 ret = c_parser_expr_no_commas (parser, NULL).value;
3754 parens.skip_until_found_close (parser);
3842 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
3846 if (c_parser_next_token_is (parser, CPP_MULT))
3850 c_parser_consume_token (parser);
3851 c_parser_declspecs (parser, quals_attrs, false, false, true,
3853 inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
3861 return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
3868 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
3892 parser's implementation, whereby the first parameter must have
3898 ??? Also following the old parser, gnu-attributes inside an empty
3903 ??? Also following the old parser, typedef names may be
3907 && c_parser_next_token_is (parser, CPP_NAME)
3909 && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
3910 || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
3911 || c_parser_peek_token (parser)->id_kind == C_ID_ID))
3914 = build_id_declarator (c_parser_peek_token (parser)->value);
3916 inner->id_loc = c_parser_peek_token (parser)->location;
3917 c_parser_consume_token (parser);
3918 if (c_parser_nth_token_starts_std_attributes (parser, 1))
3919 inner->u.id.attrs = c_parser_std_attribute_specifier_sequence (parser);
3920 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
3924 && c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3925 && !c_parser_nth_token_starts_std_attributes (parser, 1))
3928 inner->id_loc = c_parser_peek_token (parser)->location;
3929 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
3935 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
3939 c_parser_consume_token (parser);
3940 bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
3942 attrs = c_parser_gnu_attributes (parser);
3944 && (c_parser_next_token_starts_declspecs (parser)
3946 && c_parser_nth_token_starts_std_attributes (parser, 1))
3947 || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
3950 = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
3960 && c_parser_nth_token_starts_std_attributes (parser, 1))
3963 = c_parser_std_attribute_specifier_sequence (parser);
3968 return c_parser_direct_declarator_inner (parser, *seen_id,
3973 inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
3976 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3978 c_parser_consume_token (parser);
3982 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
3986 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3995 c_parser_error (parser, "expected identifier or %<(%>");
4009 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
4013 if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
4014 && !c_parser_nth_token_starts_std_attributes (parser, 1))
4016 location_t brace_loc = c_parser_peek_token (parser)->location;
4025 c_parser_consume_token (parser);
4026 c_parser_declspecs (parser, quals_attrs, false, false, true,
4028 static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
4030 c_parser_consume_token (parser);
4032 c_parser_declspecs (parser, quals_attrs, false, false, true,
4042 dimen = c_parser_expr_no_commas (parser, NULL);
4046 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
4051 else if (c_parser_next_token_is (parser, CPP_MULT))
4053 if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
4057 c_parser_consume_token (parser);
4062 dimen = c_parser_expr_no_commas (parser, NULL);
4068 dimen = c_parser_expr_no_commas (parser, NULL);
4071 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
4072 c_parser_consume_token (parser);
4075 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
4085 if (c_parser_nth_token_starts_std_attributes (parser, 1))
4088 = c_parser_std_attribute_specifier_sequence (parser);
4093 return c_parser_direct_declarator_inner (parser, id_present, inner);
4095 else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
4099 c_parser_consume_token (parser);
4100 bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
4102 attrs = c_parser_gnu_attributes (parser);
4103 args = c_parser_parms_declarator (parser, id_present, attrs,
4112 && c_parser_nth_token_starts_std_attributes (parser, 1))
4115 = c_parser_std_attribute_specifier_sequence (parser);
4120 return c_parser_direct_declarator_inner (parser, id_present, inner);
4135 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs,
4144 && c_parser_next_token_is (parser, CPP_NAME)
4145 && c_parser_peek_token (parser)->id_kind == C_ID_ID
4148 && c_parser_peek_2nd_token (parser)->type != CPP_NAME
4149 && c_parser_peek_2nd_token (parser)->type != CPP_MULT
4150 && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
4151 && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE
4152 && c_parser_peek_2nd_token (parser)->type != CPP_KEYWORD)
4155 while (c_parser_next_token_is (parser, CPP_NAME)
4156 && c_parser_peek_token (parser)->id_kind == C_ID_ID)
4159 c_parser_peek_token (parser)->value);
4161 c_parser_consume_token (parser);
4162 if (c_parser_next_token_is_not (parser, CPP_COMMA))
4164 c_parser_consume_token (parser);
4165 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4167 c_parser_error (parser, "expected identifier");
4171 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4175 c_parser_consume_token (parser);
4181 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4190 = c_parser_parms_list_declarator (parser, attrs, NULL, have_gnu_attrs);
4205 c_parser_parms_list_declarator (c_parser *parser, tree attrs, tree expr,
4210 /* ??? Following the old parser, forward parameter declarations may
4216 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4219 c_parser_consume_token (parser);
4222 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
4235 error_at (c_parser_peek_token (parser)->location,
4238 c_parser_consume_token (parser);
4239 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4241 c_parser_consume_token (parser);
4246 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4257 struct c_parm *parm = c_parser_parameter_declaration (parser, attrs,
4265 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4268 c_parser_consume_token (parser);
4271 = c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE);
4272 new_attrs = c_parser_gnu_attributes (parser);
4273 return c_parser_parms_list_declarator (parser, new_attrs, expr,
4276 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4278 c_parser_consume_token (parser);
4284 if (!c_parser_require (parser, CPP_COMMA,
4288 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4291 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
4293 c_parser_consume_token (parser);
4294 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4296 c_parser_consume_token (parser);
4304 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4318 c_parser_parameter_declaration (c_parser *parser, tree attrs,
4328 while (c_parser_next_token_is (parser, CPP_PRAGMA))
4329 c_parser_pragma (parser, pragma_param, NULL);
4331 if (!c_parser_next_token_starts_declspecs (parser)
4332 && !c_parser_nth_token_starts_std_attributes (parser, 1))
4334 c_token *token = c_parser_peek_token (parser);
4335 if (parser->error)
4338 if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
4354 parser->error = true;
4359 c_parser_error (parser,
4361 c_parser_skip_to_end_of_parameter (parser);
4365 location_t start_loc = c_parser_peek_token (parser)->location;
4373 c_parser_declspecs (parser, specs, true, true, true, true, false,
4379 declarator = c_parser_declarator (parser,
4384 c_parser_skip_until_found (parser, CPP_COMMA, NULL);
4387 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
4388 postfix_attrs = c_parser_gnu_attributes (parser);
4403 location_t end_loc = parser->last_token_location;
4427 c_parser_asm_string_literal (c_parser *parser)
4432 str = c_parser_string_literal (parser, false, false).value;
4446 c_parser_simple_asm_expr (c_parser *parser)
4449 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
4450 c_parser_consume_token (parser);
4452 if (!parens.require_open (parser))
4454 str = c_parser_asm_string_literal (parser);
4455 if (!parens.require_close (parser))
4457 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4464 c_parser_gnu_attribute_any_word (c_parser *parser)
4468 if (c_parser_next_token_is (parser, CPP_KEYWORD))
4472 switch (c_parser_peek_token (parser)->keyword)
4521 attr_name = ridpointers[(int) c_parser_peek_token (parser)->keyword];
4523 else if (c_parser_next_token_is (parser, CPP_NAME))
4524 attr_name = c_parser_peek_token (parser)->value;
4541 c_parser_attribute_arguments (c_parser *parser, bool takes_identifier,
4551 if (c_parser_next_token_is (parser, CPP_NAME)
4552 && (c_parser_peek_token (parser)->id_kind == C_ID_ID
4554 && c_parser_peek_token (parser)->id_kind
4556 && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
4557 || (c_parser_peek_2nd_token (parser)->type
4561 && c_parser_peek_token (parser)->id_kind
4564 tree arg1 = c_parser_peek_token (parser)->value;
4565 c_parser_consume_token (parser);
4566 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4571 c_parser_consume_token (parser);
4572 expr_list = c_parser_expr_list (parser, false, true,
4581 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4584 error_at (c_parser_peek_token (parser)->location,
4594 tree string = c_parser_string_literal (parser, false, true).value;
4599 expr_list = c_parser_expr_list (parser, false, true,
4629 (following the old parser), shouldn't we include them?
4636 c_parser_gnu_attribute (c_parser *parser, tree attrs,
4639 bool comma_first = c_parser_next_token_is (parser, CPP_COMMA);
4641 && !c_parser_next_token_is (parser, CPP_NAME)
4642 && !c_parser_next_token_is (parser, CPP_KEYWORD))
4645 while (c_parser_next_token_is (parser, CPP_COMMA))
4647 c_parser_consume_token (parser);
4652 tree attr_name = c_parser_gnu_attribute_any_word (parser);
4657 c_parser_consume_token (parser);
4660 if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
4666 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4675 c_parser_consume_token (parser);
4678 = c_parser_attribute_arguments (parser,
4683 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4684 c_parser_consume_token (parser);
4687 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4696 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4707 c_parser_gnu_attributes (c_parser *parser)
4710 while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
4712 bool save_translate_strings_p = parser->translate_strings_p;
4713 parser->translate_strings_p = false;
4715 c_parser_consume_token (parser);
4717 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4719 parser->translate_strings_p = save_translate_strings_p;
4722 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4724 parser->translate_strings_p = save_translate_strings_p;
4725 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4733 tree attr = c_parser_gnu_attribute (parser, attrs, expect_comma);
4742 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4743 c_parser_consume_token (parser);
4746 parser->translate_strings_p = save_translate_strings_p;
4747 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4751 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
4752 c_parser_consume_token (parser);
4755 parser->translate_strings_p = save_translate_strings_p;
4756 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4760 parser->translate_strings_p = save_translate_strings_p;
4780 c_parser_balanced_token_sequence (c_parser *parser)
4784 c_token *token = c_parser_peek_token (parser);
4790 braces.consume_open (parser);
4791 c_parser_balanced_token_sequence (parser);
4792 braces.require_close (parser);
4799 parens.consume_open (parser);
4800 c_parser_balanced_token_sequence (parser);
4801 parens.require_close (parser);
4806 c_parser_consume_token (parser);
4807 c_parser_balanced_token_sequence (parser);
4808 c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
4818 c_parser_consume_pragma (parser);
4819 c_parser_skip_to_pragma_eol (parser, false);
4823 c_parser_consume_token (parser);
4865 c_parser_std_attribute (c_parser *parser, bool for_tm)
4867 c_token *token = c_parser_peek_token (parser);
4873 c_parser_error (parser, "expected identifier");
4877 c_parser_consume_token (parser);
4878 if (c_parser_next_token_is (parser, CPP_SCOPE))
4881 c_parser_consume_token (parser);
4882 token = c_parser_peek_token (parser);
4885 c_parser_error (parser, "expected identifier");
4889 c_parser_consume_token (parser);
4897 if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
4900 location_t open_loc = c_parser_peek_token (parser)->location;
4902 parens.consume_open (parser);
4911 parens.skip_until_found_close (parser);
4924 = c_parser_attribute_arguments (parser, takes_identifier,
4928 c_parser_balanced_token_sequence (parser);
4929 parens.require_close (parser);
4947 c_parser_std_attribute_specifier (c_parser *parser, bool for_tm)
4952 location_t loc = c_parser_peek_token (parser)->location;
4953 if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
4955 if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
4957 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
4966 c_token *token = c_parser_peek_token (parser);
4971 c_parser_consume_token (parser);
4974 tree attribute = c_parser_std_attribute (parser, for_tm);
5027 if (c_parser_next_token_is_not (parser, CPP_COMMA))
5030 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
5031 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
5041 c_parser_check_balanced_raw_token_sequence (c_parser *parser, unsigned int *n)
5045 c_token *token = c_parser_peek_nth_token_raw (parser, *n);
5051 if (c_parser_check_balanced_raw_token_sequence (parser, n))
5053 token = c_parser_peek_nth_token_raw (parser, *n);
5067 if (c_parser_check_balanced_raw_token_sequence (parser, n))
5069 token = c_parser_peek_nth_token_raw (parser, *n);
5083 if (c_parser_check_balanced_raw_token_sequence (parser, n))
5085 token = c_parser_peek_nth_token_raw (parser, *n);
5112 c_parser_nth_token_starts_std_attributes (c_parser *parser, unsigned int n)
5114 if (!(c_parser_peek_nth_token (parser, n)->type == CPP_OPEN_SQUARE
5115 && c_parser_peek_nth_token (parser, n + 1)->type == CPP_OPEN_SQUARE))
5122 if (!c_parser_check_balanced_raw_token_sequence (parser, &n))
5124 c_token *token = c_parser_peek_nth_token_raw (parser, n);
5127 token = c_parser_peek_nth_token_raw (parser, n + 1);
5132 c_parser_std_attribute_specifier_sequence (c_parser *parser)
5137 tree attrs = c_parser_std_attribute_specifier (parser, false);
5140 while (c_parser_nth_token_starts_std_attributes (parser, 1));
5153 c_parser_type_name (c_parser *parser, bool alignas_ok)
5159 c_parser_declspecs (parser, specs, false, true, true, alignas_ok, false,
5163 c_parser_error (parser, "expected specifier-qualifier-list");
5171 declarator = c_parser_declarator (parser,
5226 c_parser_initializer (c_parser *parser)
5228 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5229 return c_parser_braced_init (parser, NULL_TREE, false, NULL);
5233 location_t loc = c_parser_peek_token (parser)->location;
5234 ret = c_parser_expr_no_commas (parser, NULL);
5254 c_parser_braced_init (c_parser *parser, tree type, bool nested_p,
5259 location_t brace_loc = c_parser_peek_token (parser)->location;
5261 gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
5263 braces.consume_open (parser);
5271 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
5281 c_parser_initelt (parser, &braced_init_obstack);
5282 if (parser->error)
5284 if (c_parser_next_token_is (parser, CPP_COMMA))
5286 last_init_list_comma = c_parser_peek_token (parser)->location;
5287 c_parser_consume_token (parser);
5291 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
5295 c_token *next_tok = c_parser_peek_token (parser);
5301 braces.skip_until_found_close (parser);
5307 c_parser_consume_token (parser);
5317 c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
5322 if (c_parser_next_token_is (parser, CPP_NAME)
5323 && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
5326 set_init_label (c_parser_peek_token (parser)->location,
5327 c_parser_peek_token (parser)->value,
5328 c_parser_peek_token (parser)->location,
5331 pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_Wpedantic,
5333 c_parser_consume_token (parser);
5334 c_parser_consume_token (parser);
5343 while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
5344 || c_parser_next_token_is (parser, CPP_DOT))
5348 des_loc = c_parser_peek_token (parser)->location;
5351 if (c_parser_next_token_is (parser, CPP_DOT))
5354 c_parser_consume_token (parser);
5355 if (c_parser_next_token_is (parser, CPP_NAME))
5357 set_init_label (des_loc, c_parser_peek_token (parser)->value,
5358 c_parser_peek_token (parser)->location,
5360 c_parser_consume_token (parser);
5368 c_parser_error (parser, "expected identifier");
5369 c_parser_skip_until_found (parser, CPP_COMMA, NULL);
5380 /* ??? Following the old parser, [ objc-receiver
5407 c_parser_consume_token (parser);
5408 if (c_parser_peek_token (parser)->type == CPP_NAME
5409 && ((c_parser_peek_token (parser)->id_kind
5411 || (c_parser_peek_token (parser)->id_kind
5415 tree id = c_parser_peek_token (parser)->value;
5416 c_parser_consume_token (parser);
5420 first = c_parser_expr_no_commas (parser, NULL).value;
5422 if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
5423 || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
5429 while (c_parser_next_token_is (parser, CPP_COMMA))
5433 comma_loc = c_parser_peek_token (parser)->location;
5434 c_parser_consume_token (parser);
5435 exp_loc = c_parser_peek_token (parser)->location;
5436 next = c_parser_expr_no_commas (parser, NULL);
5443 args = c_parser_objc_message_args (parser);
5444 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5453 c_parser_initval (parser, &mexpr, braced_init_obstack);
5456 c_parser_consume_token (parser);
5457 array_index_loc = c_parser_peek_token (parser)->location;
5458 first = c_parser_expr_no_commas (parser, NULL).value;
5461 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
5463 ellipsis_loc = c_parser_peek_token (parser)->location;
5464 c_parser_consume_token (parser);
5465 second = c_parser_expr_no_commas (parser, NULL).value;
5470 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
5472 c_parser_consume_token (parser);
5480 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5486 if (c_parser_next_token_is (parser, CPP_EQ))
5491 c_parser_consume_token (parser);
5496 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
5504 c_parser_error (parser, "expected %<=%>");
5505 c_parser_skip_until_found (parser, CPP_COMMA, NULL);
5513 c_parser_initval (parser, NULL, braced_init_obstack);
5523 c_parser_initval (c_parser *parser, struct c_expr *after,
5528 location_t loc = c_parser_peek_token (parser)->location;
5530 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
5531 init = c_parser_braced_init (parser, NULL_TREE, true,
5535 init = c_parser_expr_no_commas (parser, after);
5584 old parser in requiring something after label declarations.
5610 c_parser_compound_statement (c_parser *parser, location_t *endlocp)
5614 brace_loc = c_parser_peek_token (parser)->location;
5615 if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
5624 location_t end_loc = c_parser_compound_statement_nostart (parser);
5636 c_parser_compound_statement_nostart (c_parser *parser)
5642 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
5644 location_t endloc = c_parser_peek_token (parser)->location;
5646 c_parser_consume_token (parser);
5650 if (c_parser_next_token_is_keyword (parser, RID_LABEL))
5655 while (c_parser_next_token_is_keyword (parser, RID_LABEL))
5657 label_loc = c_parser_peek_token (parser)->location;
5658 c_parser_consume_token (parser);
5664 if (c_parser_next_token_is_not (parser, CPP_NAME))
5666 c_parser_error (parser, "expected identifier");
5670 = declare_label (c_parser_peek_token (parser)->value);
5673 c_parser_consume_token (parser);
5674 if (c_parser_next_token_is (parser, CPP_COMMA))
5675 c_parser_consume_token (parser);
5679 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5684 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
5687 c_parser_error (parser, "expected declaration or statement");
5688 location_t endloc = c_parser_peek_token (parser)->location;
5689 c_parser_consume_token (parser);
5692 while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
5694 location_t loc = c_parser_peek_token (parser)->location;
5698 = c_parser_nth_token_starts_std_attributes (parser, 1);
5701 std_attrs = c_parser_std_attribute_specifier_sequence (parser);
5702 if (c_parser_next_token_is_keyword (parser, RID_CASE)
5703 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
5704 || (c_parser_next_token_is (parser, CPP_NAME)
5705 && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
5708 if (c_parser_next_token_is_keyword (parser, RID_CASE))
5709 label_loc = c_parser_peek_2nd_token (parser)->location;
5711 label_loc = c_parser_peek_token (parser)->location;
5715 c_parser_label (parser);
5718 && (c_parser_next_tokens_start_declaration (parser)
5720 && c_parser_next_token_is (parser, CPP_SEMICOLON))))
5725 c_parser_declaration_or_fndef (parser, true, !have_std_attrs,
5735 && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
5744 while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
5745 && (c_parser_peek_2nd_token (parser)->keyword
5747 c_parser_consume_token (parser);
5749 && (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
5750 || c_parser_nth_token_starts_std_attributes (parser, 2)))
5754 c_parser_consume_token (parser);
5757 c_parser_declaration_or_fndef (parser, true, true, true, true,
5759 /* Following the old parser, __extension__ does not
5770 else if (c_parser_next_token_is (parser, CPP_PRAGMA))
5773 c_parser_error (parser, "expected declaration or statement");
5779 if (c_parser_pragma (parser,
5784 else if (c_parser_next_token_is (parser, CPP_EOF))
5787 c_parser_error (parser, "expected declaration or statement");
5788 return c_parser_peek_token (parser)->location;
5790 else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
5792 if (parser->in_if_block)
5796 return c_parser_peek_token (parser)->location;
5801 c_parser_consume_token (parser);
5812 c_parser_statement_after_labels (parser, NULL);
5815 parser->error = false;
5819 location_t endloc = c_parser_peek_token (parser)->location;
5820 c_parser_consume_token (parser);
5832 c_parser_all_labels (c_parser *parser)
5834 if (c_parser_nth_token_starts_std_attributes (parser, 1))
5836 tree std_attrs = c_parser_std_attribute_specifier_sequence (parser);
5837 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
5838 c_parser_error (parser, "expected statement");
5842 while (c_parser_next_token_is_keyword (parser, RID_CASE)
5843 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
5844 || (c_parser_next_token_is (parser, CPP_NAME)
5845 && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
5846 c_parser_label (parser);
5870 c_parser_label (c_parser *parser)
5872 location_t loc1 = c_parser_peek_token (parser)->location;
5877 bool fallthrough_p = c_parser_peek_token (parser)->flags & PREV_FALLTHROUGH;
5879 if (c_parser_next_token_is_keyword (parser, RID_CASE))
5882 c_parser_consume_token (parser);
5883 exp1 = c_parser_expr_no_commas (parser, NULL).value;
5884 if (c_parser_next_token_is (parser, CPP_COLON))
5886 c_parser_consume_token (parser);
5889 else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
5891 c_parser_consume_token (parser);
5892 exp2 = c_parser_expr_no_commas (parser, NULL).value;
5893 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
5897 c_parser_error (parser, "expected %<:%> or %<...%>");
5899 else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
5901 c_parser_consume_token (parser);
5902 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
5907 tree name = c_parser_peek_token (parser)->value;
5910 location_t loc2 = c_parser_peek_token (parser)->location;
5911 gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
5912 c_parser_consume_token (parser);
5913 gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
5914 c_parser_consume_token (parser);
5915 attrs = c_parser_gnu_attributes (parser);
5934 = c_parser_nth_token_starts_std_attributes (parser, 1);
5937 std_attrs = c_parser_std_attribute_specifier_sequence (parser);
5941 && c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
5943 location_t loc = c_parser_peek_token (parser)->location;
5944 tree attrs = c_parser_gnu_attributes (parser);
5947 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
5962 if (c_parser_next_tokens_start_declaration (parser)
5964 && c_parser_next_token_is (parser, CPP_SEMICOLON)))
5966 error_at (c_parser_peek_token (parser)->location,
5969 c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false,
6128 c_parser_statement (c_parser *parser, bool *if_p, location_t *loc_after_labels)
6130 c_parser_all_labels (parser);
6132 *loc_after_labels = c_parser_peek_token (parser)->location;
6133 c_parser_statement_after_labels (parser, if_p, NULL);
6145 c_parser_statement_after_labels (c_parser *parser, bool *if_p,
6148 location_t loc = c_parser_peek_token (parser)->location;
6150 bool in_if_block = parser->in_if_block;
6151 parser->in_if_block = false;
6155 if (c_parser_peek_token (parser)->type != CPP_OPEN_BRACE)
6158 switch (c_parser_peek_token (parser)->type)
6161 add_stmt (c_parser_compound_statement (parser));
6164 switch (c_parser_peek_token (parser)->keyword)
6167 c_parser_if_statement (parser, if_p, chain);
6170 c_parser_switch_statement (parser, if_p);
6173 c_parser_while_statement (parser, false, 0, if_p);
6176 c_parser_do_statement (parser, 0, false);
6179 c_parser_for_statement (parser, false, 0, if_p);
6182 c_parser_consume_token (parser);
6183 if (c_parser_next_token_is (parser, CPP_NAME))
6186 c_parser_peek_token (parser)->value);
6187 c_parser_consume_token (parser);
6189 else if (c_parser_next_token_is (parser, CPP_MULT))
6193 c_parser_consume_token (parser);
6194 val = c_parser_expression (parser);
6199 c_parser_error (parser, "expected identifier or %<*%>");
6202 c_parser_consume_token (parser);
6206 c_parser_consume_token (parser);
6210 c_parser_consume_token (parser);
6211 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6214 c_parser_consume_token (parser);
6218 location_t xloc = c_parser_peek_token (parser)->location;
6219 struct c_expr expr = c_parser_expression_conv (parser);
6227 stmt = c_parser_asm_statement (parser);
6231 stmt = c_parser_transaction (parser,
6232 c_parser_peek_token (parser)->keyword);
6235 stmt = c_parser_transaction_cancel (parser);
6239 c_parser_consume_token (parser);
6240 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6243 c_parser_consume_token (parser);
6247 struct c_expr expr = c_parser_expression (parser);
6256 c_parser_objc_try_catch_finally_statement (parser);
6260 c_parser_objc_synchronized_statement (parser);
6265 tree attrs = c_parser_gnu_attributes (parser);
6268 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6275 c_parser_consume_token (parser);
6292 c_parser_consume_token (parser);
6300 c_parser_error (parser, "expected statement");
6301 c_parser_consume_token (parser);
6304 c_parser_pragma (parser, pragma_stmt, if_p);
6308 stmt = c_finish_expr_stmt (loc, c_parser_expression_conv (parser).value);
6310 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
6326 parser->in_if_block = in_if_block;
6332 c_parser_condition (c_parser *parser)
6334 location_t loc = c_parser_peek_token (parser)->location;
6336 cond = c_parser_expression_conv (parser).value;
6350 c_parser_paren_condition (c_parser *parser)
6354 if (!parens.require_open (parser))
6356 cond = c_parser_condition (parser);
6357 parens.skip_until_found_close (parser);
6368 c_parser_c99_block_statement (c_parser *parser, bool *if_p,
6372 location_t loc = c_parser_peek_token (parser)->location;
6373 c_parser_statement (parser, if_p, loc_after_labels);
6383 parser->in_if_block.
6390 c_parser_if_body (c_parser *parser, bool *if_p,
6394 location_t body_loc = c_parser_peek_token (parser)->location;
6397 = get_token_indent_info (c_parser_peek_token (parser));
6399 c_parser_all_labels (parser);
6400 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6402 location_t loc = c_parser_peek_token (parser)->location;
6404 c_parser_consume_token (parser);
6405 if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
6409 else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6410 add_stmt (c_parser_compound_statement (parser));
6413 body_loc_after_labels = c_parser_peek_token (parser)->location;
6414 c_parser_statement_after_labels (parser, if_p);
6418 = get_token_indent_info (c_parser_peek_token (parser));
6434 c_parser_else_body (c_parser *parser, const token_indent_info &else_tinfo,
6437 location_t body_loc = c_parser_peek_token (parser)->location;
6440 = get_token_indent_info (c_parser_peek_token (parser));
6443 c_parser_all_labels (parser);
6444 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6446 location_t loc = c_parser_peek_token (parser)->location;
6451 c_parser_consume_token (parser);
6455 if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
6456 body_loc_after_labels = c_parser_peek_token (parser)->location;
6457 c_parser_statement_after_labels (parser, NULL, chain);
6461 = get_token_indent_info (c_parser_peek_token (parser));
6476 c_parser_maybe_reclassify_token (c_parser *parser)
6478 if (c_parser_next_token_is (parser, CPP_NAME))
6480 c_token *token = c_parser_peek_token (parser);
6520 c_parser_if_statement (c_parser *parser, bool *if_p, vec<tree> *chain)
6529 gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
6531 = get_token_indent_info (c_parser_peek_token (parser));
6532 c_parser_consume_token (parser);
6534 loc = c_parser_peek_token (parser)->location;
6535 cond = c_parser_paren_condition (parser);
6536 in_if_block = parser->in_if_block;
6537 parser->in_if_block = true;
6538 first_body = c_parser_if_body (parser, &nested_if, if_tinfo);
6539 parser->in_if_block = in_if_block;
6544 if (c_parser_next_token_is_keyword (parser, RID_ELSE))
6547 = get_token_indent_info (c_parser_peek_token (parser));
6548 c_parser_consume_token (parser);
6551 if (c_parser_next_token_is_keyword (parser, RID_IF)
6560 else if (!c_parser_next_token_is_keyword (parser, RID_IF))
6568 second_body = c_parser_else_body (parser, else_tinfo, chain);
6596 c_parser_maybe_reclassify_token (parser);
6606 c_parser_switch_statement (c_parser *parser, bool *if_p)
6610 location_t switch_loc = c_parser_peek_token (parser)->location;
6612 gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
6613 c_parser_consume_token (parser);
6617 if (parens.require_open (parser))
6619 switch_cond_loc = c_parser_peek_token (parser)->location;
6620 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
6621 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
6623 ce = c_parser_expression (parser);
6627 parens.skip_until_found_close (parser);
6639 bool open_brace_p = c_parser_peek_token (parser)->type == CPP_OPEN_BRACE;
6640 body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
6641 location_t next_loc = c_parser_peek_token (parser)->location;
6642 if (!open_brace_p && c_parser_peek_token (parser)->type != CPP_SEMICOLON)
6647 location_t here = c_parser_peek_token (parser)->location;
6656 c_parser_maybe_reclassify_token (parser);
6669 c_parser_while_statement (c_parser *parser, bool ivdep, unsigned short unroll,
6674 gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
6676 = get_token_indent_info (c_parser_peek_token (parser));
6677 c_parser_consume_token (parser);
6679 loc = c_parser_peek_token (parser)->location;
6680 cond = c_parser_paren_condition (parser);
6697 = get_token_indent_info (c_parser_peek_token (parser));
6700 bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
6701 body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
6705 c_parser_maybe_reclassify_token (parser);
6708 = get_token_indent_info (c_parser_peek_token (parser));
6726 c_parser_do_statement (c_parser *parser, bool ivdep, unsigned short unroll)
6730 gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
6731 c_parser_consume_token (parser);
6732 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6733 warning_at (c_parser_peek_token (parser)->location,
6737 loc = c_parser_peek_token (parser)->location;
6742 body = c_parser_c99_block_statement (parser, NULL);
6743 c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
6748 location_t cond_loc = c_parser_peek_token (parser)->location;
6749 cond = c_parser_paren_condition (parser);
6760 if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
6761 c_parser_skip_to_end_of_block_or_statement (parser);
6775 ??? In accordance with the old parser, the declaration may be a
6827 c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
6835 location_t loc = c_parser_peek_token (parser)->location;
6840 gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
6842 = get_token_indent_info (c_parser_peek_token (parser));
6843 c_parser_consume_token (parser);
6850 if (parens.require_open (parser))
6854 parser->objc_could_be_foreach_context = c_dialect_objc ();
6855 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6857 parser->objc_could_be_foreach_context = false;
6858 c_parser_consume_token (parser);
6861 else if (c_parser_next_tokens_start_declaration (parser)
6862 || c_parser_nth_token_starts_std_attributes (parser, 1))
6864 c_parser_declaration_or_fndef (parser, true, true, true, true, true,
6866 parser->objc_could_be_foreach_context = false;
6868 if (c_parser_next_token_is_keyword (parser, RID_IN))
6870 c_parser_consume_token (parser);
6873 c_parser_error (parser, "multiple iterating variables in "
6879 else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
6885 while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
6886 && (c_parser_peek_2nd_token (parser)->keyword
6888 c_parser_consume_token (parser);
6889 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
6890 || c_parser_nth_token_starts_std_attributes (parser, 2))
6894 c_parser_consume_token (parser);
6895 c_parser_declaration_or_fndef (parser, true, true, true, true,
6897 parser->objc_could_be_foreach_context = false;
6900 if (c_parser_next_token_is_keyword (parser, RID_IN))
6902 c_parser_consume_token (parser);
6905 c_parser_error (parser, "multiple iterating variables in "
6920 ce = c_parser_expression (parser);
6922 parser->objc_could_be_foreach_context = false;
6923 if (c_parser_next_token_is_keyword (parser, RID_IN))
6925 c_parser_consume_token (parser);
6928 c_parser_error (parser, "invalid iterating variable in "
6938 c_parser_skip_until_found (parser, CPP_SEMICOLON,
6945 gcc_assert (!parser->objc_could_be_foreach_context);
6948 cond_loc = c_parser_peek_token (parser)->location;
6949 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
6953 c_parser_error (parser, "missing loop condition in loop "
6959 c_parser_error (parser, "missing loop condition in loop "
6965 c_parser_consume_token (parser);
6971 cond = c_parser_condition (parser);
6972 c_parser_skip_until_found (parser, CPP_SEMICOLON,
6989 loc = incr_loc = c_parser_peek_token (parser)->location;
6990 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
6994 c_parser_error (parser,
7005 = c_fully_fold (c_parser_expression (parser).value, false, NULL);
7008 struct c_expr ce = c_parser_expression (parser);
7013 parens.skip_until_found_close (parser);
7021 = get_token_indent_info (c_parser_peek_token (parser));
7024 bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
7025 body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
7036 c_parser_maybe_reclassify_token (parser);
7039 = get_token_indent_info (c_parser_peek_token (parser));
7082 c_parser_asm_statement (c_parser *parser)
7086 location_t asm_loc = c_parser_peek_token (parser)->location;
7089 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
7090 c_parser_consume_token (parser);
7098 c_token *token = c_parser_peek_token (parser);
7110 c_parser_consume_token (parser);
7121 c_parser_consume_token (parser);
7132 c_parser_consume_token (parser);
7138 c_parser_consume_token (parser);
7154 if (!parens.require_open (parser))
7157 str = c_parser_asm_string_literal (parser);
7167 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
7174 if (c_parser_next_token_is (parser, CPP_SCOPE))
7179 c_parser_error (parser, "expected %<)%>");
7182 c_parser_consume_token (parser);
7184 else if (!c_parser_require (parser, CPP_COLON,
7194 if ((!c_parser_next_token_is (parser, CPP_COLON)
7195 && !c_parser_next_token_is (parser, CPP_SCOPE)
7196 && !c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
7204 outputs = c_parser_asm_operands (parser);
7207 inputs = c_parser_asm_operands (parser);
7210 clobbers = c_parser_asm_clobbers (parser);
7213 labels = c_parser_asm_goto_operands (parser);
7219 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN) && !is_goto)
7224 if (!parens.require_close (parser))
7226 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
7230 if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
7231 c_parser_skip_to_end_of_block_or_statement (parser);
7241 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
7257 c_parser_asm_operands (c_parser *parser)
7264 if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
7266 c_parser_consume_token (parser);
7267 if (c_parser_next_token_is (parser, CPP_NAME))
7269 tree id = c_parser_peek_token (parser)->value;
7270 c_parser_consume_token (parser);
7276 c_parser_error (parser, "expected identifier");
7277 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
7280 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
7285 str = c_parser_asm_string_literal (parser);
7289 if (!parens.require_open (parser))
7291 expr = c_parser_expression (parser);
7293 if (!parens.require_close (parser))
7295 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
7300 if (c_parser_next_token_is (parser, CPP_COMMA))
7301 c_parser_consume_token (parser);
7316 c_parser_asm_clobbers (c_parser *parser)
7321 tree str = c_parser_asm_string_literal (parser);
7326 if (c_parser_next_token_is (parser, CPP_COMMA))
7327 c_parser_consume_token (parser);
7342 c_parser_asm_goto_operands (c_parser *parser)
7349 if (c_parser_next_token_is (parser, CPP_NAME))
7351 c_token *tok = c_parser_peek_token (parser);
7354 c_parser_consume_token (parser);
7359 c_parser_error (parser, "expected identifier");
7366 if (c_parser_next_token_is (parser, CPP_COMMA))
7367 c_parser_consume_token (parser);
7380 c_parser_string_literal (c_parser *parser, bool translate, bool wide_ok)
7392 tok = c_parser_peek_token (parser);
7409 c_parser_error (parser, "expected string literal");
7419 switch (c_parser_peek_2nd_token (parser)->type)
7422 c_parser_consume_token (parser);
7439 c_parser_consume_token (parser);
7453 tok = c_parser_peek_token (parser);
7569 c_parser_expr_no_commas (c_parser *parser, struct c_expr *after,
7576 lhs = c_parser_conditional_expression (parser, after, omp_atomic_lhs);
7577 op_location = c_parser_peek_token (parser)->location;
7578 switch (c_parser_peek_token (parser)->type)
7616 c_parser_consume_token (parser);
7617 exp_location = c_parser_peek_token (parser)->location;
7618 rhs = c_parser_expr_no_commas (parser, NULL);
7651 c_parser_conditional_expression (c_parser *parser, struct c_expr *after,
7659 cond = c_parser_binary_expression (parser, after, omp_atomic_lhs);
7661 if (c_parser_next_token_is_not (parser, CPP_QUERY))
7667 cond_loc = c_parser_peek_token (parser)->location;
7669 c_parser_consume_token (parser);
7670 if (c_parser_next_token_is (parser, CPP_COLON))
7674 location_t middle_loc = c_parser_peek_token (parser)->location;
7701 exp1 = c_parser_expression_conv (parser);
7708 colon_loc = c_parser_peek_token (parser)->location;
7709 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
7718 location_t exp2_loc = c_parser_peek_token (parser)->location;
7719 exp2 = c_parser_conditional_expression (parser, NULL, NULL_TREE);
7813 c_parser_binary_expression (c_parser *parser, struct c_expr *after,
7904 && c_parser_peek_token (parser)->type == CPP_SEMICOLON \
7928 stack[0].loc = c_parser_peek_token (parser)->location;
7929 stack[0].expr = c_parser_cast_expression (parser, after);
7938 if (parser->error)
7940 switch (c_parser_peek_token (parser)->type)
8019 binary_loc = c_parser_peek_token (parser)->location;
8022 c_parser_consume_token (parser);
8052 stack[sp].expr = c_parser_cast_expression (parser, NULL);
8074 c_parser_cast_expression (c_parser *parser, struct c_expr *after)
8076 location_t cast_loc = c_parser_peek_token (parser)->location;
8079 return c_parser_postfix_expression_after_primary (parser,
8086 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
8087 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
8093 parens.consume_open (parser);
8094 type_name = c_parser_type_name (parser, true);
8095 parens.skip_until_found_close (parser);
8107 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
8108 return c_parser_postfix_expression_after_paren_type (parser, type_name,
8114 location_t expr_loc = c_parser_peek_token (parser)->location;
8115 expr = c_parser_cast_expression (parser, NULL);
8126 return c_parser_unary_expression (parser);
8164 c_parser_unary_expression (c_parser *parser)
8168 location_t op_loc = c_parser_peek_token (parser)->location;
8173 switch (c_parser_peek_token (parser)->type)
8176 c_parser_consume_token (parser);
8177 exp_loc = c_parser_peek_token (parser)->location;
8178 op = c_parser_cast_expression (parser, NULL);
8183 c_parser_consume_token (parser);
8184 exp_loc = c_parser_peek_token (parser)->location;
8185 op = c_parser_cast_expression (parser, NULL);
8190 c_parser_consume_token (parser);
8191 op = c_parser_cast_expression (parser, NULL);
8196 c_parser_consume_token (parser);
8197 exp_loc = c_parser_peek_token (parser)->location;
8198 op = c_parser_cast_expression (parser, NULL);
8212 c_parser_consume_token (parser);
8213 exp_loc = c_parser_peek_token (parser)->location;
8214 op = c_parser_cast_expression (parser, NULL);
8218 c_parser_consume_token (parser);
8219 exp_loc = c_parser_peek_token (parser)->location;
8220 op = c_parser_cast_expression (parser, NULL);
8224 c_parser_consume_token (parser);
8225 exp_loc = c_parser_peek_token (parser)->location;
8226 op = c_parser_cast_expression (parser, NULL);
8230 c_parser_consume_token (parser);
8231 exp_loc = c_parser_peek_token (parser)->location;
8232 op = c_parser_cast_expression (parser, NULL);
8237 c_parser_consume_token (parser);
8238 if (c_parser_next_token_is (parser, CPP_NAME))
8241 (c_parser_peek_token (parser)->value, op_loc);
8243 c_parser_peek_token (parser)->get_finish ());
8244 c_parser_consume_token (parser);
8248 c_parser_error (parser, "expected identifier");
8253 switch (c_parser_peek_token (parser)->keyword)
8256 return c_parser_sizeof_expression (parser);
8258 return c_parser_alignof_expression (parser);
8260 return c_parser_has_attribute_expression (parser);
8262 c_parser_consume_token (parser);
8264 ret = c_parser_cast_expression (parser, NULL);
8268 c_parser_consume_token (parser);
8269 exp_loc = c_parser_peek_token (parser)->location;
8270 op = c_parser_cast_expression (parser, NULL);
8274 c_parser_consume_token (parser);
8275 exp_loc = c_parser_peek_token (parser)->location;
8276 op = c_parser_cast_expression (parser, NULL);
8281 return c_parser_transaction_expression (parser,
8282 c_parser_peek_token (parser)->keyword);
8284 return c_parser_postfix_expression (parser);
8287 return c_parser_postfix_expression (parser);
8294 c_parser_sizeof_expression (c_parser *parser)
8299 gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF));
8304 start = c_parser_peek_token (parser)->location;
8306 c_parser_consume_token (parser);
8309 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
8310 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
8316 parens.consume_open (parser);
8317 expr_loc = c_parser_peek_token (parser)->location;
8318 type_name = c_parser_type_name (parser, true);
8319 parens.skip_until_found_close (parser);
8320 finish = parser->tokens_buf[0].location;
8331 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
8333 expr = c_parser_postfix_expression_after_paren_type (parser,
8349 expr_loc = c_parser_peek_token (parser)->location;
8350 expr = c_parser_unary_expression (parser);
8370 c_parser_alignof_expression (c_parser *parser)
8373 location_t start_loc = c_parser_peek_token (parser)->location;
8375 tree alignof_spelling = c_parser_peek_token (parser)->value;
8376 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
8391 c_parser_consume_token (parser);
8394 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
8395 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
8403 parens.consume_open (parser);
8404 loc = c_parser_peek_token (parser)->location;
8405 type_name = c_parser_type_name (parser, true);
8406 end_loc = c_parser_peek_token (parser)->location;
8407 parens.skip_until_found_close (parser);
8418 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
8420 expr = c_parser_postfix_expression_after_paren_type (parser,
8443 expr = c_parser_unary_expression (parser);
8465 c_parser_has_attribute_expression (c_parser *parser)
8467 gcc_assert (c_parser_next_token_is_keyword (parser,
8469 location_t start = c_parser_peek_token (parser)->location;
8470 c_parser_consume_token (parser);
8475 if (!parens.require_open (parser))
8494 if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
8496 struct c_type_name *tname = c_parser_type_name (parser);
8506 struct c_expr cexpr = c_parser_expr_no_commas (parser, NULL);
8527 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
8532 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
8533 c_parser_consume_token (parser);
8539 bool save_translate_strings_p = parser->translate_strings_p;
8541 location_t atloc = c_parser_peek_token (parser)->location;
8544 tree attr = c_parser_gnu_attribute (parser, NULL_TREE, false, false);
8546 parser->translate_strings_p = save_translate_strings_p;
8548 location_t finish = c_parser_peek_token (parser)->location;
8549 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
8550 c_parser_consume_token (parser);
8553 c_parser_error (parser, "expected identifier");
8554 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8563 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
8589 c_parser_get_builtin_args (c_parser *parser, const char *bname,
8594 location_t loc = c_parser_peek_token (parser)->location;
8600 if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
8606 c_parser_consume_token (parser);
8608 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
8610 *out_close_paren_loc = c_parser_peek_token (parser)->location;
8611 c_parser_consume_token (parser);
8618 expr = c_parser_expr_no_commas (parser, NULL);
8623 while (c_parser_next_token_is (parser, CPP_COMMA))
8625 c_parser_consume_token (parser);
8626 expr = c_parser_expr_no_commas (parser, NULL);
8630 *out_close_paren_loc = c_parser_peek_token (parser)->location;
8631 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
8665 c_parser_generic_selection (c_parser *parser)
8680 gcc_assert (c_parser_next_token_is_keyword (parser, RID_GENERIC));
8681 generic_loc = c_parser_peek_token (parser)->location;
8682 c_parser_consume_token (parser);
8691 if (!parens.require_open (parser))
8695 selector_loc = c_parser_peek_token (parser)->location;
8696 selector = c_parser_expr_no_commas (parser, NULL);
8702 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8719 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
8721 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8730 c_token *token = c_parser_peek_token (parser);
8735 c_parser_consume_token (parser);
8742 type_name = c_parser_type_name (parser);
8745 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8751 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8768 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
8770 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8774 assoc.expression = c_parser_expr_no_commas (parser, NULL);
8777 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8829 if (c_parser_peek_token (parser)->type != CPP_COMMA)
8831 c_parser_consume_token (parser);
8840 if (!parens.require_close (parser))
8842 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
8916 c_parser_predefined_identifier (c_parser *parser)
8918 location_t loc = c_parser_peek_token (parser)->location;
8919 switch (c_parser_peek_token (parser)->keyword)
8940 expr.value = fname_decl (loc, c_parser_peek_token (parser)->keyword,
8941 c_parser_peek_token (parser)->value);
8943 c_parser_consume_token (parser);
9012 c_parser_postfix_expression (c_parser *parser)
9016 location_t loc = c_parser_peek_token (parser)->location;
9017 source_range tok_range = c_parser_peek_token (parser)->get_range ();
9020 switch (c_parser_peek_token (parser)->type)
9023 expr.value = c_parser_peek_token (parser)->value;
9025 loc = c_parser_peek_token (parser)->location;
9026 c_parser_consume_token (parser);
9039 expr.value = c_parser_peek_token (parser)->value;
9044 c_parser_consume_token (parser);
9051 expr = c_parser_string_literal (parser, parser->translate_strings_p,
9057 = objc_build_string_object (c_parser_peek_token (parser)->value);
9059 c_parser_consume_token (parser);
9062 switch (c_parser_peek_token (parser)->id_kind)
9066 tree id = c_parser_peek_token (parser)->value;
9067 c_parser_consume_token (parser);
9069 (c_parser_peek_token (parser)->type
9079 tree class_name = c_parser_peek_token (parser)->value;
9081 c_parser_consume_token (parser);
9083 if (!c_parser_require (parser, CPP_DOT, "expected %<.%>"))
9088 if (c_parser_next_token_is_not (parser, CPP_NAME))
9090 c_parser_error (parser, "expected identifier");
9094 c_token *component_tok = c_parser_peek_token (parser);
9097 c_parser_consume_token (parser);
9104 c_parser_error (parser, "expected expression");
9112 if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
9117 c_parser_consume_token (parser);
9118 brace_loc = c_parser_peek_token (parser)->location;
9119 c_parser_consume_token (parser);
9127 parser->error = true;
9128 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
9129 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9134 c_parser_compound_statement_nostart (parser);
9135 location_t close_loc = c_parser_peek_token (parser)->location;
9136 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
9147 location_t loc_open_paren = c_parser_peek_token (parser)->location;
9148 c_parser_consume_token (parser);
9149 expr = c_parser_expression (parser);
9156 location_t loc_close_paren = c_parser_peek_token (parser)->location;
9158 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
9163 switch (c_parser_peek_token (parser)->keyword)
9168 expr = c_parser_predefined_identifier (parser);
9173 c_parser_consume_token (parser);
9175 if (!parens.require_open (parser))
9180 e1 = c_parser_expr_no_commas (parser, NULL);
9183 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
9185 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9189 loc = c_parser_peek_token (parser)->location;
9190 t1 = c_parser_type_name (parser);
9191 location_t end_loc = c_parser_peek_token (parser)->get_finish ();
9192 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
9216 c_parser_consume_token (parser);
9218 if (!parens.require_open (parser))
9223 t1 = c_parser_type_name (parser);
9225 parser->error = true;
9226 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
9227 gcc_assert (parser->error);
9228 if (parser->error)
9230 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9246 if (c_parser_next_token_is (parser, CPP_NAME))
9248 c_token *comp_tok = c_parser_peek_token (parser);
9251 c_parser_consume_token (parser);
9252 while (c_parser_next_token_is (parser, CPP_DOT)
9253 || c_parser_next_token_is (parser,
9255 || c_parser_next_token_is (parser,
9258 if (c_parser_next_token_is (parser, CPP_DEREF))
9260 loc = c_parser_peek_token (parser)->location;
9266 else if (c_parser_next_token_is (parser, CPP_DOT))
9269 c_parser_consume_token (parser);
9270 if (c_parser_next_token_is_not (parser,
9273 c_parser_error (parser, "expected identifier");
9276 c_token *comp_tok = c_parser_peek_token (parser);
9280 c_parser_consume_token (parser);
9286 loc = c_parser_peek_token (parser)->location;
9287 c_parser_consume_token (parser);
9288 ce = c_parser_expression (parser);
9292 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
9299 c_parser_error (parser, "expected identifier");
9300 location_t end_loc = c_parser_peek_token (parser)->get_finish ();
9301 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
9314 c_parser_consume_token (parser);
9315 if (!c_parser_get_builtin_args (parser,
9351 c_parser_consume_token (parser);
9353 if (!parens.require_open (parser))
9358 t1 = c_parser_type_name (parser);
9364 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
9366 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
9370 t2 = c_parser_type_name (parser);
9376 location_t close_paren_loc = c_parser_peek_token (parser)->location;
9377 parens.skip_until_found_close (parser);
9400 c_parser_consume_token (parser);
9401 if (!c_parser_get_builtin_args (parser,
9926 c_parser_consume_token (parser);
9927 if (!c_parser_get_builtin_args (parser,
9968 c_parser_consume_token (parser);
9969 if (!c_parser_get_builtin_args (parser,
10032 c_parser_consume_token (parser);
10033 if (!c_parser_get_builtin_args (parser,
10066 c_parser_consume_token (parser);
10068 if (!parens.require_open (parser))
10073 e1 = c_parser_expr_no_commas (parser, NULL);
10075 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
10077 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
10081 loc = c_parser_peek_token (parser)->location;
10082 t1 = c_parser_type_name (parser);
10083 location_t end_loc = c_parser_peek_token (parser)->get_finish ();
10084 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
10101 c_parser_consume_token (parser);
10103 if (!parens.require_open (parser))
10108 tree sel = c_parser_objc_selector_arg (parser);
10109 location_t close_loc = c_parser_peek_token (parser)->location;
10110 parens.skip_until_found_close (parser);
10118 c_parser_consume_token (parser);
10120 if (!parens.require_open (parser))
10125 if (c_parser_next_token_is_not (parser, CPP_NAME))
10127 c_parser_error (parser, "expected identifier");
10128 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
10132 tree id = c_parser_peek_token (parser)->value;
10133 c_parser_consume_token (parser);
10134 location_t close_loc = c_parser_peek_token (parser)->location;
10135 parens.skip_until_found_close (parser);
10144 c_parser_consume_token (parser);
10146 if (!parens.require_open (parser))
10151 t1 = c_parser_type_name (parser);
10155 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
10158 location_t close_loc = c_parser_peek_token (parser)->location;
10159 parens.skip_until_found_close (parser);
10166 expr = c_parser_generic_selection (parser);
10169 c_parser_error (parser, "expected expression");
10178 c_parser_consume_token (parser);
10179 receiver = c_parser_objc_receiver (parser);
10180 args = c_parser_objc_message_args (parser);
10181 location_t close_loc = c_parser_peek_token (parser)->location;
10182 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
10191 c_parser_error (parser, "expected expression");
10197 (parser, EXPR_LOC_OR_LOC (expr.value, loc), expr);
10211 c_parser_postfix_expression_after_paren_type (c_parser *parser,
10226 start_loc = c_parser_peek_token (parser)->location;
10232 init = c_parser_braced_init (parser, type, false, NULL);
10283 return c_parser_postfix_expression_after_primary (parser, start_loc, expr);
10446 c_parser_postfix_expression_after_primary (c_parser *parser,
10464 location_t op_loc = c_parser_peek_token (parser)->location;
10465 switch (c_parser_peek_token (parser)->type)
10469 c_parser_consume_token (parser);
10470 idx = c_parser_expression (parser).value;
10471 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
10474 finish = parser->tokens_buf[0].location;
10482 c_parser_consume_token (parser);
10489 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
10492 exprlist = c_parser_expr_list (parser, true, false, &origtypes,
10495 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
10520 finish = parser->tokens_buf[0].get_finish ();
10541 c_parser_consume_token (parser);
10543 if (c_parser_next_token_is (parser, CPP_NAME))
10545 c_token *comp_tok = c_parser_peek_token (parser);
10551 c_parser_error (parser, "expected identifier");
10558 finish = c_parser_peek_token (parser)->get_finish ();
10559 c_parser_consume_token (parser);
10578 c_parser_consume_token (parser);
10580 if (c_parser_next_token_is (parser, CPP_NAME))
10582 c_token *comp_tok = c_parser_peek_token (parser);
10588 c_parser_error (parser, "expected identifier");
10595 finish = c_parser_peek_token (parser)->get_finish ();
10596 c_parser_consume_token (parser);
10619 finish = c_parser_peek_token (parser)->get_finish ();
10620 c_parser_consume_token (parser);
10631 finish = c_parser_peek_token (parser)->get_finish ();
10632 c_parser_consume_token (parser);
10654 c_parser_expression (c_parser *parser)
10656 location_t tloc = c_parser_peek_token (parser)->location;
10658 expr = c_parser_expr_no_commas (parser, NULL);
10659 if (c_parser_next_token_is (parser, CPP_COMMA))
10661 while (c_parser_next_token_is (parser, CPP_COMMA))
10665 location_t loc = c_parser_peek_token (parser)->location;
10667 c_parser_consume_token (parser);
10668 expr_loc = c_parser_peek_token (parser)->location;
10674 next = c_parser_expr_no_commas (parser, NULL);
10687 c_parser_expression_conv (c_parser *parser)
10690 location_t loc = c_parser_peek_token (parser)->location;
10691 expr = c_parser_expression (parser);
10700 c_parser_check_literal_zero (c_parser *parser, unsigned *literal_zero_mask,
10706 c_token *tok = c_parser_peek_token (parser);
10719 && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
10720 || c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_PAREN))
10738 c_parser_expr_list (c_parser *parser, bool convert_p, bool fold_p,
10756 c_parser_check_literal_zero (parser, literal_zero_mask, 0);
10757 expr = c_parser_expr_no_commas (parser, NULL);
10773 while (c_parser_next_token_is (parser, CPP_COMMA))
10775 c_parser_consume_token (parser);
10777 c_parser_check_literal_zero (parser, literal_zero_mask, idx + 1);
10778 expr = c_parser_expr_no_commas (parser, NULL);
10828 c_parser_objc_class_definition (c_parser *parser, tree attributes)
10833 if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE))
10835 else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION))
10840 c_parser_consume_token (parser);
10841 if (c_parser_next_token_is_not (parser, CPP_NAME))
10843 c_parser_error (parser, "expected identifier");
10846 id1 = c_parser_peek_token (parser)->value;
10847 c_parser_consume_token (parser);
10848 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
10854 parens.consume_open (parser);
10855 if (c_parser_next_token_is_not (parser, CPP_NAME))
10857 if (iface_p && c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
10864 c_parser_error (parser, "expected identifier or %<)%>");
10865 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
10871 id2 = c_parser_peek_token (parser)->value;
10872 c_parser_consume_token (parser);
10874 parens.skip_until_found_close (parser);
10880 if (c_parser_next_token_is (parser, CPP_LESS))
10881 proto = c_parser_objc_protocol_refs (parser);
10883 c_parser_objc_methodprotolist (parser);
10884 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
10888 if (c_parser_next_token_is (parser, CPP_COLON))
10890 c_parser_consume_token (parser);
10891 if (c_parser_next_token_is_not (parser, CPP_NAME))
10893 c_parser_error (parser, "expected identifier");
10896 superclass = c_parser_peek_token (parser)->value;
10897 c_parser_consume_token (parser);
10904 if (c_parser_next_token_is (parser, CPP_LESS))
10905 proto = c_parser_objc_protocol_refs (parser);
10910 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
10911 c_parser_objc_class_instance_variables (parser);
10915 c_parser_objc_methodprotolist (parser);
10916 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
10949 c_parser_objc_class_instance_variables (c_parser *parser)
10951 gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
10952 c_parser_consume_token (parser);
10953 while (c_parser_next_token_is_not (parser, CPP_EOF))
10957 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
10959 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
10961 c_parser_consume_token (parser);
10965 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
10967 c_parser_consume_token (parser);
10971 if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
10973 c_parser_consume_token (parser);
10977 else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED))
10979 c_parser_consume_token (parser);
10983 else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC))
10985 c_parser_consume_token (parser);
10989 else if (c_parser_next_token_is_keyword (parser, RID_AT_PACKAGE))
10991 c_parser_consume_token (parser);
10995 else if (c_parser_next_token_is (parser, CPP_PRAGMA))
10997 c_parser_pragma (parser, pragma_external, NULL);
11002 decls = c_parser_struct_declaration (parser);
11012 c_token *token = c_parser_peek_token (parser);
11014 c_parser_consume_token (parser);
11017 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
11020 parser->error = false;
11031 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
11042 c_parser_objc_class_declaration (c_parser *parser)
11044 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS));
11045 c_parser_consume_token (parser);
11051 if (c_parser_next_token_is_not (parser, CPP_NAME))
11053 c_parser_error (parser, "expected identifier");
11054 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
11055 parser->error = false;
11058 id = c_parser_peek_token (parser)->value;
11060 c_parser_consume_token (parser);
11061 if (c_parser_next_token_is (parser, CPP_COMMA))
11062 c_parser_consume_token (parser);
11066 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
11076 c_parser_objc_alias_declaration (c_parser *parser)
11079 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS));
11080 c_parser_consume_token (parser);
11081 if (c_parser_next_token_is_not (parser, CPP_NAME))
11083 c_parser_error (parser, "expected identifier");
11084 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
11087 id1 = c_parser_peek_token (parser)->value;
11088 c_parser_consume_token (parser);
11089 if (c_parser_next_token_is_not (parser, CPP_NAME))
11091 c_parser_error (parser, "expected identifier");
11092 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
11095 id2 = c_parser_peek_token (parser)->value;
11096 c_parser_consume_token (parser);
11097 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
11113 c_parser_objc_protocol_definition (c_parser *parser, tree attributes)
11115 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL));
11117 c_parser_consume_token (parser);
11118 if (c_parser_next_token_is_not (parser, CPP_NAME))
11120 c_parser_error (parser, "expected identifier");
11123 if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
11124 || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
11131 if (c_parser_next_token_is_not (parser, CPP_NAME))
11133 c_parser_error (parser, "expected identifier");
11136 id = c_parser_peek_token (parser)->value;
11138 c_parser_consume_token (parser);
11139 if (c_parser_next_token_is (parser, CPP_COMMA))
11140 c_parser_consume_token (parser);
11144 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
11148 tree id = c_parser_peek_token (parser)->value;
11150 c_parser_consume_token (parser);
11151 if (c_parser_next_token_is (parser, CPP_LESS))
11152 proto = c_parser_objc_protocol_refs (parser);
11153 parser->objc_pq_context = true;
11155 c_parser_objc_methodprotolist (parser);
11156 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
11157 parser->objc_pq_context = false;
11172 c_parser_objc_method_type (c_parser *parser)
11174 switch (c_parser_peek_token (parser)->type)
11177 c_parser_consume_token (parser);
11180 c_parser_consume_token (parser);
11194 c_parser_objc_method_definition (c_parser *parser)
11196 bool is_class_method = c_parser_objc_method_type (parser);
11198 parser->objc_pq_context = true;
11199 decl = c_parser_objc_method_decl (parser, is_class_method, &attributes,
11204 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
11206 c_parser_consume_token (parser);
11207 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
11211 if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE))
11213 c_parser_error (parser, "expected %<{%>");
11217 parser->objc_pq_context = false;
11220 add_stmt (c_parser_compound_statement (parser));
11230 c_parser_compound_statement (parser);
11251 c_parser_objc_methodprotolist (c_parser *parser)
11256 switch (c_parser_peek_token (parser)->type)
11259 pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
11261 c_parser_consume_token (parser);
11265 c_parser_objc_methodproto (parser);
11268 c_parser_pragma (parser, pragma_external, NULL);
11273 if (c_parser_next_token_is_keyword (parser, RID_AT_END))
11275 else if (c_parser_next_token_is_keyword (parser, RID_AT_PROPERTY))
11276 c_parser_objc_at_property_declaration (parser);
11277 else if (c_parser_next_token_is_keyword (parser, RID_AT_OPTIONAL))
11280 c_parser_consume_token (parser);
11282 else if (c_parser_next_token_is_keyword (parser, RID_AT_REQUIRED))
11285 c_parser_consume_token (parser);
11288 c_parser_declaration_or_fndef (parser, false, false, true,
11302 c_parser_objc_methodproto (c_parser *parser)
11304 bool is_class_method = c_parser_objc_method_type (parser);
11308 parser->objc_pq_context = true;
11309 decl = c_parser_objc_method_decl (parser, is_class_method, &attributes,
11312 parser->objc_pq_context = false;
11316 if (!c_parser_next_token_is (parser, CPP_SEMICOLON))
11318 c_parser_error (parser, "expected %<;%>");
11325 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
11334 c_parser_objc_maybe_method_attributes (c_parser* parser, tree* attributes)
11339 c_parser_error (parser,
11345 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
11346 *attributes = c_parser_gnu_attributes (parser);
11354 if (c_parser_next_token_is (parser, CPP_SEMICOLON)
11355 || c_parser_next_token_is (parser, CPP_OPEN_BRACE))
11359 c_parser_error (parser,
11396 c_parser_objc_method_decl (c_parser *parser, bool is_class_method,
11406 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
11409 parens.consume_open (parser);
11410 type = c_parser_objc_type_name (parser);
11411 parens.skip_until_found_close (parser);
11413 sel = c_parser_objc_selector (parser);
11417 if (!sel || c_parser_next_token_is (parser, CPP_COLON))
11425 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
11427 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
11429 c_parser_consume_token (parser);
11430 atype = c_parser_objc_type_name (parser);
11431 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
11435 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
11436 param_attr = c_parser_gnu_attributes (parser);
11437 if (c_parser_next_token_is_not (parser, CPP_NAME))
11439 c_parser_error (parser, "expected identifier");
11442 id = c_parser_peek_token (parser)->value;
11443 c_parser_consume_token (parser);
11446 tsel = c_parser_objc_selector (parser);
11447 if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON))
11451 attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
11457 while (c_parser_next_token_is (parser, CPP_COMMA))
11460 c_parser_consume_token (parser);
11461 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
11464 c_parser_consume_token (parser);
11466 (parser, attributes) ;
11469 parm = c_parser_parameter_declaration (parser, NULL_TREE, false);
11478 attr_err |= c_parser_objc_maybe_method_attributes (parser, attributes) ;
11482 c_parser_error (parser, "objective-c method declaration is expected");
11507 c_parser_objc_type_name (c_parser *parser)
11514 c_token *token = c_parser_peek_token (parser);
11524 c_parser_consume_token (parser);
11529 if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
11530 type_name = c_parser_type_name (parser);
11551 c_parser_objc_protocol_refs (c_parser *parser)
11554 gcc_assert (c_parser_next_token_is (parser, CPP_LESS));
11555 c_parser_consume_token (parser);
11561 if (c_parser_next_token_is_not (parser, CPP_NAME))
11563 c_parser_error (parser, "expected identifier");
11566 id = c_parser_peek_token (parser)->value;
11568 c_parser_consume_token (parser);
11569 if (c_parser_next_token_is (parser, CPP_COMMA))
11570 c_parser_consume_token (parser);
11574 c_parser_require (parser, CPP_GREATER, "expected %<>%>");
11598 c_parser_objc_try_catch_finally_statement (c_parser *parser)
11603 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY));
11604 c_parser_consume_token (parser);
11605 location = c_parser_peek_token (parser)->location;
11607 stmt = c_parser_compound_statement (parser);
11610 while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH))
11616 c_parser_consume_token (parser);
11618 if (!parens.require_open (parser))
11620 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
11627 c_parser_consume_token (parser);
11634 parm = c_parser_parameter_declaration (parser, NULL_TREE, false);
11641 parens.require_close (parser);
11652 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
11653 c_parser_consume_token (parser);
11661 if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
11662 c_parser_compound_statement_nostart (parser);
11665 if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
11667 c_parser_consume_token (parser);
11668 location = c_parser_peek_token (parser)->location;
11669 stmt = c_parser_compound_statement (parser);
11682 c_parser_objc_synchronized_statement (c_parser *parser)
11686 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED));
11687 c_parser_consume_token (parser);
11688 loc = c_parser_peek_token (parser)->location;
11691 if (parens.require_open (parser))
11693 struct c_expr ce = c_parser_expression (parser);
11697 parens.skip_until_found_close (parser);
11701 stmt = c_parser_compound_statement (parser);
11721 c_parser_objc_selector (c_parser *parser)
11723 c_token *token = c_parser_peek_token (parser);
11727 c_parser_consume_token (parser);
11780 c_parser_consume_token (parser);
11803 c_parser_objc_selector_arg (c_parser *parser)
11805 tree sel = c_parser_objc_selector (parser);
11808 && c_parser_next_token_is_not (parser, CPP_COLON)
11809 && c_parser_next_token_is_not (parser, CPP_SCOPE))
11813 if (c_parser_next_token_is (parser, CPP_SCOPE))
11815 c_parser_consume_token (parser);
11821 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
11825 sel = c_parser_objc_selector (parser);
11827 && c_parser_next_token_is_not (parser, CPP_COLON)
11828 && c_parser_next_token_is_not (parser, CPP_SCOPE))
11843 c_parser_objc_receiver (c_parser *parser)
11845 location_t loc = c_parser_peek_token (parser)->location;
11847 if (c_parser_peek_token (parser)->type == CPP_NAME
11848 && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
11849 || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
11851 tree id = c_parser_peek_token (parser)->value;
11852 c_parser_consume_token (parser);
11855 struct c_expr ce = c_parser_expression (parser);
11876 c_parser_objc_message_args (c_parser *parser)
11878 tree sel = c_parser_objc_selector (parser);
11880 if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
11885 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
11887 keywordexpr = c_parser_objc_keywordexpr (parser);
11889 sel = c_parser_objc_selector (parser);
11890 if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
11903 c_parser_objc_keywordexpr (c_parser *parser)
11906 vec<tree, va_gc> *expr_list = c_parser_expr_list (parser, true, true,
11926 c_parser_objc_diagnose_bad_element_prefix (c_parser *parser,
11932 c_parser_error (parser,
11934 c_parser_skip_to_end_of_block_or_statement (parser);
11971 c_parser_objc_at_property_declaration (c_parser *parser)
11973 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROPERTY));
11974 location_t loc = c_parser_peek_token (parser)->location;
11975 c_parser_consume_token (parser); /* Eat '@property'. */
11983 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
11987 location_t attr_start = c_parser_peek_token (parser)->location;
11989 parens.consume_open (parser);
11992 parser->objc_property_attr_context = true;
11995 location_t attr_end = c_parser_peek_token (parser)->location;
11997 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
12006 c_token *token = c_parser_peek_token (parser);
12018 c_parser_consume_token (parser);
12040 c_parser_consume_token (parser);
12063 if (c_parser_next_token_is_not (parser, CPP_EQ))
12071 token = c_parser_peek_token (parser);
12073 c_parser_consume_token (parser); /* eat the = */
12074 if (c_parser_next_token_is_not (parser, CPP_NAME))
12083 token = c_parser_peek_token (parser);
12086 c_parser_consume_token (parser);
12089 if (c_parser_next_token_is_not (parser, CPP_COLON))
12100 (parser)->location);
12101 c_parser_consume_token (parser);
12121 if (c_parser_next_token_is (parser, CPP_COMMA))
12122 c_parser_consume_token (parser);
12126 parser->objc_property_attr_context = false;
12128 if (syntax_error && c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
12134 syntax_error = false, parens.skip_until_found_close (parser);
12140 tree properties = c_parser_struct_declaration (parser);
12143 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
12147 c_parser_error (parser, "expected identifier");
12157 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
12163 parser->error = false;
12187 c_parser_objc_at_synthesize_declaration (c_parser *parser)
12191 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNTHESIZE));
12192 loc = c_parser_peek_token (parser)->location;
12194 c_parser_consume_token (parser);
12198 if (c_parser_next_token_is_not (parser, CPP_NAME))
12200 c_parser_error (parser, "expected identifier");
12201 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
12203 We have to reset parser->error manually because
12206 parser->error = false;
12209 property = c_parser_peek_token (parser)->value;
12210 c_parser_consume_token (parser);
12211 if (c_parser_next_token_is (parser, CPP_EQ))
12213 c_parser_consume_token (parser);
12214 if (c_parser_next_token_is_not (parser, CPP_NAME))
12216 c_parser_error (parser, "expected identifier");
12217 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
12218 parser->error = false;
12221 ivar = c_parser_peek_token (parser)->value;
12222 c_parser_consume_token (parser);
12227 if (c_parser_next_token_is (parser, CPP_COMMA))
12228 c_parser_consume_token (parser);
12232 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
12249 c_parser_objc_at_dynamic_declaration (c_parser *parser)
12253 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_DYNAMIC));
12254 loc = c_parser_peek_token (parser)->location;
12256 c_parser_consume_token (parser);
12260 if (c_parser_next_token_is_not (parser, CPP_NAME))
12262 c_parser_error (parser, "expected identifier");
12263 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
12264 parser->error = false;
12267 property = c_parser_peek_token (parser)->value;
12269 c_parser_consume_token (parser);
12270 if (c_parser_next_token_is (parser, CPP_COMMA))
12271 c_parser_consume_token (parser);
12275 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
12284 c_parse_pragma_ivdep (c_parser *parser)
12286 c_parser_consume_pragma (parser);
12287 c_parser_skip_to_pragma_eol (parser);
12294 c_parser_pragma_unroll (c_parser *parser)
12297 c_parser_consume_pragma (parser);
12298 location_t location = c_parser_peek_token (parser)->location;
12299 tree expr = c_parser_expr_no_commas (parser, NULL).value;
12320 c_parser_skip_to_pragma_eol (parser);
12330 c_parser_pragma (c_parser *parser, enum pragma_context context, bool *if_p)
12335 input_location = c_parser_peek_token (parser)->location;
12336 id = c_parser_peek_token (parser)->pragma_kind;
12342 c_parser_oacc_declare (parser);
12352 error_at (c_parser_peek_token (parser)->location,
12355 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12360 c_parser_oacc_enter_exit_data (parser, true);
12369 c_parser_oacc_enter_exit_data (parser, false);
12375 error_at (c_parser_peek_token (parser)->location,
12377 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12380 c_parser_oacc_routine (parser, context);
12389 c_parser_oacc_update (parser);
12398 c_parser_omp_barrier (parser);
12407 c_parser_omp_depobj (parser);
12416 c_parser_omp_flush (parser);
12425 c_parser_omp_taskwait (parser);
12434 c_parser_omp_taskyield (parser);
12443 c_parser_omp_cancel (parser);
12447 c_parser_omp_cancellation_point (parser, context);
12451 c_parser_omp_threadprivate (parser);
12455 return c_parser_omp_target (parser, context, if_p);
12458 c_parser_omp_end_declare_target (parser);
12462 error_at (c_parser_peek_token (parser)->location,
12465 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12469 error_at (c_parser_peek_token (parser)->location,
12472 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12476 c_parser_omp_declare (parser, context);
12482 error_at (c_parser_peek_token (parser)->location,
12484 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12487 c_parser_omp_requires (parser);
12491 return c_parser_omp_ordered (parser, context, if_p);
12495 const bool ivdep = c_parse_pragma_ivdep (parser);
12497 if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_UNROLL)
12498 unroll = c_parser_pragma_unroll (parser);
12501 if (!c_parser_next_token_is_keyword (parser, RID_FOR)
12502 && !c_parser_next_token_is_keyword (parser, RID_WHILE)
12503 && !c_parser_next_token_is_keyword (parser, RID_DO))
12505 c_parser_error (parser, "for, while or do statement expected");
12508 if (c_parser_next_token_is_keyword (parser, RID_FOR))
12509 c_parser_for_statement (parser, ivdep, unroll, if_p);
12510 else if (c_parser_next_token_is_keyword (parser, RID_WHILE))
12511 c_parser_while_statement (parser, ivdep, unroll, if_p);
12513 c_parser_do_statement (parser, ivdep, unroll);
12519 unsigned short unroll = c_parser_pragma_unroll (parser);
12521 if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_IVDEP)
12522 ivdep = c_parse_pragma_ivdep (parser);
12525 if (!c_parser_next_token_is_keyword (parser, RID_FOR)
12526 && !c_parser_next_token_is_keyword (parser, RID_WHILE)
12527 && !c_parser_next_token_is_keyword (parser, RID_DO))
12529 c_parser_error (parser, "for, while or do statement expected");
12532 if (c_parser_next_token_is_keyword (parser, RID_FOR))
12533 c_parser_for_statement (parser, ivdep, unroll, if_p);
12534 else if (c_parser_next_token_is_keyword (parser, RID_WHILE))
12535 c_parser_while_statement (parser, ivdep, unroll, if_p);
12537 c_parser_do_statement (parser, ivdep, unroll);
12542 c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first");
12543 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12560 c_parser_error (parser, "expected declaration specifiers");
12561 c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL);
12564 c_parser_omp_construct (parser, if_p);
12570 c_parser_consume_pragma (parser);
12576 parser->error = true;
12577 c_parser_skip_to_pragma_eol (parser);
12609 c_parser_pragma_pch_preprocess (c_parser *parser)
12613 parser->lex_joined_string = true;
12614 c_parser_consume_pragma (parser);
12615 if (c_parser_next_token_is (parser, CPP_STRING))
12617 name = c_parser_peek_token (parser)->value;
12618 c_parser_consume_token (parser);
12621 c_parser_error (parser, "expected string literal");
12622 c_parser_skip_to_pragma_eol (parser);
12623 parser->lex_joined_string = false;
12638 c_parser_omp_clause_name (c_parser *parser)
12642 if (c_parser_next_token_is_keyword (parser, RID_AUTO))
12644 else if (c_parser_next_token_is_keyword (parser, RID_IF))
12646 else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
12648 else if (c_parser_next_token_is_keyword (parser, RID_FOR))
12650 else if (c_parser_next_token_is (parser, CPP_NAME))
12652 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
12868 c_parser_consume_token (parser);
12887 c_parser_oacc_wait_list (c_parser *parser, location_t clause_loc, tree list)
12893 if (!parens.require_open (parser))
12896 args = c_parser_expr_list (parser, false, true, NULL, NULL, NULL, NULL);
12907 c_parser_error (parser, "expression must be integral");
12922 parens.require_close (parser);
12942 c_parser_omp_variable_list (c_parser *parser,
12956 if (c_parser_next_token_is_not (parser, CPP_NAME)
12957 || c_parser_peek_token (parser)->id_kind != C_ID_ID)
12959 struct c_expr expr = c_parser_expr_no_commas (parser, NULL);
12968 if (c_parser_next_token_is_not (parser, CPP_COMMA))
12971 c_parser_consume_token (parser);
12980 c_token *token = c_parser_peek_token (parser);
13004 c_parser_consume_token (parser);
13017 tokens_avail = parser->tokens_avail;
13018 gcc_assert (parser->tokens == &parser->tokens_buf[0]);
13019 parser->tokens = tokens.address ();
13020 parser->tokens_avail = tokens.length ();
13025 if (c_parser_next_token_is (parser, CPP_NAME)
13026 && c_parser_peek_token (parser)->id_kind == C_ID_ID)
13028 t = lookup_name (c_parser_peek_token (parser)->value);
13032 undeclared_variable (c_parser_peek_token (parser)->location,
13033 c_parser_peek_token (parser)->value);
13037 c_parser_consume_token (parser);
13039 else if (c_parser_next_token_is (parser, CPP_KEYWORD)
13040 && (c_parser_peek_token (parser)->keyword == RID_FUNCTION_NAME
13041 || (c_parser_peek_token (parser)->keyword
13043 || (c_parser_peek_token (parser)->keyword
13045 t = c_parser_predefined_identifier (parser).value;
13049 c_parser_error (parser, "expected identifier");
13062 if (c_parser_peek_token (parser)->type != CPP_OPEN_SQUARE)
13064 c_parser_error (parser, "expected %<[%>");
13072 while (c_parser_next_token_is (parser, CPP_DOT)
13074 && c_parser_next_token_is (parser, CPP_DEREF)))
13076 location_t op_loc = c_parser_peek_token (parser)->location;
13077 if (c_parser_next_token_is (parser, CPP_DEREF))
13079 c_parser_consume_token (parser);
13080 if (!c_parser_next_token_is (parser, CPP_NAME))
13082 c_parser_error (parser, "expected identifier");
13087 c_token *comp_tok = c_parser_peek_token (parser);
13090 c_parser_consume_token (parser);
13098 while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
13102 c_parser_consume_token (parser);
13103 if (!c_parser_next_token_is (parser, CPP_COLON))
13106 = c_parser_peek_token (parser)->location;
13107 c_expr expr = c_parser_expression (parser);
13112 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
13117 if (!c_parser_require (parser, CPP_COLON,
13124 if (!c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
13127 = c_parser_peek_token (parser)->location;
13128 c_expr expr = c_parser_expression (parser);
13135 if (!c_parser_require (parser, CPP_CLOSE_SQUARE,
13146 && parser->tokens_avail != 2)
13150 error_at (c_parser_peek_token (parser)->location,
13156 parser->tokens = tokens.address ();
13157 parser->tokens_avail = tokens.length ();
13159 t = c_parser_expr_no_commas (parser, NULL).value;
13160 if (t != error_mark_node && parser->tokens_avail != 2)
13162 error_at (c_parser_peek_token (parser)->location,
13186 parser->tokens = &parser->tokens_buf[0];
13187 parser->tokens_avail = tokens_avail;
13189 if (c_parser_next_token_is_not (parser, CPP_COMMA))
13192 c_parser_consume_token (parser);
13204 c_parser_omp_var_list_parens (c_parser *parser, enum omp_clause_code kind,
13208 location_t loc = c_parser_peek_token (parser)->location;
13211 if (parens.require_open (parser))
13213 list = c_parser_omp_variable_list (parser, loc, kind, list, allow_deref);
13214 parens.skip_until_found_close (parser);
13233 c_parser_oacc_data_clause (c_parser *parser, pragma_omp_clause c_kind,
13282 nl = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_MAP, list, true);
13294 c_parser_oacc_data_clause_deviceptr (c_parser *parser, tree list)
13296 location_t loc = c_parser_peek_token (parser)->location;
13302 vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
13334 c_parser_omp_clause_collapse (c_parser *parser, tree list)
13343 loc = c_parser_peek_token (parser)->location;
13345 if (parens.require_open (parser))
13347 num = c_parser_expr_no_commas (parser, NULL).value;
13348 parens.skip_until_found_close (parser);
13373 c_parser_omp_clause_copyin (c_parser *parser, tree list)
13375 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list);
13382 c_parser_omp_clause_copyprivate (c_parser *parser, tree list)
13384 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list);
13394 c_parser_omp_clause_default (c_parser *parser, tree list, bool is_oacc)
13397 location_t loc = c_parser_peek_token (parser)->location;
13401 if (!parens.require_open (parser))
13403 if (c_parser_next_token_is (parser, CPP_NAME))
13405 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
13431 c_parser_consume_token (parser);
13437 c_parser_error (parser, "expected %<none%> or %<present%>");
13439 c_parser_error (parser, "expected %<none%> or %<shared%>");
13441 parens.skip_until_found_close (parser);
13458 c_parser_omp_clause_firstprivate (c_parser *parser, tree list)
13460 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list);
13467 c_parser_omp_clause_final (c_parser *parser, tree list)
13469 location_t loc = c_parser_peek_token (parser)->location;
13470 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
13474 if (!parens.require_open (parser))
13478 location_t eloc = c_parser_peek_token (parser)->location;
13479 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13483 parens.skip_until_found_close (parser);
13494 c_parser_error (parser, "expected %<(%>");
13514 c_parser_omp_clause_if (c_parser *parser, tree list, bool is_omp)
13516 location_t location = c_parser_peek_token (parser)->location;
13520 if (!parens.require_open (parser))
13523 if (is_omp && c_parser_next_token_is (parser, CPP_NAME))
13525 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
13540 if (c_parser_peek_2nd_token (parser)->type == CPP_NAME)
13542 p = IDENTIFIER_POINTER (c_parser_peek_2nd_token (parser)->value);
13554 c_parser_consume_token (parser);
13558 location_t loc = c_parser_peek_2nd_token (parser)->location;
13566 if (c_parser_peek_2nd_token (parser)->type == CPP_NAME)
13569 (c_parser_peek_2nd_token (parser)->value);
13574 c_parser_consume_token (parser);
13578 = c_parser_peek_2nd_token (parser)->location;
13587 if (c_parser_peek_2nd_token (parser)->type == CPP_COLON)
13589 c_parser_consume_token (parser);
13590 c_parser_consume_token (parser);
13596 location_t loc = c_parser_peek_2nd_token (parser)->location;
13604 location_t loc = c_parser_peek_token (parser)->location;
13605 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13609 parens.skip_until_found_close (parser);
13667 c_parser_omp_clause_lastprivate (c_parser *parser, tree list)
13670 location_t loc = c_parser_peek_token (parser)->location;
13672 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
13675 if (c_parser_next_token_is (parser, CPP_NAME)
13676 && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
13679 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
13683 c_parser_consume_token (parser);
13684 c_parser_consume_token (parser);
13687 tree nlist = c_parser_omp_variable_list (parser, loc,
13689 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
13702 c_parser_omp_clause_mergeable (c_parser *parser ATTRIBUTE_UNUSED, tree list)
13709 c = build_omp_clause (c_parser_peek_token (parser)->location,
13720 c_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list)
13723 location_t loc = c_parser_peek_token (parser)->location;
13736 c_parser_omp_clause_num_threads (c_parser *parser, tree list)
13738 location_t num_threads_loc = c_parser_peek_token (parser)->location;
13740 if (parens.require_open (parser))
13742 location_t expr_loc = c_parser_peek_token (parser)->location;
13743 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13748 parens.skip_until_found_close (parser);
13752 c_parser_error (parser, "expected integer expression");
13782 c_parser_omp_clause_num_tasks (c_parser *parser, tree list)
13784 location_t num_tasks_loc = c_parser_peek_token (parser)->location;
13786 if (parens.require_open (parser))
13788 location_t expr_loc = c_parser_peek_token (parser)->location;
13789 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13794 parens.skip_until_found_close (parser);
13798 c_parser_error (parser, "expected integer expression");
13828 c_parser_omp_clause_grainsize (c_parser *parser, tree list)
13830 location_t grainsize_loc = c_parser_peek_token (parser)->location;
13832 if (parens.require_open (parser))
13834 location_t expr_loc = c_parser_peek_token (parser)->location;
13835 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13840 parens.skip_until_found_close (parser);
13844 c_parser_error (parser, "expected integer expression");
13874 c_parser_omp_clause_priority (c_parser *parser, tree list)
13876 location_t priority_loc = c_parser_peek_token (parser)->location;
13878 if (parens.require_open (parser))
13880 location_t expr_loc = c_parser_peek_token (parser)->location;
13881 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13886 parens.skip_until_found_close (parser);
13890 c_parser_error (parser, "expected integer expression");
13921 c_parser_omp_clause_hint (c_parser *parser, tree list)
13923 location_t hint_loc = c_parser_peek_token (parser)->location;
13925 if (parens.require_open (parser))
13927 location_t expr_loc = c_parser_peek_token (parser)->location;
13928 c_expr expr = c_parser_expr_no_commas (parser, NULL);
13933 parens.skip_until_found_close (parser);
13938 c_parser_error (parser, "expected constant integer expression");
13960 c_parser_omp_clause_defaultmap (c_parser *parser, tree list)
13962 location_t loc = c_parser_peek_token (parser)->location;
13970 if (!parens.require_open (parser))
13972 if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
13974 else if (!c_parser_next_token_is (parser, CPP_NAME))
13977 c_parser_error (parser, "expected %<alloc%>, %<to%>, %<from%>, "
13983 p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
14029 c_parser_consume_token (parser);
14031 if (!c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
14033 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
14035 if (!c_parser_next_token_is (parser, CPP_NAME))
14038 c_parser_error (parser, "expected %<scalar%>, %<aggregate%> or "
14042 p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
14070 c_parser_consume_token (parser);
14072 parens.skip_until_found_close (parser);
14118 parens.skip_until_found_close (parser);
14129 c_parser_omp_clause_use_device_ptr (c_parser *parser, tree list)
14131 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_USE_DEVICE_PTR,
14139 c_parser_omp_clause_use_device_addr (c_parser *parser, tree list)
14141 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_USE_DEVICE_ADDR,
14149 c_parser_omp_clause_is_device_ptr (c_parser *parser, tree list)
14151 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_IS_DEVICE_PTR, list);
14160 c_parser_oacc_single_int_clause (c_parser *parser, omp_clause_code code,
14163 location_t loc = c_parser_peek_token (parser)->location;
14166 if (!parens.require_open (parser))
14169 location_t expr_loc = c_parser_peek_token (parser)->location;
14170 c_expr expr = c_parser_expression (parser);
14175 parens.skip_until_found_close (parser);
14224 c_parser_oacc_shape_clause (c_parser *parser, location_t loc,
14234 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
14236 c_parser_consume_token (parser);
14240 c_token *next = c_parser_peek_token (parser);
14245 && c_parser_next_token_is_keyword (parser, RID_STATIC))
14247 c_parser_consume_token (parser);
14249 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
14255 c_parser_error (parser, "too many %<static%> arguments");
14260 if (c_parser_next_token_is (parser, CPP_MULT)
14261 && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
14262 || c_parser_peek_2nd_token (parser)->type
14265 c_parser_consume_token (parser);
14268 if (c_parser_next_token_is (parser, CPP_COMMA))
14270 c_parser_consume_token (parser);
14278 else if (c_parser_next_token_is (parser, CPP_NAME)
14280 && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
14282 c_parser_consume_token (parser); /* id */
14283 c_parser_consume_token (parser); /* ':' */
14289 c_parser_error (parser, "unexpected argument");
14293 location_t expr_loc = c_parser_peek_token (parser)->location;
14294 c_expr cexpr = c_parser_expr_no_commas (parser, NULL);
14307 c_parser_error (parser, "expected integer expression");
14323 && c_parser_next_token_is (parser, CPP_COMMA))
14325 c_parser_consume_token (parser);
14332 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
14349 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
14376 c_parser_oacc_clause_async (c_parser *parser, tree list)
14379 location_t loc = c_parser_peek_token (parser)->location;
14383 if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
14385 c_parser_consume_token (parser);
14387 t = c_parser_expr_no_commas (parser, NULL).value;
14389 c_parser_error (parser, "expected integer expression");
14391 || !c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
14411 c_parser_oacc_clause_tile (c_parser *parser, tree list)
14420 loc = c_parser_peek_token (parser)->location;
14421 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
14426 if (tile && !c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
14429 if (c_parser_next_token_is (parser, CPP_MULT)
14430 && (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
14431 || c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_PAREN))
14433 c_parser_consume_token (parser);
14438 location_t expr_loc = c_parser_peek_token (parser)->location;
14439 c_expr cexpr = c_parser_expr_no_commas (parser, NULL);
14445 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
14464 while (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN));
14467 c_parser_consume_token (parser);
14480 c_parser_oacc_clause_wait (c_parser *parser, tree list)
14482 location_t clause_loc = c_parser_peek_token (parser)->location;
14484 if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
14485 list = c_parser_oacc_wait_list (parser, clause_loc, list);
14503 c_parser_omp_clause_order (c_parser *parser, tree list)
14505 location_t loc = c_parser_peek_token (parser)->location;
14510 if (!parens.require_open (parser))
14512 if (!c_parser_next_token_is (parser, CPP_NAME))
14514 c_parser_error (parser, "expected %<concurrent%>");
14517 p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
14520 c_parser_error (parser, "expected %<concurrent%>");
14523 c_parser_consume_token (parser);
14524 parens.skip_until_found_close (parser);
14531 parens.skip_until_found_close (parser);
14540 c_parser_omp_clause_bind (c_parser *parser, tree list)
14542 location_t loc = c_parser_peek_token (parser)->location;
14548 if (!parens.require_open (parser))
14550 if (!c_parser_next_token_is (parser, CPP_NAME))
14553 c_parser_error (parser,
14555 parens.skip_until_found_close (parser);
14558 p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
14565 c_parser_consume_token (parser);
14566 parens.skip_until_found_close (parser);
14582 c_parser_omp_clause_ordered (c_parser *parser, tree list)
14588 location_t loc = c_parser_peek_token (parser)->location;
14589 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
14592 parens.consume_open (parser);
14593 num = c_parser_expr_no_commas (parser, NULL).value;
14594 parens.skip_until_found_close (parser);
14622 c_parser_omp_clause_private (c_parser *parser, tree list)
14624 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list);
14650 c_parser_omp_clause_reduction (c_parser *parser, enum omp_clause_code kind,
14653 location_t clause_loc = c_parser_peek_token (parser)->location;
14655 if (parens.require_open (parser))
14664 if (c_parser_next_token_is_keyword (parser, RID_DEFAULT)
14665 && c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
14667 c_parser_consume_token (parser);
14668 c_parser_consume_token (parser);
14670 else if (c_parser_next_token_is (parser, CPP_NAME)
14671 && c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
14674 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
14681 c_parser_consume_token (parser);
14682 c_parser_consume_token (parser);
14687 switch (c_parser_peek_token (parser)->type)
14716 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
14727 reduc_id = c_parser_peek_token (parser)->value;
14731 c_parser_error (parser,
14734 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
14737 c_parser_consume_token (parser);
14739 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
14743 nl = c_parser_omp_variable_list (parser, clause_loc, kind, list);
14783 parens.skip_until_found_close (parser);
14805 c_parser_omp_clause_schedule (c_parser *parser, tree list)
14808 location_t loc = c_parser_peek_token (parser)->location;
14812 if (!parens.require_open (parser))
14817 while (c_parser_next_token_is (parser, CPP_NAME))
14819 tree kind = c_parser_peek_token (parser)->value;
14829 c_parser_consume_token (parser);
14831 && c_parser_next_token_is (parser, CPP_COMMA))
14832 c_parser_consume_token (parser);
14835 c_parser_require (parser, CPP_COLON, "expected %<:%>");
14850 if (c_parser_next_token_is (parser, CPP_NAME))
14852 tree kind = c_parser_peek_token (parser)->value;
14879 else if (c_parser_next_token_is_keyword (parser, RID_STATIC))
14881 else if (c_parser_next_token_is_keyword (parser, RID_AUTO))
14886 c_parser_consume_token (parser);
14887 if (c_parser_next_token_is (parser, CPP_COMMA))
14890 c_parser_consume_token (parser);
14892 here = c_parser_peek_token (parser)->location;
14893 c_expr expr = c_parser_expr_no_commas (parser, NULL);
14921 c_parser_error (parser, "expected integer expression");
14923 parens.skip_until_found_close (parser);
14926 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
14938 c_parser_error (parser, "invalid schedule kind");
14939 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0);
14947 c_parser_omp_clause_shared (c_parser *parser, tree list)
14949 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list);
14956 c_parser_omp_clause_untied (c_parser *parser ATTRIBUTE_UNUSED, tree list)
14963 c = build_omp_clause (c_parser_peek_token (parser)->location,
14975 c_parser_omp_clause_branch (c_parser *parser ATTRIBUTE_UNUSED,
14980 tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
14993 c_parser_omp_clause_cancelkind (c_parser *parser ATTRIBUTE_UNUSED,
14996 tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
15006 c_parser_omp_clause_nogroup (c_parser *parser ATTRIBUTE_UNUSED, tree list)
15009 tree c = build_omp_clause (c_parser_peek_token (parser)->location,
15020 c_parser_omp_clause_orderedkind (c_parser *parser ATTRIBUTE_UNUSED,
15024 tree c = build_omp_clause (c_parser_peek_token (parser)->location, code);
15033 c_parser_omp_clause_num_teams (c_parser *parser, tree list)
15035 location_t num_teams_loc = c_parser_peek_token (parser)->location;
15037 if (parens.require_open (parser))
15039 location_t expr_loc = c_parser_peek_token (parser)->location;
15040 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15045 parens.skip_until_found_close (parser);
15049 c_parser_error (parser, "expected integer expression");
15078 c_parser_omp_clause_thread_limit (c_parser *parser, tree list)
15080 location_t num_thread_limit_loc = c_parser_peek_token (parser)->location;
15082 if (parens.require_open (parser))
15084 location_t expr_loc = c_parser_peek_token (parser)->location;
15085 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15090 parens.skip_until_found_close (parser);
15094 c_parser_error (parser, "expected integer expression");
15125 c_parser_omp_clause_aligned (c_parser *parser, tree list)
15127 location_t clause_loc = c_parser_peek_token (parser)->location;
15131 if (!parens.require_open (parser))
15134 nl = c_parser_omp_variable_list (parser, clause_loc,
15137 if (c_parser_next_token_is (parser, CPP_COLON))
15139 c_parser_consume_token (parser);
15140 location_t expr_loc = c_parser_peek_token (parser)->location;
15141 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15158 parens.skip_until_found_close (parser);
15171 c_parser_omp_clause_linear (c_parser *parser, tree list)
15173 location_t clause_loc = c_parser_peek_token (parser)->location;
15178 if (!parens.require_open (parser))
15181 if (c_parser_next_token_is (parser, CPP_NAME))
15183 c_token *tok = c_parser_peek_token (parser);
15187 if (c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN)
15191 c_parser_consume_token (parser);
15192 c_parser_consume_token (parser);
15196 nl = c_parser_omp_variable_list (parser, clause_loc,
15200 parens.skip_until_found_close (parser);
15202 if (c_parser_next_token_is (parser, CPP_COLON))
15204 c_parser_consume_token (parser);
15205 location_t expr_loc = c_parser_peek_token (parser)->location;
15206 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15227 parens.skip_until_found_close (parser);
15235 c_parser_omp_clause_nontemporal (c_parser *parser, tree list)
15237 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_NONTEMPORAL, list);
15244 c_parser_omp_clause_safelen (c_parser *parser, tree list)
15246 location_t clause_loc = c_parser_peek_token (parser)->location;
15250 if (!parens.require_open (parser))
15253 location_t expr_loc = c_parser_peek_token (parser)->location;
15254 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15267 parens.skip_until_found_close (parser);
15283 c_parser_omp_clause_simdlen (c_parser *parser, tree list)
15285 location_t clause_loc = c_parser_peek_token (parser)->location;
15289 if (!parens.require_open (parser))
15292 location_t expr_loc = c_parser_peek_token (parser)->location;
15293 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15306 parens.skip_until_found_close (parser);
15325 c_parser_omp_clause_depend_sink (c_parser *parser, location_t clause_loc,
15329 if (c_parser_next_token_is_not (parser, CPP_NAME)
15330 || c_parser_peek_token (parser)->id_kind != C_ID_ID)
15332 c_parser_error (parser, "expected identifier");
15336 while (c_parser_next_token_is (parser, CPP_NAME)
15337 && c_parser_peek_token (parser)->id_kind == C_ID_ID)
15339 tree t = lookup_name (c_parser_peek_token (parser)->value);
15344 undeclared_variable (c_parser_peek_token (parser)->location,
15345 c_parser_peek_token (parser)->value);
15349 c_parser_consume_token (parser);
15352 if (c_parser_next_token_is (parser, CPP_MINUS))
15354 else if (!c_parser_next_token_is (parser, CPP_PLUS))
15360 c_parser_consume_token (parser);
15362 if (c_parser_next_token_is_not (parser, CPP_NUMBER))
15364 c_parser_error (parser, "expected integer");
15368 addend = c_parser_peek_token (parser)->value;
15371 c_parser_error (parser, "expected integer");
15374 c_parser_consume_token (parser);
15384 if (c_parser_next_token_is_not (parser, CPP_COMMA))
15387 c_parser_consume_token (parser);
15416 c_parser_omp_iterators (c_parser *parser)
15419 c_parser_consume_token (parser);
15424 if (!parens.require_open (parser))
15430 if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
15432 struct c_type_name *type = c_parser_type_name (parser);
15439 location_t loc = c_parser_peek_token (parser)->location;
15440 if (!c_parser_next_token_is (parser, CPP_NAME))
15442 c_parser_error (parser, "expected identifier");
15446 tree id = c_parser_peek_token (parser)->value;
15447 c_parser_consume_token (parser);
15449 if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
15452 location_t eloc = c_parser_peek_token (parser)->location;
15453 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15457 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
15460 eloc = c_parser_peek_token (parser)->location;
15461 expr = c_parser_expr_no_commas (parser, NULL);
15466 if (c_parser_next_token_is (parser, CPP_COLON))
15468 c_parser_consume_token (parser);
15469 eloc = c_parser_peek_token (parser)->location;
15470 expr = c_parser_expr_no_commas (parser, NULL);
15487 if (c_parser_next_token_is (parser, CPP_COMMA))
15489 c_parser_consume_token (parser);
15496 parens.skip_until_found_close (parser);
15521 c_parser_omp_clause_depend (c_parser *parser, tree list)
15523 location_t clause_loc = c_parser_peek_token (parser)->location;
15528 if (!parens.require_open (parser))
15533 if (c_parser_next_token_is_not (parser, CPP_NAME))
15536 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
15539 iterators = c_parser_omp_iterators (parser);
15540 c_parser_require (parser, CPP_COMMA, "expected %<,%>");
15563 c_parser_consume_token (parser);
15580 parens.skip_until_found_close (parser);
15584 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
15588 nl = c_parser_omp_clause_depend_sink (parser, clause_loc, list);
15591 nl = c_parser_omp_variable_list (parser, clause_loc,
15612 parens.skip_until_found_close (parser);
15616 c_parser_error (parser, "invalid depend kind");
15618 parens.skip_until_found_close (parser);
15638 c_parser_omp_clause_map (c_parser *parser, tree list)
15640 location_t clause_loc = c_parser_peek_token (parser)->location;
15649 if (!parens.require_open (parser))
15652 if (c_parser_next_token_is (parser, CPP_NAME))
15654 c_token *tok = c_parser_peek_token (parser);
15661 c_token *sectok = c_parser_peek_2nd_token (parser);
15664 c_parser_consume_token (parser);
15665 c_parser_consume_token (parser);
15678 c_parser_consume_token (parser);
15685 if (c_parser_next_token_is (parser, CPP_NAME)
15686 && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
15688 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
15703 c_parser_error (parser, "invalid map kind");
15704 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
15708 c_parser_consume_token (parser);
15709 c_parser_consume_token (parser);
15715 c_parser_error (parser, "expected identifier");
15716 parens.skip_until_found_close (parser);
15736 parens.skip_until_found_close (parser);
15741 nl = c_parser_omp_variable_list (parser, clause_loc, OMP_CLAUSE_MAP, list);
15746 parens.skip_until_found_close (parser);
15754 c_parser_omp_clause_device (c_parser *parser, tree list)
15756 location_t clause_loc = c_parser_peek_token (parser)->location;
15758 if (parens.require_open (parser))
15760 location_t expr_loc = c_parser_peek_token (parser)->location;
15761 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15766 parens.skip_until_found_close (parser);
15770 c_parser_error (parser, "expected integer expression");
15790 c_parser_omp_clause_dist_schedule (c_parser *parser, tree list)
15793 location_t loc = c_parser_peek_token (parser)->location;
15796 if (!parens.require_open (parser))
15799 if (!c_parser_next_token_is_keyword (parser, RID_STATIC))
15801 c_parser_error (parser, "invalid dist_schedule kind");
15802 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
15807 c_parser_consume_token (parser);
15808 if (c_parser_next_token_is (parser, CPP_COMMA))
15810 c_parser_consume_token (parser);
15812 location_t expr_loc = c_parser_peek_token (parser)->location;
15813 c_expr expr = c_parser_expr_no_commas (parser, NULL);
15817 parens.skip_until_found_close (parser);
15820 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
15843 c_parser_omp_clause_proc_bind (c_parser *parser, tree list)
15845 location_t clause_loc = c_parser_peek_token (parser)->location;
15850 if (!parens.require_open (parser))
15853 if (c_parser_next_token_is (parser, CPP_NAME))
15855 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
15869 c_parser_consume_token (parser);
15870 parens.skip_until_found_close (parser);
15877 c_parser_error (parser, "invalid proc_bind kind");
15878 parens.skip_until_found_close (parser);
15886 c_parser_omp_clause_device_type (c_parser *parser, tree list)
15888 location_t clause_loc = c_parser_peek_token (parser)->location;
15893 if (!parens.require_open (parser))
15896 if (c_parser_next_token_is (parser, CPP_NAME))
15898 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
15913 c_parser_consume_token (parser);
15914 parens.skip_until_found_close (parser);
15921 c_parser_error (parser, "expected %<host%>, %<nohost%> or %<any%>");
15922 parens.skip_until_found_close (parser);
15930 c_parser_omp_clause_to (c_parser *parser, tree list)
15932 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_TO, list);
15939 c_parser_omp_clause_from (c_parser *parser, tree list)
15941 return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FROM, list);
15948 c_parser_omp_clause_uniform (c_parser *parser, tree list)
15951 location_t loc = c_parser_peek_token (parser)->location;
15954 if (parens.require_open (parser))
15956 list = c_parser_omp_variable_list (parser, loc, OMP_CLAUSE_UNIFORM,
15958 parens.skip_until_found_close (parser);
15967 c_parser_oacc_all_clauses (c_parser *parser, omp_clause_mask mask,
15973 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
15980 if (!first && c_parser_next_token_is (parser, CPP_COMMA))
15981 c_parser_consume_token (parser);
15983 here = c_parser_peek_token (parser)->location;
15984 c_kind = c_parser_omp_clause_name (parser);
15989 clauses = c_parser_oacc_clause_async (parser, clauses);
15998 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16002 clauses = c_parser_omp_clause_collapse (parser, clauses);
16006 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16010 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16014 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16018 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16022 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16026 clauses = c_parser_omp_clause_default (parser, clauses, true);
16030 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16034 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16038 clauses = c_parser_oacc_data_clause_deviceptr (parser, clauses);
16042 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16051 clauses = c_parser_omp_clause_firstprivate (parser, clauses);
16056 clauses = c_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_GANG,
16060 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16064 clauses = c_parser_omp_clause_if (parser, clauses, false);
16078 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16082 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16086 clauses = c_parser_oacc_single_int_clause (parser,
16092 clauses = c_parser_oacc_single_int_clause (parser,
16098 clauses = c_parser_oacc_data_clause (parser, c_kind, clauses);
16102 clauses = c_parser_omp_clause_private (parser, clauses);
16107 = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
16117 clauses = c_parser_oacc_clause_tile (parser, clauses);
16121 clauses = c_parser_omp_clause_use_device_ptr (parser, clauses);
16126 clauses = c_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_VECTOR,
16130 clauses = c_parser_oacc_single_int_clause (parser,
16136 clauses = c_parser_oacc_clause_wait (parser, clauses);
16141 clauses = c_parser_oacc_shape_clause (parser, here, OMP_CLAUSE_WORKER,
16145 c_parser_error (parser, "expected %<#pragma acc%> clause");
16161 c_parser_skip_to_pragma_eol (parser);
16177 c_parser_omp_all_clauses (c_parser *parser, omp_clause_mask mask,
16184 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
16191 if (nested && c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
16196 if (c_parser_next_token_is (parser, CPP_COMMA))
16197 c_parser_consume_token (parser);
16199 error_at (c_parser_peek_token (parser)->location,
16204 here = c_parser_peek_token (parser)->location;
16205 c_kind = c_parser_omp_clause_name (parser);
16210 clauses = c_parser_omp_clause_bind (parser, clauses);
16214 clauses = c_parser_omp_clause_collapse (parser, clauses);
16218 clauses = c_parser_omp_clause_copyin (parser, clauses);
16222 clauses = c_parser_omp_clause_copyprivate (parser, clauses);
16226 clauses = c_parser_omp_clause_default (parser, clauses, false);
16230 clauses = c_parser_omp_clause_firstprivate (parser, clauses);
16234 clauses = c_parser_omp_clause_final (parser, clauses);
16238 clauses = c_parser_omp_clause_grainsize (parser, clauses);
16242 clauses = c_parser_omp_clause_hint (parser, clauses);
16246 clauses = c_parser_omp_clause_defaultmap (parser, clauses);
16250 clauses = c_parser_omp_clause_if (parser, clauses, true);
16255 = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_IN_REDUCTION,
16260 clauses = c_parser_omp_clause_lastprivate (parser, clauses);
16264 clauses = c_parser_omp_clause_mergeable (parser, clauses);
16268 clauses = c_parser_omp_clause_nowait (parser, clauses);
16272 clauses = c_parser_omp_clause_num_tasks (parser, clauses);
16276 clauses = c_parser_omp_clause_num_threads (parser, clauses);
16280 clauses = c_parser_omp_clause_order (parser, clauses);
16284 clauses = c_parser_omp_clause_ordered (parser, clauses);
16288 clauses = c_parser_omp_clause_priority (parser, clauses);
16292 clauses = c_parser_omp_clause_private (parser, clauses);
16297 = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_REDUCTION,
16302 clauses = c_parser_omp_clause_schedule (parser, clauses);
16306 clauses = c_parser_omp_clause_shared (parser, clauses);
16311 = c_parser_omp_clause_reduction (parser, OMP_CLAUSE_TASK_REDUCTION,
16316 clauses = c_parser_omp_clause_untied (parser, clauses);
16320 clauses = c_parser_omp_clause_branch (parser, OMP_CLAUSE_INBRANCH,
16325 clauses = c_parser_omp_clause_nontemporal (parser, clauses);
16329 clauses = c_parser_omp_clause_branch (parser, OMP_CLAUSE_NOTINBRANCH,
16335 = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_PARALLEL,
16348 = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_FOR,
16356 = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_SECTIONS,
16364 = c_parser_omp_clause_cancelkind (parser, OMP_CLAUSE_TASKGROUP,
16372 = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LINK, clauses);
16378 = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_TO_DECLARE,
16381 clauses = c_parser_omp_clause_to (parser, clauses);
16385 clauses = c_parser_omp_clause_from (parser, clauses);
16389 clauses = c_parser_omp_clause_uniform (parser, clauses);
16393 clauses = c_parser_omp_clause_num_teams (parser, clauses);
16397 clauses = c_parser_omp_clause_thread_limit (parser, clauses);
16401 clauses = c_parser_omp_clause_aligned (parser, clauses);
16405 clauses = c_parser_omp_clause_linear (parser, clauses);
16409 clauses = c_parser_omp_clause_depend (parser, clauses);
16413 clauses = c_parser_omp_clause_map (parser, clauses);
16417 clauses = c_parser_omp_clause_use_device_ptr (parser, clauses);
16421 clauses = c_parser_omp_clause_use_device_addr (parser, clauses);
16425 clauses = c_parser_omp_clause_is_device_ptr (parser, clauses);
16429 clauses = c_parser_omp_clause_device (parser, clauses);
16433 clauses = c_parser_omp_clause_dist_schedule (parser, clauses);
16437 clauses = c_parser_omp_clause_proc_bind (parser, clauses);
16441 clauses = c_parser_omp_clause_device_type (parser, clauses);
16445 clauses = c_parser_omp_clause_safelen (parser, clauses);
16449 clauses = c_parser_omp_clause_simdlen (parser, clauses);
16453 clauses = c_parser_omp_clause_nogroup (parser, clauses);
16458 = c_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_THREADS,
16464 = c_parser_omp_clause_orderedkind (parser, OMP_CLAUSE_SIMD,
16469 c_parser_error (parser, "expected %<#pragma omp%> clause");
16486 c_parser_skip_to_pragma_eol (parser);
16507 c_parser_omp_structured_block (c_parser *parser, bool *if_p)
16510 c_parser_statement (parser, if_p);
16521 c_parser_oacc_cache (location_t loc, c_parser *parser)
16525 clauses = c_parser_omp_var_list_parens (parser, OMP_CLAUSE__CACHE_, NULL);
16528 c_parser_skip_to_pragma_eol (parser);
16558 c_parser_oacc_data (location_t loc, c_parser *parser, bool *if_p)
16562 clauses = c_parser_oacc_all_clauses (parser, OACC_DATA_CLAUSE_MASK,
16566 add_stmt (c_parser_omp_structured_block (parser, if_p));
16588 c_parser_oacc_declare (c_parser *parser)
16590 location_t pragma_loc = c_parser_peek_token (parser)->location;
16595 c_parser_consume_pragma (parser);
16597 clauses = c_parser_oacc_all_clauses (parser, OACC_DECLARE_CLAUSE_MASK,
16756 c_parser_oacc_enter_exit_data (c_parser *parser, bool enter)
16758 location_t loc = c_parser_peek_token (parser)->location;
16762 c_parser_consume_pragma (parser);
16764 if (c_parser_next_token_is (parser, CPP_NAME))
16766 p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
16767 c_parser_consume_token (parser);
16774 parser->error = true;
16775 c_parser_skip_to_pragma_eol (parser);
16780 clauses = c_parser_oacc_all_clauses (parser, OACC_ENTER_DATA_CLAUSE_MASK,
16783 clauses = c_parser_oacc_all_clauses (parser, OACC_EXIT_DATA_CLAUSE_MASK,
16812 c_parser_oacc_host_data (location_t loc, c_parser *parser, bool *if_p)
16816 clauses = c_parser_oacc_all_clauses (parser, OACC_HOST_DATA_CLAUSE_MASK,
16820 add_stmt (c_parser_omp_structured_block (parser, if_p));
16846 c_parser_oacc_loop (location_t loc, c_parser *parser, char *p_name,
16854 tree clauses = c_parser_oacc_all_clauses (parser, mask, p_name,
16866 tree stmt = c_parser_omp_for_loop (loc, parser, OACC_LOOP, clauses, NULL,
16946 c_parser_oacc_compute (location_t loc, c_parser *parser,
16972 if (c_parser_next_token_is (parser, CPP_NAME))
16974 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
16977 c_parser_consume_token (parser);
16980 c_parser_oacc_loop (loc, parser, p_name, mask, &clauses, if_p);
16985 tree clauses = c_parser_oacc_all_clauses (parser, mask, p_name);
16988 add_stmt (c_parser_omp_structured_block (parser, if_p));
17011 c_parser_oacc_routine (c_parser *parser, enum pragma_context context)
17018 data.loc = c_parser_peek_token (parser)->location;
17020 c_parser_consume_pragma (parser);
17023 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
17025 c_parser_consume_token (parser); /* '(' */
17028 c_token *name_token = c_parser_peek_token (parser);
17038 c_parser_consume_token (parser);
17041 c_parser_error (parser, "expected function name");
17044 || !c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
17046 c_parser_skip_to_pragma_eol (parser, false);
17051 = c_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
17068 = c_parser_oacc_all_clauses (parser, OACC_ROUTINE_CLAUSE_MASK,
17078 if (c_parser_next_token_is (parser, CPP_PRAGMA)
17079 || c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
17089 if (c_parser_next_token_is (parser, CPP_KEYWORD)
17090 && c_parser_peek_token (parser)->keyword == RID_EXTENSION)
17094 c_parser_consume_token (parser);
17095 while (c_parser_next_token_is (parser, CPP_KEYWORD)
17096 && c_parser_peek_token (parser)->keyword == RID_EXTENSION);
17097 c_parser_declaration_or_fndef (parser, true, true, true, false, true,
17102 c_parser_declaration_or_fndef (parser, true, true, true, false, true,
17187 c_parser_oacc_update (c_parser *parser)
17189 location_t loc = c_parser_peek_token (parser)->location;
17191 c_parser_consume_pragma (parser);
17193 tree clauses = c_parser_oacc_all_clauses (parser, OACC_UPDATE_CLAUSE_MASK,
17203 if (parser->error)
17223 c_parser_oacc_wait (location_t loc, c_parser *parser, char *p_name)
17227 if (c_parser_peek_token (parser)->type == CPP_OPEN_PAREN)
17228 list = c_parser_oacc_wait_list (parser, loc, list);
17231 clauses = c_parser_oacc_all_clauses (parser, OACC_WAIT_CLAUSE_MASK, p_name);
17292 c_parser_omp_atomic (location_t loc, c_parser *parser)
17307 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
17309 if (!first && c_parser_next_token_is (parser, CPP_COMMA))
17310 c_parser_consume_token (parser);
17314 if (c_parser_next_token_is (parser, CPP_NAME))
17317 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17318 location_t cloc = c_parser_peek_token (parser)->location;
17343 c_parser_consume_token (parser);
17344 clauses = c_parser_omp_clause_hint (parser, clauses);
17370 c_parser_consume_token (parser);
17376 c_parser_skip_to_pragma_eol (parser);
17452 v = c_parser_cast_expression (parser, NULL).value;
17459 loc = c_parser_peek_token (parser)->location;
17460 if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
17464 lhs = c_parser_expression (parser).value;
17471 lhs = c_parser_cast_expression (parser, NULL).value;
17490 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
17492 c_parser_consume_token (parser);
17497 v = c_parser_cast_expression (parser, NULL).value;
17504 if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
17515 eloc = c_parser_peek_token (parser)->location;
17516 expr = c_parser_cast_expression (parser, NULL);
17526 c_parser_skip_to_end_of_block_or_statement (parser);
17529 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
17530 c_parser_consume_token (parser);
17533 c_parser_skip_to_end_of_block_or_statement (parser);
17534 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
17535 c_parser_consume_token (parser);
17611 switch (c_parser_peek_token (parser)->type)
17641 c_parser_consume_token (parser);
17642 eloc = c_parser_peek_token (parser)->location;
17643 expr = c_parser_expr_no_commas (parser, NULL, unfolded_lhs);
17682 if (c_parser_peek_token (parser)->type == CPP_SEMICOLON)
17693 c_parser_consume_token (parser);
17705 c_parser_error (parser, "invalid form of %<#pragma omp atomic%>");
17708 c_parser_error (parser,
17715 loc = c_parser_peek_token (parser)->location;
17716 c_parser_consume_token (parser);
17717 eloc = c_parser_peek_token (parser)->location;
17718 expr = c_parser_expression (parser);
17727 if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
17729 v = c_parser_cast_expression (parser, NULL).value;
17736 if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
17738 eloc = c_parser_peek_token (parser)->location;
17739 expr = c_parser_cast_expression (parser, NULL);
17751 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
17752 c_parser_require (parser, CPP_CLOSE_BRACE, "expected %<}%>");
17769 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
17778 c_parser_omp_barrier (c_parser *parser)
17780 location_t loc = c_parser_peek_token (parser)->location;
17781 c_parser_consume_pragma (parser);
17782 c_parser_skip_to_pragma_eol (parser);
17800 c_parser_omp_critical (location_t loc, c_parser *parser, bool *if_p)
17804 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
17806 c_parser_consume_token (parser);
17807 if (c_parser_next_token_is (parser, CPP_NAME))
17809 name = c_parser_peek_token (parser)->value;
17810 c_parser_consume_token (parser);
17811 c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>");
17814 c_parser_error (parser, "expected identifier");
17816 if (c_parser_next_token_is (parser, CPP_COMMA)
17817 && c_parser_peek_2nd_token (parser)->type == CPP_NAME)
17818 c_parser_consume_token (parser);
17820 clauses = c_parser_omp_all_clauses (parser,
17826 if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
17827 c_parser_error (parser, "expected %<(%> or end of line");
17828 c_parser_skip_to_pragma_eol (parser);
17831 stmt = c_parser_omp_structured_block (parser, if_p);
17850 c_parser_omp_depobj (c_parser *parser)
17852 location_t loc = c_parser_peek_token (parser)->location;
17853 c_parser_consume_pragma (parser);
17855 if (!parens.require_open (parser))
17857 c_parser_skip_to_pragma_eol (parser);
17861 tree depobj = c_parser_expr_no_commas (parser, NULL).value;
17882 parens.skip_until_found_close (parser);
17885 location_t c_loc = c_parser_peek_token (parser)->location;
17886 if (c_parser_next_token_is (parser, CPP_NAME))
17888 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17890 c_parser_consume_token (parser);
17893 clause = c_parser_omp_clause_depend (parser, NULL_TREE);
17903 if (c_parens.require_open (parser))
17905 location_t c2_loc = c_parser_peek_token (parser)->location;
17906 if (c_parser_next_token_is (parser, CPP_NAME))
17909 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17911 c_parser_consume_token (parser);
17927 c_parens.skip_until_found_close (parser);
17938 c_parser_skip_to_pragma_eol (parser);
17954 c_parser_omp_flush (c_parser *parser)
17956 location_t loc = c_parser_peek_token (parser)->location;
17957 c_parser_consume_pragma (parser);
17959 if (c_parser_next_token_is (parser, CPP_NAME))
17962 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
17971 error_at (c_parser_peek_token (parser)->location,
17973 c_parser_consume_token (parser);
17975 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
17978 error_at (c_parser_peek_token (parser)->location,
17981 c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
17983 else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
17984 c_parser_error (parser, "expected %<(%> or end of line");
17985 c_parser_skip_to_pragma_eol (parser);
17996 c_parser_omp_scan_loop_body (c_parser *parser, bool open_brace_parsed)
18002 loc = c_parser_peek_token (parser)->location;
18004 && !c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
18007 parser->error = false;
18011 substmt = c_parser_omp_structured_block (parser, NULL);
18016 loc = c_parser_peek_token (parser)->location;
18017 if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SCAN)
18021 c_parser_consume_pragma (parser);
18023 if (c_parser_next_token_is (parser, CPP_NAME))
18026 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18034 c_parser_consume_token (parser);
18035 clauses = c_parser_omp_var_list_parens (parser, clause, NULL_TREE);
18038 c_parser_error (parser, "expected %<inclusive%> or "
18040 c_parser_skip_to_pragma_eol (parser);
18046 substmt = c_parser_omp_structured_block (parser, NULL);
18051 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
18062 c_parser_omp_for_loop (location_t loc, c_parser *parser, enum tree_code code,
18125 if (!c_parser_next_token_is_keyword (parser, RID_FOR))
18127 c_parser_error (parser, "for statement expected");
18130 for_loc = c_parser_peek_token (parser)->location;
18131 c_parser_consume_token (parser);
18138 if (!parens.require_open (parser))
18142 if (c_parser_next_tokens_start_declaration (parser))
18147 c_parser_declaration_or_fndef (parser, true, true, true, true, true,
18170 else if (c_parser_next_token_is (parser, CPP_NAME)
18171 && c_parser_peek_2nd_token (parser)->type == CPP_EQ)
18177 decl_exp = c_parser_postfix_expression (parser);
18180 c_parser_require (parser, CPP_EQ, "expected %<=%>");
18182 init_loc = c_parser_peek_token (parser)->location;
18183 init_exp = c_parser_expr_no_commas (parser, NULL);
18191 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
18196 c_parser_error (parser,
18198 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
18206 if (c_parser_next_token_is_not (parser, CPP_SEMICOLON))
18208 location_t cond_loc = c_parser_peek_token (parser)->location;
18210 = c_parser_binary_expression (parser, NULL, NULL_TREE);
18241 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
18245 if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN))
18247 location_t incr_loc = c_parser_peek_token (parser)->location;
18250 c_parser_expression (parser).value);
18252 parens.skip_until_found_close (parser);
18274 if (c_parser_next_token_is_keyword (parser, RID_FOR))
18276 c_parser_consume_token (parser);
18279 else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
18281 c_parser_consume_token (parser);
18285 && c_parser_next_token_is (parser, CPP_SEMICOLON))
18286 c_parser_consume_token (parser);
18289 c_parser_error (parser, "not enough perfectly nested loops");
18315 c_parser_omp_scan_loop_body (parser, open_brace_parsed);
18318 location_t here = c_parser_peek_token (parser)->location;
18320 c_parser_compound_statement_nostart (parser);
18324 add_stmt (c_parser_c99_block_statement (parser, if_p));
18338 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
18340 c_parser_consume_token (parser);
18343 else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
18344 c_parser_consume_token (parser);
18347 c_parser_error (parser, "collapsed loops not perfectly nested");
18350 location_t here = c_parser_peek_token (parser)->location;
18353 c_parser_compound_statement_nostart (parser);
18464 c_parser_omp_loop (location_t loc, c_parser *parser,
18473 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
18481 ret = c_parser_omp_for_loop (loc, parser, OMP_LOOP, clauses, cclauses, if_p);
18509 c_parser_omp_simd (location_t loc, c_parser *parser,
18518 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
18535 ret = c_parser_omp_for_loop (loc, parser, OMP_SIMD, clauses, cclauses, if_p);
18566 c_parser_omp_for (location_t loc, c_parser *parser,
18582 if (c_parser_next_token_is (parser, CPP_NAME))
18584 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18592 c_parser_consume_token (parser);
18594 return c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
18597 ret = c_parser_omp_simd (loc, parser, p_name, mask, cclauses, if_p);
18612 c_parser_skip_to_pragma_eol (parser, false);
18620 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
18628 ret = c_parser_omp_for_loop (loc, parser, OMP_FOR, clauses, cclauses, if_p);
18646 c_parser_omp_master (location_t loc, c_parser *parser,
18654 if (c_parser_next_token_is (parser, CPP_NAME))
18656 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18664 c_parser_consume_token (parser);
18666 return c_parser_omp_taskloop (loc, parser, p_name, mask, cclauses,
18669 ret = c_parser_omp_taskloop (loc, parser, p_name, mask, cclauses,
18680 c_parser_skip_to_pragma_eol (parser, false);
18686 clauses = c_parser_omp_all_clauses (parser, mask, p_name, false);
18690 c_parser_skip_to_pragma_eol (parser);
18692 return c_finish_omp_master (loc, c_parser_omp_structured_block (parser,
18714 c_parser_omp_ordered (c_parser *parser, enum pragma_context context,
18717 location_t loc = c_parser_peek_token (parser)->location;
18718 c_parser_consume_pragma (parser);
18722 c_parser_error (parser, "expected declaration specifiers");
18723 c_parser_skip_to_pragma_eol (parser, false);
18727 if (c_parser_next_token_is (parser, CPP_NAME))
18729 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18735 c_parser_skip_to_pragma_eol (parser, false);
18743 c_parser_skip_to_pragma_eol (parser, false);
18748 = c_parser_omp_all_clauses (parser,
18756 tree clauses = c_parser_omp_all_clauses (parser, OMP_ORDERED_CLAUSE_MASK,
18764 c_parser_omp_structured_block (parser, if_p));
18780 c_parser_omp_sections_scope (location_t sections_loc, c_parser *parser)
18786 loc = c_parser_peek_token (parser)->location;
18787 if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
18790 parser->error = false;
18796 if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION)
18798 substmt = c_parser_omp_structured_block (parser, NULL);
18806 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
18808 if (c_parser_next_token_is (parser, CPP_EOF))
18811 loc = c_parser_peek_token (parser)->location;
18812 if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION)
18814 c_parser_consume_pragma (parser);
18815 c_parser_skip_to_pragma_eol (parser);
18824 substmt = c_parser_omp_structured_block (parser, NULL);
18829 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE,
18857 c_parser_omp_sections (location_t loc, c_parser *parser,
18867 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
18875 ret = c_parser_omp_sections_scope (loc, parser);
18911 c_parser_omp_parallel (location_t loc, c_parser *parser,
18924 if (c_parser_next_token_is_keyword (parser, RID_FOR))
18930 c_parser_consume_token (parser);
18932 return c_parser_omp_for (loc, parser, p_name, mask, cclauses, if_p);
18934 tree ret = c_parser_omp_for (loc, parser, p_name, mask, cclauses, if_p);
18950 c_parser_skip_to_pragma_eol (parser);
18953 else if (c_parser_next_token_is (parser, CPP_NAME))
18955 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
18961 c_parser_consume_token (parser);
18963 return c_parser_omp_master (loc, parser, p_name, mask, cclauses,
18966 tree ret = c_parser_omp_master (loc, parser, p_name, mask, cclauses,
18982 c_parser_consume_token (parser);
18984 return c_parser_omp_loop (loc, parser, p_name, mask, cclauses,
18987 tree ret = c_parser_omp_loop (loc, parser, p_name, mask, cclauses,
19000 c_parser_skip_to_pragma_eol (parser, false);
19008 c_parser_consume_token (parser);
19010 c_parser_omp_sections (loc, parser, p_name, mask, cclauses);
19020 c_parser_skip_to_pragma_eol (parser, false);
19024 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
19032 c_parser_statement (parser, if_p);
19052 c_parser_omp_single (location_t loc, c_parser *parser, bool *if_p)
19059 = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK,
19061 OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser, if_p);
19086 c_parser_omp_task (location_t loc, c_parser *parser, bool *if_p)
19090 clauses = c_parser_omp_all_clauses (parser, OMP_TASK_CLAUSE_MASK,
19094 c_parser_statement (parser, if_p);
19109 c_parser_omp_taskwait (c_parser *parser)
19111 location_t loc = c_parser_peek_token (parser)->location;
19112 c_parser_consume_pragma (parser);
19115 = c_parser_omp_all_clauses (parser, OMP_TASKWAIT_CLAUSE_MASK,
19136 c_parser_omp_taskyield (c_parser *parser)
19138 location_t loc = c_parser_peek_token (parser)->location;
19139 c_parser_consume_pragma (parser);
19140 c_parser_skip_to_pragma_eol (parser);
19156 c_parser_omp_taskgroup (location_t loc, c_parser *parser, bool *if_p)
19158 tree clauses = c_parser_omp_all_clauses (parser, OMP_TASKGROUP_CLAUSE_MASK,
19161 tree body = c_parser_omp_structured_block (parser, if_p);
19179 c_parser_omp_cancel (c_parser *parser)
19181 location_t loc = c_parser_peek_token (parser)->location;
19183 c_parser_consume_pragma (parser);
19184 tree clauses = c_parser_omp_all_clauses (parser, OMP_CANCEL_CLAUSE_MASK,
19203 c_parser_omp_cancellation_point (c_parser *parser, enum pragma_context context)
19205 location_t loc = c_parser_peek_token (parser)->location;
19209 c_parser_consume_pragma (parser);
19210 if (c_parser_next_token_is (parser, CPP_NAME))
19212 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19215 c_parser_consume_token (parser);
19221 c_parser_error (parser, "expected %<point%>");
19222 c_parser_skip_to_pragma_eol (parser);
19233 c_parser_error (parser, "expected declaration specifiers");
19234 c_parser_skip_to_pragma_eol (parser, false);
19239 = c_parser_omp_all_clauses (parser, OMP_CANCELLATION_POINT_CLAUSE_MASK,
19257 c_parser_omp_distribute (location_t loc, c_parser *parser,
19266 if (c_parser_next_token_is (parser, CPP_NAME))
19268 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19281 c_parser_consume_token (parser);
19285 return c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
19288 return c_parser_omp_parallel (loc, parser, p_name, mask,
19293 ret = c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
19296 ret = c_parser_omp_parallel (loc, parser, p_name, mask, cclauses,
19312 c_parser_skip_to_pragma_eol (parser, false);
19316 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
19324 ret = c_parser_omp_for_loop (loc, parser, OMP_DISTRIBUTE, clauses, NULL,
19346 c_parser_omp_teams (location_t loc, c_parser *parser,
19355 if (c_parser_next_token_is (parser, CPP_NAME))
19357 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19364 c_parser_consume_token (parser);
19366 return c_parser_omp_distribute (loc, parser, p_name, mask,
19369 ret = c_parser_omp_distribute (loc, parser, p_name, mask, cclauses,
19389 c_parser_consume_token (parser);
19391 return c_parser_omp_loop (loc, parser, p_name, mask, cclauses,
19394 ret = c_parser_omp_loop (loc, parser, p_name, mask, cclauses, if_p);
19410 c_parser_skip_to_pragma_eol (parser, false);
19414 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
19425 add_stmt (c_parser_omp_structured_block (parser, if_p));
19444 c_parser_omp_target_data (location_t loc, c_parser *parser, bool *if_p)
19447 = c_parser_omp_all_clauses (parser, OMP_TARGET_DATA_CLAUSE_MASK,
19497 add_stmt (c_parser_omp_structured_block (parser, if_p));
19516 c_parser_omp_target_update (location_t loc, c_parser *parser,
19523 c_parser_skip_to_pragma_eol (parser, false);
19528 = c_parser_omp_all_clauses (parser, OMP_TARGET_UPDATE_CLAUSE_MASK,
19558 c_parser_omp_target_enter_data (location_t loc, c_parser *parser,
19562 if (c_parser_next_token_is (parser, CPP_NAME))
19564 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19567 c_parser_consume_token (parser);
19573 c_parser_error (parser, "expected %<data%>");
19574 c_parser_skip_to_pragma_eol (parser);
19582 c_parser_skip_to_pragma_eol (parser, false);
19587 = c_parser_omp_all_clauses (parser, OMP_TARGET_ENTER_DATA_CLAUSE_MASK,
19642 c_parser_omp_target_exit_data (location_t loc, c_parser *parser,
19646 if (c_parser_next_token_is (parser, CPP_NAME))
19648 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19651 c_parser_consume_token (parser);
19657 c_parser_error (parser, "expected %<data%>");
19658 c_parser_skip_to_pragma_eol (parser);
19666 c_parser_skip_to_pragma_eol (parser, false);
19671 = c_parser_omp_all_clauses (parser, OMP_TARGET_EXIT_DATA_CLAUSE_MASK,
19734 c_parser_omp_target (c_parser *parser, enum pragma_context context, bool *if_p)
19736 location_t loc = c_parser_peek_token (parser)->location;
19737 c_parser_consume_pragma (parser);
19742 c_parser_error (parser, "expected declaration specifiers");
19743 c_parser_skip_to_pragma_eol (parser);
19751 if (c_parser_next_token_is (parser, CPP_NAME))
19753 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
19768 c_parser_consume_token (parser);
19776 stmt = c_parser_omp_teams (loc, parser, p_name,
19781 stmt = c_parser_omp_parallel (loc, parser, p_name,
19786 stmt = c_parser_omp_simd (loc, parser, p_name,
19800 ret = c_parser_omp_teams (loc, parser, p_name,
19805 ret = c_parser_omp_parallel (loc, parser, p_name,
19810 ret = c_parser_omp_simd (loc, parser, p_name,
19858 c_parser_skip_to_pragma_eol (parser, false);
19863 c_parser_consume_token (parser);
19864 c_parser_omp_target_data (loc, parser, if_p);
19869 c_parser_consume_token (parser);
19870 c_parser_omp_target_enter_data (loc, parser, context);
19875 c_parser_consume_token (parser);
19876 c_parser_omp_target_exit_data (loc, parser, context);
19881 c_parser_consume_token (parser);
19882 return c_parser_omp_target_update (loc, parser, context);
19887 c_parser_skip_to_pragma_eol (parser, false);
19895 = c_parser_omp_all_clauses (parser, OMP_TARGET_CLAUSE_MASK,
19900 add_stmt (c_parser_omp_structured_block (parser, if_p));
19951 c_parser_omp_declare_simd (c_parser *parser, enum pragma_context context)
19953 c_token *token = c_parser_peek_token (parser);
19960 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
19962 c_token *token = c_parser_peek_token (parser);
19965 c_parser_skip_to_pragma_eol (parser);
19969 c_parser_consume_token (parser);
19971 clauses.safe_push (*c_parser_peek_token (parser));
19972 c_parser_skip_to_pragma_eol (parser);
19974 while (c_parser_next_token_is (parser, CPP_PRAGMA))
19976 if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_DECLARE
19977 || c_parser_peek_2nd_token (parser)->type != CPP_NAME
19978 || c_parser_peek_2nd_token (parser)->value != kind)
19986 c_parser_consume_pragma (parser);
19987 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
19989 c_token *token = c_parser_peek_token (parser);
19992 c_parser_skip_to_pragma_eol (parser);
19996 c_parser_consume_token (parser);
19998 clauses.safe_push (*c_parser_peek_token (parser));
19999 c_parser_skip_to_pragma_eol (parser);
20012 if (c_parser_next_token_is (parser, CPP_KEYWORD)
20013 && c_parser_peek_token (parser)->keyword == RID_EXTENSION)
20017 c_parser_consume_token (parser);
20018 while (c_parser_next_token_is (parser, CPP_KEYWORD)
20019 && c_parser_peek_token (parser)->keyword == RID_EXTENSION);
20020 c_parser_declaration_or_fndef (parser, true, true, true, false, true,
20025 c_parser_declaration_or_fndef (parser, true, true, true, false, true,
20036 if (c_parser_next_token_is (parser, CPP_KEYWORD)
20037 && c_parser_peek_token (parser)->keyword == RID_EXTENSION)
20041 c_parser_consume_token (parser);
20042 while (c_parser_next_token_is (parser, CPP_KEYWORD)
20043 && c_parser_peek_token (parser)->keyword == RID_EXTENSION);
20044 if (c_parser_next_tokens_start_declaration (parser))
20046 c_parser_declaration_or_fndef (parser, true, true, true, true,
20053 else if (c_parser_next_tokens_start_declaration (parser))
20055 c_parser_declaration_or_fndef (parser, true, true, true, true, true,
20087 c_parser_omp_context_selector (c_parser *parser, tree set, tree parms)
20093 if (c_parser_next_token_is (parser, CPP_KEYWORD)
20094 || c_parser_next_token_is (parser, CPP_NAME))
20095 selector = c_parser_peek_token (parser)->value;
20098 c_parser_error (parser, "expected trait selector name");
20150 error_at (c_parser_peek_token (parser)->location,
20154 c_parser_consume_token (parser);
20169 c_parser_consume_token (parser);
20171 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
20175 error_at (c_parser_peek_token (parser)->location,
20182 parens.require_open (parser);
20184 c_token *token = c_parser_peek_token (parser);
20186 && c_parser_next_token_is (parser, CPP_NAME)
20188 && c_parser_peek_2nd_token (parser)->type == CPP_OPEN_PAREN)
20190 c_parser_consume_token (parser);
20193 parens2.require_open (parser);
20194 tree score = c_parser_expr_no_commas (parser, NULL).value;
20195 parens2.skip_until_found_close (parser);
20196 c_parser_require (parser, CPP_COLON, "expected %<:%>");
20212 token = c_parser_peek_token (parser);
20221 t = c_parser_expr_no_commas (parser, NULL).value;
20239 if (c_parser_next_token_is (parser, CPP_COMMA))
20240 c_parser_consume_token (parser);
20247 if (c_parser_next_token_is (parser, CPP_KEYWORD)
20248 || c_parser_next_token_is (parser, CPP_NAME))
20250 tree prop = c_parser_peek_token (parser)->value;
20251 c_parser_consume_token (parser);
20256 c_parser_error (parser, "expected identifier");
20264 if (c_parser_next_token_is (parser, CPP_KEYWORD)
20265 || c_parser_next_token_is (parser, CPP_NAME))
20267 prop = c_parser_peek_token (parser)->value;
20268 c_parser_consume_token (parser);
20270 else if (c_parser_next_token_is (parser, CPP_STRING))
20271 value = c_parser_string_literal (parser, false,
20275 c_parser_error (parser, "expected identifier or "
20282 if (c_parser_next_token_is (parser, CPP_COMMA))
20283 c_parser_consume_token (parser);
20290 t = c_parser_expr_no_commas (parser, NULL).value;
20314 c = c_parser_omp_all_clauses (parser,
20327 parens.skip_until_found_close (parser);
20334 c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>");
20340 if (c_parser_next_token_is (parser, CPP_COMMA))
20341 c_parser_consume_token (parser);
20364 c_parser_omp_context_selector_specification (c_parser *parser, tree parms)
20370 if (c_parser_next_token_is (parser, CPP_NAME))
20371 setp = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20395 c_parser_error (parser, "expected %<construct%>, %<device%>, "
20400 tree set = c_parser_peek_token (parser)->value;
20401 c_parser_consume_token (parser);
20403 if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
20407 if (!braces.require_open (parser))
20410 tree selectors = c_parser_omp_context_selector (parser, set, parms);
20416 braces.skip_until_found_close (parser);
20418 if (c_parser_next_token_is (parser, CPP_COMMA))
20419 c_parser_consume_token (parser);
20434 c_finish_omp_declare_variant (c_parser *parser, tree fndecl, tree parms)
20437 if (!parens.require_open (parser))
20440 c_parser_skip_to_pragma_eol (parser, false);
20444 if (c_parser_next_token_is_not (parser, CPP_NAME)
20445 || c_parser_peek_token (parser)->id_kind != C_ID_ID)
20447 c_parser_error (parser, "expected identifier");
20451 c_token *token = c_parser_peek_token (parser);
20460 c_parser_consume_token (parser);
20462 parens.require_close (parser);
20465 location_t match_loc = c_parser_peek_token (parser)->location;
20466 if (c_parser_next_token_is (parser, CPP_NAME))
20467 clause = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20470 c_parser_error (parser, "expected %<match%>");
20474 c_parser_consume_token (parser);
20476 if (!parens.require_open (parser))
20482 tree ctx = c_parser_omp_context_selector_specification (parser, parms);
20527 parens.require_close (parser);
20528 c_parser_skip_to_pragma_eol (parser);
20536 c_finish_omp_declare_simd (c_parser *parser, tree fndecl, tree parms,
20568 unsigned int tokens_avail = parser->tokens_avail;
20569 gcc_assert (parser->tokens == &parser->tokens_buf[0]);
20571 parser->tokens = clauses.address ();
20572 parser->tokens_avail = clauses.length ();
20575 while (parser->tokens_avail > 3)
20577 c_token *token = c_parser_peek_token (parser);
20580 c_parser_consume_token (parser);
20581 parser->in_pragma = true;
20586 c = c_parser_omp_all_clauses (parser, OMP_DECLARE_SIMD_CLAUSE_MASK,
20598 c_finish_omp_declare_variant (parser, fndecl, parms);
20602 parser->tokens = &parser->tokens_buf[0];
20603 parser->tokens_avail = tokens_avail;
20625 c_parser_omp_declare_target (c_parser *parser)
20630 if (c_parser_next_token_is (parser, CPP_NAME))
20631 clauses = c_parser_omp_all_clauses (parser, OMP_DECLARE_TARGET_CLAUSE_MASK,
20633 else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
20635 clauses = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_TO_DECLARE,
20638 c_parser_skip_to_pragma_eol (parser);
20642 c_parser_skip_to_pragma_eol (parser);
20721 c_parser_omp_end_declare_target (c_parser *parser)
20723 location_t loc = c_parser_peek_token (parser)->location;
20724 c_parser_consume_pragma (parser);
20725 if (c_parser_next_token_is (parser, CPP_NAME)
20726 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
20729 c_parser_consume_token (parser);
20730 if (c_parser_next_token_is (parser, CPP_NAME)
20731 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser)->value),
20733 c_parser_consume_token (parser);
20736 c_parser_error (parser, "expected %<target%>");
20737 c_parser_skip_to_pragma_eol (parser);
20743 c_parser_error (parser, "expected %<declare%>");
20744 c_parser_skip_to_pragma_eol (parser);
20747 c_parser_skip_to_pragma_eol (parser);
20765 c_parser_omp_declare_reduction (c_parser *parser, enum pragma_context context)
20773 location_t rloc = c_parser_peek_token (parser)->location;
20781 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
20784 switch (c_parser_peek_token (parser)->type)
20812 p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
20823 reduc_id = c_parser_peek_token (parser)->value;
20826 c_parser_error (parser,
20836 c_parser_consume_token (parser);
20838 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
20843 location_t loc = c_parser_peek_token (parser)->location;
20844 struct c_type_name *ctype = c_parser_type_name (parser);
20888 if (c_parser_next_token_is (parser, CPP_COMMA))
20889 c_parser_consume_token (parser);
20897 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")
20905 c_token *token = c_parser_peek_token (parser);
20908 c_parser_consume_token (parser);
20910 c_parser_skip_to_pragma_eol (parser);
20916 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
20918 c_token *token = c_parser_peek_token (parser);
20922 c_parser_consume_token (parser);
20924 clauses.safe_push (*c_parser_peek_token (parser));
20925 c_parser_skip_to_pragma_eol (parser);
20938 tokens_avail = parser->tokens_avail;
20939 gcc_assert (parser->tokens == &parser->tokens_buf[0]);
20942 parser->tokens = clauses.address ();
20943 parser->tokens_avail = clauses.length ();
20944 parser->in_pragma = true;
20968 struct c_expr combiner = c_parser_expression (parser);
20973 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
20975 else if (c_parser_next_token_is (parser, CPP_NAME)
20977 (c_parser_peek_token (parser)->value),
20980 c_parser_consume_token (parser);
20994 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
20996 else if (!c_parser_next_token_is (parser, CPP_NAME))
20998 c_parser_error (parser, "expected %<omp_priv%> or "
21003 (c_parser_peek_token (parser)->value),
21006 if (c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN
21007 || c_parser_peek_token (parser)->id_kind != C_ID_ID)
21009 c_parser_error (parser, "expected function-name %<(%>");
21013 initializer = c_parser_postfix_expression (parser);
21034 c_parser_consume_token (parser);
21035 if (!c_parser_require (parser, CPP_EQ, "expected %<=%>"))
21040 location_t loc = c_parser_peek_token (parser)->location;
21043 struct c_expr init = c_parser_initializer (parser);
21051 && !c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
21057 c_parser_skip_to_pragma_eol (parser);
21096 parser->tokens = &parser->tokens_buf[0];
21097 parser->tokens_avail = tokens_avail;
21120 c_parser_omp_declare (c_parser *parser, enum pragma_context context)
21122 c_parser_consume_pragma (parser);
21123 if (c_parser_next_token_is (parser, CPP_NAME))
21125 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
21128 /* c_parser_consume_token (parser); done in
21130 c_parser_omp_declare_simd (parser, context);
21135 c_parser_consume_token (parser);
21136 c_parser_omp_declare_reduction (parser, context);
21141 c_parser_skip_to_pragma_eol (parser, false);
21146 c_parser_consume_token (parser);
21147 c_parser_omp_declare_target (parser);
21152 /* c_parser_consume_token (parser); done in
21154 c_parser_omp_declare_simd (parser, context);
21159 c_parser_error (parser, "expected %<simd%>, %<reduction%>, "
21161 c_parser_skip_to_pragma_eol (parser);
21168 c_parser_omp_requires (c_parser *parser)
21173 c_parser_consume_pragma (parser);
21175 location_t loc = c_parser_peek_token (parser)->location;
21176 while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL))
21178 if (!first && c_parser_next_token_is (parser, CPP_COMMA))
21179 c_parser_consume_token (parser);
21183 if (c_parser_next_token_is (parser, CPP_NAME))
21186 = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
21187 location_t cloc = c_parser_peek_token (parser)->location;
21200 c_parser_consume_token (parser);
21203 if (parens.require_open (parser))
21205 if (c_parser_next_token_is (parser, CPP_NAME))
21207 tree v = c_parser_peek_token (parser)->value;
21222 error_at (c_parser_peek_token (parser)->location,
21225 if (c_parser_peek_2nd_token (parser)->type
21227 c_parser_consume_token (parser);
21230 c_parser_consume_token (parser);
21232 parens.skip_until_found_close (parser);
21235 c_parser_skip_to_pragma_eol (parser, false);
21248 c_parser_skip_to_pragma_eol (parser, false);
21255 c_parser_consume_token (parser);
21296 c_parser_skip_to_pragma_eol (parser);
21363 c_parser_omp_taskloop (location_t loc, c_parser *parser,
21376 if (c_parser_next_token_is (parser, CPP_NAME))
21378 const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value);
21385 c_parser_consume_token (parser);
21387 return c_parser_omp_simd (loc, parser, p_name, mask, cclauses,
21390 ret = c_parser_omp_simd (loc, parser, p_name, mask, cclauses, if_p);
21407 c_parser_skip_to_pragma_eol (parser, false);
21411 clauses = c_parser_omp_all_clauses (parser, mask, p_name, cclauses == NULL);
21420 ret = c_parser_omp_for_loop (loc, parser, OMP_TASKLOOP, clauses, NULL, if_p);
21430 c_parser_omp_construct (c_parser *parser, bool *if_p)
21438 loc = c_parser_peek_token (parser)->location;
21439 p_kind = c_parser_peek_token (parser)->pragma_kind;
21440 c_parser_consume_pragma (parser);
21445 c_parser_omp_atomic (loc, parser);
21449 stmt = c_parser_oacc_cache (loc, parser);
21452 stmt = c_parser_oacc_data (loc, parser, if_p);
21455 stmt = c_parser_oacc_host_data (loc, parser, if_p);
21461 stmt = c_parser_oacc_compute (loc, parser, p_kind, p_name, if_p);
21465 stmt = c_parser_oacc_loop (loc, parser, p_name, mask, NULL, if_p);
21469 stmt = c_parser_oacc_wait (loc, parser, p_name);
21472 c_parser_omp_atomic (loc, parser);
21475 stmt = c_parser_omp_critical (loc, parser, if_p);
21479 stmt = c_parser_omp_distribute (loc, parser, p_name, mask, NULL, if_p);
21483 stmt = c_parser_omp_for (loc, parser, p_name, mask, NULL, if_p);
21487 stmt = c_parser_omp_loop (loc, parser, p_name, mask, NULL, if_p);
21491 stmt = c_parser_omp_master (loc, parser, p_name, mask, NULL, if_p);
21495 stmt = c_parser_omp_parallel (loc, parser, p_name, mask, NULL, if_p);
21499 stmt = c_parser_omp_sections (loc, parser, p_name, mask, NULL);
21503 stmt = c_parser_omp_simd (loc, parser, p_name, mask, NULL, if_p);
21506 stmt = c_parser_omp_single (loc, parser, if_p);
21509 stmt = c_parser_omp_task (loc, parser, if_p);
21512 stmt = c_parser_omp_taskgroup (loc, parser, if_p);
21516 stmt = c_parser_omp_taskloop (loc, parser, p_name, mask, NULL, if_p);
21520 stmt = c_parser_omp_teams (loc, parser, p_name, mask, NULL, if_p);
21535 c_parser_omp_threadprivate (c_parser *parser)
21540 c_parser_consume_pragma (parser);
21541 loc = c_parser_peek_token (parser)->location;
21542 vars = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_ERROR, NULL);
21582 c_parser_skip_to_pragma_eol (parser);
21593 c_parser_transaction_attributes (c_parser *parser)
21595 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
21596 return c_parser_gnu_attributes (parser);
21598 if (!c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
21600 return c_parser_std_attribute_specifier (parser, true);
21614 c_parser_transaction (c_parser *parser, enum rid keyword)
21616 unsigned int old_in = parser->in_transaction;
21618 location_t loc = c_parser_peek_token (parser)->location;
21623 && c_parser_next_token_is_keyword (parser, keyword));
21624 c_parser_consume_token (parser);
21630 attrs = c_parser_transaction_attributes (parser);
21638 parser->in_transaction = new_in;
21639 stmt = c_parser_compound_statement (parser);
21640 parser->in_transaction = old_in;
21662 c_parser_transaction_expression (c_parser *parser, enum rid keyword)
21665 unsigned int old_in = parser->in_transaction;
21667 location_t loc = c_parser_peek_token (parser)->location;
21672 && c_parser_next_token_is_keyword (parser, keyword));
21673 c_parser_consume_token (parser);
21679 attrs = c_parser_transaction_attributes (parser);
21684 parser->in_transaction = this_in;
21686 if (parens.require_open (parser))
21688 tree expr = c_parser_expression (parser).value;
21695 if (!parens.require_close (parser))
21697 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
21708 parser->in_transaction = old_in;
21730 c_parser_transaction_cancel (c_parser *parser)
21732 location_t loc = c_parser_peek_token (parser)->location;
21736 gcc_assert (c_parser_next_token_is_keyword (parser, RID_TRANSACTION_CANCEL));
21737 c_parser_consume_token (parser);
21739 attrs = c_parser_transaction_attributes (parser);
21749 else if (parser->in_transaction & TM_STMT_ATTR_RELAXED)
21757 if ((parser->in_transaction & TM_STMT_ATTR_OUTER) == 0
21766 else if (parser->in_transaction == 0)
21815 The RTL parser works on the level of characters read from a
21820 lines within the RTL parser.
21828 c_parser_parse_rtl_body (c_parser *parser, char *start_with_pass)
21830 if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
21833 return c_parser_peek_token (parser)->location;
21836 location_t start_loc = c_parser_peek_token (parser)->location;
21843 switch (c_parser_peek_token (parser)->type)
21855 return c_parser_peek_token (parser)->location;
21859 c_parser_consume_token (parser);
21864 location_t end_loc = c_parser_peek_token (parser)->location;
21867 c_parser_consume_token (parser);
21869 /* Invoke the RTL parser. */
21882 #include "gt-c-c-parser.h"