| blob | 33fb40a5b59a3fb09f0c35ea6073658be31b3b81 |
1 /* -*- C++ -*- Parser.
2 Copyright (C) 2000-2021 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 #define INCLUDE_MEMORY
50 \f
51 /* The lexer. */
53 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
54 and c-lex.c) and the C++ parser. */
56 /* The various kinds of non integral constant we encounter. */
58 NIC_NONE,
59 /* floating-point literal */
60 NIC_FLOAT,
61 /* %<this%> */
62 NIC_THIS,
63 /* %<__FUNCTION__%> */
64 NIC_FUNC_NAME,
65 /* %<__PRETTY_FUNCTION__%> */
66 NIC_PRETTY_FUNC,
67 /* %<__func__%> */
68 NIC_C99_FUNC,
69 /* "%<va_arg%> */
70 NIC_VA_ARG,
71 /* a cast */
72 NIC_CAST,
73 /* %<typeid%> operator */
74 NIC_TYPEID,
75 /* non-constant compound literals */
76 NIC_NCC,
77 /* a function call */
78 NIC_FUNC_CALL,
79 /* an increment */
80 NIC_INC,
81 /* an decrement */
82 NIC_DEC,
83 /* an array reference */
84 NIC_ARRAY_REF,
85 /* %<->%> */
86 NIC_ARROW,
87 /* %<.%> */
88 NIC_POINT,
89 /* the address of a label */
90 NIC_ADDR_LABEL,
91 /* %<*%> */
92 NIC_STAR,
93 /* %<&%> */
94 NIC_ADDR,
95 /* %<++%> */
96 NIC_PREINCREMENT,
97 /* %<--%> */
98 NIC_PREDECREMENT,
99 /* %<new%> */
100 NIC_NEW,
101 /* %<delete%> */
102 NIC_DEL,
103 /* calls to overloaded operators */
104 NIC_OVERLOADED,
105 /* an assignment */
106 NIC_ASSIGNMENT,
107 /* a comma operator */
108 NIC_COMMA,
109 /* a call to a constructor */
110 NIC_CONSTRUCTOR,
111 /* a transaction expression */
112 NIC_TRANSACTION
113 };
115 /* The various kinds of errors about name-lookup failing. */
117 /* NULL */
118 NLE_NULL,
119 /* is not a type */
120 NLE_TYPE,
121 /* is not a class or namespace */
122 NLE_CXX98,
123 /* is not a class, namespace, or enumeration */
124 NLE_NOT_CXX98
125 };
127 /* The various kinds of required token */
129 RT_NONE,
151 /* The type is CPP_KEYWORD */
183 RT_CO_YIELD /* co_yield */
184 };
186 /* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
187 reverting it on destruction. */
189 class type_id_in_expr_sentinel
190 {
200 };
202 /* Prototypes. */
208 static void cp_lexer_destroy
210 static int cp_lexer_saving_tokens
214 static void cp_lexer_get_preprocessor_token
222 static bool cp_lexer_next_token_is_not
224 static bool cp_lexer_next_token_is_keyword
228 static void cp_lexer_purge_token
230 static void cp_lexer_purge_tokens_after
232 static void cp_lexer_save_tokens
234 static void cp_lexer_commit_tokens
236 static void cp_lexer_rollback_tokens
238 static void cp_lexer_print_token
242 static void cp_lexer_start_debugging
244 static void cp_lexer_stop_debugging
249 static tree cp_parser_late_noexcept_specifier
251 static void noexcept_override_late_checks
254 static void cp_parser_initial_pragma
257 static bool cp_parser_omp_declare_reduction_exprs
259 static void cp_finalize_oacc_routine
262 /* Manifest constants. */
263 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
264 #define CP_SAVED_TOKEN_STACK 5
266 /* Variables. */
268 /* The stream to which debugging output should be written. */
271 /* Nonzero if we are parsing an unevaluated operand: an operand to
272 sizeof, typeof, or alignof. */
275 /* Dump up to NUM tokens in BUFFER to FILE starting with token
276 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
277 first token in BUFFER. If NUM is 0, dump all the tokens. If
278 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
279 highlighted by surrounding it in [[ ]]. */
281 static void
285 {
302 {
305 }
310 {
317 nprinted++;
327 {
337 }
338 }
341 {
344 }
347 }
350 /* Dump all tokens in BUFFER to stderr. */
352 void
354 {
356 }
358 DEBUG_FUNCTION void
360 {
362 }
364 DEBUG_FUNCTION void
366 {
369 else
371 }
374 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
375 description for T. */
377 static void
379 {
381 {
384 }
385 }
388 /* Dump parser context C to FILE. */
390 static void
392 {
397 }
400 /* Print the stack of parsing contexts to FILE starting with FIRST. */
402 static void
404 {
410 {
413 }
414 }
417 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
419 static void
421 {
424 }
427 /* Print an unparsed function entry UF to FILE. */
429 static void
431 {
434 tree fn;
439 i++)
440 {
446 }
451 {
454 }
460 {
463 }
465 }
468 /* Print the stack of unparsed member functions S to FILE. */
470 static void
473 {
479 {
482 }
483 }
486 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
487 the given PARSER. If FILE is NULL, the output is printed on stderr. */
489 static void
491 {
503 next_token);
504 }
507 /* Dump debugging information for the given PARSER. If FILE is NULL,
508 the output is printed on stderr. */
510 void
512 {
515 expanded_location eloc;
580 parser->type_definition_forbidden_message_arg
596 }
598 DEBUG_FUNCTION void
600 {
602 }
604 DEBUG_FUNCTION void
606 {
609 else
611 }
613 /* Allocate memory for a new lexer object and return it. */
617 {
618 /* Allocate the memory. */
621 /* Initially we are not debugging. */
626 /* Create the buffer. */
630 }
632 /* Create a new main C++ lexer, the lexer that gets tokens from the
633 preprocessor. */
637 {
638 cp_token token;
640 /* It's possible that parsing the first pragma will load a PCH file,
641 which is a GC collection point. So we have to do that before
642 allocating any memory. */
648 /* Put the first token in the buffer. */
655 /* Get the remaining tokens from the preprocessor. */
657 {
659 /* Process the previous token. */
664 }
672 {
673 /* Set the EOF token's location to be the just after the previous
674 token's range. That way 'at-eof' diagnostics point at something
675 meaninful. */
679 }
684 /* Subsequent preprocessor diagnostics should use compiler
685 diagnostic functions to get the compiler source location. */
692 }
694 /* Create a new lexer whose token stream is primed with the tokens in
695 CACHE. When these tokens are exhausted, no new tokens will be read. */
699 {
704 /* We do not own the buffer. */
707 /* Insert an EOF token. */
718 /* Initially we are not debugging. */
724 }
726 /* Frees all resources associated with LEXER. */
728 static void
730 {
733 else
734 {
735 /* Restore the token we overwrite with EOF. */
738 }
741 }
743 /* This needs to be set to TRUE before the lexer-debugging infrastructure can
744 be used. The point of this flag is to help the compiler to fold away calls
745 to cp_lexer_debugging_p within this source file at compile time, when the
746 lexer is not being debugged. */
748 #define LEXER_DEBUGGING_ENABLED_P false
750 /* Returns nonzero if debugging information should be output. */
754 {
759 }
764 {
766 }
770 {
772 }
776 {
778 }
782 {
784 }
788 {
791 /* Skip past purged tokens. */
793 {
795 tp--;
796 }
799 }
801 /* Same as above, but return NULL when the lexer doesn't own the token
802 buffer or if the next_token is at the start of the token
803 vector or if all previous tokens are purged. */
807 {
810 {
813 /* Skip past purged tokens. */
815 {
818 tp--;
819 }
821 }
824 }
826 /* Overload for make_location, taking the lexer to mean the location of the
827 previous token. */
831 {
834 }
836 /* Overload for make_location taking tokens instead of locations. */
840 {
842 }
844 /* nonzero if we are presently saving tokens. */
848 {
850 }
852 /* Store the next token from the preprocessor in *TOKEN. Return true
853 if we reach EOF. If LEXER is NULL, assume we are handling an
854 initial #pragma pch_preprocess, and thus want the lexer to return
855 processed strings. */
857 static void
859 {
862 /* Get a new token from the preprocessor. */
863 token->type
865 flags);
870 /* Usually never see a zero, but just in case ... */
873 /* On some systems, some header files are surrounded by an
874 implicit extern "C" block. Set a flag in the token if it
875 comes from such a header. */
880 /* Check to see if this token is a keyword. */
882 {
884 {
885 /* Mark this token as a keyword. */
887 /* Record which keyword. */
889 }
890 else
891 {
895 {
896 /* Warn about the C++0x keyword (but still treat it as
897 an identifier). */
902 /* Clear out the C_RID_CODE so we don't warn about this
903 particular identifier-turned-keyword again. */
905 }
909 {
910 /* Warn about the C++20 keyword (but still treat it as
911 an identifier). */
916 /* Clear out the C_RID_CODE so we don't warn about this
917 particular identifier-turned-keyword again. */
919 }
922 }
923 }
925 {
926 /* This only happens in Objective-C++; it must be a keyword. */
929 {
930 /* Replace 'class' with '@class', 'private' with '@private',
931 etc. This prevents confusion with the C++ keyword
932 'class', and makes the tokens consistent with other
933 Objective-C 'AT' keywords. For example '@class' is
934 reported as RID_AT_CLASS which is consistent with
935 '@synchronized', which is reported as
936 RID_AT_SYNCHRONIZED.
937 */
947 }
948 }
949 }
951 /* Update the globals input_location and the input file stack from TOKEN. */
954 {
956 }
958 /* Update the globals input_location and the input file stack from LEXER. */
961 {
964 }
966 /* Return a pointer to the next token in the token stream, but do not
967 consume it. */
971 {
973 {
977 }
979 }
981 /* Return true if the next token has the indicated TYPE. */
985 {
987 }
989 /* Return true if the next token does not have the indicated TYPE. */
993 {
995 }
997 /* Return true if the next token is the indicated KEYWORD. */
1001 {
1003 }
1007 {
1009 }
1013 {
1015 }
1017 /* Return true if KEYWORD can start a decl-specifier. */
1019 bool
1021 {
1023 {
1024 /* auto specifier: storage-class-specifier in C++,
1025 simple-type-specifier in C++0x. */
1027 /* Storage classes. */
1033 /* Elaborated type specifiers. */
1039 /* Simple type specifiers. */
1054 /* CV qualifiers. */
1057 /* Function specifiers. */
1060 /* friend/typdef/inline specifiers. */
1064 /* GNU extensions. */
1066 /* C++11 extensions. */
1070 /* C++20 extensions. */
1081 }
1082 }
1084 /* Return true if the next token is a keyword for a decl-specifier. */
1086 static bool
1088 {
1093 }
1095 /* Returns TRUE iff the token T begins a decltype type. */
1097 static bool
1099 {
1102 }
1104 /* Returns TRUE iff the next token begins a decltype type. */
1106 static bool
1108 {
1111 }
1113 /* Called when processing a token with tree_check_value; perform or defer the
1114 associated checks and return the value. */
1116 static tree
1118 {
1119 /* Perform any access checks that were deferred. */
1124 {
1130 }
1131 /* Return the stored value. */
1133 }
1135 /* Return a pointer to the Nth token in the token stream. If N is 1,
1136 then this is precisely equivalent to cp_lexer_peek_token (except
1137 that it is not inline). One would like to disallow that case, but
1138 there is one case (cp_parser_nth_token_starts_template_id) where
1139 the caller passes a variable for N and it might be 1. */
1143 {
1146 /* N is 1-based, not zero-based. */
1156 {
1160 }
1163 {
1166 }
1169 }
1171 /* Return the next token, and advance the lexer's next_token pointer
1172 to point to the next non-purged token. */
1176 {
1179 do
1180 {
1183 }
1188 /* Provide debugging output. */
1190 {
1194 }
1197 }
1199 /* Permanently remove the next token from the token stream, and
1200 advance the next_token pointer to refer to the next non-purged
1201 token. */
1203 static void
1205 {
1214 do
1215 tok++;
1218 }
1220 /* Permanently remove all tokens after TOK, up to, but not
1221 including, the token that will be returned next by
1222 cp_lexer_peek_token. */
1224 static void
1226 {
1232 {
1237 }
1238 }
1240 /* Begin saving tokens. All tokens consumed after this point will be
1241 preserved. */
1243 static void
1245 {
1246 /* Provide debugging output. */
1251 }
1253 /* Commit to the portion of the token stream most recently saved. */
1255 static void
1257 {
1258 /* Provide debugging output. */
1263 }
1265 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1266 to the token stream. Stop saving tokens. */
1268 static void
1270 {
1271 /* Provide debugging output. */
1276 }
1278 /* RAII wrapper around the above functions, with sanity checking. Creating
1279 a variable saves tokens, which are committed when the variable is
1280 destroyed unless they are explicitly rolled back by calling the rollback
1281 member function. */
1283 struct saved_token_sentinel
1284 {
1289 {
1292 }
1294 {
1297 }
1299 {
1303 }
1304 };
1306 /* Print a representation of the TOKEN on the STREAM. */
1308 static void
1310 {
1311 /* We don't use cpp_type2name here because the parser defines
1312 a few tokens of its own. */
1314 /* cpplib-defined token types */
1315 #define OP(e, s) #e,
1316 #define TK(e, s) #e,
1317 TTYPE_TABLE
1318 #undef OP
1319 #undef TK
1320 /* C++ parser token types - see "Manifest constants", above. */
1324 };
1326 /* For some tokens, print the associated data. */
1328 {
1330 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1331 For example, `struct' is mapped to an INTEGER_CST. */
1334 /* fall through */
1352 /* If we have a name for the token, print it out. Otherwise, we
1353 simply give the numeric code. */
1356 else
1359 }
1360 }
1362 DEBUG_FUNCTION void
1364 {
1367 }
1369 DEBUG_FUNCTION void
1371 {
1374 else
1376 }
1379 /* Start emitting debugging information. */
1381 static void
1383 {
1390 }
1392 /* Stop emitting debugging information. */
1394 static void
1396 {
1403 }
1405 /* Create a new cp_token_cache, representing a range of tokens. */
1409 {
1414 }
1416 /* Diagnose if #pragma omp declare simd isn't followed immediately
1417 by function declaration or definition. */
1421 {
1423 {
1428 }
1429 }
1431 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1432 and put that into "omp declare simd" attribute. */
1436 {
1438 {
1440 {
1443 }
1445 {
1448 }
1449 }
1450 }
1452 /* Similarly, but for use in declaration parsing functions
1453 which call cp_parser_handle_directive_omp_attributes. */
1457 {
1464 "%<declare %s%> directive not immediately followed by "
1468 }
1470 /* Diagnose if #pragma acc routine isn't followed immediately by function
1471 declaration or definition. */
1475 {
1477 {
1479 "%<#pragma acc routine%> not immediately followed by "
1482 }
1483 }
1484 \f
1485 /* Decl-specifiers. */
1487 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1489 static void
1491 {
1493 }
1495 /* Declarators. */
1497 /* Nothing other than the parser should be creating declarators;
1498 declarators are a semi-syntactic representation of C++ entities.
1499 Other parts of the front end that need to create entities (like
1500 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1514 /* An erroneous declarator. */
1517 /* The obstack on which declarators and related data structures are
1518 allocated. */
1521 /* Alloc BYTES from the declarator memory pool. */
1525 {
1527 }
1529 /* Allocate a declarator of the indicated KIND. Clear fields that are
1530 common to all declarators. */
1534 {
1548 }
1550 /* Make a declarator for a generalized identifier. If
1551 QUALIFYING_SCOPE is non-NULL, the identifier is
1552 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1553 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1554 is, if any. */
1559 {
1562 /* It is valid to write:
1564 class C { void f(); };
1565 typedef C D;
1566 void D::f();
1568 The standard is not clear about whether `typedef const C D' is
1569 legal; as of 2002-09-15 the committee is considering that
1570 question. EDG 3.0 allows that syntax. Therefore, we do as
1571 well. */
1586 }
1588 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1589 of modifiers such as const or volatile to apply to the pointer
1590 type, represented as identifiers. ATTRIBUTES represent the attributes that
1591 appertain to the pointer or reference. */
1593 cp_declarator *
1595 tree attributes)
1596 {
1604 {
1608 }
1609 else
1615 }
1617 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1618 represent the attributes that appertain to the pointer or
1619 reference. */
1621 cp_declarator *
1624 {
1632 {
1636 }
1637 else
1643 }
1645 /* Like make_pointer_declarator -- but for a pointer to a non-static
1646 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1647 appertain to the pointer or reference. */
1649 cp_declarator *
1652 tree attributes)
1653 {
1662 {
1665 }
1666 else
1672 }
1674 /* Make a declarator for the function given by TARGET, with the
1675 indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1676 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1677 indicates what exceptions can be thrown. */
1679 cp_declarator *
1681 tree parms,
1682 cp_cv_quals cv_qualifiers,
1683 cp_virt_specifiers virt_specifiers,
1684 cp_ref_qualifier ref_qualifier,
1685 tree tx_qualifier,
1686 tree exception_specification,
1687 tree late_return_type,
1688 tree requires_clause,
1689 location_t parens_loc)
1690 {
1705 {
1709 }
1710 else
1714 }
1716 /* Make a declarator for an array of BOUNDS elements, each of which is
1717 defined by ELEMENT. */
1719 cp_declarator *
1721 {
1728 {
1732 }
1733 else
1737 }
1739 /* Determine whether the declarator we've seen so far can be a
1740 parameter pack, when followed by an ellipsis. */
1741 static bool
1743 {
1745 /* We already saw an ellipsis. */
1748 /* Search for a declarator name, or any other declarator that goes
1749 after the point where the ellipsis could appear in a parameter
1750 pack. If we find any of these, then this declarator cannot be
1751 made into a parameter pack. */
1754 {
1756 {
1769 }
1770 }
1773 }
1777 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1778 DECLARATOR and DEFAULT_ARGUMENT. */
1780 cp_parameter_declarator *
1783 tree default_argument,
1784 location_t loc,
1786 {
1794 else
1802 }
1804 /* Returns true iff DECLARATOR is a declaration for a function. */
1806 static bool
1808 {
1810 {
1819 }
1821 }
1823 /* The parser. */
1825 /* Overview
1826 --------
1828 A cp_parser parses the token stream as specified by the C++
1829 grammar. Its job is purely parsing, not semantic analysis. For
1830 example, the parser breaks the token stream into declarators,
1831 expressions, statements, and other similar syntactic constructs.
1832 It does not check that the types of the expressions on either side
1833 of an assignment-statement are compatible, or that a function is
1834 not declared with a parameter of type `void'.
1836 The parser invokes routines elsewhere in the compiler to perform
1837 semantic analysis and to build up the abstract syntax tree for the
1838 code processed.
1840 The parser (and the template instantiation code, which is, in a
1841 way, a close relative of parsing) are the only parts of the
1842 compiler that should be calling push_scope and pop_scope, or
1843 related functions. The parser (and template instantiation code)
1844 keeps track of what scope is presently active; everything else
1845 should simply honor that. (The code that generates static
1846 initializers may also need to set the scope, in order to check
1847 access control correctly when emitting the initializers.)
1849 Methodology
1850 -----------
1852 The parser is of the standard recursive-descent variety. Upcoming
1853 tokens in the token stream are examined in order to determine which
1854 production to use when parsing a non-terminal. Some C++ constructs
1855 require arbitrary look ahead to disambiguate. For example, it is
1856 impossible, in the general case, to tell whether a statement is an
1857 expression or declaration without scanning the entire statement.
1858 Therefore, the parser is capable of "parsing tentatively." When the
1859 parser is not sure what construct comes next, it enters this mode.
1860 Then, while we attempt to parse the construct, the parser queues up
1861 error messages, rather than issuing them immediately, and saves the
1862 tokens it consumes. If the construct is parsed successfully, the
1863 parser "commits", i.e., it issues any queued error messages and
1864 the tokens that were being preserved are permanently discarded.
1865 If, however, the construct is not parsed successfully, the parser
1866 rolls back its state completely so that it can resume parsing using
1867 a different alternative.
1869 Future Improvements
1870 -------------------
1872 The performance of the parser could probably be improved substantially.
1873 We could often eliminate the need to parse tentatively by looking ahead
1874 a little bit. In some places, this approach might not entirely eliminate
1875 the need to parse tentatively, but it might still speed up the average
1876 case. */
1878 /* Flags that are passed to some parsing functions. These values can
1879 be bitwise-ored together. */
1881 enum
1882 {
1883 /* No flags. */
1885 /* The construct is optional. If it is not present, then no error
1886 should be issued. */
1888 /* When parsing a type-specifier, treat user-defined type-names
1889 as non-type identifiers. */
1891 /* When parsing a type-specifier, do not try to parse a class-specifier
1892 or enum-specifier. */
1894 /* When parsing a decl-specifier-seq, only allow type-specifier or
1895 constexpr. */
1897 /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
1898 for C++20 consteval. */
1900 /* When parsing a decl-specifier-seq, allow missing typename. */
1902 /* When parsing of the noexcept-specifier should be delayed. */
1904 /* When parsing a consteval declarator. */
1906 };
1908 /* This type is used for parameters and variables which hold
1909 combinations of the above flags. */
1912 /* The different kinds of declarators we want to parse. */
1914 enum cp_parser_declarator_kind
1915 {
1916 /* We want an abstract declarator. */
1917 CP_PARSER_DECLARATOR_ABSTRACT,
1918 /* We want a named declarator. */
1919 CP_PARSER_DECLARATOR_NAMED,
1920 /* We don't mind, but the name must be an unqualified-id. */
1921 CP_PARSER_DECLARATOR_EITHER
1922 };
1924 /* The precedence values used to parse binary expressions. The minimum value
1925 of PREC must be 1, because zero is reserved to quickly discriminate
1926 binary operators from other tokens. */
1928 enum cp_parser_prec
1929 {
1930 PREC_NOT_OPERATOR,
1931 PREC_LOGICAL_OR_EXPRESSION,
1932 PREC_LOGICAL_AND_EXPRESSION,
1933 PREC_INCLUSIVE_OR_EXPRESSION,
1934 PREC_EXCLUSIVE_OR_EXPRESSION,
1935 PREC_AND_EXPRESSION,
1936 PREC_EQUALITY_EXPRESSION,
1937 PREC_RELATIONAL_EXPRESSION,
1938 PREC_SPACESHIP_EXPRESSION,
1939 PREC_SHIFT_EXPRESSION,
1940 PREC_ADDITIVE_EXPRESSION,
1941 PREC_MULTIPLICATIVE_EXPRESSION,
1942 PREC_PM_EXPRESSION,
1943 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1944 };
1946 /* A mapping from a token type to a corresponding tree node type, with a
1947 precedence value. */
1949 struct cp_parser_binary_operations_map_node
1950 {
1951 /* The token type. */
1953 /* The corresponding tree code. */
1955 /* The precedence of this operator. */
1957 };
1959 struct cp_parser_expression_stack_entry
1960 {
1961 /* Left hand side of the binary operation we are currently
1962 parsing. */
1963 cp_expr lhs;
1964 /* Original tree code for left hand side, if it was a binary
1965 expression itself (used for -Wparentheses). */
1967 /* Tree code for the binary operation we are parsing. */
1969 /* Precedence of the binary operation we are parsing. */
1971 /* Location of the binary operation we are parsing. */
1972 location_t loc;
1973 };
1975 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1976 entries because precedence levels on the stack are monotonically
1977 increasing. */
1981 /* Prototypes. */
1983 /* Constructors and destructors. */
1988 /* Class variables. */
1992 /* The operator-precedence table used by cp_parser_binary_expression.
1993 Transformed into an associative array (binops_by_token) by
1994 cp_parser_new. */
2029 };
2031 /* The same as binops, but initialized by cp_parser_new so that
2032 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2033 for speed. */
2036 /* Constructors and destructors. */
2038 /* Construct a new context. The context below this one on the stack
2039 is given by NEXT. */
2043 {
2046 /* Allocate the storage. */
2048 {
2049 /* Pull the first entry from the free list. */
2053 }
2054 else
2057 /* No errors have occurred yet in this context. */
2059 /* If this is not the bottommost context, copy information that we
2060 need from the previous context. */
2062 {
2063 /* If, in the NEXT context, we are parsing an `x->' or `x.'
2064 expression, then we are parsing one in this context, too. */
2066 /* Thread the stack. */
2068 }
2071 }
2073 /* Managing the unparsed function queues. */
2075 #define unparsed_funs_with_default_args \
2076 parser->unparsed_queues->last ().funs_with_default_args
2077 #define unparsed_funs_with_definitions \
2078 parser->unparsed_queues->last ().funs_with_definitions
2079 #define unparsed_nsdmis \
2080 parser->unparsed_queues->last ().nsdmis
2081 #define unparsed_noexcepts \
2082 parser->unparsed_queues->last ().noexcepts
2084 static void
2086 {
2089 }
2091 static void
2093 {
2096 }
2098 /* Prototypes. */
2100 /* Constructors and destructors. */
2105 /* Routines to parse various constructs.
2107 Those that return `tree' will return the error_mark_node (rather
2108 than NULL_TREE) if a parse error occurs, unless otherwise noted.
2109 Sometimes, they will return an ordinary node if error-recovery was
2110 attempted, even though a parse error occurred. So, to check
2111 whether or not a parse error occurred, you should always use
2112 cp_parser_error_occurred. If the construct is optional (indicated
2113 either by an `_opt' in the name of the function that does the
2114 parsing or via a FLAGS parameter), then NULL_TREE is returned if
2115 the construct is not present. */
2117 /* Lexical conventions [gram.lex] */
2119 static cp_expr cp_parser_identifier
2121 static cp_expr cp_parser_string_literal
2123 static cp_expr cp_parser_userdef_char_literal
2125 static tree cp_parser_userdef_string_literal
2127 static cp_expr cp_parser_userdef_numeric_literal
2130 /* Basic concepts [gram.basic] */
2134 /* Expressions [gram.expr] */
2136 static cp_expr cp_parser_primary_expression
2138 static cp_expr cp_parser_id_expression
2140 static cp_expr cp_parser_unqualified_id
2142 static tree cp_parser_nested_name_specifier_opt
2144 static tree cp_parser_nested_name_specifier
2146 static tree cp_parser_qualifying_entity
2148 static cp_expr cp_parser_postfix_expression
2150 static tree cp_parser_postfix_open_square_expression
2152 static tree cp_parser_postfix_dot_deref_expression
2157 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2159 static void cp_parser_pseudo_destructor_name
2161 static cp_expr cp_parser_unary_expression
2163 static enum tree_code cp_parser_unary_operator
2165 static tree cp_parser_has_attribute_expression
2167 static tree cp_parser_new_expression
2171 static tree cp_parser_new_type_id
2179 static tree cp_parser_delete_expression
2181 static cp_expr cp_parser_cast_expression
2183 static cp_expr cp_parser_binary_expression
2185 static tree cp_parser_question_colon_clause
2187 static cp_expr cp_parser_assignment_expression
2189 static enum tree_code cp_parser_assignment_operator_opt
2191 static cp_expr cp_parser_expression
2193 static cp_expr cp_parser_constant_expression
2195 static cp_expr cp_parser_builtin_offsetof
2197 static cp_expr cp_parser_lambda_expression
2199 static void cp_parser_lambda_introducer
2201 static bool cp_parser_lambda_declarator_opt
2203 static void cp_parser_lambda_body
2206 /* Statements [gram.stmt.stmt] */
2208 static void cp_parser_statement
2210 static void cp_parser_label_for_labeled_statement
2212 static tree cp_parser_expression_statement
2214 static tree cp_parser_compound_statement
2216 static void cp_parser_statement_seq_opt
2218 static tree cp_parser_selection_statement
2220 static tree cp_parser_condition
2222 static tree cp_parser_iteration_statement
2224 static bool cp_parser_init_statement
2226 static tree cp_parser_for
2228 static tree cp_parser_c_for
2230 static tree cp_parser_range_for
2232 static void do_range_for_auto_deduction
2234 static tree cp_parser_perform_range_for_lookup
2236 static tree cp_parser_range_for_member_function
2238 static tree cp_parser_jump_statement
2240 static void cp_parser_declaration_statement
2243 static tree cp_parser_implicitly_scoped_statement
2245 static void cp_parser_already_scoped_statement
2248 /* State of module-declaration parsing. */
2249 enum module_parse
2250 {
2253 _MP_UNUSED,
2263 };
2265 static module_parse cp_parser_module_declaration
2267 static void cp_parser_import_declaration
2270 /* Declarations [gram.dcl.dcl] */
2272 static void cp_parser_declaration_seq_opt
2274 static void cp_parser_declaration
2276 static void cp_parser_toplevel_declaration
2278 static void cp_parser_block_declaration
2280 static void cp_parser_simple_declaration
2282 static void cp_parser_decl_specifier_seq
2284 static tree cp_parser_storage_class_specifier_opt
2286 static tree cp_parser_function_specifier_opt
2288 static tree cp_parser_type_specifier
2291 static tree cp_parser_simple_type_specifier
2293 static tree cp_parser_placeholder_type_specifier
2295 static tree cp_parser_type_name
2297 static tree cp_parser_nonclass_name
2299 static tree cp_parser_elaborated_type_specifier
2301 static tree cp_parser_enum_specifier
2303 static void cp_parser_enumerator_list
2305 static void cp_parser_enumerator_definition
2307 static tree cp_parser_namespace_name
2309 static void cp_parser_namespace_definition
2311 static void cp_parser_namespace_body
2313 static tree cp_parser_qualified_namespace_specifier
2315 static void cp_parser_namespace_alias_definition
2317 static bool cp_parser_using_declaration
2319 static void cp_parser_using_directive
2321 static void cp_parser_using_enum
2323 static tree cp_parser_alias_declaration
2325 static void cp_parser_asm_definition
2327 static void cp_parser_linkage_specification
2329 static void cp_parser_static_assert
2331 static tree cp_parser_decltype
2333 static tree cp_parser_decomposition_declaration
2336 /* Declarators [gram.dcl.decl] */
2338 static tree cp_parser_init_declarator
2348 static enum tree_code cp_parser_ptr_operator
2350 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2352 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2354 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2356 static tree cp_parser_tx_qualifier_opt
2358 static tree cp_parser_late_return_type_opt
2360 static tree cp_parser_declarator_id
2362 static tree cp_parser_type_id
2364 static tree cp_parser_template_type_arg
2367 static tree cp_parser_type_id_1
2369 static void cp_parser_type_specifier_seq
2371 static tree cp_parser_parameter_declaration_clause
2373 static tree cp_parser_parameter_declaration_list
2377 static tree cp_parser_default_argument
2379 static void cp_parser_function_body
2381 static tree cp_parser_initializer
2383 static cp_expr cp_parser_initializer_clause
2385 static cp_expr cp_parser_braced_list
2390 static void cp_parser_ctor_initializer_opt_and_function_body
2393 static tree cp_parser_late_parsing_omp_declare_simd
2396 static tree cp_parser_late_parsing_oacc_routine
2399 static tree synthesize_implicit_template_parm
2401 static tree finish_fully_implicit_template
2403 static void abort_fully_implicit_template
2406 /* Classes [gram.class] */
2408 static tree cp_parser_class_name
2410 static tree cp_parser_class_specifier
2412 static tree cp_parser_class_head
2414 static enum tag_types cp_parser_class_key
2416 static void cp_parser_type_parameter_key
2418 static void cp_parser_member_specification_opt
2420 static void cp_parser_member_declaration
2422 static tree cp_parser_pure_specifier
2424 static tree cp_parser_constant_initializer
2427 /* Derived classes [gram.class.derived] */
2429 static tree cp_parser_base_clause
2431 static tree cp_parser_base_specifier
2434 /* Special member functions [gram.special] */
2436 static tree cp_parser_conversion_function_id
2438 static tree cp_parser_conversion_type_id
2442 static void cp_parser_ctor_initializer_opt
2444 static void cp_parser_mem_initializer_list
2446 static tree cp_parser_mem_initializer
2448 static tree cp_parser_mem_initializer_id
2451 /* Overloading [gram.over] */
2453 static cp_expr cp_parser_operator_function_id
2455 static cp_expr cp_parser_operator
2458 /* Templates [gram.temp] */
2460 static void cp_parser_template_declaration
2462 static tree cp_parser_template_parameter_list
2464 static tree cp_parser_template_parameter
2466 static tree cp_parser_type_parameter
2468 static tree cp_parser_template_id
2470 static tree cp_parser_template_id_expr
2472 static tree cp_parser_template_name
2474 static tree cp_parser_template_argument_list
2476 static tree cp_parser_template_argument
2478 static void cp_parser_explicit_instantiation
2480 static void cp_parser_explicit_specialization
2483 /* Exception handling [gram.except] */
2485 static tree cp_parser_try_block
2487 static void cp_parser_function_try_block
2489 static void cp_parser_handler_seq
2491 static void cp_parser_handler
2493 static tree cp_parser_exception_declaration
2495 static tree cp_parser_throw_expression
2497 static tree cp_parser_exception_specification_opt
2499 static tree cp_parser_type_id_list
2501 static tree cp_parser_noexcept_specification_opt
2504 /* GNU Extensions */
2506 static tree cp_parser_asm_specification_opt
2508 static tree cp_parser_asm_operand_list
2510 static tree cp_parser_asm_clobber_list
2512 static tree cp_parser_asm_label_list
2514 static bool cp_next_tokens_can_be_attribute_p
2516 static bool cp_next_tokens_can_be_gnu_attribute_p
2518 static bool cp_next_tokens_can_be_std_attribute_p
2520 static bool cp_nth_tokens_can_be_std_attribute_p
2522 static bool cp_nth_tokens_can_be_gnu_attribute_p
2524 static bool cp_nth_tokens_can_be_attribute_p
2526 static tree cp_parser_attributes_opt
2528 static tree cp_parser_gnu_attributes_opt
2530 static tree cp_parser_gnu_attribute_list
2532 static tree cp_parser_std_attribute
2534 static tree cp_parser_std_attribute_spec
2536 static tree cp_parser_std_attribute_spec_seq
2538 static size_t cp_parser_skip_std_attribute_spec_seq
2540 static size_t cp_parser_skip_attributes_opt
2542 static bool cp_parser_extension_opt
2544 static void cp_parser_label_declaration
2547 /* Concept Extensions */
2549 static tree cp_parser_concept_definition
2551 static tree cp_parser_constraint_expression
2553 static tree cp_parser_requires_clause_opt
2555 static tree cp_parser_requires_expression
2557 static tree cp_parser_requirement_parameter_list
2559 static tree cp_parser_requirement_body
2561 static tree cp_parser_requirement_seq
2563 static tree cp_parser_requirement
2565 static tree cp_parser_simple_requirement
2567 static tree cp_parser_compound_requirement
2569 static tree cp_parser_type_requirement
2571 static tree cp_parser_nested_requirement
2574 /* Transactional Memory Extensions */
2576 static tree cp_parser_transaction
2578 static tree cp_parser_transaction_expression
2580 static void cp_parser_function_transaction
2582 static tree cp_parser_transaction_cancel
2585 /* Coroutine extensions. */
2587 static tree cp_parser_yield_expression
2592 pragma_external,
2593 pragma_member,
2594 pragma_objc_icode,
2595 pragma_stmt,
2596 pragma_compound
2597 };
2598 static bool cp_parser_pragma
2601 /* Objective-C++ Productions */
2603 static tree cp_parser_objc_message_receiver
2605 static tree cp_parser_objc_message_args
2607 static tree cp_parser_objc_message_expression
2609 static cp_expr cp_parser_objc_encode_expression
2611 static tree cp_parser_objc_defs_expression
2613 static tree cp_parser_objc_protocol_expression
2615 static tree cp_parser_objc_selector_expression
2617 static cp_expr cp_parser_objc_expression
2619 static bool cp_parser_objc_selector_p
2621 static tree cp_parser_objc_selector
2623 static tree cp_parser_objc_protocol_refs_opt
2625 static void cp_parser_objc_declaration
2627 static tree cp_parser_objc_statement
2629 static bool cp_parser_objc_valid_prefix_attributes
2631 static void cp_parser_objc_at_property_declaration
2633 static void cp_parser_objc_at_synthesize_declaration
2635 static void cp_parser_objc_at_dynamic_declaration
2637 static tree cp_parser_objc_struct_declaration
2640 /* Utility Routines */
2642 static cp_expr cp_parser_lookup_name
2644 static tree cp_parser_lookup_name_simple
2646 static tree cp_parser_maybe_treat_template_as_class
2648 static bool cp_parser_check_declarator_template_parameters
2650 static bool cp_parser_check_template_parameters
2652 static cp_expr cp_parser_simple_cast_expression
2654 static tree cp_parser_global_scope_opt
2656 static bool cp_parser_constructor_declarator_p
2658 static tree cp_parser_function_definition_from_specifiers_and_declarator
2660 static tree cp_parser_function_definition_after_declarator
2662 static bool cp_parser_template_declaration_after_export
2664 static void cp_parser_perform_template_parameter_access_checks
2666 static tree cp_parser_single_declaration
2668 static cp_expr cp_parser_functional_cast
2670 static tree cp_parser_save_member_function_body
2672 static tree cp_parser_save_nsdmi
2674 static tree cp_parser_enclosed_template_argument_list
2676 static void cp_parser_save_default_args
2678 static void cp_parser_late_parsing_for_member
2680 static tree cp_parser_late_parse_one_default_arg
2682 static void cp_parser_late_parsing_nsdmi
2684 static void cp_parser_late_parsing_default_args
2686 static tree cp_parser_sizeof_operand
2688 static cp_expr cp_parser_trait_expr
2690 static bool cp_parser_declares_only_class_p
2692 static void cp_parser_set_storage_class
2694 static void cp_parser_set_decl_spec_type
2696 static void set_and_check_decl_spec_loc
2699 static bool cp_parser_friend_p
2701 static void cp_parser_required_error
2707 static bool cp_parser_token_starts_function_definition_p
2709 static bool cp_parser_next_token_starts_class_definition_p
2711 static bool cp_parser_next_token_ends_template_argument_p
2713 static bool cp_parser_nth_token_starts_template_argument_list_p
2715 static enum tag_types cp_parser_token_is_class_key
2717 static enum tag_types cp_parser_token_is_type_parameter_key
2720 static void cp_parser_check_class_key
2722 static void cp_parser_check_access_in_redeclaration
2724 static bool cp_parser_optional_template_keyword
2726 static void cp_parser_pre_parsed_nested_name_specifier
2728 static bool cp_parser_cache_group
2730 static tree cp_parser_cache_defarg
2732 static void cp_parser_parse_tentatively
2734 static void cp_parser_commit_to_tentative_parse
2736 static void cp_parser_commit_to_topmost_tentative_parse
2738 static void cp_parser_abort_tentative_parse
2740 static bool cp_parser_parse_definitely
2744 static bool cp_parser_uncommitted_to_tentative_parse_p
2746 static void cp_parser_error
2748 static void cp_parser_name_lookup_error
2750 static bool cp_parser_simulate_error
2752 static bool cp_parser_check_type_definition
2754 static void cp_parser_check_for_definition_in_return_type
2756 static void cp_parser_check_for_invalid_template_id
2758 static bool cp_parser_non_integral_constant_expression
2760 static void cp_parser_diagnose_invalid_type_name
2762 static bool cp_parser_parse_and_diagnose_invalid_type_name
2764 static int cp_parser_skip_to_closing_parenthesis
2766 static void cp_parser_skip_to_end_of_statement
2768 static void cp_parser_consume_semicolon_at_end_of_statement
2770 static void cp_parser_skip_to_end_of_block_or_statement
2772 static bool cp_parser_skip_to_closing_brace
2774 static void cp_parser_skip_to_end_of_template_parameter_list
2776 static void cp_parser_skip_to_pragma_eol
2778 static bool cp_parser_error_occurred
2780 static bool cp_parser_allow_gnu_extensions_p
2782 static bool cp_parser_is_pure_string_literal
2784 static bool cp_parser_is_string_literal
2786 static bool cp_parser_is_keyword
2788 static tree cp_parser_make_typename_type
2792 static bool cp_parser_compound_literal_p
2794 static bool cp_parser_array_designator_p
2796 static bool cp_parser_init_statement_p
2798 static bool cp_parser_skip_to_closing_square_bracket
2802 // -------------------------------------------------------------------------- //
2803 // Unevaluated Operand Guard
2804 //
2805 // Implementation of an RAII helper for unevaluated operand parsing.
2807 {
2810 }
2813 {
2816 }
2818 // -------------------------------------------------------------------------- //
2819 // Tentative Parsing
2821 /* Returns nonzero if we are parsing tentatively. */
2825 {
2827 }
2829 /* Returns nonzero if TOKEN is a string literal. */
2831 static bool
2833 {
2839 }
2841 /* Returns nonzero if TOKEN is a string literal
2842 of a user-defined string literal. */
2844 static bool
2846 {
2853 }
2855 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2857 static bool
2859 {
2861 }
2863 /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
2864 PRAGMA_NONE. */
2866 static enum pragma_kind
2868 {
2871 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
2873 }
2875 /* Helper function for cp_parser_error.
2876 Having peeked a token of kind TOK1_KIND that might signify
2877 a conflict marker, peek successor tokens to determine
2878 if we actually do have a conflict marker.
2879 Specifically, we consider a run of 7 '<', '=' or '>' characters
2880 at the start of a line as a conflict marker.
2881 These come through the lexer as three pairs and a single,
2882 e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
2883 If it returns true, *OUT_LOC is written to with the location/range
2884 of the marker. */
2886 static bool
2889 {
2900 /* It must be at the start of the line. */
2905 /* We have a conflict marker. Construct a location of the form:
2906 <<<<<<<
2907 ^~~~~~~
2908 with start == caret, finishing at the end of the marker. */
2913 }
2915 /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
2916 RT_CLOSE_PAREN. */
2920 {
2922 {
2930 }
2931 }
2933 /* Attempt to convert TOKEN_DESC from a required_token to an
2934 enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
2936 static enum cpp_ttype
2938 {
2940 {
2961 /* Use CPP_EOF as a "no completions possible" code. */
2963 }
2964 }
2967 /* Subroutine of cp_parser_error and cp_parser_required_error.
2969 Issue a diagnostic of the form
2970 FILE:LINE: MESSAGE before TOKEN
2971 where TOKEN is the next token in the input stream. MESSAGE
2972 (specified by the caller) is usually of the form "expected
2973 OTHER-TOKEN".
2975 This bypasses the check for tentative passing, and potentially
2976 adds material needed by cp_parser_required_error.
2978 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
2979 suggesting insertion of the missing token.
2981 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
2982 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
2983 location. */
2985 static void
2987 required_token missing_token_desc,
2988 location_t matching_location)
2989 {
2991 /* This diagnostic makes more sense if it is tagged to the line
2992 of the token we just peeked at. */
2996 {
3001 }
3003 /* If this is actually a conflict marker, report it as such. */
3007 {
3008 location_t loc;
3010 {
3013 /* Consume tokens until the end of the source line. */
3015 {
3029 }
3031 }
3032 }
3034 auto_diagnostic_group d;
3041 {
3042 /* Potentially supply a fix-it hint, suggesting to add the
3043 missing token immediately after the *previous* token.
3044 This may move the primary location within richloc. */
3048 prev_token_loc);
3050 /* If matching_location != UNKNOWN_LOCATION, highlight it.
3051 Attempt to consolidate diagnostics by printing it as a
3052 secondary range within the main diagnostic. */
3054 added_matching_location
3056 }
3058 /* If we were parsing a string-literal and there is an unknown name
3059 token right after, then check to see if that could also have been
3060 a literal string by checking the name against a list of known
3061 standard string literal constants defined in header files. If
3062 there is one, then add that as an hint to the error message. */
3063 name_hint h;
3067 {
3074 token_name,
3075 header_hint));
3076 }
3078 /* Actually emit the error. */
3080 /* Because c_parser_error does not understand
3081 CPP_KEYWORD, keywords are treated like
3082 identifiers. */
3087 {
3088 /* If we weren't able to consolidate matching_location, then
3089 print it as a secondary diagnostic. */
3094 }
3095 }
3097 /* If not parsing tentatively, issue a diagnostic of the form
3098 FILE:LINE: MESSAGE before TOKEN
3099 where TOKEN is the next token in the input stream. MESSAGE
3100 (specified by the caller) is usually of the form "expected
3101 OTHER-TOKEN". */
3103 static void
3105 {
3108 }
3110 /* Issue an error about name-lookup failing. NAME is the
3111 IDENTIFIER_NODE DECL is the result of
3112 the lookup (as returned from cp_parser_lookup_name). DESIRED is
3113 the thing that we hoped to find. */
3115 static void
3117 tree name,
3118 tree decl,
3119 name_lookup_error desired,
3120 location_t location)
3121 {
3122 /* If name lookup completely failed, tell the user that NAME was not
3123 declared. */
3125 {
3138 else
3140 }
3142 {
3144 {
3161 }
3162 }
3164 {
3166 {
3176 name);
3180 }
3181 }
3182 else
3183 {
3185 {
3198 }
3199 }
3200 }
3202 /* If we are parsing tentatively, remember that an error has occurred
3203 during this tentative parse. Returns true if the error was
3204 simulated; false if a message should be issued by the caller. */
3206 static bool
3208 {
3210 {
3213 }
3215 }
3217 /* This function is called when a type is defined. If type
3218 definitions are forbidden at this point, an error message is
3219 issued. */
3221 static bool
3223 {
3224 /* If types are forbidden here, issue a message. */
3226 {
3227 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3228 or %qs in the message need to be interpreted. */
3232 }
3234 }
3236 /* This function is called when the DECLARATOR is processed. The TYPE
3237 was a type defined in the decl-specifiers. If it is invalid to
3238 define a type in the decl-specifiers for DECLARATOR, an error is
3239 issued. TYPE_LOCATION is the location of TYPE and is used
3240 for error reporting. */
3242 static void
3245 {
3246 /* [dcl.fct] forbids type definitions in return types.
3247 Unfortunately, it's not easy to know whether or not we are
3248 processing a return type until after the fact. */
3256 {
3261 type);
3262 }
3263 }
3265 /* A type-specifier (TYPE) has been parsed which cannot be followed by
3266 "<" in any valid C++ program. If the next token is indeed "<",
3267 issue a message warning the user about what appears to be an
3268 invalid attempt to form a template-id. LOCATION is the location
3269 of the type-specifier (TYPE) */
3271 static void
3273 tree type,
3275 location_t location)
3276 {
3280 {
3286 {
3289 else
3291 }
3292 else
3294 /* Remember the location of the invalid "<". */
3297 /* Consume the "<". */
3299 /* Parse the template arguments. */
3301 /* Permanently remove the invalid template arguments so that
3302 this error message is not issued again. */
3305 }
3306 }
3308 /* If parsing an integral constant-expression, issue an error message
3309 about the fact that THING appeared and return true. Otherwise,
3310 return false. In either case, set
3311 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3313 static bool
3315 non_integral_constant thing)
3316 {
3319 {
3321 {
3324 {
3327 "ISO C++ forbids using a floating-point literal "
3332 "enumeration type cannot appear in a "
3423 }
3427 }
3428 }
3430 }
3432 /* Emit a diagnostic for an invalid type name. This function commits
3433 to the current active tentative parse, if any. (Otherwise, the
3434 problematic construct might be encountered again later, resulting
3435 in duplicate error messages.) LOCATION is the location of ID. */
3437 static void
3439 location_t location)
3440 {
3443 /* Try to lookup the identifier. */
3450 /* If the lookup was ambiguous, an error will already have
3451 been issued. */
3453 /* If the lookup found a template-name, it means that the user forgot
3454 to specify an argument list. Emit a useful error message. */
3456 {
3457 auto_diagnostic_group d;
3460 decl);
3465 }
3469 /* Something like 'unsigned A a;' */
3472 {
3473 /* Issue an error message. */
3474 auto_diagnostic_group d;
3475 name_hint hint;
3479 {
3485 }
3486 else
3488 /* If we're in a template class, it's possible that the user was
3489 referring to a type from a base class. For example:
3491 template <typename T> struct A { typedef T X; };
3492 template <typename T> struct B : public A<T> { X x; };
3494 The user should have said "typename A<T>::X". */
3503 {
3506 id);
3509 id);
3510 else
3513 }
3530 {
3533 {
3537 {
3538 /* Go from a particular instantiation of the
3539 template (which will have an empty TYPE_FIELDs),
3540 to the main version. */
3546 {
3551 }
3552 }
3553 }
3554 found:;
3555 }
3556 }
3557 /* Here we diagnose qualified-ids where the scope is actually correct,
3558 but the identifier does not resolve to a valid type name. */
3560 {
3562 {
3563 auto_diagnostic_group d;
3564 name_hint hint;
3573 {
3576 "%qE in namespace %qE does not name a template"
3579 else
3583 }
3585 {
3588 "%qE in namespace %qE does not name a template"
3591 else
3593 "%qE in namespace %qE does not name a template"
3596 }
3597 else
3598 {
3601 "%qE in namespace %qE does not name a type"
3604 else
3608 }
3611 }
3614 {
3615 /* A<T>::A<T>() */
3616 auto_diagnostic_group d;
3622 }
3625 {
3630 "need %<typename%> before %<%T::%D::%E%> because "
3634 id,
3637 else
3641 }
3643 {
3644 auto_diagnostic_group d;
3656 else
3662 }
3663 else
3665 }
3666 }
3668 /* Check for a common situation where a type-name should be present,
3669 but is not, and issue a sensible error message. Returns true if an
3670 invalid type-name was detected.
3672 The situation handled by this function are variable declarations of the
3673 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3674 Usually, `ID' should name a type, but if we got here it means that it
3675 does not. We try to emit the best possible error message depending on
3676 how exactly the id-expression looks like. */
3678 static bool
3680 {
3681 tree id;
3684 /* Avoid duplicate error about ambiguous lookup. */
3686 {
3690 }
3699 /* If the next token is a (, this is a function with no explicit return
3700 type, i.e. constructor, destructor or conversion op. */
3703 {
3706 }
3710 /* Emit a diagnostic for the invalid type. */
3712 out:
3713 /* If we aren't in the middle of a declarator (i.e. in a
3714 parameter-declaration-clause), skip to the end of the declaration;
3715 there's no point in trying to process it. */
3719 }
3721 /* Consume tokens up to, and including, the next non-nested closing `)'.
3722 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3723 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3724 found an unnested token of that type. */
3726 static int
3729 cpp_ttype or_ttype,
3731 {
3742 {
3745 /* Have we found what we're looking for before the closing paren? */
3751 {
3755 /* FALLTHRU */
3757 /* If we've run out of tokens, then there is no closing `)'. */
3760 /* This is good for lambda expression capture-lists. */
3770 /* This matches the processing in skip_to_end_of_statement. */
3790 {
3794 }
3804 condop_depth--;
3812 /* FALLTHROUGH */
3815 /* We fell into a pragma. Skip it, and continue. */
3821 }
3823 /* Consume the token. */
3825 }
3826 }
3828 /* Consume tokens up to, and including, the next non-nested closing `)'.
3829 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3830 are doing error recovery. Returns -1 if OR_COMMA is true and we
3831 found an unnested token of that type. */
3833 static int
3838 {
3842 }
3844 /* Consume tokens until we reach the end of the current statement.
3845 Normally, that will be just before consuming a `;'. However, if a
3846 non-nested `}' comes first, then we stop before consuming that. */
3848 static void
3850 {
3853 /* Unwind generic function template scope if necessary. */
3858 {
3862 {
3866 /* FALLTHRU */
3868 /* If we've run out of tokens, stop. */
3872 /* If the next token is a `;', we have reached the end of the
3873 statement. */
3879 /* If this is a non-nested '}', stop before consuming it.
3880 That way, when confronted with something like:
3882 { 3 + }
3884 we stop before consuming the closing '}', even though we
3885 have not yet reached a `;'. */
3889 /* If it is the closing '}' for a block that we have
3890 scanned, stop -- but only after consuming the token.
3891 That way given:
3893 void f g () { ... }
3894 typedef int I;
3896 we will stop after the body of the erroneously declared
3897 function, but before consuming the following `typedef'
3898 declaration. */
3900 {
3903 }
3915 /* FALLTHROUGH */
3918 /* We fell into a pragma. Skip it, and continue or return. */
3926 }
3928 /* Consume the token. */
3930 }
3931 }
3933 /* This function is called at the end of a statement or declaration.
3934 If the next token is a semicolon, it is consumed; otherwise, error
3935 recovery is attempted. */
3937 static void
3939 {
3940 /* Look for the trailing `;'. */
3942 {
3943 /* If there is additional (erroneous) input, skip to the end of
3944 the statement. */
3946 /* If the next token is now a `;', consume it. */
3949 }
3950 }
3952 /* Skip tokens until we have consumed an entire block, or until we
3953 have consumed a non-nested `;'. */
3955 static void
3957 {
3960 /* Unwind generic function template scope if necessary. */
3965 {
3969 {
3973 /* FALLTHRU */
3975 /* If we've run out of tokens, stop. */
3979 /* Stop if this is an unnested ';'. */
3985 /* Stop if this is an unnested '}', or closes the outermost
3986 nesting level. */
3987 nesting_depth--;
3995 /* Nest. */
3996 nesting_depth++;
4004 /* FALLTHROUGH */
4007 /* Skip it, and continue or return. */
4015 }
4017 /* Consume the token. */
4019 }
4020 }
4022 /* Skip tokens until a non-nested closing curly brace is the next
4023 token, or there are no more tokens. Return true in the first case,
4024 false otherwise. */
4026 static bool
4028 {
4032 {
4036 {
4040 /* FALLTHRU */
4042 /* If we've run out of tokens, stop. */
4046 /* If the next token is a non-nested `}', then we have reached
4047 the end of the current block. */
4053 /* If it the next token is a `{', then we are entering a new
4054 block. Consume the entire block. */
4060 }
4062 /* Consume the token. */
4064 }
4065 }
4067 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4068 parameter is the PRAGMA token, allowing us to purge the entire pragma
4069 sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4070 forwards (not error recovery). */
4072 static void
4074 {
4077 do
4078 {
4079 /* The preprocessor makes sure that a PRAGMA_EOL token appears
4080 before an EOF token, even when the EOF is on the pragma line.
4081 We should never get here without being inside a deferred
4082 pragma. */
4085 }
4089 {
4090 /* Ensure that the pragma is not parsed again. */
4095 {
4097 /* Put the current source position back where it was before this
4098 lexer was pushed. */
4100 }
4101 }
4102 }
4104 /* Require pragma end of line, resyncing with it as necessary. The
4105 arguments are as for cp_parser_skip_to_pragma_eol. */
4107 static void
4109 {
4115 {
4117 /* Put the current source position back where it was before this
4118 lexer was pushed. */
4120 }
4121 }
4123 /* This is a simple wrapper around make_typename_type. When the id is
4124 an unresolved identifier node, we can provide a superior diagnostic
4125 using cp_parser_diagnose_invalid_type_name. */
4127 static tree
4129 location_t id_location)
4130 {
4131 tree result;
4133 {
4139 }
4141 }
4143 /* This is a wrapper around the
4144 make_{pointer,ptrmem,reference}_declarator functions that decides
4145 which one to call based on the CODE and CLASS_TYPE arguments. The
4146 CODE argument should be one of the values returned by
4147 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4148 appertain to the pointer or reference. */
4152 cp_cv_quals cv_qualifiers,
4154 tree attributes)
4155 {
4162 else
4172 }
4174 /* Create a new C++ parser. */
4178 {
4179 /* Initialize the binops_by_token so that we can get the tree
4180 directly from the token. */
4188 /* For now, we always accept GNU extensions. */
4191 /* The `>' token is a greater-than operator, not the end of a
4192 template-id. */
4197 /* We are not parsing a constant-expression. */
4202 /* Local variable names are not forbidden. */
4205 /* We are not processing an `extern "C"' declaration. */
4208 /* We are not processing a declarator. */
4211 /* We are not processing a template-argument-list. */
4214 /* We are not in an iteration statement. */
4217 /* We are not in a switch statement. */
4220 /* We are not parsing a type-id inside an expression. */
4223 /* String literals should be translated to the execution character set. */
4226 /* We are not parsing a function body. */
4229 /* We can correct until told otherwise. */
4232 /* The unparsed function queue is empty. */
4235 /* There are no classes being defined. */
4238 /* No template parameters apply. */
4241 /* Special parsing data structures. */
4245 /* Not declaring an implicit function template. */
4251 /* Allow constrained-type-specifiers. */
4254 /* We haven't yet seen an 'extern "C"'. */
4258 }
4260 /* Create a cp_lexer structure which will emit the tokens in CACHE
4261 and push it onto the parser's lexer stack. This is used for delayed
4262 parsing of in-class method bodies and default arguments, and should
4263 not be confused with tentative parsing. */
4264 static void
4266 {
4271 /* Move the current source position to that of the first token in the
4272 new lexer. */
4274 }
4276 /* Pop the top lexer off the parser stack. This is never used for the
4277 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4278 static void
4280 {
4285 /* Put the current source position back where it was before this
4286 lexer was pushed. */
4288 }
4290 /* Lexical conventions [gram.lex] */
4292 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4293 identifier. */
4295 static cp_expr
4297 {
4300 /* Look for the identifier. */
4302 /* Return the value. */
4305 else
4307 }
4309 /* Parse a sequence of adjacent string constants. Returns a
4310 TREE_STRING representing the combined, nul-terminated string
4311 constant. If TRANSLATE is true, translate the string to the
4312 execution character set. If WIDE_OK is true, a wide string is
4313 invalid here.
4315 C++98 [lex.string] says that if a narrow string literal token is
4316 adjacent to a wide string literal token, the behavior is undefined.
4317 However, C99 6.4.5p4 says that this results in a wide string literal.
4318 We follow C99 here, for consistency with the C front end.
4320 This code is largely lifted from lex_string() in c-lex.c.
4322 FUTURE: ObjC++ will need to handle @-strings here. */
4323 static cp_expr
4326 {
4327 tree value;
4335 tree string_tree;
4341 {
4344 }
4349 {
4353 }
4354 else
4355 {
4358 }
4361 /* Try to avoid the overhead of creating and destroying an obstack
4362 for the common case of just one string. */
4365 {
4373 {
4377 }
4378 else
4382 }
4383 else
4384 {
4390 do
4391 {
4393 count++;
4398 {
4401 {
4404 }
4407 {
4412 }
4414 }
4415 else
4419 {
4423 {
4427 "concatenation of string literals with "
4429 }
4430 }
4439 {
4443 }
4444 else
4445 {
4449 }
4450 }
4453 /* A string literal built by concatenation has its caret=start at
4454 the start of the initial string, and its finish at the finish of
4455 the final string literal. */
4459 }
4462 {
4465 }
4469 {
4473 {
4477 }
4480 {
4488 else
4500 }
4505 {
4510 else
4512 }
4513 }
4514 else
4515 /* cpp_interpret_string has issued an error. */
4519 {
4522 }
4525 }
4527 /* Look up a literal operator with the name and the exact arguments. */
4529 static tree
4531 {
4537 {
4541 {
4548 {
4558 }
4562 /* May be this should be sufficient_parms_p instead,
4563 depending on how exactly should user-defined literals
4564 work in presence of default arguments on the literal
4565 operator parameters. */
4568 }
4569 }
4572 }
4574 /* Parse a user-defined char constant. Returns a call to a user-defined
4575 literal operator taking the character as an argument. */
4577 static cp_expr
4579 {
4587 /* Build up a call to the user-defined operator */
4588 /* Lookup the name we got back from the id-expression. */
4589 releasing_vec args;
4593 {
4597 }
4600 }
4602 /* A subroutine of cp_parser_userdef_numeric_literal to
4603 create a char... template parameter pack from a string node. */
4605 static tree
4607 {
4608 tree charvec;
4614 /* Fill in CHARVEC with all of the parameters. */
4617 {
4626 }
4628 /* Build the argument packs. */
4634 }
4636 /* A subroutine of cp_parser_userdef_numeric_literal to
4637 create a char... template parameter pack from a string node. */
4639 static tree
4641 {
4642 tree charvec;
4653 /* First template parm is character type. */
4656 /* Fill in CHARVEC with all of the parameters. */
4663 /* Build the argument packs. */
4669 }
4671 /* Parse a user-defined numeric constant. returns a call to a user-defined
4672 literal operator. */
4674 static cp_expr
4676 {
4686 /* Look for a literal operator taking the exact type of numeric argument
4687 as the literal value. */
4688 releasing_vec args;
4692 {
4694 tf_warning_or_error);
4697 {
4700 long_long_unsigned_type_node);
4701 }
4702 else
4703 {
4707 long_double_type_node);
4711 }
4714 }
4716 /* If the numeric argument didn't work, look for a raw literal
4717 operator taking a const char* argument consisting of the number
4718 in string format. */
4723 {
4725 tf_warning_or_error);
4727 }
4729 /* If the raw literal didn't work, look for a non-type template
4730 function with parameter pack char.... Call the function with
4731 template parameter characters representing the number. */
4735 {
4738 {
4740 num_string);
4742 }
4745 tf_warning_or_error);
4747 }
4749 /* In C++14 the standard library defines complex number suffixes that
4750 conflict with GNU extensions. Prefer them if <complex> is #included. */
4760 {
4764 {
4765 /* No <complex>, so pedwarn and use GNU semantics. */
4768 }
4769 }
4771 bool complained
4778 {
4780 "(from %<<complex>%>) to enable the C++14 user-defined literal "
4785 }
4792 else
4793 {
4794 /* Use the built-in semantics. */
4795 tree type;
4797 {
4800 else
4802 }
4810 }
4813 /* Avoid repeated diagnostics. */
4816 }
4818 /* Parse a user-defined string constant. Returns a call to a user-defined
4819 literal operator taking a character pointer and the length of the string
4820 as arguments. */
4822 static tree
4824 {
4830 tree decl;
4832 /* Build up a call to the user-defined operator. */
4833 /* Lookup the name we got back from the id-expression. */
4834 releasing_vec args;
4841 tf_warning_or_error);
4843 /* Look for a suitable template function, either (C++20) with a single
4844 parameter of class type, or (N3599) with typename parameter CharT and
4845 parameter pack CharT... */
4849 {
4850 /* Use resolve_nondeduced_context to try to choose one form of template
4851 or the other. */
4858 else
4859 {
4864 }
4868 tf_warning_or_error);
4869 }
4874 }
4877 /* Basic concepts [gram.basic] */
4879 /* Parse a translation-unit.
4881 translation-unit:
4882 declaration-seq [opt] */
4884 static void
4886 {
4889 /* Create the declarator obstack. */
4891 /* Create the error declarator. */
4893 /* Create the empty parameter list. */
4895 UNKNOWN_LOCATION);
4896 /* Remember where the base of the declarator obstack lies. */
4908 /* Parse until EOF. */
4910 {
4913 /* If we're entering or exiting a region that's implicitly
4914 extern "C", modify the lang context appropriately. This is
4915 so horrible. Please die. */
4918 {
4922 else
4924 }
4930 {
4931 /* Top-level module declarations are ok, and change the
4932 portion of file we're in. Top-level import declarations
4933 are significant for the import portions. */
4938 {
4941 }
4943 {
4944 mp_state
4947 }
4949 {
4954 }
4955 else
4959 {
4962 {
4965 "global module fragment contents must be"
4967 }
4968 }
4969 }
4971 /* This relies on the ordering of module_parse values. */
4973 /* We're no longer in the import portion of a named module. */
4979 {
4982 /* If the next token is now a `;', consume it. */
4985 }
4986 else
4988 }
4990 /* Get rid of the token array; we don't need it any more. */
4994 /* The EOF should have reset this. */
4997 /* Make sure the declarator obstack was fully cleaned up. */
5000 }
5002 /* Return the appropriate tsubst flags for parsing, possibly in N3276
5003 decltype context. */
5007 {
5012 }
5014 /* We're about to parse a collection of statements. If we're currently
5015 parsing tentatively, set up a firewall so that any nested
5016 cp_parser_commit_to_tentative_parse won't affect the current context. */
5018 static cp_token_position
5020 {
5027 }
5029 /* We've finished parsing the collection of statements. Wrap up the
5030 firewall and replace the relevant tokens with the parsed form. */
5032 static void
5034 tree expr)
5035 {
5039 /* Finish the firewall level. */
5041 /* And remember the result of the parse for when we try again. */
5047 }
5049 /* Like the above functions, but let the user modify the tokens. Used by
5050 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5051 later parses, so it makes sense to localize the effects of
5052 cp_parser_commit_to_tentative_parse. */
5054 struct tentative_firewall
5055 {
5060 {
5061 /* If we're currently parsing tentatively, start a committed level as a
5062 firewall and then an inner tentative parse. */
5064 {
5068 }
5069 }
5072 {
5074 {
5075 /* Finish the inner tentative parse and the firewall, propagating any
5076 uncommitted error state to the outer tentative parse. */
5082 }
5083 }
5084 };
5086 /* Some tokens naturally come in pairs e.g.'(' and ')'.
5087 This class is for tracking such a matching pair of symbols.
5088 In particular, it tracks the location of the first token,
5089 so that if the second token is missing, we can highlight the
5090 location of the first token when notifying the user about the
5091 problem. */
5094 class token_pair
5095 {
5097 /* token_pair's ctor. */
5100 /* If the next token is the opening symbol for this pair, consume it and
5101 return true.
5102 Otherwise, issue an error and return false.
5103 In either case, record the location of the opening token. */
5106 {
5110 }
5112 /* Consume the next token from PARSER, recording its location as
5113 that of the opening token within the pair. */
5116 {
5121 }
5123 /* If the next token is the closing symbol for this pair, consume it
5124 and return it.
5125 Otherwise, issue an error, highlighting the location of the
5126 corresponding opening token, and return NULL. */
5129 {
5132 m_open_loc);
5133 }
5138 location_t m_open_loc;
5139 };
5141 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5143 struct matching_paren_traits
5144 {
5149 };
5151 /* "matching_parens" is a token_pair<T> class for tracking matching
5152 pairs of parentheses. */
5156 /* Traits for token_pair<T> for tracking matching pairs of braces. */
5158 struct matching_brace_traits
5159 {
5164 };
5166 /* "matching_braces" is a token_pair<T> class for tracking matching
5167 pairs of braces. */
5172 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5173 enclosing parentheses. */
5175 static cp_expr
5177 {
5180 /* Consume the '('. */
5182 matching_parens parens;
5184 /* Start the statement-expression. */
5186 /* Parse the compound-statement. */
5188 /* Finish up. */
5190 /* Consume the ')'. */
5198 }
5200 /* Expressions [gram.expr] */
5202 /* Parse a fold-operator.
5204 fold-operator:
5205 - * / % ^ & | = < > << >>
5206 = -= *= /= %= ^= &= |= <<= >>=
5207 == != <= >= && || , .* ->*
5209 This returns the tree code corresponding to the matched operator
5210 as an int. When the current token matches a compound assignment
5211 operator, the resulting tree code is the negative value of the
5212 non-assignment operator. */
5214 static int
5216 {
5218 {
5258 }
5259 }
5261 /* Returns true if CODE indicates a binary expression, which is not allowed in
5262 the LHS of a fold-expression. More codes will need to be added to use this
5263 function in other contexts. */
5265 static bool
5267 {
5269 {
5302 }
5303 }
5305 /* If the next token is a suitable fold operator, consume it and return as
5306 the function above. */
5308 static int
5310 {
5316 }
5318 /* Parse a fold-expression.
5320 fold-expression:
5321 ( ... folding-operator cast-expression)
5322 ( cast-expression folding-operator ... )
5323 ( cast-expression folding operator ... folding-operator cast-expression)
5325 Note that the '(' and ')' are matched in primary expression. */
5327 static cp_expr
5329 {
5330 cp_id_kind pidk;
5332 // Left fold.
5334 {
5340 {
5343 }
5350 }
5355 {
5358 }
5361 {
5364 }
5367 /* The operands of a fold-expression are cast-expressions, so binary or
5368 conditional expressions are not allowed. We check this here to avoid
5369 tentative parsing. */
5381 // Right fold.
5386 {
5389 }
5392 // Binary left or right fold.
5397 }
5399 /* Parse a primary-expression.
5401 primary-expression:
5402 literal
5403 this
5404 ( expression )
5405 id-expression
5406 lambda-expression (C++11)
5408 GNU Extensions:
5410 primary-expression:
5411 ( compound-statement )
5412 __builtin_va_arg ( assignment-expression , type-id )
5413 __builtin_offsetof ( type-id , offsetof-expression )
5415 C++ Extensions:
5416 __has_nothrow_assign ( type-id )
5417 __has_nothrow_constructor ( type-id )
5418 __has_nothrow_copy ( type-id )
5419 __has_trivial_assign ( type-id )
5420 __has_trivial_constructor ( type-id )
5421 __has_trivial_copy ( type-id )
5422 __has_trivial_destructor ( type-id )
5423 __has_virtual_destructor ( type-id )
5424 __is_abstract ( type-id )
5425 __is_base_of ( type-id , type-id )
5426 __is_class ( type-id )
5427 __is_empty ( type-id )
5428 __is_enum ( type-id )
5429 __is_final ( type-id )
5430 __is_literal_type ( type-id )
5431 __is_pod ( type-id )
5432 __is_polymorphic ( type-id )
5433 __is_std_layout ( type-id )
5434 __is_trivial ( type-id )
5435 __is_union ( type-id )
5437 Objective-C++ Extension:
5439 primary-expression:
5440 objc-expression
5442 literal:
5443 __null
5445 ADDRESS_P is true iff this expression was immediately preceded by
5446 "&" and therefore might denote a pointer-to-member. CAST_P is true
5447 iff this expression is the target of a cast. TEMPLATE_ARG_P is
5448 true iff this expression is a template argument.
5450 Returns a representation of the expression. Upon return, *IDK
5451 indicates what kind of id-expression (if any) was present. */
5453 static cp_expr
5460 {
5463 /* Assume the primary expression is not an id-expression. */
5466 /* Peek at the next token. */
5469 {
5470 /* literal:
5471 integer-literal
5472 character-literal
5473 floating-literal
5474 string-literal
5475 boolean-literal
5476 pointer-literal
5477 user-defined-literal */
5489 {
5493 }
5494 /* Floating-point literals are only allowed in an integral
5495 constant expression if they are cast to an integral or
5496 enumeration type. */
5500 {
5501 /* CAST_P will be set even in invalid code like "int(2.7 +
5502 ...)". Therefore, we have to check that the next token
5503 is sure to end the cast. */
5505 {
5510 enumerator-definition. */
5512 /* The curly brace at the end of an enum-specifier. */
5514 /* The end of a statement. */
5516 /* The end of the cast-expression. */
5518 /* The end of an array bound. */
5520 /* The closing ">" in a template-argument-list. */
5523 /* C++0x only: A ">>" treated like two ">" tokens,
5524 in a template-argument-list. */
5529 }
5531 /* If we are within a cast, then the constraint that the
5532 cast is to an integral or enumeration type will be
5533 checked at that point. If we are not within a cast, then
5534 this code is invalid. */
5537 }
5558 /* ??? Should wide strings be allowed when parser->translate_strings_p
5559 is false (i.e. in attributes)? If not, we can kill the third
5560 argument to cp_parser_string_literal. */
5567 /* If we see `( { ' then we are looking at the beginning of
5568 a GNU statement-expression. */
5571 {
5572 /* Statement-expressions are not allowed by the standard. */
5576 /* And they're not allowed outside of a function-body; you
5577 cannot, for example, write:
5579 int i = ({ int j = 3; j + 1; });
5581 at class or namespace scope. */
5584 {
5586 "statement-expressions are not allowed outside "
5592 }
5593 else
5595 }
5596 /* Otherwise it's a normal parenthesized expression. */
5597 {
5598 cp_expr expr;
5603 /* Consume the `('. */
5604 matching_parens parens;
5606 /* Within a parenthesized expression, a `>' token is always
5607 the greater-than operator. */
5608 saved_greater_than_is_operator_p
5613 /* Left fold expression. */
5615 else
5616 /* Parse the parenthesized expression. */
5621 {
5626 "fold-expressions only available with %<-std=c++17%> "
5628 }
5629 else
5630 /* Let the front end know that this expression was
5631 enclosed in parentheses. This matters in case, for
5632 example, the expression is of the form `A::B', since
5633 `&A::B' might be a pointer-to-member, but `&(A::B)' is
5634 not. */
5637 /* DR 705: Wrapping an unqualified name in parentheses
5638 suppresses arg-dependent lookup. We want to pass back
5639 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5640 (c++/37862), but none of the others. */
5644 /* The `>' token might be the end of a template-id or
5645 template-parameter-list now. */
5646 parser->greater_than_is_operator_p
5649 /* Consume the `)'. */
5661 }
5664 {
5666 {
5667 /* We might have an Objective-C++ message. */
5670 /* If that works out, we're done ... */
5673 /* ... else, fall though to see if it's a lambda. */
5674 }
5676 /* Don't warn about a failed tentative parse. */
5681 }
5685 /* We have an Objective-C++ string literal. */
5692 {
5693 /* These two are the boolean literals. */
5701 /* The `__null' literal. */
5706 /* The `nullptr' literal. */
5711 /* Recognize the `this' keyword. */
5715 {
5719 }
5720 /* Pointers cannot appear in constant-expressions. */
5725 /* The `operator' keyword can be the beginning of an
5726 id-expression. */
5733 {
5734 non_integral_constant name;
5736 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
5737 __func__ are the names of variables -- but they are
5738 treated specially. Therefore, they are handled here,
5739 rather than relying on the generic id-expression logic
5740 below. Grammatically, these names are id-expressions.
5742 Consume the token. */
5746 {
5758 }
5763 /* Look up the name. */
5765 }
5768 {
5769 tree expression;
5770 tree type;
5771 location_t type_location;
5772 location_t start_loc
5774 /* The `__builtin_va_arg' construct is used to handle
5775 `va_arg'. Consume the `__builtin_va_arg' token. */
5777 /* Look for the opening `('. */
5778 matching_parens parens;
5780 /* Now, parse the assignment-expression. */
5782 /* Look for the `,'. */
5785 /* Parse the type-id. */
5786 {
5789 }
5790 /* Look for the closing `)'. */
5791 location_t finish_loc
5794 /* Using `va_arg' in a constant-expression is not
5795 allowed. */
5797 NIC_VA_ARG))
5799 /* Construct a location of the form:
5800 __builtin_va_arg (v, int)
5801 ~~~~~~~~~~~~~~~~~~~~~^~~~
5802 with the caret at the type, ranging from the start of the
5803 "__builtin_va_arg" token to the close paren. */
5804 location_t combined_loc
5807 }
5846 // C++ concepts
5850 /* Objective-C++ expressions. */
5860 {
5865 }
5866 /* FALLTHRU */
5870 }
5872 /* An id-expression can start with either an identifier, a
5873 `::' as the beginning of a qualified-id, or the "operator"
5874 keyword. */
5879 {
5880 id_expression:
5881 cp_expr id_expression;
5882 cp_expr decl;
5888 /* Parse the id-expression. */
5889 id_expression
5906 /* If we have a template-id, then no further lookup is
5907 required. If the template-id was for a template-class, we
5908 will sometimes have a TYPE_DECL at this point. */
5912 /* Look up the name. */
5913 else
5914 {
5915 tree ambiguous_decls;
5917 /* If we already know that this lookup is ambiguous, then
5918 we've already issued an error message; there's no reason
5919 to check again. */
5922 {
5925 }
5928 none_type,
5929 template_p,
5934 /* If the lookup was ambiguous, an error will already have
5935 been issued. */
5939 /* In Objective-C++, we may have an Objective-C 2.0
5940 dot-syntax for classes here. */
5945 {
5946 tree component;
5953 component);
5954 /* Build a location of the form:
5955 expr.component
5956 ~~~~~^~~~~~~~~
5957 with caret at the start of the component name (at
5958 input_location), ranging from the start of the id_expression
5959 to the end of the component name. */
5960 location_t combined_loc
5965 }
5967 /* In Objective-C++, an instance variable (ivar) may be preferred
5968 to whatever cp_parser_lookup_name() found.
5969 Call objc_lookup_ivar. To avoid exposing cp_expr to the
5970 rest of c-family, we have to do a little extra work to preserve
5971 any location information in cp_expr "decl". Given that
5972 objc_lookup_ivar is implemented in "c-family" and "objc", we
5973 have a trip through the pure "tree" type, rather than cp_expr.
5974 Naively copying it back to "decl" would implicitly give the
5975 new cp_expr value an UNKNOWN_LOCATION for nodes that don't
5976 store an EXPR_LOCATION. Hence we only update "decl" (and
5977 hence its location_t) if we get back a different tree node. */
5979 id_expression);
5983 /* If name lookup gives us a SCOPE_REF, then the
5984 qualifying scope was dependent. */
5986 {
5987 /* At this point, we do not know if DECL is a valid
5988 integral constant expression. We assume that it is
5989 in fact such an expression, so that code like:
5991 template <int N> struct A {
5992 int a[B<N>::i];
5993 };
5995 is accepted. At template-instantiation time, we
5996 will check that B<N>::i is actually a constant. */
5998 }
5999 /* Check to see if DECL is a local variable in a context
6000 where that is forbidden. */
6003 /* DR 2082 permits local variables in unevaluated contexts
6004 within a default argument. */
6006 {
6014 }
6015 }
6017 decl = (finish_id_expression
6019 idk,
6024 template_arg_p,
6029 /* Build a location for an id-expression of the form:
6030 ::ns::id
6031 ~~~~~~^~
6032 or:
6033 id
6034 ^~
6035 i.e. from the start of the first token to the end of the final
6036 token, with the caret at the start of the unqualified-id. */
6040 location_t combined_loc
6045 }
6047 /* Anything else is an error. */
6051 }
6052 }
6060 {
6063 }
6065 /* Parse an id-expression.
6067 id-expression:
6068 unqualified-id
6069 qualified-id
6071 qualified-id:
6072 :: [opt] nested-name-specifier template [opt] unqualified-id
6073 :: identifier
6074 :: operator-function-id
6075 :: template-id
6077 Return a representation of the unqualified portion of the
6078 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6079 a `::' or nested-name-specifier.
6081 Often, if the id-expression was a qualified-id, the caller will
6082 want to make a SCOPE_REF to represent the qualified-id. This
6083 function does not do this in order to avoid wastefully creating
6084 SCOPE_REFs when they are not required.
6086 If TEMPLATE_KEYWORD_P is true, then we have just seen the
6087 `template' keyword.
6089 If CHECK_DEPENDENCY_P is false, then names are looked up inside
6090 uninstantiated templates.
6092 If *TEMPLATE_P is non-NULL, it is set to true iff the
6093 `template' keyword is used to explicitly indicate that the entity
6094 named is a template.
6096 If DECLARATOR_P is true, the id-expression is appearing as part of
6097 a declarator, rather than as part of an expression. */
6099 static cp_expr
6106 {
6110 /* Assume the `template' keyword was not used. */
6114 /* Look for the optional `::' operator. */
6115 global_scope_p
6116 = (!template_keyword_p
6121 /* Look for the optional nested-name-specifier. */
6122 nested_name_specifier_p
6125 check_dependency_p,
6127 declarator_p,
6128 template_keyword_p)
6131 /* If there is a nested-name-specifier, then we are looking at
6132 the first qualified-id production. */
6134 {
6135 tree saved_scope;
6136 tree saved_object_scope;
6137 tree saved_qualifying_scope;
6138 cp_expr unqualified_id;
6141 /* See if the next token is the `template' keyword. */
6145 /* Name lookup we do during the processing of the
6146 unqualified-id might obliterate SCOPE. */
6150 /* Process the final unqualified-id. */
6152 check_dependency_p,
6153 declarator_p,
6155 /* Restore the SAVED_SCOPE for our caller. */
6161 }
6162 /* Otherwise, if we are in global scope, then we are looking at one
6163 of the other qualified-id productions. */
6165 {
6167 tree id;
6169 /* Peek at the next token. */
6172 /* If it's an identifier, and the next token is not a "<", then
6173 we can avoid the template-id case. This is an optimization
6174 for this common case. */
6176 && !cp_parser_nth_token_starts_template_argument_list_p
6181 /* Try a template-id. */
6185 declarator_p);
6186 /* If that worked, we're done. */
6190 /* Peek at the next token. (Changes in the token buffer may
6191 have invalidated the pointer obtained above.) */
6195 {
6202 /* Fall through. */
6207 }
6208 }
6209 else
6212 declarator_p,
6213 optional_p);
6214 }
6216 /* Parse an unqualified-id.
6218 unqualified-id:
6219 identifier
6220 operator-function-id
6221 conversion-function-id
6222 ~ class-name
6223 template-id
6225 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6226 keyword, in a construct like `A::template ...'.
6228 Returns a representation of unqualified-id. For the `identifier'
6229 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6230 production a BIT_NOT_EXPR is returned; the operand of the
6231 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6232 other productions, see the documentation accompanying the
6233 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6234 names are looked up in uninstantiated templates. If DECLARATOR_P
6235 is true, the unqualified-id is appearing as part of a declarator,
6236 rather than as part of an expression. */
6238 static cp_expr
6244 {
6247 /* Peek at the next token. */
6251 {
6253 {
6254 tree id;
6256 /* We don't know yet whether or not this will be a
6257 template-id. */
6259 /* Try a template-id. */
6261 check_dependency_p,
6262 declarator_p);
6263 /* If it worked, we're done. */
6266 /* Otherwise, it's an ordinary identifier. */
6268 }
6272 check_dependency_p,
6273 declarator_p);
6276 {
6277 tree type_decl;
6278 tree qualifying_scope;
6279 tree object_scope;
6280 tree scope;
6284 /* Consume the `~' token. */
6286 /* Parse the class-name. The standard, as written, seems to
6287 say that:
6289 template <typename T> struct S { ~S (); };
6290 template <typename T> S<T>::~S() {}
6292 is invalid, since `~' must be followed by a class-name, but
6293 `S<T>' is dependent, and so not known to be a class.
6294 That's not right; we need to look in uninstantiated
6295 templates. A further complication arises from:
6297 template <typename T> void f(T t) {
6298 t.T::~T();
6299 }
6301 Here, it is not possible to look up `T' in the scope of `T'
6302 itself. We must look in both the current scope, and the
6303 scope of the containing complete expression.
6305 Yet another issue is:
6307 struct S {
6308 int S;
6309 ~S();
6310 };
6312 S::~S() {}
6314 The standard does not seem to say that the `S' in `~S'
6315 should refer to the type `S' and not the data member
6316 `S::S'. */
6318 /* DR 244 says that we look up the name after the "~" in the
6319 same scope as we looked up the qualifying name. That idea
6320 isn't fully worked out; it's more complicated than that. */
6325 /* Check for invalid scopes. */
6327 {
6331 }
6333 {
6337 scope);
6342 }
6344 {
6350 }
6356 /* Create a location with caret == start at the tilde,
6357 finishing at the end of the peeked token, e.g:
6358 ~token
6359 ^~~~~~. */
6360 location_t loc
6363 /* If the name is of the form "X::~X" it's OK even if X is a
6364 typedef. */
6373 {
6376 }
6378 /* ~auto means the destructor of whatever the object is. */
6380 {
6383 "%<~auto%> only available with "
6387 }
6389 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6390 declarator-id of a constructor or destructor. */
6393 {
6397 }
6399 /* If there was an explicit qualification (S::~T), first look
6400 in the scope given by the qualification (i.e., S).
6402 Note: in the calls to cp_parser_class_name below we pass
6403 typename_type so that lookup finds the injected-class-name
6404 rather than the constructor. */
6408 {
6413 typename_type,
6416 declarator_p);
6419 }
6420 /* In "N::S::~S", look in "N" as well. */
6422 {
6427 type_decl
6431 typename_type,
6434 declarator_p);
6437 }
6438 /* In "p->S::~T", look in the scope given by "*p" as well. */
6440 {
6445 type_decl
6449 typename_type,
6452 declarator_p);
6455 }
6456 /* Look in the surrounding context. */
6458 {
6464 type_decl
6468 typename_type,
6471 declarator_p);
6474 {
6475 /* We couldn't find a type with this name. If we're parsing
6476 tentatively, fail and try something else. */
6478 {
6481 }
6482 /* Otherwise, accept it and check for a match at instantiation
6483 time. */
6488 }
6489 }
6490 /* If an error occurred, assume that the name of the
6491 destructor is the same as the name of the qualifying
6492 class. That allows us to keep parsing after running
6493 into ill-formed destructor names. */
6499 /* Check that destructor name and scope match. */
6501 {
6508 }
6510 /* [class.dtor]
6512 A typedef-name that names a class shall not be used as the
6513 identifier in the declarator for a destructor declaration. */
6520 type_decl);
6523 }
6527 {
6528 cp_expr id;
6530 /* This could be a template-id, so we try that first. */
6532 /* Try a template-id. */
6535 declarator_p);
6536 /* If that worked, we're done. */
6539 /* We still don't know whether we're looking at an
6540 operator-function-id or a conversion-function-id. */
6542 /* Try an operator-function-id. */
6544 /* If that didn't work, try a conversion-function-id. */
6549 }
6550 /* Fall through. */
6557 }
6558 }
6560 /* Check [temp.names]/5: A name prefixed by the keyword template shall
6561 be a template-id or the name shall refer to a class template or an
6562 alias template. */
6564 static void
6566 {
6576 /* Alias templates are also OK. */
6583 name);
6584 }
6586 /* Parse an (optional) nested-name-specifier.
6588 nested-name-specifier: [C++98]
6589 class-or-namespace-name :: nested-name-specifier [opt]
6590 class-or-namespace-name :: template nested-name-specifier [opt]
6592 nested-name-specifier: [C++0x]
6593 type-name ::
6594 namespace-name ::
6595 nested-name-specifier identifier ::
6596 nested-name-specifier template [opt] simple-template-id ::
6598 PARSER->SCOPE should be set appropriately before this function is
6599 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6600 effect. TYPE_P is TRUE if we non-type bindings should be ignored
6601 in name lookups.
6603 Sets PARSER->SCOPE to the class (TYPE) or namespace
6604 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6605 it unchanged if there is no nested-name-specifier. Returns the new
6606 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6608 If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
6610 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6611 part of a declaration and/or decl-specifier. */
6613 static tree
6620 {
6625 /* Remember where the nested-name-specifier starts. */
6628 {
6631 }
6634 {
6635 tree new_scope;
6636 tree old_scope;
6637 tree saved_qualifying_scope;
6639 /* Spot cases that cannot be the beginning of a
6640 nested-name-specifier. */
6643 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
6644 the already parsed nested-name-specifier. */
6646 {
6647 /* Grab the nested-name-specifier and continue the loop. */
6649 /* If we originally encountered this nested-name-specifier
6650 with CHECK_DEPENDENCY_P set to true, we will not have
6651 resolved TYPENAME_TYPEs, so we must do so here. */
6653 && !check_dependency_p
6655 {
6660 }
6663 }
6665 /* Spot cases that cannot be the beginning of a
6666 nested-name-specifier. On the second and subsequent times
6667 through the loop, we look for the `template' keyword. */
6669 ;
6670 /* A template-id can start a nested-name-specifier. */
6672 ;
6673 /* DR 743: decltype can be used in a nested-name-specifier. */
6675 ;
6676 else
6677 {
6678 /* If the next token is not an identifier, then it is
6679 definitely not a type-name or namespace-name. */
6682 /* If the following token is neither a `<' (to begin a
6683 template-id), nor a `::', then we are not looking at a
6684 nested-name-specifier. */
6690 /* name:name is a valid sequence in an Objective C message. */
6692 {
6696 "found %<:%> in nested-name-specifier, "
6699 }
6702 && !cp_parser_nth_token_starts_template_argument_list_p
6705 }
6707 /* The nested-name-specifier is optional, so we parse
6708 tentatively. */
6711 /* Look for the optional `template' keyword, if this isn't the
6712 first time through the loop. */
6714 {
6716 /* DR1710: "In a qualified-id used as the name in
6717 a typename-specifier, elaborated-type-specifier, using-declaration,
6718 or class-or-decltype, an optional keyword template appearing at
6719 the top level is ignored." */
6721 && typename_keyword_p
6724 }
6726 /* Save the old scope since the name lookup we are about to do
6727 might destroy it. */
6730 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
6731 look up names in "X<T>::I" in order to determine that "Y" is
6732 a template. So, if we have a typename at this point, we make
6733 an effort to look through it. */
6735 && !check_dependency_p
6736 && !typename_keyword_p
6741 /* Parse the qualifying entity. */
6742 new_scope
6744 typename_keyword_p,
6745 template_keyword_p,
6746 check_dependency_p,
6747 type_p,
6748 is_declaration);
6749 /* Look for the `::' token. */
6752 /* If we found what we wanted, we keep going; otherwise, we're
6753 done. */
6755 {
6758 /* Restore the OLD_SCOPE since it was valid before the
6759 failed attempt at finding the last
6760 class-or-namespace-name. */
6764 /* If the next token is a decltype, and the one after that is a
6765 `::', then the decltype has failed to resolve to a class or
6766 enumeration type. Give this error even when parsing
6767 tentatively since it can't possibly be valid--and we're going
6768 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
6769 won't get another chance.*/
6773 {
6779 dtype);
6782 /* As below. */
6785 }
6789 {
6790 /* If we have a non-type template-id followed by ::, it can't
6791 possibly be valid. */
6796 {
6799 {
6806 else
6809 }
6810 else
6811 {
6817 else
6818 {
6819 /* Variable template. */
6823 }
6824 }
6831 /* As below. */
6835 }
6836 }
6840 /* If the next token is an identifier, and the one after
6841 that is a `::', then any valid interpretation would have
6842 found a class-or-namespace-name. */
6848 {
6851 {
6853 {
6854 tree decl;
6855 tree ambiguous_decls;
6858 none_type,
6867 decl);
6869 {
6870 // cp_parser_lookup_name has the same diagnostic,
6871 // thus make sure to emit it at most once.
6874 {
6879 }
6881 }
6882 else
6883 {
6885 cp_parser_name_lookup_error
6888 else
6889 cp_parser_name_lookup_error
6892 }
6893 }
6896 /* Treat this as a successful nested-name-specifier
6897 due to:
6899 [basic.lookup.qual]
6901 If the name found is not a class-name (clause
6902 _class_) or namespace-name (_namespace.def_), the
6903 program is ill-formed. */
6905 }
6907 }
6909 }
6910 /* We've found one valid nested-name-specifier. */
6912 /* Name lookup always gives us a DECL. */
6915 /* Uses of "template" must be followed by actual templates. */
6918 /* If it is a class scope, try to complete it; we are about to
6919 be looking up names inside the class. */
6921 /* Since checking types for dependency can be expensive,
6922 avoid doing it if the type is already complete. */
6924 /* Do not try to complete dependent types. */
6926 {
6928 /* If it is a typedef to current class, use the current
6929 class instead, as the typedef won't have any names inside
6930 it yet. */
6934 }
6935 /* Make sure we look in the right scope the next time through
6936 the loop. */
6938 }
6940 /* If parsing tentatively, replace the sequence of tokens that makes
6941 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
6942 token. That way, should we re-parse the token stream, we will
6943 not have to repeat the effort required to do the parse, nor will
6944 we issue duplicate error messages. */
6946 {
6950 /* Reset the contents of the START token. */
6952 /* Retrieve any deferred checks. Do not pop this access checks yet
6953 so the memory will not be reclaimed during token replacing below. */
6962 /* Purge all subsequent tokens. */
6964 }
6970 }
6972 /* Parse a nested-name-specifier. See
6973 cp_parser_nested_name_specifier_opt for details. This function
6974 behaves identically, except that it will an issue an error if no
6975 nested-name-specifier is present. */
6977 static tree
6983 {
6984 tree scope;
6986 /* Look for the nested-name-specifier. */
6988 typename_keyword_p,
6989 check_dependency_p,
6990 type_p,
6991 is_declaration);
6992 /* If it was not present, issue an error message. */
6994 {
6997 }
7000 }
7002 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7003 this is either a class-name or a namespace-name (which corresponds
7004 to the class-or-namespace-name production in the grammar). For
7005 C++0x, it can also be a type-name that refers to an enumeration
7006 type or a simple-template-id.
7008 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7009 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7010 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7011 TYPE_P is TRUE iff the next name should be taken as a class-name,
7012 even the same name is declared to be another entity in the same
7013 scope.
7015 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7016 specified by the class-or-namespace-name. If neither is found the
7017 ERROR_MARK_NODE is returned. */
7019 static tree
7026 {
7027 tree saved_scope;
7028 tree saved_qualifying_scope;
7029 tree saved_object_scope;
7030 tree scope;
7034 /* DR 743: decltype can appear in a nested-name-specifier. */
7036 {
7040 {
7043 }
7047 }
7049 /* Before we try to parse the class-name, we must save away the
7050 current PARSER->SCOPE since cp_parser_class_name will destroy
7051 it. */
7055 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7056 there is no need to look for a namespace-name. */
7057 only_class_p = template_keyword_p
7062 typename_keyword_p,
7063 template_keyword_p,
7065 check_dependency_p,
7067 is_declaration,
7070 /* If that didn't work, try for a namespace-name. */
7072 {
7073 /* Restore the saved scope. */
7077 /* If we are not looking at an identifier followed by the scope
7078 resolution operator, then this is not part of a
7079 nested-name-specifier. (Note that this function is only used
7080 to parse the components of a nested-name-specifier.) */
7085 }
7088 }
7090 /* Return true if we are looking at a compound-literal, false otherwise. */
7092 static bool
7094 {
7097 /* Skip tokens until the next token is a closing parenthesis.
7098 If we find the closing `)', and the next token is a `{', then
7099 we are looking at a compound-literal. */
7100 bool compound_literal_p
7105 /* Roll back the tokens we skipped. */
7109 }
7111 /* Return true if EXPR is the integer constant zero or a complex constant
7112 of zero, without any folding, but ignoring location wrappers. */
7114 bool
7116 {
7119 }
7121 /* Parse a postfix-expression.
7123 postfix-expression:
7124 primary-expression
7125 postfix-expression [ expression ]
7126 postfix-expression ( expression-list [opt] )
7127 simple-type-specifier ( expression-list [opt] )
7128 typename :: [opt] nested-name-specifier identifier
7129 ( expression-list [opt] )
7130 typename :: [opt] nested-name-specifier template [opt] template-id
7131 ( expression-list [opt] )
7132 postfix-expression . template [opt] id-expression
7133 postfix-expression -> template [opt] id-expression
7134 postfix-expression . pseudo-destructor-name
7135 postfix-expression -> pseudo-destructor-name
7136 postfix-expression ++
7137 postfix-expression --
7138 dynamic_cast < type-id > ( expression )
7139 static_cast < type-id > ( expression )
7140 reinterpret_cast < type-id > ( expression )
7141 const_cast < type-id > ( expression )
7142 typeid ( expression )
7143 typeid ( type-id )
7145 GNU Extension:
7147 postfix-expression:
7148 ( type-id ) { initializer-list , [opt] }
7150 This extension is a GNU version of the C99 compound-literal
7151 construct. (The C99 grammar uses `type-name' instead of `type-id',
7152 but they are essentially the same concept.)
7154 If ADDRESS_P is true, the postfix expression is the operand of the
7155 `&' operator. CAST_P is true if this expression is the target of a
7156 cast.
7158 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
7159 class member access expressions [expr.ref].
7161 Returns a representation of the expression. */
7163 static cp_expr
7167 {
7169 location_t loc;
7175 /* Peek at the next token. */
7180 /* Some of the productions are determined by keywords. */
7183 {
7188 {
7189 tree type;
7190 cp_expr expression;
7194 /* All of these can be handled in the same way from the point
7195 of view of parsing. Begin by consuming the token
7196 identifying the cast. */
7199 /* New types cannot be defined in the cast. */
7201 parser->type_definition_forbidden_message
7204 /* Look for the opening `<'. */
7206 /* Parse the type to which we are casting. */
7210 NULL);
7212 /* Look for the closing `>'. */
7214 /* Restore the old message. */
7217 bool saved_greater_than_is_operator_p
7221 /* And the expression which is being cast. */
7222 matching_parens parens;
7226 RT_CLOSE_PAREN);
7230 parser->greater_than_is_operator_p
7233 /* Only type conversions to integral or enumeration types
7234 can be used in constant-expressions. */
7237 {
7240 }
7242 /* Construct a location e.g. :
7243 reinterpret_cast <int *> (expr)
7244 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7245 ranging from the start of the "*_cast" token to the final closing
7246 paren, with the caret at the start. */
7250 {
7252 postfix_expression
7254 tf_warning_or_error);
7257 postfix_expression
7259 tf_warning_or_error);
7262 postfix_expression
7264 tf_warning_or_error);
7267 postfix_expression
7269 tf_warning_or_error);
7273 }
7274 }
7278 {
7279 tree type;
7283 /* Consume the `typeid' token. */
7285 /* Look for the `(' token. */
7286 matching_parens parens;
7288 /* Types cannot be defined in a `typeid' expression. */
7290 parser->type_definition_forbidden_message
7292 /* We can't be sure yet whether we're looking at a type-id or an
7293 expression. */
7295 /* Try a type-id first. */
7300 /* Look for the `)' token. Otherwise, we can't be sure that
7301 we're not looking at an expression: consider `typeid (int
7302 (3))', for example. */
7304 /* If all went well, simply lookup the type-id. */
7307 /* Otherwise, fall back to the expression variant. */
7308 else
7309 {
7310 tree expression;
7312 /* Look for an expression. */
7314 /* Compute its typeid. */
7316 /* Look for the `)' token. */
7318 }
7319 /* Restore the saved message. */
7321 /* `typeid' may not appear in an integral constant expression. */
7325 /* Construct a location e.g. :
7326 typeid (expr)
7327 ^~~~~~~~~~~~~
7328 ranging from the start of the "typeid" token to the final closing
7329 paren, with the caret at the start. */
7331 {
7332 location_t typeid_loc
7336 }
7337 }
7341 {
7342 tree type;
7343 /* The syntax permitted here is the same permitted for an
7344 elaborated-type-specifier. */
7351 }
7359 {
7367 {
7370 }
7376 {
7379 postfix_expression
7381 else
7382 {
7386 }
7392 tf_warning_or_error);
7393 else
7394 {
7398 }
7406 else
7407 {
7411 }
7416 postfix_expression
7420 postfix_expression
7423 else
7424 {
7428 }
7433 {
7437 }
7438 else
7439 {
7440 postfix_expression
7442 }
7447 }
7449 }
7452 {
7453 tree expression;
7454 tree type;
7455 /* Consume the `__builtin_convertvector' token. */
7457 /* Look for the opening `('. */
7458 matching_parens parens;
7460 /* Now, parse the assignment-expression. */
7462 /* Look for the `,'. */
7464 location_t type_location
7466 /* Parse the type-id. */
7467 {
7470 }
7471 /* Look for the closing `)'. */
7474 tf_warning_or_error);
7475 }
7478 {
7479 tree expression;
7480 tree type;
7481 /* Consume the `__builtin_bit_cast' token. */
7483 /* Look for the opening `('. */
7484 matching_parens parens;
7486 location_t type_location
7488 /* Parse the type-id. */
7489 {
7492 }
7493 /* Look for the `,'. */
7495 /* Now, parse the assignment-expression. */
7497 /* Look for the closing `)'. */
7500 tf_warning_or_error);
7501 }
7504 {
7505 tree type;
7507 /* If the next thing is a simple-type-specifier, we may be
7508 looking at a functional cast. We could also be looking at
7509 an id-expression. So, we try the functional cast, and if
7510 that doesn't work we fall back to the primary-expression. */
7512 /* Look for the simple-type-specifier. */
7516 CP_PARSER_FLAGS_NONE);
7518 /* Parse the cast itself. */
7520 postfix_expression
7522 /* If that worked, we're done. */
7526 /* If the functional-cast didn't work out, try a
7527 compound-literal. */
7530 {
7535 matching_parens parens;
7538 /* Avoid calling cp_parser_type_id pointlessly, see comment
7539 in cp_parser_cast_expression about c++/29234. */
7542 else
7543 {
7544 /* Parse the type. */
7550 }
7552 /* If things aren't going well, there's no need to
7553 keep going. */
7555 {
7557 /* Parse the brace-enclosed initializer list. */
7560 }
7561 /* If that worked, we're definitely looking at a
7562 compound-literal expression. */
7564 {
7565 /* Warn the user that a compound literal is not
7566 allowed in standard C++. */
7569 /* For simplicity, we disallow compound literals in
7570 constant-expressions. We could
7571 allow compound literals of integer type, whose
7572 initializer was a constant, in constant
7573 expressions. Permitting that usage, as a further
7574 extension, would not change the meaning of any
7575 currently accepted programs. (Of course, as
7576 compound literals are not part of ISO C++, the
7577 standard has nothing to say.) */
7579 NIC_NCC))
7580 {
7583 }
7584 /* Form the representation of the compound-literal. */
7585 postfix_expression
7590 }
7591 }
7593 /* It must be a primary-expression. */
7594 postfix_expression
7597 decltype_p,
7599 }
7601 }
7603 /* Note that we don't need to worry about calling build_cplus_new on a
7604 class-valued CALL_EXPR in decltype when it isn't the end of the
7605 postfix-expression; unary_complex_lvalue will take care of that for
7606 all these cases. */
7608 /* Keep looping until the postfix-expression is complete. */
7610 {
7614 /* It is not a Koenig lookup function call. */
7615 postfix_expression
7618 /* Peek at the next token. */
7622 {
7625 {
7627 "two consecutive %<[%> shall "
7630 }
7631 postfix_expression
7633 postfix_expression,
7635 decltype_p);
7644 /* postfix-expression ( expression-list [opt] ) */
7645 {
7657 tree stripped_expression
7659 is_builtin_constant_p
7662 {
7663 /* The whole point of __builtin_constant_p is to allow
7664 non-constant expressions to appear as arguments. */
7665 saved_integral_constant_expression_p
7667 saved_non_integral_constant_expression_p
7670 }
7671 args = (cp_parser_parenthesized_expression_list
7678 {
7679 parser->integral_constant_expression_p
7681 parser->non_integral_constant_expression_p
7683 }
7686 {
7689 }
7691 /* Function calls are not permitted in
7692 constant-expressions. */
7695 NIC_FUNC_CALL))
7696 {
7700 }
7705 {
7707 /* In C++20, we may need to perform ADL for a template
7708 name. */
7711 {
7713 {
7716 postfix_expression
7718 complain);
7719 }
7720 else
7721 postfix_expression
7723 }
7724 /* We do not perform argument-dependent lookup if
7725 normal lookup finds a non-function, in accordance
7726 with the expected resolution of DR 218. */
7729 {
7730 /* Do not do argument dependent lookup if regular
7731 lookup finds a member function or a block-scope
7732 function declaration. [basic.lookup.argdep]/3 */
7736 {
7742 {
7745 }
7746 }
7749 {
7752 postfix_expression
7754 complain);
7755 }
7756 }
7757 }
7759 /* Temporarily set input_location to the combined location
7760 with call expression range, as e.g. build_out_target_exprs
7761 called from convert_default_arg relies on input_location,
7762 so updating it only when the call is fully built results
7763 in inconsistencies between location handling in templates
7764 and outside of templates. */
7767 close_paren_loc);
7771 {
7781 {
7783 postfix_expression
7785 }
7787 {
7788 postfix_expression
7789 = (build_new_method_call
7795 complain));
7796 }
7797 else
7798 postfix_expression
7802 complain);
7803 }
7807 postfix_expression = (build_offset_ref_call_from_tree
7809 complain));
7811 /* A call to a static class member, or a namespace-scope
7812 function. */
7813 postfix_expression
7816 koenig_p,
7817 complain);
7818 else
7819 /* All other function calls. */
7820 postfix_expression
7823 koenig_p,
7824 complain);
7829 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
7833 }
7838 /* postfix-expression . template [opt] id-expression
7839 postfix-expression . pseudo-destructor-name
7840 postfix-expression -> template [opt] id-expression
7841 postfix-expression -> pseudo-destructor-name */
7843 /* Consume the `.' or `->' operator. */
7846 postfix_expression
7848 postfix_expression,
7855 /* postfix-expression ++ */
7856 /* Consume the `++' token. */
7858 /* Generate a representation for the complete expression. */
7859 postfix_expression
7861 POSTINCREMENT_EXPR);
7862 /* Increments may not appear in constant-expressions. */
7870 /* postfix-expression -- */
7871 /* Consume the `--' token. */
7873 /* Generate a representation for the complete expression. */
7874 postfix_expression
7876 POSTDECREMENT_EXPR);
7877 /* Decrements may not appear in constant-expressions. */
7888 return is_member_access
7889 ? postfix_expression
7891 else
7893 }
7894 }
7895 }
7897 /* Helper function for cp_parser_parenthesized_expression_list and
7898 cp_parser_postfix_open_square_expression. Parse a single element
7899 of parenthesized expression list. */
7901 static cp_expr
7906 {
7910 /* Parse the next assignment-expression. */
7912 {
7913 /* A braced-init-list. */
7919 }
7921 {
7927 }
7928 else
7934 /* If we have an ellipsis, then this is an expression expansion. */
7937 {
7938 /* Consume the `...'. */
7941 /* Build the argument pack. */
7943 }
7945 }
7947 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
7948 by cp_parser_builtin_offsetof. We're looking for
7950 postfix-expression [ expression ]
7951 postfix-expression [ braced-init-list ] (C++11)
7952 postfix-expression [ expression-list[opt] ] (C++23)
7954 FOR_OFFSETOF is set if we're being called in that context, which
7955 changes how we deal with integer constant expressions. */
7957 static tree
7959 tree postfix_expression,
7962 {
7968 /* Consume the `[' token. */
7974 /* Parse the index expression. */
7975 /* ??? For offsetof, there is a question of what to allow here. If
7976 offsetof is not being used in an integral constant expression context,
7977 then we *could* get the right answer by computing the value at runtime.
7978 If we are in an integral constant expression context, then we might
7979 could accept any constant expression; hard to say without analysis.
7980 Rather than open the barn door too wide right away, allow only integer
7981 constant expressions here. */
7984 else
7985 {
7990 {
7992 {
7993 cp_expr expr
7995 /*cast_p=*/
7997 /*allow_exp_p=*/
7999 /*fold_expr_p=*/
8001 /*non_cst_p=*/
8002 NULL);
8009 else
8012 /* If the next token isn't a `,', then we are done. */
8017 {
8020 }
8022 /* Otherwise, consume the `,' and keep going. */
8024 }
8027 }
8029 {
8034 }
8035 else
8039 }
8043 /* Look for the closing `]'. */
8046 /* Build the ARRAY_REF. */
8049 tf_warning_or_error
8052 /* When not doing offsetof, array references are not permitted in
8053 constant-expressions. */
8059 }
8061 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8062 dereference of incomplete type, returns true if error_mark_node should
8063 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8064 and *DEPENDENT_P. */
8066 bool
8069 {
8070 /* In a template, be permissive by treating an object expression
8071 of incomplete type as dependent (after a pedwarn). */
8072 diagnostic_t kind = (processing_template_decl
8076 {
8088 /* Don't emit any diagnostic for OVERLOADs. */
8092 /* Avoid clobbering e.g. DECLs. */
8096 }
8108 {
8111 }
8113 }
8115 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8116 by cp_parser_builtin_offsetof. We're looking for
8118 postfix-expression . template [opt] id-expression
8119 postfix-expression . pseudo-destructor-name
8120 postfix-expression -> template [opt] id-expression
8121 postfix-expression -> pseudo-destructor-name
8123 FOR_OFFSETOF is set if we're being called in that context. That sorta
8124 limits what of the above we'll actually accept, but nevermind.
8125 TOKEN_TYPE is the "." or "->" token, which will already have been
8126 removed from the stream. */
8128 static tree
8131 cp_expr postfix_expression,
8133 location_t location)
8134 {
8135 tree name;
8141 /* If this is a `->' operator, dereference the pointer. */
8144 tf_warning_or_error);
8145 /* Check to see whether or not the expression is type-dependent and
8146 not the current instantiation. */
8148 /* The identifier following the `->' or `.' is not qualified. */
8154 /* Enter the scope corresponding to the type of the object
8155 given by the POSTFIX_EXPRESSION. */
8157 {
8159 /* According to the standard, no expression should ever have
8160 reference type. Unfortunately, we do not currently match
8161 the standard in this respect in that our internal representation
8162 of an expression may have reference type even when the standard
8163 says it does not. Therefore, we have to manually obtain the
8164 underlying type here. */
8166 /* The type of the POSTFIX_EXPRESSION must be complete. */
8167 /* Unlike the object expression in other contexts, *this is not
8168 required to be of complete type for purposes of class member
8169 access (5.2.5) outside the member function body. */
8173 {
8179 }
8182 {
8183 /* Let the name lookup machinery know that we are processing a
8184 class member access expression. */
8186 /* If something went wrong, we want to be able to discern that case,
8187 as opposed to the case where there was no SCOPE due to the type
8188 of expression being dependent. */
8191 /* If the SCOPE was erroneous, make the various semantic analysis
8192 functions exit quickly -- and without issuing additional error
8193 messages. */
8196 }
8197 }
8200 {
8202 /* If we don't have a (type-dependent) object of class type, use
8203 typeof to figure out the type of the object. */
8207 }
8209 /* Assume this expression is not a pseudo-destructor access. */
8212 /* If the SCOPE is a scalar type, then, if this is a valid program,
8213 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8214 is type dependent, it can be pseudo-destructor-name or something else.
8215 Try to parse it as pseudo-destructor-name first. */
8217 {
8218 tree s;
8219 tree type;
8222 /* Parse the pseudo-destructor-name. */
8231 {
8233 postfix_expression
8236 }
8237 }
8240 {
8241 /* If the SCOPE is not a scalar type, we are looking at an
8242 ordinary class member access expression, rather than a
8243 pseudo-destructor-name. */
8246 /* Parse the id-expression. */
8247 name = (cp_parser_id_expression
8254 /* In general, build a SCOPE_REF if the member name is qualified.
8255 However, if the name was not dependent and has already been
8256 resolved; there is no need to build the SCOPE_REF. For example;
8258 struct X { void f(); };
8259 template <typename T> void f(T* t) { t->X::f(); }
8261 Even though "t" is dependent, "X::f" is not and has been resolved
8262 to a BASELINK; there is no need to include scope information. */
8264 /* But we do need to remember that there was an explicit scope for
8265 virtual function calls. */
8269 /* If the name is a template-id that names a type, we will get a
8270 TYPE_DECL here. That is invalid code. */
8272 {
8275 }
8276 else
8277 {
8279 {
8281 {
8285 }
8286 else
8289 name,
8290 template_p);
8294 }
8296 adjust_result_of_qualified_name_lookup
8298 postfix_expression
8300 template_p,
8301 tf_warning_or_error);
8302 /* Build a location e.g.:
8303 ptr->access_expr
8304 ~~~^~~~~~~~~~~~~
8305 where the caret is at the deref token, ranging from
8306 the start of postfix_expression to the end of the access expr. */
8307 location_t combined_loc
8310 }
8311 }
8313 /* We no longer need to look up names in the scope of the object on
8314 the left-hand side of the `.' or `->' operator. */
8317 /* Outside of offsetof, these operators may not appear in
8318 constant-expressions. */
8320 && (cp_parser_non_integral_constant_expression
8325 }
8327 /* Parse a parenthesized expression-list.
8329 expression-list:
8330 assignment-expression
8331 expression-list, assignment-expression
8333 attribute-list:
8334 expression-list
8335 identifier
8336 identifier, expression-list
8338 CAST_P is true if this expression is the target of a cast.
8340 ALLOW_EXPANSION_P is true if this expression allows expansion of an
8341 argument pack.
8343 WRAP_LOCATIONS_P is true if expressions within this list for which
8344 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8345 their source locations.
8347 Returns a vector of trees. Each element is a representation of an
8348 assignment-expression. NULL is returned if the ( and or ) are
8349 missing. An empty, but allocated, vector is returned on no
8350 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8351 if we are parsing an attribute list for an attribute that wants a
8352 plain identifier argument, normal_attr for an attribute that wants
8353 an expression, or non_attr if we aren't parsing an attribute list. If
8354 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8355 not all of the expressions in the list were constant.
8356 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8357 will be written to with the location of the closing parenthesis. If
8358 an error occurs, it may or may not be written to. */
8368 {
8374 /* Assume all the expressions will be constant. */
8378 matching_parens parens;
8384 /* Within a parenthesized expression, a `>' token is always
8385 the greater-than operator. */
8386 saved_greater_than_is_operator_p
8392 /* Consume expressions until there are no more. */
8395 {
8396 /* At the beginning of attribute lists, check to see if the
8397 next token is an identifier. */
8400 {
8403 /* Consume the identifier. */
8405 /* Save the identifier. */
8407 }
8408 else
8409 {
8410 expr
8412 allow_expansion_p,
8413 fold_expr_p,
8414 non_constant_p);
8419 /* Add it to the list. We add error_mark_node
8420 expressions to the list, so that we can still tell if
8421 the correct form for a parenthesized expression-list
8422 is found. That gives better errors. */
8427 }
8429 /* After the first item, attribute lists look the same as
8430 expression lists. */
8433 get_comma:;
8434 /* If the next token isn't a `,', then we are done. */
8438 /* Otherwise, consume the `,' and keep going. */
8440 }
8446 {
8449 skip_comma:;
8450 /* We try and resync to an unnested comma, as that will give the
8451 user better diagnostics. */
8459 {
8460 parser->greater_than_is_operator_p
8463 }
8464 }
8466 parser->greater_than_is_operator_p
8473 }
8475 /* Parse a pseudo-destructor-name.
8477 pseudo-destructor-name:
8478 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
8479 :: [opt] nested-name-specifier template template-id :: ~ type-name
8480 :: [opt] nested-name-specifier [opt] ~ type-name
8482 If either of the first two productions is used, sets *SCOPE to the
8483 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
8484 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
8485 or ERROR_MARK_NODE if the parse fails. */
8487 static void
8489 tree object,
8492 {
8495 /* Handle ~auto. */
8499 {
8502 "%<~auto%> only available with "
8509 }
8511 /* Assume that things will not work out. */
8514 /* Look for the optional `::' operator. */
8516 /* Look for the optional nested-name-specifier. */
8517 nested_name_specifier_p
8524 /* Now, if we saw a nested-name-specifier, we might be doing the
8525 second production. */
8528 {
8529 /* Consume the `template' keyword. */
8531 /* Parse the template-id. */
8535 class_type,
8537 /* Look for the `::' token. */
8539 }
8540 /* If the next token is not a `~', then there might be some
8541 additional qualification. */
8543 {
8544 /* At this point, we're looking for "type-name :: ~". The type-name
8545 must not be a class-name, since this is a pseudo-destructor. So,
8546 it must be either an enum-name, or a typedef-name -- both of which
8547 are just identifiers. So, we peek ahead to check that the "::"
8548 and "~" tokens are present; if they are not, then we can avoid
8549 calling type_name. */
8553 {
8556 }
8558 /* Look for the type-name. */
8563 /* Look for the `::' token. */
8565 }
8566 else
8569 /* Look for the `~'. */
8572 /* Once we see the ~, this has to be a pseudo-destructor. */
8576 /* Look for the type-name again. We are not responsible for
8577 checking that it matches the first type-name. */
8579 }
8581 /* Parse a unary-expression.
8583 unary-expression:
8584 postfix-expression
8585 ++ cast-expression
8586 -- cast-expression
8587 await-expression
8588 unary-operator cast-expression
8589 sizeof unary-expression
8590 sizeof ( type-id )
8591 alignof ( type-id ) [C++0x]
8592 new-expression
8593 delete-expression
8595 GNU Extensions:
8597 unary-expression:
8598 __extension__ cast-expression
8599 __alignof__ unary-expression
8600 __alignof__ ( type-id )
8601 alignof unary-expression [C++0x]
8602 __real__ cast-expression
8603 __imag__ cast-expression
8604 && identifier
8605 sizeof ( type-id ) { initializer-list , [opt] }
8606 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
8607 __alignof__ ( type-id ) { initializer-list , [opt] }
8609 ADDRESS_P is true iff the unary-expression is appearing as the
8610 operand of the `&' operator. CAST_P is true if this expression is
8611 the target of a cast.
8613 Returns a representation of the expression. */
8615 static cp_expr
8618 {
8622 /* Peek at the next token. */
8624 /* Some keywords give away the kind of expression. */
8626 {
8630 {
8633 {
8641 /* Consume the token. */
8643 /* Parse the operand. */
8646 /* Construct a location e.g. :
8647 alignof (expr)
8648 ^~~~~~~~~~~~~~
8649 with start == caret at the start of the "alignof"/"sizeof"
8650 token, with the endpoint at the final closing paren. */
8651 location_t compound_loc
8657 else
8658 {
8659 /* ISO C++ defines alignof only with types, not with
8660 expressions. So pedwarn if alignof is used with a non-
8661 type expression. However, __alignof__ is ok. */
8664 "ISO C++ does not allow %<alignof%> "
8669 }
8670 /* For SIZEOF_EXPR, just issue diagnostics, but keep
8671 SIZEOF_EXPR with the original operand. */
8673 {
8675 {
8677 {
8680 error_mark_node));
8682 }
8683 else
8688 }
8689 }
8694 }
8706 {
8707 /* The saved value of the PEDANTIC flag. */
8709 tree expr;
8711 /* Save away the PEDANTIC flag. */
8713 /* Parse the cast-expression. */
8715 /* Restore the PEDANTIC flag. */
8719 }
8723 {
8724 tree expression;
8726 /* Consume the `__real__' or `__imag__' token. */
8728 /* Parse the cast-expression. */
8730 /* Create the complete representation. */
8735 tf_warning_or_error);
8736 }
8744 {
8745 tree expr;
8754 matching_parens parens;
8758 parser->type_definition_forbidden_message
8761 saved_integral_constant_expression_p
8763 saved_non_integral_constant_expression_p
8767 saved_greater_than_is_operator_p
8779 parser->greater_than_is_operator_p
8782 parser->integral_constant_expression_p
8784 parser->non_integral_constant_expression_p
8791 /* Construct a location of the form:
8792 noexcept (expr)
8793 ^~~~~~~~~~~~~~~
8794 with start == caret, finishing at the close-paren. */
8795 location_t noexcept_loc
8799 noexcept_loc);
8800 }
8803 {
8804 tree expr;
8807 /* Consume the `co_await' token. */
8809 /* Parse its cast-expression. */
8814 /* Handle [expr.await]. */
8816 }
8820 }
8821 }
8823 /* Look for the `:: new' and `:: delete', which also signal the
8824 beginning of a new-expression, or delete-expression,
8825 respectively. If the next token is `::', then it might be one of
8826 these. */
8828 {
8831 /* See if the token after the `::' is one of the keywords in
8832 which we're interested. */
8834 /* If it's `new', we have a new-expression. */
8837 /* Similarly, for `delete'. */
8840 }
8842 /* Look for a unary operator. */
8844 /* The `++' and `--' operators can be handled similarly, even though
8845 they are not technically unary-operators in the grammar. */
8847 {
8852 /* Handle the GNU address-of-label extension. */
8855 {
8856 tree identifier;
8857 tree expression;
8860 /* Consume the '&&' token. */
8862 /* Look for the identifier. */
8864 /* Construct a location of the form:
8865 &&label
8866 ^~~~~~~
8867 with caret==start at the "&&", finish at the end of the label. */
8868 location_t combined_loc
8870 /* Create an expression representing the address. */
8873 NIC_ADDR_LABEL))
8876 }
8877 }
8879 {
8880 cp_expr cast_expression;
8886 /* Consume the operator token. */
8890 /* Parse the cast-expression. */
8891 cast_expression
8896 pidk);
8898 /* Make a location:
8899 OP_TOKEN CAST_EXPRESSION
8900 ^~~~~~~~~~~~~~~~~~~~~~~~~
8901 with start==caret at the operator token, and
8902 extending to the end of the cast_expression. */
8905 /* Now, build an appropriate representation. */
8907 {
8912 complain);
8913 /* TODO: build_x_indirect_ref does not always honor the
8914 location, so ensure it is set. */
8920 /* Fall through. */
8923 cast_expression,
8925 /* TODO: build_x_unary_op does not always honor the location,
8926 so ensure it is set. */
8934 /* Fall through. */
8936 /* Immediately fold negation of a constant, unless the constant is 0
8937 (since -0 == 0) or it would overflow. */
8939 {
8940 tree stripped_expr
8945 {
8948 stripped_expr);
8950 {
8953 }
8954 }
8955 }
8956 /* Fall through. */
8965 }
8969 non_constant_p))
8973 }
8977 decltype_p,
8978 pidk);
8979 }
8981 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
8982 unary-operator, the corresponding tree code is returned. */
8984 static enum tree_code
8986 {
8988 {
9009 }
9010 }
9012 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9013 Returns a representation of the expression. */
9015 static tree
9017 {
9020 /* Consume the __builtin_has_attribute token. */
9023 matching_parens parens;
9027 /* Types cannot be defined in a `sizeof' expression. Save away the
9028 old message. */
9032 parser->type_definition_forbidden_message
9034 parser->type_definition_forbidden_message_arg
9037 /* The restrictions on constant-expressions do not apply inside
9038 sizeof expressions. */
9039 bool saved_integral_constant_expression_p
9041 bool saved_non_integral_constant_expression_p
9045 /* Do not actually evaluate the expression. */
9051 /* We can't be sure yet whether we're looking at a type-id or an
9052 expression. */
9057 /* Look for the type-id. */
9063 /* If the type-id production did not work out, then we must be
9064 looking at an expression. */
9070 /* Go back to evaluating expressions. */
9074 /* And restore the old one. */
9077 parser->integral_constant_expression_p
9079 parser->non_integral_constant_expression_p
9082 /* Consume the comma if it's there. */
9084 {
9088 }
9090 /* Parse the attribute specification. */
9094 {
9100 else
9101 {
9102 /* Fold constant expressions used in attributes first. */
9105 /* Finally, see if OPER has been declared with ATTR. */
9107 }
9110 }
9111 else
9112 {
9115 }
9117 /* Construct a location e.g. :
9118 __builtin_has_attribute (oper, attr)
9119 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9120 with start == caret at the start of the built-in token,
9121 and with the endpoint at the final closing paren. */
9122 location_t compound_loc
9129 }
9131 /* Parse a new-expression.
9133 new-expression:
9134 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9135 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9137 Returns a representation of the expression. */
9139 static tree
9141 {
9144 tree type;
9147 tree ret;
9151 /* Look for the optional `::' operator. */
9152 global_scope_p
9156 /* Look for the `new' operator. */
9158 /* There's no easy way to tell a new-placement from the
9159 `( type-id )' construct. */
9161 /* Look for a new-placement. */
9163 /* If that didn't work out, there's no new-placement. */
9165 {
9169 }
9171 /* If the next token is a `(', then we have a parenthesized
9172 type-id. */
9174 {
9178 /* Consume the `('. */
9179 matching_parens parens;
9182 /* Parse the type-id. */
9183 parser->type_definition_forbidden_message
9185 {
9188 }
9191 /* Look for the closing `)'. */
9194 /* There should not be a direct-new-declarator in this production,
9195 but GCC used to allowed this, so we check and emit a sensible error
9196 message for this case. */
9198 {
9204 }
9205 }
9206 /* Otherwise, there must be a new-type-id. */
9207 else
9210 /* If the next token is a `(' or '{', then we have a new-initializer. */
9215 else
9218 /* A new-expression may not appear in an integral constant
9219 expression. */
9222 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9223 of a new-type-id or type-id of a new-expression, the new-expression shall
9224 contain a new-initializer of the form ( assignment-expression )".
9225 Additionally, consistently with the spirit of DR 1467, we want to accept
9226 'new auto { 2 }' too. */
9232 {
9234 "initialization of new-expression for type %<auto%> "
9237 }
9238 else
9239 {
9240 /* Construct a location e.g.:
9241 ptr = new int[100]
9242 ^~~~~~~~~~~~
9243 with caret == start at the start of the "new" token, and the end
9244 at the end of the final token we consumed. */
9247 /* Create a representation of the new-expression. */
9250 }
9258 }
9260 /* Parse a new-placement.
9262 new-placement:
9263 ( expression-list )
9265 Returns the same representation as for an expression-list. */
9269 {
9272 /* Parse the expression-list. */
9273 expression_list = (cp_parser_parenthesized_expression_list
9282 }
9284 /* Parse a new-type-id.
9286 new-type-id:
9287 type-specifier-seq new-declarator [opt]
9289 Returns the TYPE allocated. If the new-type-id indicates an array
9290 type, *NELTS is set to the number of elements in the last array
9291 bound; the TYPE will not include the last array bound. */
9293 static tree
9295 {
9296 cp_decl_specifier_seq type_specifier_seq;
9302 /* The type-specifier sequence must not contain type definitions.
9303 (It cannot contain declarations of new types either, but if they
9304 are not definitions we will catch that because they are not
9305 complete.) */
9307 parser->type_definition_forbidden_message
9309 /* Parse the type-specifier-seq. */
9314 /* Restore the old message. */
9320 /* Parse the new-declarator. */
9323 /* Determine the number of elements in the last array dimension, if
9324 any. */
9326 /* Skip down to the last array dimension. */
9331 {
9334 }
9339 {
9342 }
9345 {
9354 else
9356 }
9359 }
9361 /* Parse an (optional) new-declarator.
9363 new-declarator:
9364 ptr-operator new-declarator [opt]
9365 direct-new-declarator
9367 Returns the declarator. */
9371 {
9374 cp_cv_quals cv_quals;
9376 /* We don't know if there's a ptr-operator next, or not. */
9378 /* Look for a ptr-operator. */
9380 /* If that worked, look for more new-declarators. */
9382 {
9385 /* Parse another optional declarator. */
9388 declarator = cp_parser_make_indirect_declarator
9392 }
9394 /* If the next token is a `[', there is a direct-new-declarator. */
9399 }
9401 /* Parse a direct-new-declarator.
9403 direct-new-declarator:
9404 [ expression ]
9405 direct-new-declarator [constant-expression]
9407 */
9411 {
9416 {
9417 tree expression;
9420 /* Look for the opening `['. */
9426 else
9428 /* The standard requires that the expression have integral
9429 type. DR 74 adds enumeration types. We believe that the
9430 real intent is that these expressions be handled like the
9431 expression in a `switch' condition, which also allows
9432 classes with a single conversion to integral or
9433 enumeration type. */
9435 {
9436 expression
9438 expression,
9441 {
9443 "expression in new-declarator must have integral "
9446 }
9447 }
9449 /* Look for the closing `]'. */
9452 /* Add this bound to the declarator. */
9455 /* If the next token is not a `[', then there are no more
9456 bounds. */
9460 }
9463 }
9465 /* Parse a new-initializer.
9467 new-initializer:
9468 ( expression-list [opt] )
9469 braced-init-list
9471 Returns a representation of the expression-list. */
9475 {
9479 {
9480 tree t;
9487 }
9488 else
9489 expression_list = (cp_parser_parenthesized_expression_list
9495 }
9497 /* Parse a delete-expression.
9499 delete-expression:
9500 :: [opt] delete cast-expression
9501 :: [opt] delete [ ] cast-expression
9503 Returns a representation of the expression. */
9505 static tree
9507 {
9510 tree expression;
9513 /* Look for the optional `::' operator. */
9514 global_scope_p
9518 /* Look for the `delete' keyword. */
9520 /* See if the array syntax is in use. */
9522 {
9523 /* Consume the `[' token. */
9525 /* Look for the `]' token. */
9527 /* Remember that this is the `[]' construct. */
9529 }
9530 else
9533 /* Parse the cast-expression. */
9536 /* A delete-expression may not appear in an integral constant
9537 expression. */
9541 /* Construct a location e.g.:
9542 delete [ ] ptr
9543 ^~~~~~~~~~~~~~
9544 with caret == start at the start of the "delete" token, and
9545 the end at the end of the final token we consumed. */
9552 }
9554 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9555 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9556 0 otherwise. */
9558 static int
9560 {
9563 {
9605 /* In ((type ()) () the last () isn't a valid cast-expression,
9606 so the whole must be parsed as postfix-expression. */
9611 /* '[' may start a primary-expression in obj-c++ and in C++11,
9612 as a lambda-expression, eg, '(void)[]{}'. */
9619 /* '++' and '--' may or may not start a cast-expression:
9621 struct T { void operator++(int); };
9622 void f() { (T())++; }
9624 vs
9626 int a;
9627 (int)++a; */
9632 }
9633 }
9635 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
9636 in the order: const_cast, static_cast, reinterpret_cast.
9638 Don't suggest dynamic_cast.
9640 Return the first legal cast kind found, or NULL otherwise. */
9644 {
9645 tree trial;
9647 /* Reuse the parser logic by attempting to build the various kinds of
9648 cast, with "complain" disabled.
9649 Identify the first such cast that is valid. */
9651 /* Don't attempt to run such logic within template processing. */
9655 /* First try const_cast. */
9660 /* If that fails, try static_cast. */
9665 /* Finally, try reinterpret_cast. */
9667 tf_none);
9671 /* No such cast possible. */
9673 }
9675 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
9676 suggesting how to convert a C-style cast of the form:
9678 (DST_TYPE)ORIG_EXPR
9680 to a C++-style cast.
9682 The primary range of RICHLOC is asssumed to be that of the original
9683 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
9684 of the parens in the C-style cast. */
9686 static void
9689 tree dst_type)
9690 {
9691 /* This function is non-trivial, so bail out now if the warning isn't
9692 going to be emitted. */
9696 /* Try to find a legal C++ cast, trying them in order:
9697 const_cast, static_cast, reinterpret_cast. */
9702 /* Replace the open paren with "CAST_SUGGESTION<". */
9703 pretty_printer pp;
9708 /* Replace the close paren with "> (". */
9711 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
9713 }
9716 /* Parse a cast-expression.
9718 cast-expression:
9719 unary-expression
9720 ( type-id ) cast-expression
9722 ADDRESS_P is true iff the unary-expression is appearing as the
9723 operand of the `&' operator. CAST_P is true if this expression is
9724 the target of a cast.
9726 Returns a representation of the expression. */
9728 static cp_expr
9731 {
9732 /* If it's a `(', then we might be looking at a cast. */
9734 {
9740 /* There's no way to know yet whether or not this is a cast.
9741 For example, `(int (3))' is a unary-expression, while `(int)
9742 3' is a cast. So, we resort to parsing tentatively. */
9744 /* Types may not be defined in a cast. */
9746 parser->type_definition_forbidden_message
9748 /* Consume the `('. */
9749 matching_parens parens;
9754 /* A very tricky bit is that `(struct S) { 3 }' is a
9755 compound-literal (which we permit in C++ as an extension).
9756 But, that construct is not a cast-expression -- it is a
9757 postfix-expression. (The reason is that `(struct S) { 3 }.i'
9758 is legal; if the compound-literal were a cast-expression,
9759 you'd need an extra set of parentheses.) But, if we parse
9760 the type-id, and it happens to be a class-specifier, then we
9761 will commit to the parse at that point, because we cannot
9762 undo the action that is done when creating a new class. So,
9763 then we cannot back up and do a postfix-expression.
9765 Another tricky case is the following (c++/29234):
9767 struct S { void operator () (); };
9769 void foo ()
9770 {
9771 ( S()() );
9772 }
9774 As a type-id we parse the parenthesized S()() as a function
9775 returning a function, groktypename complains and we cannot
9776 back up in this case either.
9778 Therefore, we scan ahead to the closing `)', and check to see
9779 if the tokens after the `)' can start a cast-expression. Otherwise
9780 we are dealing with an unary-expression, a postfix-expression
9781 or something else.
9783 Yet another tricky case, in C++11, is the following (c++/54891):
9785 (void)[]{};
9787 The issue is that usually, besides the case of lambda-expressions,
9788 the parenthesized type-id cannot be followed by '[', and, eg, we
9789 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
9790 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
9791 we don't commit, we try a cast-expression, then an unary-expression.
9793 Save tokens so that we can put them back. */
9796 /* We may be looking at a cast-expression. */
9799 cast_expression
9802 /* Roll back the tokens we skipped. */
9804 /* If we aren't looking at a cast-expression, simulate an error so
9805 that the call to cp_parser_error_occurred below returns true. */
9808 else
9809 {
9812 /* Look for the type-id. */
9814 /* Look for the closing `)'. */
9819 }
9821 /* Restore the saved message. */
9824 /* At this point this can only be either a cast or a
9825 parenthesized ctor such as `(T ())' that looks like a cast to
9826 function returning T. */
9828 {
9829 /* Only commit if the cast-expression doesn't start with
9830 '++', '--', or '[' in C++11. */
9838 pidk);
9841 {
9842 /* Warn about old-style casts, if so requested. */
9847 {
9853 }
9855 /* Only type conversions to integral or enumeration types
9856 can be used in constant-expressions. */
9859 NIC_CAST))
9862 /* Perform the cast. */
9863 /* Make a location:
9864 (TYPE) EXPR
9865 ^~~~~~~~~~~
9866 with start==caret at the open paren, extending to the
9867 end of "expr". */
9869 open_paren_loc,
9873 }
9874 }
9875 else
9877 }
9879 /* If we get here, then it's not a cast, so it must be a
9880 unary-expression. */
9883 }
9885 /* Parse a binary expression of the general form:
9887 pm-expression:
9888 cast-expression
9889 pm-expression .* cast-expression
9890 pm-expression ->* cast-expression
9892 multiplicative-expression:
9893 pm-expression
9894 multiplicative-expression * pm-expression
9895 multiplicative-expression / pm-expression
9896 multiplicative-expression % pm-expression
9898 additive-expression:
9899 multiplicative-expression
9900 additive-expression + multiplicative-expression
9901 additive-expression - multiplicative-expression
9903 shift-expression:
9904 additive-expression
9905 shift-expression << additive-expression
9906 shift-expression >> additive-expression
9908 relational-expression:
9909 shift-expression
9910 relational-expression < shift-expression
9911 relational-expression > shift-expression
9912 relational-expression <= shift-expression
9913 relational-expression >= shift-expression
9915 GNU Extension:
9917 relational-expression:
9918 relational-expression <? shift-expression
9919 relational-expression >? shift-expression
9921 equality-expression:
9922 relational-expression
9923 equality-expression == relational-expression
9924 equality-expression != relational-expression
9926 and-expression:
9927 equality-expression
9928 and-expression & equality-expression
9930 exclusive-or-expression:
9931 and-expression
9932 exclusive-or-expression ^ and-expression
9934 inclusive-or-expression:
9935 exclusive-or-expression
9936 inclusive-or-expression | exclusive-or-expression
9938 logical-and-expression:
9939 inclusive-or-expression
9940 logical-and-expression && inclusive-or-expression
9942 logical-or-expression:
9943 logical-and-expression
9944 logical-or-expression || logical-and-expression
9946 All these are implemented with a single function like:
9948 binary-expression:
9949 simple-cast-expression
9950 binary-expression <token> binary-expression
9952 CAST_P is true if this expression is the target of a cast.
9954 The binops_by_token map is used to get the tree codes for each <token> type.
9955 binary-expressions are associated according to a precedence table. */
9957 #define TOKEN_PRECEDENCE(token) \
9958 (((token->type == CPP_GREATER \
9959 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
9960 && !parser->greater_than_is_operator_p) \
9961 ? PREC_NOT_OPERATOR \
9962 : binops_by_token[token->type].prec)
9964 static cp_expr
9970 {
9971 cp_parser_expression_stack stack;
9974 cp_parser_expression_stack_entry current;
9975 cp_expr rhs;
9979 tree overload;
9981 /* Parse the first expression. */
9992 {
9993 /* Get an operator token. */
9999 {
10001 "%<>>%> operator is treated"
10005 }
10010 /* This is a fold-expression; handle it later. */
10013 /* Popping an entry off the stack means we completed a subexpression:
10014 - either we found a token which is not an operator (`>' where it is not
10015 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10016 will happen repeatedly;
10017 - or, we found an operator which has lower priority. This is the case
10018 where the recursive descent *ascends*, as in `3 * 4 + 5' after
10019 parsing `3 * 4'. */
10021 {
10024 else
10026 }
10028 get_rhs:
10032 /* We used the operator token. */
10035 /* For "false && x" or "true || x", x will never be executed;
10036 disable warnings while evaluating it. */
10041 {
10044 }
10046 /* Extract another operand. It may be the RHS of this expression
10047 or the LHS of a new, higher priority expression. */
10052 /* Get another operator token. Look up its precedence to avoid
10053 building a useless (immediately popped) stack entry for common
10054 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10061 {
10062 /* ... and prepare to parse the RHS of the new, higher priority
10063 expression. Since precedence levels on the stack are
10064 monotonically increasing, we do not have to care about
10065 stack overflows. */
10074 pop:
10076 /* If the stack is not empty, we have parsed into LHS the right side
10077 (`4' in the example above) of an expression we had suspended.
10078 We can use the information on the stack to recover the LHS (`3')
10079 from the stack together with the tree code (`MULT_EXPR'), and
10080 the precedence of the higher level subexpression
10081 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10082 which will be used to actually build the additive expression. */
10087 }
10089 /* Undo the disabling of warnings done above. */
10091 {
10094 }
10099 /* Avoid warning for !!x == y. */
10104 /* Avoid warning for !b == y where b is boolean. */
10108 /* Avoid warning for !!b == y where b is boolean. */
10121 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10122 ERROR_MARK for everything that is not a binary expression.
10123 This makes warn_about_parentheses miss some warnings that
10124 involve unary operators. For unary expressions we should
10125 pass the correct tree_code unless the unary expression was
10126 surrounded by parentheses.
10127 */
10131 {
10134 else
10135 {
10138 current.lhs
10141 == tcc_comparison
10145 }
10146 }
10147 else
10148 {
10154 /* TODO: build_x_binary_op doesn't always honor the location. */
10156 }
10159 /* If the binary operator required the use of an overloaded operator,
10160 then this expression cannot be an integral constant-expression.
10161 An overloaded operator can be used even if both operands are
10162 otherwise permissible in an integral constant-expression if at
10163 least one of the operands is of enumeration type. */
10167 NIC_OVERLOADED))
10169 }
10172 }
10174 static cp_expr
10179 {
10182 }
10184 /* Parse the `? expression : assignment-expression' part of a
10185 conditional-expression. The LOGICAL_OR_EXPR is the
10186 logical-or-expression that started the conditional-expression.
10187 Returns a representation of the entire conditional-expression.
10189 This routine is used by cp_parser_assignment_expression.
10191 ? expression : assignment-expression
10193 GNU Extensions:
10195 ? : assignment-expression */
10197 static tree
10199 {
10201 cp_expr assignment_expr;
10205 /* Consume the `?' token. */
10210 {
10213 /* Implicit true clause. */
10215 c_inhibit_evaluation_warnings +=
10218 }
10219 else
10220 {
10223 /* Parse the expression. */
10224 c_inhibit_evaluation_warnings +=
10227 c_inhibit_evaluation_warnings +=
10231 }
10233 /* The next token should be a `:'. */
10235 /* Parse the assignment-expression. */
10237 c_inhibit_evaluation_warnings -=
10240 /* Make a location:
10241 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10242 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10243 with the caret at the "?", ranging from the start of
10244 the logical_or_expr to the end of the assignment_expr. */
10249 /* Build the conditional-expression. */
10251 expr,
10252 assignment_expr,
10253 tf_warning_or_error);
10254 }
10256 /* Parse an assignment-expression.
10258 assignment-expression:
10259 conditional-expression
10260 logical-or-expression assignment-operator assignment_expression
10261 throw-expression
10262 yield-expression
10264 CAST_P is true if this expression is the target of a cast.
10265 DECLTYPE_P is true if this expression is the operand of decltype.
10267 Returns a representation for the expression. */
10269 static cp_expr
10272 {
10273 cp_expr expr;
10275 /* If the next token is the `throw' keyword, then we're looking at
10276 a throw-expression. */
10279 /* If the next token is the `co_yield' keyword, then we're looking at
10280 a yield-expression. */
10283 /* Otherwise, it must be that we are looking at a
10284 logical-or-expression. */
10285 else
10286 {
10287 /* Parse the binary expressions (logical-or-expression). */
10289 decltype_p,
10291 /* If the next token is a `?' then we're actually looking at a
10292 conditional-expression. */
10295 else
10296 {
10299 /* If it's an assignment-operator, we're using the second
10300 production. */
10301 enum tree_code assignment_operator
10304 {
10307 /* Parse the right-hand side of the assignment. */
10314 /* An assignment may not appear in a
10315 constant-expression. */
10317 NIC_ASSIGNMENT))
10319 /* Build the assignment expression. Its default
10320 location:
10321 LHS = RHS
10322 ~~~~^~~~~
10323 is the location of the '=' token as the
10324 caret, ranging from the start of the lhs to the
10325 end of the rhs. */
10330 assignment_operator,
10333 /* TODO: build_x_modify_expr doesn't honor the location,
10334 so we must set it here. */
10336 }
10337 }
10338 }
10341 }
10343 /* Parse an (optional) assignment-operator.
10345 assignment-operator: one of
10346 = *= /= %= += -= >>= <<= &= ^= |=
10348 GNU Extension:
10350 assignment-operator: one of
10351 <?= >?=
10353 If the next token is an assignment operator, the corresponding tree
10354 code is returned, and the token is consumed. For example, for
10355 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
10356 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
10357 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
10358 operator, ERROR_MARK is returned. */
10360 static enum tree_code
10362 {
10366 /* Peek at the next token. */
10370 {
10416 /* Nothing else is an assignment operator. */
10418 }
10420 /* An operator followed by ... is a fold-expression, handled elsewhere. */
10425 /* If it was an assignment operator, consume it. */
10430 }
10432 /* Parse an expression.
10434 expression:
10435 assignment-expression
10436 expression , assignment-expression
10438 CAST_P is true if this expression is the target of a cast.
10439 DECLTYPE_P is true if this expression is the immediate operand of decltype,
10440 except possibly parenthesized or on the RHS of a comma (N3276).
10441 WARN_COMMA_P is true if a comma should be diagnosed.
10443 Returns a representation of the expression. */
10445 static cp_expr
10448 {
10453 {
10454 cp_expr assignment_expression;
10456 /* Parse the next assignment-expression. */
10457 assignment_expression
10460 /* We don't create a temporary for a call that is the immediate operand
10461 of decltype or on the RHS of a comma. But when we see a comma, we
10462 need to create a temporary for a call on the LHS. */
10467 assignment_expression
10471 /* If this is the first assignment-expression, we can just
10472 save it away. */
10475 else
10476 {
10477 /* Create a location with caret at the comma, ranging
10478 from the start of the LHS to the end of the RHS. */
10486 }
10487 /* If the next token is not a comma, or we're in a fold-expression, then
10488 we are done with the expression. */
10492 /* Consume the `,'. */
10495 {
10496 /* [depr.comma.subscript]: A comma expression appearing as
10497 the expr-or-braced-init-list of a subscripting expression
10498 is deprecated. A parenthesized comma expression is not
10499 deprecated. */
10501 "top-level comma expression in array subscript "
10504 }
10506 /* A comma operator cannot appear in a constant-expression. */
10509 }
10512 }
10514 /* Parse a constant-expression.
10516 constant-expression:
10517 conditional-expression
10519 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
10520 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
10521 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
10522 is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
10523 greater than 1, this isn't really a constant-expression, only a
10524 potentially constant-evaluated expression. If STRICT_P is true,
10525 only parse a conditional-expression, otherwise parse an
10526 assignment-expression. See below for rationale. */
10528 static cp_expr
10533 {
10537 cp_expr expression;
10539 /* It might seem that we could simply parse the
10540 conditional-expression, and then check to see if it were
10541 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
10542 one that the compiler can figure out is constant, possibly after
10543 doing some simplifications or optimizations. The standard has a
10544 precise definition of constant-expression, and we must honor
10545 that, even though it is somewhat more restrictive.
10547 For example:
10549 int i[(2, 3)];
10551 is not a legal declaration, because `(2, 3)' is not a
10552 constant-expression. The `,' operator is forbidden in a
10553 constant-expression. However, GCC's constant-folding machinery
10554 will fold this operation to an INTEGER_CST for `3'. */
10556 /* Save the old settings. */
10558 saved_allow_non_integral_constant_expression_p
10561 /* We are now parsing a constant-expression. */
10563 parser->allow_non_integral_constant_expression_p
10567 /* A manifestly constant-evaluated expression is evaluated even in an
10568 unevaluated operand. */
10571 /* Although the grammar says "conditional-expression", when not STRICT_P,
10572 we parse an "assignment-expression", which also permits
10573 "throw-expression" and the use of assignment operators. In the case
10574 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
10575 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
10576 actually essential that we look for an assignment-expression.
10577 For example, cp_parser_initializer_clauses uses this function to
10578 determine whether a particular assignment-expression is in fact
10579 constant. */
10581 {
10582 /* Parse the binary expressions (logical-or-expression). */
10585 /* If the next token is a `?' then we're actually looking at
10586 a conditional-expression; otherwise we're done. */
10589 }
10590 else
10592 /* Restore the old settings. */
10593 parser->integral_constant_expression_p
10595 parser->allow_non_integral_constant_expression_p
10598 {
10599 /* Require an rvalue constant expression here; that's what our
10600 callers expect. Reference constant expressions are handled
10601 separately in e.g. cp_parser_template_argument. */
10610 }
10613 parser->non_integral_constant_expression_p
10617 }
10619 /* Parse __builtin_offsetof.
10621 offsetof-expression:
10622 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
10624 offsetof-member-designator:
10625 id-expression
10626 | offsetof-member-designator "." id-expression
10627 | offsetof-member-designator "[" expression "]"
10628 | offsetof-member-designator "->" id-expression */
10630 static cp_expr
10632 {
10634 tree type;
10635 cp_expr expr;
10636 cp_id_kind dummy;
10638 location_t finish_loc;
10640 /* We're about to accept non-integral-constant things, but will
10641 definitely yield an integral constant expression. Save and
10642 restore these values around our local parsing. */
10648 /* Consume the "__builtin_offsetof" token. */
10650 /* Consume the opening `('. */
10651 matching_parens parens;
10653 /* Parse the type-id. */
10655 {
10657 parser->type_definition_forbidden_message
10661 }
10662 /* Look for the `,'. */
10666 /* Build the (type *)null that begins the traditional offsetof macro. */
10667 tree object_ptr
10671 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
10675 {
10678 {
10680 /* offsetof-member-designator "[" expression "]" */
10686 /* offsetof-member-designator "->" identifier */
10689 /* FALLTHRU */
10692 /* offsetof-member-designator "." identifier */
10700 /* Consume the ")" token. */
10706 /* Error. We know the following require will fail, but
10707 that gives the proper error message. */
10712 }
10713 }
10715 success:
10716 /* Make a location of the form:
10717 __builtin_offsetof (struct s, f)
10718 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
10719 with caret at the type-id, ranging from the start of the
10720 "_builtin_offsetof" token to the close paren. */
10722 /* The result will be an INTEGER_CST, so we need to explicitly
10723 preserve the location. */
10726 failure:
10732 }
10734 /* Parse a trait expression.
10736 Returns a representation of the expression, the underlying type
10737 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
10739 static cp_expr
10741 {
10742 cp_trait_kind kind;
10748 {
10866 }
10868 /* Get location of initial token. */
10871 /* Consume the token. */
10874 matching_parens parens;
10877 {
10880 }
10886 {
10889 {
10892 }
10896 }
10898 {
10900 {
10904 {
10907 }
10911 }
10913 }
10918 /* Construct a location of the form:
10919 __is_trivially_copyable(_Tp)
10920 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
10921 with start == caret, finishing at the close-paren. */
10924 /* Complete the trait expression, which may mean either processing
10925 the trait expr now or saving it for template instantiation. */
10927 {
10936 }
10937 }
10939 /* Parse a lambda expression.
10941 lambda-expression:
10942 lambda-introducer lambda-declarator [opt] compound-statement
10943 lambda-introducer < template-parameter-list > requires-clause [opt]
10944 lambda-declarator [opt] compound-statement
10946 Returns a representation of the expression. */
10948 static cp_expr
10950 {
10952 tree type;
10960 {
10961 /* C++20 allows lambdas in unevaluated context, but one in the type of a
10962 non-type parameter is nonsensical.
10964 Distinguish a lambda in the parameter type from a lambda in the
10965 default argument by looking at local_variables_forbidden_p, which is
10966 only set in default arguments. */
10968 {
10973 }
10974 }
10976 {
10978 {
10980 "lambda-expression in unevaluated context"
10983 }
10985 }
10987 {
10989 {
10993 }
10995 }
10997 /* We may be in the middle of deferred access check. Disable
10998 it now. */
11011 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11014 /* Now that we've started the type, add the capture fields for any
11015 explicit captures. */
11018 {
11019 /* Inside the class, surrounding template-parameter-lists do not apply. */
11020 unsigned int saved_num_template_parameter_lists
11024 bool fully_implicit_function_template_p
11028 bool auto_is_implicit_function_template_parm_p
11039 /* The body of a lambda in a discarded statement is not discarded. */
11043 /* Similarly the body of a lambda in immediate function context is not
11044 in immediate function context. */
11048 /* By virtue of defining a local class, a lambda expression has access to
11049 the private variables of enclosing classes. */
11060 {
11062 }
11064 {
11067 }
11069 /* The capture list was built up in reverse order; fix that now. */
11084 parser->fully_implicit_function_template_p
11088 parser->auto_is_implicit_function_template_parm_p
11090 }
11092 /* This field is only used during parsing of the lambda. */
11095 /* This lambda shouldn't have any proxies left at this point. */
11097 /* And now that we're done, push proxies for an enclosing lambda. */
11100 /* Update the lambda expression to a range. */
11107 else
11115 }
11117 /* Parse the beginning of a lambda expression.
11119 lambda-introducer:
11120 [ lambda-capture [opt] ]
11122 LAMBDA_EXPR is the current representation of the lambda expression. */
11124 static void
11126 {
11127 /* Need commas after the first capture. */
11130 /* Eat the leading `['. */
11133 /* Record default capture mode. "[&" "[=" "[&," "[=," */
11143 {
11149 }
11154 {
11156 tree capture_id;
11157 tree capture_init_expr;
11161 enum capture_kind_type
11162 {
11163 BY_COPY,
11164 BY_REFERENCE
11165 };
11169 {
11172 }
11176 else
11179 /* Possibly capture `this'. */
11181 {
11186 "explicit by-copy capture of %<this%> "
11187 "with by-copy capture default only available with "
11193 this_identifier);
11194 else
11199 }
11201 /* Possibly capture `*this'. */
11204 {
11208 "%<*this%> capture only available with "
11215 this_identifier);
11216 else
11221 }
11223 /* But reject `&this'. */
11226 {
11232 }
11234 /* Remember whether we want to capture as a reference or not. */
11236 {
11239 }
11244 {
11248 "pack init-capture only available with "
11252 }
11254 /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11257 {
11262 }
11264 /* Get the identifier. */
11269 /* Would be nice to have a cp_parser_skip_to_closing_x for general
11270 delimiters, but I modified this to stop on unnested ']' as well. It
11271 was already changed to stop on unnested '}', so the
11272 "closing_parenthesis" name is no more misleading with my change. */
11273 {
11279 }
11281 /* Find the initializer for this capture. */
11285 {
11287 /* An explicit initializer exists. */
11290 "lambda capture initializers "
11296 {
11299 }
11302 }
11303 else
11304 {
11307 /* Turn the identifier into an id-expression. */
11308 capture_init_expr
11313 {
11316 }
11319 {
11322 capture_init_expr);
11327 }
11330 {
11333 capture_init_expr))
11337 }
11339 capture_init_expr
11340 = finish_id_expression
11342 capture_init_expr,
11356 {
11361 {
11362 /* If what follows is an initializer, the second '...' is
11363 invalid. But for cases like [...xs...], the first one
11364 is invalid. */
11371 }
11372 }
11373 }
11377 {
11382 capture_id);
11386 "capture of %qD redundant with by-reference capture "
11388 }
11390 /* Check for duplicates.
11391 Optimize for the zero or one explicit captures cases and only create
11392 the hash_set after adding second capture. */
11400 else
11401 {
11404 }
11408 else
11411 explicit_init_p);
11413 /* If there is any qualification still in effect, clear it
11414 now; we will be starting fresh with the next capture. */
11418 }
11421 }
11423 /* Parse the (optional) middle of a lambda expression.
11425 lambda-declarator:
11426 ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
11427 lambda-specifiers (C++23)
11429 lambda-specifiers:
11430 decl-specifier-seq [opt] noexcept-specifier [opt]
11431 attribute-specifier-seq [opt] trailing-return-type [opt]
11433 LAMBDA_EXPR is the current representation of the lambda expression. */
11435 static bool
11437 {
11438 /* 5.1.1.4 of the standard says:
11439 If a lambda-expression does not include a lambda-declarator, it is as if
11440 the lambda-declarator were ().
11441 This means an empty parameter list, no attributes, and no exception
11442 specification. */
11453 cp_decl_specifier_seq lambda_specs;
11455 /* A lambda op() is const unless explicitly 'mutable'. */
11458 /* The template-parameter-list is optional, but must begin with
11459 an opening angle if present. */
11461 {
11464 "lambda templates are only available with "
11468 "lambda templates are only available with "
11476 /* We may have a constrained generic lambda; parse the requires-clause
11477 immediately after the template-parameter-list and combine with any
11478 shorthand constraints present. */
11481 {
11486 }
11488 /* We just processed one more parameter list. */
11490 }
11492 /* Committee discussion supports allowing attributes here. */
11495 /* The parameter-declaration-clause is optional (unless
11496 template-parameter-list was given), but must begin with an
11497 opening parenthesis if present. */
11499 {
11501 /* For C++20, before parsing the parameter list check if there is
11502 a consteval specifier in the corresponding decl-specifier-seq. */
11504 {
11507 {
11510 {
11513 }
11514 }
11515 }
11517 matching_parens parens;
11525 /* Parse parameters. */
11526 param_list
11527 = cp_parser_parameter_declaration_clause
11530 /* Default arguments shall not be specified in the
11531 parameter-declaration-clause of a lambda-declarator. */
11536 OPT_Wc__14_extensions,
11541 }
11545 /* In the decl-specifier-seq of the lambda-declarator, each
11546 decl-specifier shall either be mutable or constexpr. */
11550 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
11554 {
11556 "parameter declaration before lambda declaration "
11557 "specifiers only optional with %<-std=c++2b%> or "
11560 }
11563 {
11569 }
11573 {
11575 "parameter declaration before lambda transaction "
11576 "qualifier only optional with %<-std=c++2b%> or "
11579 }
11581 /* Parse optional exception specification. */
11582 exception_spec
11586 {
11588 "parameter declaration before lambda exception "
11589 "specification only optional with %<-std=c++2b%> or "
11592 }
11594 /* GCC 8 accepted attributes here, and this is the place for standard C++11
11595 attributes that appertain to the function type. */
11598 else
11601 /* Parse optional trailing return type. */
11603 {
11606 "parameter declaration before lambda trailing "
11607 "return type only optional with %<-std=c++2b%> or "
11611 }
11613 /* Also allow GNU attributes at the very end of the declaration, the usual
11614 place for GNU attributes. */
11619 {
11620 /* Parse optional trailing requires clause. */
11623 /* The function parameters must be in scope all the way until after the
11624 trailing-return-type in case of decltype. */
11626 }
11628 /* Create the function call operator.
11630 Messing with declarators like this is no uglier than building up the
11631 FUNCTION_DECL by hand, and this is less likely to get out of sync with
11632 other code. */
11633 {
11634 cp_decl_specifier_seq return_type_specs;
11636 tree fco;
11643 {
11647 else
11649 "lambda only available with %<-std=c++17%> or "
11651 }
11662 VIRT_SPEC_UNSPECIFIED,
11663 REF_QUAL_NONE,
11664 tx_qual,
11665 exception_spec,
11666 return_type,
11667 trailing_requires_clause,
11668 UNKNOWN_LOCATION);
11672 declarator,
11675 {
11678 /* Give the object parameter a different name. */
11681 }
11683 {
11687 }
11696 }
11697 }
11699 /* Parse the body of a lambda expression, which is simply
11701 compound-statement
11703 but which requires special handling.
11704 LAMBDA_EXPR is the current representation of the lambda expression. */
11706 static void
11708 {
11710 unsigned char local_variables_forbidden_p
11714 /* The body of a lambda-expression is not a subexpression of the enclosing
11715 expression. */
11716 cp_evaluated ev;
11720 else
11721 /* Still increment function_depth so that we don't GC in the
11722 middle of an expression. */
11730 /* Clear this in case we're in the middle of a default argument. */
11734 {
11739 /* Originally C++11 required us to peek for 'return expr'; and
11740 process it specially here to deduce the return type. N3638
11741 removed the need for that. */
11745 }
11752 else
11754 }
11756 /* Statements [gram.stmt.stmt] */
11758 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
11760 static void
11762 {
11766 /* A concept is never expanded normally. */
11772 }
11774 struct cp_omp_attribute_data
11775 {
11778 c_omp_directive_kind kind;
11779 };
11781 /* Handle omp::directive and omp::sequence attributes in ATTRS
11782 (if any) at the start of a statement or in attribute-declaration. */
11784 static tree
11786 {
11797 {
11798 cnt++;
11800 {
11806 {
11808 "mixing OpenMP directives with attribute and pragma "
11812 }
11815 {
11823 else
11826 }
11832 {
11834 "unknown OpenMP directive name in %<omp::directive%>"
11837 }
11840 {
11841 /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
11842 depend clause. */
11851 }
11853 {
11854 /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
11858 paren_depth++;
11860 paren_depth--;
11871 {
11874 }
11875 }
11880 }
11881 cp_omp_attribute_data v = {};
11884 }
11885 else
11898 {
11903 }
11904 else
11905 {
11907 {
11910 }
11911 }
11914 {
11916 "OpenMP construct among %<omp::directive%> attributes"
11917 " requires all %<omp::directive%> attributes on the"
11920 }
11922 {
11924 "multiple OpenMP standalone directives among"
11925 " %<omp::directive%> attributes must be all within the"
11928 }
11934 {
11936 "standalone OpenMP directives in %<omp::directive%> attribute"
11939 }
11941 {
11945 {
11947 "mixing OpenMP directives with attribute and pragma "
11950 }
11951 }
11955 tokens++;
11960 {
11967 cp_token tok = {};
11975 tok = {};
11980 }
11981 cp_token tok = {};
11993 /* Move the current source position to that of the first token in the
11994 new lexer. */
11997 }
11999 /* Handle omp::directive and omp::sequence attributes in *PATTRS
12000 (if any) at the start or after declaration-id of a declaration. */
12002 static void
12006 {
12017 {
12019 {
12026 {
12034 else
12037 }
12047 {
12049 {
12052 }
12054 {
12056 "mixing OpenMP directives with attribute and "
12059 }
12060 }
12061 }
12062 }
12065 {
12070 else
12073 }
12078 {
12087 }
12089 }
12091 /* Parse a statement.
12093 statement:
12094 labeled-statement
12095 expression-statement
12096 compound-statement
12097 selection-statement
12098 iteration-statement
12099 jump-statement
12100 declaration-statement
12101 try-block
12103 C++11:
12105 statement:
12106 labeled-statement
12107 attribute-specifier-seq (opt) expression-statement
12108 attribute-specifier-seq (opt) compound-statement
12109 attribute-specifier-seq (opt) selection-statement
12110 attribute-specifier-seq (opt) iteration-statement
12111 attribute-specifier-seq (opt) jump-statement
12112 declaration-statement
12113 attribute-specifier-seq (opt) try-block
12115 init-statement:
12116 expression-statement
12117 simple-declaration
12118 alias-declaration
12120 TM Extension:
12122 statement:
12123 atomic-statement
12125 IN_COMPOUND is true when the statement is nested inside a
12126 cp_parser_compound_statement; this matters for certain pragmas.
12128 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12129 is a (possibly labeled) if statement which is not enclosed in braces
12130 and has an else clause. This is used to implement -Wparentheses.
12132 CHAIN is a vector of if-else-if conditions. */
12134 static void
12138 {
12145 restart:
12148 /* There is no statement yet. */
12155 /* In obj-c++, seeing '[[' might be the either the beginning of
12156 c++11 attributes, or a nested objc-message-expression. So
12157 let's parse the c++11 attributes tentatively. */
12163 {
12166 }
12169 /* Peek at the next token. */
12175 {
12179 {
12206 }
12212 {
12214 std_attrs);
12216 }
12217 }
12220 /* Remember the location of the first token in the statement. */
12224 /* If this is a keyword, then that will often determine what kind of
12225 statement we have. */
12227 {
12231 {
12234 /* Looks like a labeled-statement with a case label.
12235 Parse the label, and then use tail recursion to parse
12236 the statement. */
12264 /* Objective-C++ exception-handling constructs. */
12280 /* This must be a namespace alias definition. */
12282 {
12283 /* Attributes should be parsed as part of the
12284 declaration, so let's un-parse them. */
12287 }
12305 /* It might be a keyword like `int' that can start a
12306 declaration-statement. */
12308 }
12309 }
12311 {
12312 /* If the next token is a `:', then we are looking at a
12313 labeled-statement. */
12316 {
12317 /* Looks like a labeled-statement with an ordinary label.
12318 Parse the label, and then use tail recursion to parse
12319 the statement. */
12325 }
12326 }
12327 /* Anything that starts with a `{' must be a compound-statement. */
12329 {
12332 }
12333 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
12334 a statement all its own. */
12336 {
12337 do_pragma:;
12340 /* Only certain OpenMP pragmas are attached to statements, and thus
12341 are considered statements themselves. All others are not. In
12342 the context of a compound, accept the pragma as a "statement" and
12343 return so that we can check for a close brace. Otherwise we
12344 require a real statement and must go back and read one. */
12352 {
12354 {
12361 }
12364 }
12372 }
12374 {
12377 }
12379 /* Everything else must be a declaration-statement or an
12380 expression-statement. Try for the declaration-statement
12381 first, unless we are looking at a `;', in which case we know that
12382 we have an expression-statement. */
12384 {
12386 {
12388 /* Attributes should be parsed as part of the declaration,
12389 so let's un-parse them. */
12394 /* Try to parse the declaration-statement. */
12397 /* If that worked, we're done. */
12400 /* It didn't work, restore the post-attribute position. */
12402 {
12405 {
12410 i++;
12412 {
12418 /* Don't handle OpenMP attribs on keywords that
12419 always start a declaration statement but don't
12420 accept attribute before it and therefore
12421 the tentative cp_parser_declaration_statement
12422 fails to parse because of that. */
12427 }
12430 {
12432 std_attrs
12433 = cp_parser_handle_statement_omp_attributes
12439 }
12440 }
12441 }
12442 }
12443 /* All preceding labels have been parsed at this point. */
12449 /* Look for an expression-statement instead. */
12452 /* Handle [[fallthrough]];. */
12454 {
12455 /* The next token after the fallthrough attribute is ';'. */
12457 {
12458 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12460 IFN_FALLTHROUGH,
12463 }
12464 else
12468 }
12469 }
12471 /* Set the line number for the statement. */
12475 /* Allow "[[fallthrough]];", but warn otherwise. */
12478 OPT_Wattributes,
12480 }
12482 /* Append ATTR to attribute list ATTRS. */
12484 static tree
12486 {
12492 }
12494 /* Parse the label for a labeled-statement, i.e.
12496 identifier :
12497 case constant-expression :
12498 default :
12500 GNU Extension:
12501 case constant-expression ... constant-expression : statement
12503 When a label is parsed without errors, the label is added to the
12504 parse tree by the finish_* functions, so this function doesn't
12505 have to return the label. */
12507 static void
12509 {
12514 /* The next token should be an identifier. */
12518 {
12521 }
12523 /* Remember whether this case or a user-defined label is allowed to fall
12524 through to. */
12529 {
12531 {
12535 /* Consume the `case' token. */
12537 /* Parse the constant-expression. */
12544 {
12545 /* Consume the `...' token. */
12551 /* We don't need to emit warnings here, as the common code
12552 will do this for us. */
12553 }
12554 else
12558 {
12561 {
12564 }
12565 }
12566 else
12569 expr);
12570 }
12574 /* Consume the `default' token. */
12578 {
12581 {
12584 }
12585 }
12586 else
12591 /* Anything else must be an ordinary label. */
12596 }
12598 /* Require the `:' token. */
12601 /* An ordinary label may optionally be followed by attributes.
12602 However, this is only permitted if the attributes are then
12603 followed by a semicolon. This is because, for backward
12604 compatibility, when parsing
12605 lab: __attribute__ ((unused)) int i;
12606 we want the attribute to attach to "i", not "lab". */
12609 {
12610 tree attrs;
12614 /* And fallthrough always binds to the expression-statement. */
12619 ;
12620 else
12622 }
12628 }
12630 /* Parse an expression-statement.
12632 expression-statement:
12633 expression [opt] ;
12635 Returns the new EXPR_STMT -- or NULL_TREE if the expression
12636 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
12637 indicates whether this expression-statement is part of an
12638 expression statement. */
12640 static tree
12642 {
12647 /* There might be attribute fallthrough. */
12650 /* If the next token is a ';', then there is no expression
12651 statement. */
12653 {
12657 {
12660 }
12661 }
12663 /* Handle [[fallthrough]];. */
12665 {
12666 /* The next token after the fallthrough attribute is ';'. */
12668 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12671 else
12675 }
12677 /* Allow "[[fallthrough]];", but warn otherwise. */
12682 /* Give a helpful message for "A<T>::type t;" and the like. */
12685 {
12692 {
12693 /* A::A a; */
12698 }
12699 }
12701 /* Consume the final `;'. */
12706 /* This is the final expression statement of a statement
12707 expression. */
12713 }
12715 /* Parse a compound-statement.
12717 compound-statement:
12718 { statement-seq [opt] }
12720 GNU extension:
12722 compound-statement:
12723 { label-declaration-seq [opt] statement-seq [opt] }
12725 label-declaration-seq:
12726 label-declaration
12727 label-declaration-seq label-declaration
12729 Returns a tree representing the statement. */
12731 static tree
12734 {
12735 tree compound_stmt;
12736 matching_braces braces;
12738 /* Consume the `{'. */
12745 /* Begin the compound-statement. */
12747 /* If the next keyword is `__label__' we have a label declaration. */
12750 /* Parse an (optional) statement-seq. */
12756 /* Consume the `}'. */
12759 /* Finish the compound-statement. */
12763 }
12765 /* Parse an (optional) statement-seq.
12767 statement-seq:
12768 statement
12769 statement-seq [opt] statement */
12771 static void
12773 {
12774 /* Scan statements until there aren't any more. */
12776 {
12779 /* If we are looking at a `}', then we have run out of
12780 statements; the same is true if we have reached the end
12781 of file, or have stumbled upon a stray '@end'. */
12788 /* If we are in a compound statement and find 'else' then
12789 something went wrong. */
12791 {
12794 else
12795 {
12798 }
12799 }
12801 /* Parse the statement. */
12803 }
12804 }
12806 /* Return true if this is the C++20 version of range-based-for with
12807 init-statement. */
12809 static bool
12811 {
12814 /* Save tokens so that we can put them back. */
12817 /* There has to be an unnested ; followed by an unnested :. */
12820 CPP_SEMICOLON,
12824 /* We found the semicolon, eat it now. */
12827 /* Now look for ':' that is not nested in () or {}. */
12830 CPP_COLON,
12833 out:
12834 /* Roll back the tokens we skipped. */
12838 }
12840 /* Return true if we're looking at (init; cond), false otherwise. */
12842 static bool
12844 {
12845 /* Save tokens so that we can put them back. */
12848 /* Look for ';' that is not nested in () or {}. */
12851 CPP_SEMICOLON,
12854 /* Roll back the tokens we skipped. */
12858 }
12860 /* Parse a selection-statement.
12862 selection-statement:
12863 if ( init-statement [opt] condition ) statement
12864 if ( init-statement [opt] condition ) statement else statement
12865 switch ( init-statement [opt] condition ) statement
12867 Returns the new IF_STMT or SWITCH_STMT.
12869 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12870 is a (possibly labeled) if statement which is not enclosed in
12871 braces and has an else clause. This is used to implement
12872 -Wparentheses.
12874 CHAIN is a vector of if-else-if conditions. This is used to implement
12875 -Wduplicated-cond. */
12877 static tree
12880 {
12883 token_indent_info guard_tinfo;
12888 /* Peek at the next token. */
12892 /* See what kind of keyword it is. */
12895 {
12898 {
12899 tree statement;
12900 tree condition;
12905 RID_CONSTEXPR))
12906 {
12911 "%<if constexpr%> only available with "
12913 }
12916 {
12918 RID_CONSTEVAL))
12922 RID_CONSTEVAL))
12923 {
12926 }
12927 }
12929 {
12933 "%<if consteval%> only available with "
12944 {
12947 }
12953 {
12954 location_t before_loc
12960 }
12964 /* If the next token is `else', parse the else-clause. */
12966 RID_ELSE))
12967 {
12971 /* Consume the `else' keyword. */
12977 {
12981 }
12985 guard_tinfo);
12988 {
12989 location_t before_loc
12994 }
12997 }
13001 {
13005 }
13009 }
13011 /* Look for the `('. */
13012 matching_parens parens;
13014 {
13017 }
13019 /* Begin the selection-statement. */
13021 {
13024 }
13025 else
13028 /* Parse the optional init-statement. */
13030 {
13031 tree decl;
13034 OPT_Wc__17_extensions,
13035 "init-statement in selection statements only available "
13038 /* A non-empty init-statement can have arbitrary side
13039 effects. */
13042 }
13044 /* Parse the condition. */
13046 /* Look for the `)'. */
13052 {
13056 /* Add the condition. */
13063 /* Parse the then-clause. */
13067 /* Outside a template, the non-selected branch of a constexpr
13068 if is a 'discarded statement', i.e. unevaluated. */
13073 {
13076 }
13079 guard_tinfo);
13086 {
13090 }
13092 /* If the next token is `else', parse the else-clause. */
13094 RID_ELSE))
13095 {
13099 {
13102 }
13104 guard_tinfo
13106 /* Consume the `else' keyword. */
13109 {
13111 RID_IF)
13113 {
13114 /* We've got "if (COND) else if (COND2)". Start
13115 the condition chain and add COND as the first
13116 element. */
13120 {
13121 /* Wrap it in a NOP_EXPR so that we can set the
13122 location of the condition. */
13124 condition);
13127 }
13128 }
13130 RID_IF))
13131 /* This is if-else without subsequent if. Zap the
13132 condition chain; we would have already warned at
13133 this point. */
13135 }
13137 /* Parse the else-clause. */
13143 /* If we are currently parsing a then-clause, then
13144 IF_P will not be NULL. We set it to true to
13145 indicate that this if statement has an else clause.
13146 This may trigger the Wparentheses warning below
13147 when we get back up to the parent if statement. */
13152 {
13156 }
13157 }
13158 else
13159 {
13160 /* This if statement does not have an else clause. If
13161 NESTED_IF is true, then the then-clause has an if
13162 statement which does have an else clause. We warn
13163 about the potential ambiguity. */
13166 "suggest explicit braces to avoid ambiguous"
13169 /* We don't need the condition chain anymore. */
13171 }
13173 /* Now we're all done with the if-statement. */
13175 }
13176 else
13177 {
13181 /* Add the condition. */
13184 /* Parse the body of the switch-statement. */
13190 guard_tinfo);
13194 /* Now we're all done with the switch-statement. */
13196 }
13199 }
13205 }
13206 }
13208 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
13209 If we have seen at least one decl-specifier, and the next token is not
13210 a parenthesis (after "int (" we might be looking at a functional cast)
13211 neither we are dealing with a concept-check expression then we must be
13212 looking at a declaration. */
13214 static void
13217 {
13226 }
13228 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
13229 The declarator shall not specify a function or an array. Returns
13230 TRUE if the declarator is valid, FALSE otherwise. */
13232 static bool
13235 location_t loc)
13236 {
13240 {
13245 else
13253 }
13254 else
13256 }
13258 /* Parse a condition.
13260 condition:
13261 expression
13262 type-specifier-seq declarator = initializer-clause
13263 type-specifier-seq declarator braced-init-list
13265 GNU Extension:
13267 condition:
13268 type-specifier-seq declarator asm-specification [opt]
13269 attributes [opt] = assignment-expression
13271 Returns the expression that should be tested. */
13273 static tree
13275 {
13276 cp_decl_specifier_seq type_specifiers;
13280 /* Try the declaration first. */
13282 /* New types are not allowed in the type-specifier-seq for a
13283 condition. */
13285 parser->type_definition_forbidden_message
13287 /* Parse the type-specifier-seq. */
13289 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
13292 /* Restore the saved message. */
13295 /* Gather the attributes that were provided with the
13296 decl-specifiers. */
13301 /* If all is well, we might be looking at a declaration. */
13303 {
13304 tree decl;
13305 tree asm_specification;
13306 tree attributes;
13311 /* Parse the declarator. */
13313 CP_PARSER_FLAGS_NONE,
13319 /* Parse the attributes. */
13321 /* Parse the asm-specification. */
13323 /* If the next token is not an `=' or '{', then we might still be
13324 looking at an expression. For example:
13326 if (A(a).x)
13328 looks like a decl-specifier-seq and a declarator -- but then
13329 there is no `=', so this is an expression. */
13334 /* If we did see an `=' or '{', then we are looking at a declaration
13335 for sure. */
13337 {
13338 tree pushed_scope;
13345 /* Create the declaration. */
13352 /* Parse the initializer. */
13354 {
13358 }
13360 {
13361 /* Consume the `='. */
13365 }
13366 else
13367 {
13370 }
13374 /* Process the initializer. */
13377 asm_specification,
13378 flags);
13384 }
13385 }
13386 /* If we didn't even get past the declarator successfully, we are
13387 definitely not looking at a declaration. */
13388 else
13391 /* Otherwise, we are looking at an expression. */
13393 }
13395 /* Parses a for-statement or range-for-statement until the closing ')',
13396 not included. */
13398 static tree
13400 {
13404 /* Begin the for-statement. */
13407 /* Maybe parse the optional init-statement in a range-based for loop. */
13409 /* Checked for diagnostic purposes only. */
13411 {
13412 tree dummy;
13415 {
13417 OPT_Wc__20_extensions,
13418 "range-based %<for%> loops with initializer only "
13421 }
13422 }
13424 /* Parse the initialization. */
13430 else
13432 }
13434 static tree
13437 {
13438 /* Normal for loop */
13441 tree stmt;
13444 /* The init-statement has already been parsed in
13445 cp_parser_init_statement, so no work is needed here. */
13448 /* If there's a condition, process it. */
13452 {
13456 }
13458 {
13462 }
13464 /* Look for the `;'. */
13467 /* If there's an expression, process it. */
13473 }
13475 /* Tries to parse a range-based for-statement:
13477 range-based-for:
13478 decl-specifier-seq declarator : expression
13480 The decl-specifier-seq declarator and the `:' are already parsed by
13481 cp_parser_init_statement. If processing_template_decl it returns a
13482 newly created RANGE_FOR_STMT; if not, it is converted to a
13483 regular FOR_STMT. */
13485 static tree
13488 {
13495 /* Get the range declaration momentarily out of the way so that
13496 the range expression doesn't clash with it. */
13498 {
13500 {
13502 /* For decomposition declaration get all of the corresponding
13503 declarations out of the way. */
13507 {
13513 {
13519 }
13520 }
13521 }
13523 {
13528 }
13529 }
13532 {
13535 }
13536 else
13539 /* Put the range declaration(s) back into scope. */
13541 {
13545 }
13547 /* finish_omp_for has its own code for the following, so just
13548 return the range_expr instead. */
13552 /* If in template, STMT is converted to a normal for-statement
13553 at instantiation. If not, it is done just ahead. */
13555 {
13565 /* do_auto_deduction doesn't mess with template init-lists. */
13568 }
13569 else
13570 {
13574 unroll);
13575 }
13577 }
13579 /* Subroutine of cp_convert_range_for: given the initializer expression,
13580 builds up the range temporary. */
13582 static tree
13584 {
13585 /* Find out the type deduced by the declaration
13586 `auto &&__range = range_expr'. */
13591 /* Create the __range variable. */
13598 }
13600 /* Used by cp_parser_range_for in template context: we aren't going to
13601 do a full conversion yet, but we still need to resolve auto in the
13602 type of the for-range-declaration if present. This is basically
13603 a shortcut version of cp_convert_range_for. */
13605 static void
13607 {
13610 {
13613 iter_type = (cp_parser_perform_range_for_lookup
13616 {
13618 iter_type);
13621 tf_warning_or_error);
13624 tf_warning_or_error,
13625 adc_variable_type);
13626 }
13627 }
13628 }
13630 /* Warns when the loop variable should be changed to a reference type to
13631 avoid unnecessary copying. I.e., from
13633 for (const auto x : range)
13635 where range returns a reference, to
13637 for (const auto &x : range)
13639 if this version doesn't make a copy.
13641 This function also warns when the loop variable is initialized with
13642 a value of a different type resulting in a copy:
13644 int arr[10];
13645 for (const double &x : arr)
13647 DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
13648 This function is never called when processing_template_decl is on. */
13650 static void
13652 {
13664 {
13666 {
13667 auto_diagnostic_group d;
13669 "loop variable %qD of type %qT binds to a temporary "
13672 {
13674 TYPE_QUAL_CONST);
13679 }
13680 }
13682 }
13686 /* Since small trivially copyable types are cheap to copy, we suppress the
13687 warning for them. 64B is a common size of a cache line. */
13694 /* If we could initialize the reference directly, it wouldn't involve any
13695 copies. */
13699 auto_diagnostic_group d;
13703 {
13707 }
13708 }
13710 /* Converts a range-based for-statement into a normal
13711 for-statement, as per the definition.
13713 for (RANGE_DECL : RANGE_EXPR)
13714 BLOCK
13716 should be equivalent to:
13718 {
13719 auto &&__range = RANGE_EXPR;
13720 for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
13721 __begin != __end;
13722 ++__begin)
13723 {
13724 RANGE_DECL = *__begin;
13725 BLOCK
13726 }
13727 }
13729 If RANGE_EXPR is an array:
13730 BEGIN_EXPR = __range
13731 END_EXPR = __range + ARRAY_SIZE(__range)
13732 Else if RANGE_EXPR has a member 'begin' or 'end':
13733 BEGIN_EXPR = __range.begin()
13734 END_EXPR = __range.end()
13735 Else:
13736 BEGIN_EXPR = begin(__range)
13737 END_EXPR = end(__range);
13739 If __range has a member 'begin' but not 'end', or vice versa, we must
13740 still use the second alternative (it will surely fail, however).
13741 When calling begin()/end() in the third alternative we must use
13742 argument dependent lookup, but always considering 'std' as an associated
13743 namespace. */
13745 tree
13749 {
13757 /* If an error happened previously do nothing or else a lot of
13758 unhelpful errors would be issued. */
13760 else
13761 {
13762 tree range_temp;
13766 /* Can't bind a reference to an array of runtime bound. */
13768 else
13769 {
13774 LOOKUP_ONLYCONVERTING);
13776 }
13779 }
13781 /* The new for initialization statement. */
13783 iter_type);
13789 LOOKUP_ONLYCONVERTING);
13799 LOOKUP_ONLYCONVERTING);
13803 /* The new for condition. */
13810 /* The new increment expression. */
13813 tf_warning_or_error);
13819 /* The declaration is initialized with *__begin inside the loop body. */
13824 LOOKUP_ONLYCONVERTING);
13831 }
13833 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
13834 We need to solve both at the same time because the method used
13835 depends on the existence of members begin or end.
13836 Returns the type deduced for the iterator expression. */
13838 static tree
13840 {
13842 {
13845 }
13848 {
13853 }
13855 {
13856 /* If RANGE is an array, we will use pointer arithmetic. */
13859 range,
13863 }
13864 else
13865 {
13866 /* If it is not an array, we must do a bit of magic. */
13876 tf_warning_or_error);
13879 tf_warning_or_error);
13882 {
13883 /* Use the member functions. */
13886 }
13887 else
13888 {
13889 /* Use global functions with ADL. */
13890 releasing_vec vec;
13895 tf_warning_or_error);
13897 tf_warning_or_error);
13899 tf_warning_or_error);
13901 tf_warning_or_error);
13902 }
13904 /* Last common checks. */
13906 {
13907 /* If one of the expressions is an error do no more checks. */
13910 }
13913 /* Can happen, when, eg, in a template context, Koenig lookup
13914 can't resolve begin/end (c++/58503). */
13916 else
13917 {
13919 /* The unqualified type of the __begin and __end temporaries should
13920 be the same, as required by the multiple auto declaration. */
13922 {
13929 /* P0184R0 allows __begin and __end to have different types,
13930 but make sure they are comparable so we can give a better
13932 else
13936 }
13938 }
13939 }
13940 }
13942 /* Helper function for cp_parser_perform_range_for_lookup.
13943 Builds a tree for RANGE.IDENTIFIER(). */
13945 static tree
13947 {
13955 releasing_vec vec;
13959 tf_warning_or_error);
13961 }
13963 /* Parse an iteration-statement.
13965 iteration-statement:
13966 while ( condition ) statement
13967 do statement while ( expression ) ;
13968 for ( init-statement condition [opt] ; expression [opt] )
13969 statement
13971 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
13973 static tree
13976 {
13979 tree statement;
13981 token_indent_info guard_tinfo;
13983 /* Peek at the next token. */
13990 /* Remember whether or not we are already within an iteration
13991 statement. */
13994 /* See what kind of keyword it is. */
13997 {
13999 {
14000 tree condition;
14002 /* Begin the while-statement. */
14004 /* Look for the `('. */
14005 matching_parens parens;
14007 /* Parse the condition. */
14010 /* Look for the `)'. */
14012 /* Parse the dependent statement. */
14018 /* We're done with the while-statement. */
14020 }
14024 {
14025 tree expression;
14027 /* Begin the do-statement. */
14029 /* Parse the body of the do-statement. */
14036 /* Look for the `while' keyword. */
14038 /* Look for the `('. */
14039 matching_parens parens;
14041 /* Parse the expression. */
14043 /* We're done with the do-statement. */
14045 /* Look for the `)'. */
14047 /* Look for the `;'. */
14049 }
14053 {
14054 /* Look for the `('. */
14055 matching_parens parens;
14060 /* Look for the `)'. */
14063 /* Parse the body of the for-statement. */
14070 /* We're done with the for-statement. */
14072 }
14079 }
14082 }
14084 /* Parse an init-statement or the declarator of a range-based-for.
14085 Returns true if a range-based-for declaration is seen.
14087 init-statement:
14088 expression-statement
14089 simple-declaration
14090 alias-declaration */
14092 static bool
14094 {
14095 /* If the next token is a `;', then we have an empty
14096 expression-statement. Grammatically, this is also a
14097 simple-declaration, but an invalid one, because it does not
14098 declare anything. Therefore, if we did not handle this case
14099 specially, we would issue an error message about an invalid
14100 declaration. */
14102 {
14106 /* A colon is used in range-based for. */
14109 /* We're going to speculatively look for a declaration, falling back
14110 to an expression, if necessary. */
14114 {
14120 OPT_Wc__23_extensions,
14121 "alias-declaration in init-statement only "
14123 }
14124 else
14125 /* Parse the declaration. */
14128 decl);
14131 {
14132 /* It is a range-for, consume the ':'. */
14137 OPT_Wc__11_extensions,
14138 "range-based %<for%> loops only available with "
14140 }
14142 /* The ';' is not consumed yet because we told
14143 cp_parser_simple_declaration not to. */
14148 /* If the tentative parse failed, then we shall need to look for an
14149 expression-statement. */
14150 }
14151 /* If we are here, it is an expression-statement. */
14154 }
14156 /* Parse a jump-statement.
14158 jump-statement:
14159 break ;
14160 continue ;
14161 return expression [opt] ;
14162 return braced-init-list ;
14163 coroutine-return-statement;
14164 goto identifier ;
14166 GNU extension:
14168 jump-statement:
14169 goto * expression ;
14171 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
14173 static tree
14175 {
14181 /* Peek at the next token. */
14186 /* See what kind of keyword it is. */
14189 {
14193 {
14210 }
14216 {
14220 /* Fall through. */
14230 }
14236 {
14237 tree expr;
14241 {
14245 }
14248 else
14249 /* If the next token is a `;', then there is no
14250 expression. */
14252 /* Build the return-statement, check co-return first, since type
14253 deduction is not valid there. */
14258 else
14260 /* Look for the final `;'. */
14262 }
14269 {
14273 }
14275 /* Create the goto-statement. */
14277 {
14278 /* Issue a warning about this use of a GNU extension. */
14280 /* Consume the '*' token. */
14282 /* Parse the dependent expression. */
14284 }
14285 else
14287 /* Look for the final `;'. */
14294 }
14297 }
14299 /* Parse a declaration-statement.
14301 declaration-statement:
14302 block-declaration */
14304 static void
14306 {
14309 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14312 /* Parse the block-declaration. */
14315 /* Free any declarators allocated. */
14317 }
14319 /* Some dependent statements (like `if (cond) statement'), are
14320 implicitly in their own scope. In other words, if the statement is
14321 a single statement (as opposed to a compound-statement), it is
14322 none-the-less treated as if it were enclosed in braces. Any
14323 declarations appearing in the dependent statement are out of scope
14324 after control passes that point. This function parses a statement,
14325 but ensures that is in its own scope, even if it is not a
14326 compound-statement.
14328 If IF_P is not NULL, *IF_P is set to indicate whether the statement
14329 is a (possibly labeled) if statement which is not enclosed in
14330 braces and has an else clause. This is used to implement
14331 -Wparentheses.
14333 CHAIN is a vector of if-else-if conditions. This is used to implement
14334 -Wduplicated-cond.
14336 Returns the new statement. */
14338 static tree
14342 {
14343 tree statement;
14346 token_indent_info body_tinfo
14352 /* Mark if () ; with a special NOP_EXPR. */
14354 {
14365 }
14366 /* if a compound is opened, we simply parse the statement directly. */
14369 /* If the token is not a `{', then we must take special action. */
14370 else
14371 {
14372 /* Create a compound-statement. */
14374 /* Parse the dependent-statement. */
14377 /* Finish the dummy compound-statement. */
14379 }
14381 token_indent_info next_tinfo
14390 /* Return the statement. */
14392 }
14394 /* For some dependent statements (like `while (cond) statement'), we
14395 have already created a scope. Therefore, even if the dependent
14396 statement is a compound-statement, we do not want to create another
14397 scope. */
14399 static void
14402 {
14403 /* If the token is a `{', then we must take special action. */
14405 {
14406 token_indent_info body_tinfo
14412 token_indent_info next_tinfo
14421 }
14422 else
14423 {
14424 /* Avoid calling cp_parser_compound_statement, so that we
14425 don't create a new scope. Do everything else by hand. */
14426 matching_braces braces;
14428 /* If the next keyword is `__label__' we have a label declaration. */
14431 /* Parse an (optional) statement-seq. */
14434 }
14435 }
14437 /* Modules */
14439 /* Parse a module-name,
14440 identifier
14441 module-name . identifier
14442 header-name
14444 Returns a pointer to module object, NULL. */
14448 {
14451 {
14455 }
14460 {
14463 }
14466 {
14468 {
14471 }
14482 }
14485 }
14487 /* Named module-declaration
14488 __module ; PRAGMA_EOL
14489 __module private ; PRAGMA_EOL (unimplemented)
14490 [__export] __module module-name attr-spec-seq-opt ; PRAGMA_EOL
14491 */
14493 static module_parse
14496 {
14497 /* We're a pseudo pragma. */
14502 {
14506 }
14509 {
14510 /* Start global module fragment. */
14515 }
14520 {
14529 "private module fragment only permitted in purview"
14531 else
14532 {
14535 }
14536 }
14538 {
14539 /* Neither the first declaration, nor in a GMF. */
14542 skip_eol:
14544 }
14545 else
14546 {
14556 }
14559 }
14561 /* Import-declaration
14562 [__export] __import module-name attr-spec-seq-opt ; PRAGMA_EOL */
14564 static void
14567 {
14568 /* We're a pseudo pragma. */
14576 {
14579 note_lexer:
14581 " disambiguation, to prevent this being considered a"
14583 skip_eol:
14585 }
14587 {
14590 }
14591 else
14592 {
14604 /* Module-purview imports must not be from source inclusion
14605 [cpp.import]/7 */
14618 }
14619 }
14621 /* export-declaration.
14623 export declaration
14624 export { declaration-seq-opt } */
14626 static void
14628 {
14647 {
14654 }
14655 else
14656 {
14657 /* Explicitly check if the next tokens might be a
14658 module-directive line, so we can give a clearer error message
14659 about why the directive will be rejected. */
14666 }
14669 }
14671 /* Declarations [gram.dcl.dcl] */
14673 /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
14674 is the top-level declaration sequence. That affects whether we
14675 deal with module-preamble.
14677 declaration-seq:
14678 declaration
14679 declaration-seq declaration */
14681 static void
14683 {
14685 {
14691 else
14693 }
14694 }
14696 /* Parse a declaration.
14698 declaration:
14699 block-declaration
14700 function-definition
14701 template-declaration
14702 explicit-instantiation
14703 explicit-specialization
14704 linkage-specification
14705 namespace-definition
14707 C++17:
14708 deduction-guide
14710 modules:
14711 (all these are only allowed at the outermost level, check
14712 that semantically, for better diagnostics)
14713 module-declaration
14714 module-export-declaration
14715 module-import-declaration
14716 export-declaration
14718 GNU extension:
14720 declaration:
14721 __extension__ declaration */
14723 static void
14725 {
14728 /* Check for the `__extension__' keyword. */
14730 {
14731 /* Parse the qualified declaration. */
14733 /* Restore the PEDANTIC flag. */
14737 }
14739 /* Try to figure out what kind of declaration is present. */
14745 {
14747 /* A declaration consisting of a single semicolon is invalid
14748 * before C++11. Allow it unless we're being pedantic. */
14752 }
14756 CPP_SEMICOLON))
14757 {
14762 {
14765 std_attrs);
14767 {
14770 {
14772 CPP_PRAGMA));
14774 }
14776 }
14777 }
14785 }
14787 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14792 /* Conditionally, allow attributes to precede a linkage specification. */
14794 {
14802 {
14804 /* We might have already been here. */
14806 {
14814 }
14817 }
14818 else
14819 {
14822 }
14823 }
14824 /* If we already had some attributes, and we've added more, then prepend.
14825 Otherwise attributes just contains any that we just read. */
14827 {
14831 }
14833 /* If the next token is `extern' and the following token is a string
14834 literal, then we have a linkage specification. */
14838 /* If the next token is `template', then we have either a template
14839 declaration, an explicit instantiation, or an explicit
14840 specialization. */
14842 {
14843 /* `template <>' indicates a template specialization. */
14847 /* `template <' indicates a template declaration. */
14850 /* Anything else must be an explicit instantiation. */
14851 else
14853 }
14854 /* If the next token is `export', it's new-style modules or
14855 old-style template. */
14857 {
14860 else
14862 }
14866 {
14873 else
14875 }
14876 /* If the next token is `extern', 'static' or 'inline' and the one
14877 after that is `template', we have a GNU extended explicit
14878 instantiation directive. */
14885 /* If the next token is `namespace', check for a named or unnamed
14886 namespace definition. */
14895 /* An unnamed namespace definition. */
14899 /* An inline (associated) namespace definition. */
14903 /* Objective-C++ declaration/definition. */
14910 /* At this point we may have a template declared by a concept
14911 introduction. */
14916 else
14917 /* Try to parse a block-declaration, or a function-definition. */
14920 /* Free any declarators allocated. */
14922 }
14924 /* Parse a namespace-scope declaration. */
14926 static void
14928 {
14932 /* A top-level declaration can consist solely of a #pragma. A
14933 nested declaration cannot, so this is done here and not in
14934 cp_parser_declaration. (A #pragma at block scope is
14935 handled in cp_parser_statement.) */
14937 else
14938 /* Parse the declaration itself. */
14940 }
14942 /* Parse a block-declaration.
14944 block-declaration:
14945 simple-declaration
14946 asm-definition
14947 namespace-alias-definition
14948 using-declaration
14949 using-directive
14951 GNU Extension:
14953 block-declaration:
14954 __extension__ block-declaration
14956 C++0x Extension:
14958 block-declaration:
14959 static_assert-declaration
14961 If STATEMENT_P is TRUE, then this block-declaration is occurring as
14962 part of a declaration-statement. */
14964 static void
14967 {
14970 /* Check for the `__extension__' keyword. */
14972 {
14973 /* Parse the qualified declaration. */
14975 /* Restore the PEDANTIC flag. */
14979 }
14981 /* Peek at the next token to figure out which kind of declaration is
14982 present. */
14986 /* If the next keyword is `asm', we have an asm-definition. */
14988 {
14992 }
14993 /* If the next keyword is `namespace', we have a
14994 namespace-alias-definition. */
14997 /* If the next keyword is `using', we have a
14998 using-declaration, a using-directive, or an alias-declaration. */
15000 {
15005 /* If the token after `using' is `namespace', then we have a
15006 using-directive. */
15012 /* If the second token after 'using' is '=', then we have an
15013 alias-declaration. */
15019 /* Otherwise, it's a using-declaration. */
15020 else
15023 }
15024 /* If the next keyword is `__label__' we have a misplaced label
15025 declaration. */
15027 {
15031 /* If the next token is now a `;', consume it. */
15034 }
15035 /* If the next token is `static_assert' we have a static assertion. */
15038 /* If the next tokens after attributes is `using namespace', then we have
15039 a using-directive. */
15042 RID_USING)
15044 RID_NAMESPACE))
15045 {
15049 }
15050 /* Anything else must be a simple-declaration. */
15051 else
15054 }
15056 /* Parse a simple-declaration.
15058 simple-declaration:
15059 decl-specifier-seq [opt] init-declarator-list [opt] ;
15060 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15061 brace-or-equal-initializer ;
15063 init-declarator-list:
15064 init-declarator
15065 init-declarator-list , init-declarator
15067 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
15068 function-definition as a simple-declaration.
15070 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15071 parsed declaration if it is an uninitialized single declarator not followed
15072 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15073 if present, will not be consumed. */
15075 static void
15079 {
15080 cp_decl_specifier_seq decl_specifiers;
15089 /* Defer access checks until we know what is being declared; the
15090 checks for names appearing in the decl-specifier-seq should be
15091 done as if we were in the scope of the thing being declared. */
15094 /* Parse the decl-specifier-seq. We have to keep track of whether
15095 or not the decl-specifier-seq declares a named class or
15096 enumeration type, since that is the only case in which the
15097 init-declarator-list is allowed to be empty.
15099 [dcl.dcl]
15101 In a simple-declaration, the optional init-declarator-list can be
15102 omitted only when declaring a class or enumeration, that is when
15103 the decl-specifier-seq contains either a class-specifier, an
15104 elaborated-type-specifier, or an enum-specifier. */
15106 CP_PARSER_FLAGS_OPTIONAL,
15109 /* We no longer need to defer access checks. */
15112 cp_omp_declare_simd_data odsd;
15118 /* In a block scope, a valid declaration must always have a
15119 decl-specifier-seq. By not trying to parse declarators, we can
15120 resolve the declaration/expression ambiguity more quickly. */
15123 {
15126 }
15128 /* If the next two tokens are both identifiers, the code is
15129 erroneous. The usual cause of this situation is code like:
15131 T t;
15133 where "T" should name a type -- but does not. */
15136 {
15137 /* If parsing tentatively, we should commit; we really are
15138 looking at a declaration. */
15140 /* Give up. */
15142 }
15146 /* Look for C++17 decomposition declaration. */
15154 {
15155 tree decl
15157 maybe_range_for_decl,
15160 /* The next token should be either a `,' or a `;'. */
15162 /* If it's a `;', we are done. */
15166 {
15170 }
15171 /* Anything else is an error. */
15172 else
15173 {
15174 /* If we have already issued an error message we don't need
15175 to issue another one. */
15180 /* Skip tokens until we reach the end of the statement. */
15182 /* If the next token is now a `;', consume it. */
15186 }
15187 }
15188 else
15191 tree last_type;
15193 /* NULL_TREE if both variable and function declaration are allowed,
15194 error_mark_node if function declaration are not allowed and
15195 a FUNCTION_DECL that should be diagnosed if it is followed by
15196 variable declarations. */
15197 tree auto_function_declaration;
15200 auto_specifier_p
15204 /* Keep going until we hit the `;' at the end of the simple
15205 declaration. */
15208 CPP_SEMICOLON))
15209 {
15212 tree decl;
15216 {
15217 /* If we are processing next declarator, comma is expected */
15222 {
15226 }
15227 }
15228 else
15231 /* Parse the init-declarator. */
15233 CP_PARSER_FLAGS_NONE,
15236 function_definition_allowed_p,
15238 declares_class_or_enum,
15240 maybe_range_for_decl,
15243 /* If an error occurred while parsing tentatively, exit quickly.
15244 (That usually happens when in the body of a function; each
15245 statement is treated as a declaration-statement until proven
15246 otherwise.) */
15251 {
15252 /* If the init-declarator-list contains more than one
15253 init-declarator, they shall all form declarations of
15254 variables. */
15256 auto_function_declaration
15260 {
15262 "non-variable %qD in declaration with more than one "
15267 }
15268 }
15272 {
15276 {
15277 /* If the list of declarators contains more than one declarator,
15278 the type of each declared variable is determined as described
15279 above. If the type deduced for the template parameter U is not
15280 the same in each deduction, the program is ill-formed. */
15285 }
15286 else
15288 }
15290 /* Handle function definitions specially. */
15292 {
15293 /* If the next token is a `,', then we are probably
15294 processing something like:
15296 void f() {}, *p;
15298 which is erroneous. */
15300 {
15303 "mixing"
15305 }
15306 /* Otherwise, we're done with the list of declarators. */
15307 else
15308 {
15312 }
15313 }
15316 /* The next token should be either a `,' or a `;'. */
15318 /* If it's a `,', there are more declarators to come. */
15321 /* If it's a `;', we are done. */
15325 {
15330 }
15331 /* Anything else is an error. */
15332 else
15333 {
15334 /* If we have already issued an error message we don't need
15335 to issue another one. */
15340 /* Skip tokens until we reach the end of the statement. */
15342 /* If the next token is now a `;', consume it. */
15346 }
15347 /* After the first time around, a function-definition is not
15348 allowed -- even if it was OK at first. For example:
15350 int i, f() {}
15352 is not valid. */
15354 }
15356 /* Issue an error message if no declarators are present, and the
15357 decl-specifier-seq does not itself declare a class or
15358 enumeration: [dcl.dcl]/3. */
15360 {
15362 {
15366 /* Ensure an error is issued anyway when finish_decltype_type,
15367 called via cp_parser_decl_specifier_seq, returns a class or
15368 an enumeration (c++/51786). */
15371 }
15372 /* Perform any deferred access checks. */
15374 }
15376 /* Consume the `;'. */
15377 finish:
15381 {
15387 }
15389 done:
15392 }
15394 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
15395 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15396 initializer ; */
15398 static tree
15403 {
15408 /* Parse the identifier-list. */
15412 {
15420 }
15424 {
15430 else
15431 {
15434 }
15435 }
15439 "structured bindings only available with "
15442 tree pushed_scope;
15449 NULL_TREE);
15456 cp_expr e;
15457 cp_decl_specifier_seq decl_specs;
15462 {
15466 else
15467 {
15470 }
15471 tree elt_pushed_scope;
15477 {
15478 /* Ensure we've diagnosed redeclaration if we aren't creating
15479 a new VAR_DECL. */
15482 }
15483 else
15487 }
15490 {
15493 }
15497 {
15505 || (is_direct_init
15508 {
15512 }
15515 {
15520 }
15521 }
15523 {
15525 /* Ensure DECL_VALUE_EXPR is created for all the decls but
15526 the underlying DECL. */
15528 }
15534 {
15537 }
15540 }
15542 /* Parse a decl-specifier-seq.
15544 decl-specifier-seq:
15545 decl-specifier-seq [opt] decl-specifier
15546 decl-specifier attribute-specifier-seq [opt] (C++11)
15548 decl-specifier:
15549 storage-class-specifier
15550 type-specifier
15551 function-specifier
15552 friend
15553 typedef
15555 GNU Extension:
15557 decl-specifier:
15558 attributes
15560 Concepts Extension:
15562 decl-specifier:
15563 concept
15565 Set *DECL_SPECS to a representation of the decl-specifier-seq.
15567 The parser flags FLAGS is used to control type-specifier parsing.
15569 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
15570 flags:
15572 1: one of the decl-specifiers is an elaborated-type-specifier
15573 (i.e., a type declaration)
15574 2: one of the decl-specifiers is an enum-specifier or a
15575 class-specifier (i.e., a type definition)
15577 */
15579 static void
15581 cp_parser_flags flags,
15584 {
15588 cp_decl_spec ds;
15590 /* Clear DECL_SPECS. */
15593 /* Assume no class or enumeration type is declared. */
15596 /* Keep reading specifiers until there are no more to read. */
15598 {
15603 /* Peek at the next token. */
15606 /* Save the first token of the decl spec list for error
15607 reporting. */
15610 /* Handle attributes. */
15613 {
15614 /* Parse the attributes. */
15617 /* In a sequence of declaration specifiers, c++11 attributes
15618 appertain to the type that precede them. In that case
15619 [dcl.spec]/1 says:
15621 The attribute-specifier-seq affects the type only for
15622 the declaration it appears in, not other declarations
15623 involving the same type.
15625 But for now let's force the user to position the
15626 attribute either at the beginning of the declaration or
15627 after the declarator-id, which would clearly mean that it
15628 applies to the declarator. */
15630 {
15632 /* The c++11 attribute is at the beginning of the
15633 declaration. It appertains to the entity being
15635 else
15636 {
15638 {
15639 /* This is an attribute following a
15640 class-specifier. */
15645 }
15646 else
15647 {
15648 decl_specs->std_attributes
15652 }
15654 }
15655 }
15657 decl_specs->attributes
15662 }
15663 /* Assume we will find a decl-specifier keyword. */
15665 /* If the next token is an appropriate keyword, we can simply
15666 add it to the list. */
15668 {
15669 /* decl-specifier:
15670 friend
15671 constexpr
15672 constinit */
15675 {
15680 }
15681 else
15682 {
15684 /* Consume the token. */
15686 }
15711 /* Warn for concept as a decl-specifier. We'll rewrite these as
15712 concept declarations later. */
15714 {
15719 else
15722 }
15724 /* In C++20 a concept definition is just 'concept name = expr;'
15725 Support that syntax as a TS extension by pretending we've seen
15726 the 'bool' specifier. */
15730 {
15734 }
15737 /* function-specifier:
15738 inline
15739 virtual
15740 explicit */
15747 /* decl-specifier:
15748 typedef */
15751 /* Consume the token. */
15757 /* A constructor declarator cannot appear in a typedef. */
15759 /* The "typedef" keyword can only occur in a declaration; we
15760 may as well commit at this point. */
15767 /* storage-class-specifier:
15768 auto
15769 register
15770 static
15771 extern
15772 mutable
15774 GNU Extension:
15775 thread */
15778 {
15779 /* Consume the token. */
15782 /* Complain about `auto' as a storage specifier, if
15783 we're complaining about C++0x compatibility. */
15787 "%<auto%> changes meaning in C++11; "
15790 /* Set the storage class anyway. */
15792 token);
15793 }
15794 else
15795 /* C++0x auto type-specifier. */
15803 /* Consume the token. */
15806 token);
15809 /* Consume the token. */
15815 /* We did not yet find a decl-specifier yet. */
15818 }
15836 /* Constructors are a special case. The `S' in `S()' is not a
15837 decl-specifier; it is the beginning of the declarator. */
15838 constructor_p
15839 = (!found_decl_spec
15840 && constructor_possible_p
15841 && (cp_parser_constructor_declarator_p
15843 ds_friend))));
15845 /* If we don't have a DECL_SPEC yet, then we must be looking at
15846 a type-specifier. */
15848 {
15851 tree type_spec;
15856 type_spec
15858 decl_specs,
15864 /* If this type-specifier referenced a user-defined type
15865 (a typedef, class-name, etc.), then we can't allow any
15866 more such type-specifiers henceforth.
15868 [dcl.spec]
15870 The longest sequence of decl-specifiers that could
15871 possibly be a type name is taken as the
15872 decl-specifier-seq of a declaration. The sequence shall
15873 be self-consistent as described below.
15875 [dcl.type]
15877 As a general rule, at most one type-specifier is allowed
15878 in the complete decl-specifier-seq of a declaration. The
15879 only exceptions are the following:
15881 -- const or volatile can be combined with any other
15882 type-specifier.
15884 -- signed or unsigned can be combined with char, long,
15885 short, or int.
15887 -- ..
15889 Example:
15891 typedef char* Pc;
15892 void g (const int Pc);
15894 Here, Pc is *not* part of the decl-specifier seq; it's
15895 the declarator. Therefore, once we see a type-specifier
15896 (other than a cv-qualifier), we forbid any additional
15897 user-defined types. We *do* still allow things like `int
15898 int' to be considered a decl-specifier-seq, and issue the
15899 error message later. */
15902 /* A constructor declarator cannot follow a type-specifier. */
15904 {
15912 }
15913 }
15915 /* If we still do not have a DECL_SPEC, then there are no more
15916 decl-specifiers. */
15921 {
15925 "standard attributes must precede the decl-specifiers to "
15926 "apply to the declaration, or follow them to apply to "
15928 }
15931 /* After we see one decl-specifier, further decl-specifiers are
15932 always optional. */
15934 }
15936 /* Don't allow a friend specifier with a class definition. */
15941 }
15943 /* Parse an (optional) storage-class-specifier.
15945 storage-class-specifier:
15946 auto
15947 register
15948 static
15949 extern
15950 mutable
15952 GNU Extension:
15954 storage-class-specifier:
15955 thread
15957 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
15959 static tree
15961 {
15963 {
15967 /* Fall through for C++98. */
15975 /* Consume the token. */
15980 }
15981 }
15983 /* Parse an (optional) function-specifier.
15985 function-specifier:
15986 inline
15987 virtual
15988 explicit
15990 C++20 Extension:
15991 explicit(constant-expression)
15993 Returns an IDENTIFIER_NODE corresponding to the keyword used.
15994 Updates DECL_SPECS, if it is non-NULL. */
15996 static tree
15999 {
16002 {
16008 /* 14.5.2.3 [temp.mem]
16010 A member function template shall not be virtual. */
16014 else
16019 {
16021 /* If we see '(', it's C++20 explicit(bool). */
16022 tree expr;
16024 {
16025 matching_parens parens;
16028 /* New types are not allowed in an explicit-specifier. */
16031 parser->type_definition_forbidden_message
16036 "%<explicit(bool)%> only available with %<-std=c++20%> "
16039 /* Parse the constant-expression. */
16042 /* Restore the saved message. */
16045 }
16046 else
16047 /* The explicit-specifier explicit without a constant-expression is
16048 equivalent to the explicit-specifier explicit(true). */
16051 /* [dcl.fct.spec]
16052 "the constant-expression, if supplied, shall be a contextually
16053 converted constant expression of type bool." */
16055 /* We could evaluate it -- mark the decl as appropriate. */
16061 /* The expression was value-dependent. Remember it so that we can
16062 substitute it later. */
16065 }
16069 }
16071 /* Consume the token. */
16073 }
16075 /* Parse a linkage-specification.
16077 linkage-specification:
16078 extern string-literal { declaration-seq [opt] }
16079 extern string-literal declaration */
16081 static void
16083 {
16084 tree linkage;
16086 /* Look for the `extern' keyword. */
16087 cp_token *extern_token
16090 /* Look for the string-literal. */
16094 /* Transform the literal into an identifier. If the literal is a
16095 wide-character string, or contains embedded NULs, then we can't
16096 handle it as the user wants. */
16099 {
16101 /* Assume C++ linkage. */
16103 }
16104 else
16107 /* We're now using the new linkage. */
16110 /* Preserve the location of the innermost linkage specification,
16111 tracking the locations of nested specifications via a local. */
16112 location_t saved_location
16114 /* Construct a location ranging from the start of the "extern" to
16115 the end of the string-literal, with the caret at the start, e.g.:
16116 extern "C" {
16117 ^~~~~~~~~~
16118 */
16119 parser->innermost_linkage_specification_location
16124 /* If the next token is a `{', then we're using the first
16125 production. */
16127 {
16131 /* Consume the `{' token. */
16132 matching_braces braces;
16134 /* Parse the declarations. */
16136 /* Look for the closing `}'. */
16138 }
16139 /* Otherwise, there's just one declaration. */
16140 else
16141 {
16144 saved_in_unbraced_linkage_specification_p
16148 parser->in_unbraced_linkage_specification_p
16150 }
16152 /* We're done with the linkage-specification. */
16155 /* Restore location of parent linkage specification, if any. */
16157 }
16159 /* Parse a static_assert-declaration.
16161 static_assert-declaration:
16162 static_assert ( constant-expression , string-literal ) ;
16163 static_assert ( constant-expression ) ; (C++17)
16165 If MEMBER_P, this static_assert is a class member. */
16167 static void
16169 {
16170 cp_expr condition;
16171 location_t token_loc;
16172 tree message;
16175 /* Peek at the `static_assert' token so we can keep track of exactly
16176 where the static assertion started. */
16179 /* Look for the `static_assert' keyword. */
16181 RT_STATIC_ASSERT))
16184 /* We know we are in a static assertion; commit to any tentative
16185 parse. */
16189 /* Parse the `(' starting the static assertion condition. */
16190 matching_parens parens;
16193 /* Parse the constant-expression. Allow a non-constant expression
16194 here in order to give better diagnostics in finish_static_assert. */
16195 condition =
16201 {
16204 "%<static_assert%> without a message "
16206 /* Eat the ')' */
16211 }
16212 else
16213 {
16214 /* Parse the separating `,'. */
16217 /* Parse the string-literal message. */
16222 /* A `)' completes the static assertion. */
16228 }
16230 /* A semicolon terminates the declaration. */
16233 /* Get the location for the static assertion. Use that of the
16234 condition if available, otherwise, use that of the "static_assert"
16235 token. */
16240 /* Complete the static assertion, which may mean either processing
16241 the static assert now or saving it for template instantiation. */
16244 }
16246 /* Parse the expression in decltype ( expression ). */
16248 static tree
16251 {
16253 tree expr;
16255 /* First, try parsing an id-expression. */
16266 {
16269 cp_id_kind idk;
16273 /* Lookup the name we got back from the id-expression. */
16278 /* A template without args is not a complete id-expression. */
16287 {
16288 /* Complete lookup of the id-expression. */
16289 expr = (finish_id_expression
16302 /* We found an id-expression, but it was something that we
16303 should not have found. This is an error, not something
16304 we can recover from, so note that we found an
16305 id-expression and we'll recover as gracefully as
16306 possible. */
16308 }
16313 /* We have an id-expression. */
16315 }
16318 {
16319 /* Abort the id-expression parse. */
16322 /* Parsing tentatively, again. */
16325 /* Parse a class member access. */
16333 /* We have an id-expression. */
16335 }
16338 /* We have parsed the complete id-expression or member access. */
16340 else
16341 {
16342 /* Abort our attempt to parse an id-expression or member access
16343 expression. */
16346 /* Parse a full expression. */
16349 }
16352 }
16354 /* Parse a `decltype' type. Returns the type.
16356 decltype-specifier:
16357 decltype ( expression )
16358 C++14:
16359 decltype ( auto ) */
16361 static tree
16363 {
16368 {
16369 /* Already parsed. */
16372 }
16374 /* Look for the `decltype' token. */
16378 /* Parse the opening `('. */
16379 matching_parens parens;
16383 /* Since we're going to preserve any side-effects from this parse, set up a
16384 firewall to protect our callers from cp_parser_commit_to_tentative_parse
16385 in the expression. */
16388 /* If in_declarator_p, a reparse as an expression might succeed (60361).
16389 Otherwise, commit now for better diagnostics. */
16400 {
16401 /* decltype (auto) */
16404 {
16406 "%<decltype(auto)%> type specifier only available with "
16409 }
16410 }
16411 else
16412 {
16413 /* decltype (expression) */
16415 /* Types cannot be defined in a `decltype' expression. Save away the
16416 old message and set the new one. */
16418 parser->type_definition_forbidden_message
16421 /* The restrictions on constant-expressions do not apply inside
16422 decltype expressions. */
16423 bool saved_integral_constant_expression_p
16425 bool saved_non_integral_constant_expression_p
16429 /* Within a parenthesized expression, a `>' token is always
16430 the greater-than operator. */
16431 bool saved_greater_than_is_operator_p
16435 /* Don't synthesize an implicit template type parameter here. This
16436 could happen with C++23 code like
16438 void f(decltype(new auto{0}));
16440 where we want to deduce the auto right away so that the parameter
16441 is of type 'int *'. */
16445 /* Do not actually evaluate the expression. */
16448 /* Do not warn about problems with the expression. */
16454 /* Go back to evaluating expressions. */
16458 /* The `>' token might be the end of a template-id or
16459 template-parameter-list now. */
16460 parser->greater_than_is_operator_p
16463 /* Restore the old message and the integral constant expression
16464 flags. */
16466 parser->integral_constant_expression_p
16468 parser->non_integral_constant_expression_p
16470 }
16472 /* Parse to the closing `)'. */
16474 {
16478 }
16480 /* If we got a parse error while tentative, bail out now. */
16482 {
16485 }
16488 /* Build auto. */
16490 else
16492 tf_warning_or_error);
16494 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
16495 it again. */
16512 }
16514 /* Special member functions [gram.special] */
16516 /* Parse a conversion-function-id.
16518 conversion-function-id:
16519 operator conversion-type-id
16521 Returns an IDENTIFIER_NODE representing the operator. */
16523 static tree
16525 {
16526 tree type;
16527 tree saved_scope;
16528 tree saved_qualifying_scope;
16529 tree saved_object_scope;
16532 /* Look for the `operator' token. */
16535 /* When we parse the conversion-type-id, the current scope will be
16536 reset. However, we need that information in able to look up the
16537 conversion function later, so we save it here. */
16541 /* We must enter the scope of the class so that the names of
16542 entities declared within the class are available in the
16543 conversion-type-id. For example, consider:
16545 struct S {
16546 typedef int I;
16547 operator I();
16548 };
16550 S::operator I() { ... }
16552 In order to see that `I' is a type-name in the definition, we
16553 must be in the scope of `S'. */
16556 /* Parse the conversion-type-id. */
16558 /* Leave the scope of the class, if any. */
16561 /* Restore the saved scope. */
16565 /* If the TYPE is invalid, indicate failure. */
16569 }
16571 /* Parse a conversion-type-id:
16573 conversion-type-id:
16574 type-specifier-seq conversion-declarator [opt]
16576 Returns the TYPE specified. */
16578 static tree
16580 {
16581 tree attributes;
16582 cp_decl_specifier_seq type_specifiers;
16584 tree type_specified;
16587 /* Parse the attributes. */
16591 parser->type_definition_forbidden_message
16594 /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
16595 optional in conversion-type-id. */
16603 /* If that didn't work, stop. */
16606 /* Parse the conversion-declarator. */
16614 /* Don't give this error when parsing tentatively. This happens to
16615 work because we always parse this definitively once. */
16618 {
16620 {
16623 }
16627 }
16630 }
16632 /* Parse an (optional) conversion-declarator.
16634 conversion-declarator:
16635 ptr-operator conversion-declarator [opt]
16637 */
16641 {
16644 cp_cv_quals cv_quals;
16646 /* We don't know if there's a ptr-operator next, or not. */
16648 /* Try the ptr-operator. */
16651 /* If it worked, look for more conversion-declarators. */
16653 {
16656 /* Parse another optional declarator. */
16659 declarator = cp_parser_make_indirect_declarator
16663 }
16666 }
16668 /* Parse an (optional) ctor-initializer.
16670 ctor-initializer:
16671 : mem-initializer-list */
16673 static void
16675 {
16676 /* If the next token is not a `:', then there is no
16677 ctor-initializer. */
16679 {
16680 /* Do default initialization of any bases and members. */
16684 }
16686 /* Consume the `:' token. */
16688 /* And the mem-initializer-list. */
16690 }
16692 /* Parse a mem-initializer-list.
16694 mem-initializer-list:
16695 mem-initializer ... [opt]
16696 mem-initializer ... [opt] , mem-initializer-list */
16698 static void
16700 {
16705 /* Let the semantic analysis code know that we are starting the
16706 mem-initializer-list. */
16711 /* Loop through the list. */
16713 {
16714 tree mem_initializer;
16717 /* Parse the mem-initializer. */
16719 /* If the next token is a `...', we're expanding member initializers. */
16725 {
16726 /* Consume the `...'. */
16730 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
16731 can be expanded but members cannot. */
16734 {
16739 }
16741 /* Construct the pack expansion type. */
16744 }
16747 {
16751 }
16752 /* Look for a target constructor. */
16756 {
16759 {
16763 }
16765 }
16766 /* Add it to the list, unless it was erroneous. */
16768 {
16771 }
16772 /* If the next token is not a `,', we're done. */
16775 /* Consume the `,' token. */
16777 }
16779 /* Perform semantic analysis. */
16782 }
16784 /* Parse a mem-initializer.
16786 mem-initializer:
16787 mem-initializer-id ( expression-list [opt] )
16788 mem-initializer-id braced-init-list
16790 GNU extension:
16792 mem-initializer:
16793 ( expression-list [opt] )
16795 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
16796 class) or FIELD_DECL (for a non-static data member) to initialize;
16797 the TREE_VALUE is the expression-list. An empty initialization
16798 list is represented by void_list_node. */
16800 static tree
16802 {
16803 tree mem_initializer_id;
16804 tree expression_list;
16805 tree member;
16808 /* Find out what is being initialized. */
16810 {
16814 }
16815 else
16816 {
16820 }
16826 {
16833 }
16834 else
16835 {
16847 }
16860 /* We can't attach the source location of this initializer directly to
16861 the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
16862 within the TREE_TYPE of the list node. */
16863 location_t loc
16870 }
16872 /* Parse a mem-initializer-id.
16874 mem-initializer-id:
16875 :: [opt] nested-name-specifier [opt] class-name
16876 decltype-specifier (C++11)
16877 identifier
16879 Returns a TYPE indicating the class to be initialized for the first
16880 production (and the second in C++11). Returns an IDENTIFIER_NODE
16881 indicating the data member to be initialized for the last production. */
16883 static tree
16885 {
16889 tree id;
16893 /* `typename' is not allowed in this context ([temp.res]). */
16895 {
16897 "keyword %<typename%> not allowed in this context (a qualified "
16900 }
16901 /* Look for the optional `::' operator. */
16902 global_scope_p
16906 /* Look for the optional nested-name-specifier. The simplest way to
16907 implement:
16909 [temp.res]
16911 The keyword `typename' is not permitted in a base-specifier or
16912 mem-initializer; in these contexts a qualified name that
16913 depends on a template-parameter is implicitly assumed to be a
16914 type name.
16916 is to assume that we have seen the `typename' keyword at this
16917 point. */
16918 nested_name_specifier_p
16927 /* If there is a `::' operator or a nested-name-specifier, then we
16928 are definitely looking for a class-name. */
16933 typename_type,
16937 /* Otherwise, we could also be looking for an ordinary identifier. */
16940 /* Try a decltype-specifier. */
16942 else
16943 /* Otherwise, try a class-name. */
16947 none_type,
16951 /* If we found one, we're done. */
16954 /* Otherwise, look for an ordinary identifier. */
16956 }
16958 /* Overloading [gram.over] */
16960 /* Parse an operator-function-id.
16962 operator-function-id:
16963 operator operator
16965 Returns an IDENTIFIER_NODE for the operator which is a
16966 human-readable spelling of the identifier, e.g., `operator +'. */
16968 static cp_expr
16970 {
16972 /* Look for the `operator' keyword. */
16975 /* And then the name of the operator itself. */
16977 }
16979 /* Return an identifier node for a user-defined literal operator.
16980 The suffix identifier is chained to the operator name identifier. */
16982 tree
16984 {
16985 tree identifier;
16993 }
16995 /* Parse an operator.
16997 operator:
16998 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
16999 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
17000 || ++ -- , ->* -> () []
17002 GNU Extensions:
17004 operator:
17005 <? >? <?= >?=
17007 Returns an IDENTIFIER_NODE for the operator which is a
17008 human-readable spelling of the identifier, e.g., `operator +'. */
17010 static cp_expr
17012 {
17017 /* Peek at the next token. */
17022 /* Figure out which operator we have. */
17027 {
17029 {
17030 /* The keyword should be either `new', `delete' or `co_await'. */
17037 else
17040 /* Consume the `new', `delete' or co_await token. */
17043 /* Peek at the next token. */
17045 /* If it's a `[' token then this is the array variant of the
17046 operator. */
17049 {
17050 /* Consume the `[' token. */
17052 /* Look for the `]' token. */
17057 }
17060 }
17223 /* Consume the `?'. */
17225 /* Look for the matching `:'. */
17231 {
17232 /* Consume the `('. */
17233 matching_parens parens;
17235 /* Look for the matching `)'. */
17242 }
17245 /* Consume the `['. */
17247 /* Look for the matching `]'. */
17258 /* FALLTHRU */
17267 {
17268 cp_expr str;
17269 tree string_tree;
17275 /* Consume the string. */
17281 {
17285 }
17286 else
17287 {
17289 /* Look for the suffix identifier. */
17292 {
17295 }
17297 {
17301 }
17302 else
17303 {
17306 }
17307 }
17312 {
17315 }
17318 {
17321 }
17323 {
17326 }
17327 /* Generate a location of the form:
17328 "" _suffix_identifier
17329 ^~~~~~~~~~~~~~~~~~~~~
17330 with caret == start at the start token, finish at the end of the
17331 suffix identifier. */
17332 location_t combined_loc
17335 }
17338 /* Anything else is an error. */
17340 }
17342 /* If we have selected an identifier, we need to consume the
17343 operator token. */
17345 {
17349 }
17350 /* Otherwise, no valid operator name was present. */
17351 else
17352 {
17355 }
17359 }
17361 /* Parse a template-declaration.
17363 template-declaration:
17364 export [opt] template < template-parameter-list > declaration
17366 If MEMBER_P is TRUE, this template-declaration occurs within a
17367 class-specifier.
17369 The grammar rule given by the standard isn't correct. What
17370 is really meant is:
17372 template-declaration:
17373 export [opt] template-parameter-list-seq
17374 decl-specifier-seq [opt] init-declarator [opt] ;
17375 export [opt] template-parameter-list-seq
17376 function-definition
17378 template-parameter-list-seq:
17379 template-parameter-list-seq [opt]
17380 template < template-parameter-list >
17382 Concept Extensions:
17384 template-parameter-list-seq:
17385 template < template-parameter-list > requires-clause [opt]
17387 requires-clause:
17388 requires logical-or-expression */
17390 static void
17392 {
17393 /* Check for `export'. */
17395 {
17396 /* Consume the `export' token. */
17398 /* Warn that this use of export is deprecated. */
17403 else
17405 }
17408 }
17410 /* Parse a template-parameter-list.
17412 template-parameter-list:
17413 template-parameter
17414 template-parameter-list , template-parameter
17416 Returns a TREE_LIST. Each node represents a template parameter.
17417 The nodes are connected via their TREE_CHAINs. */
17419 static tree
17421 {
17424 /* Don't create wrapper nodes within a template-parameter-list,
17425 since we don't want to have different types based on the
17426 spelling location of constants and decls within them. */
17427 auto_suppress_location_wrappers sentinel;
17431 /* The loop below parses the template parms. We first need to know
17432 the total number of template parms to be able to compute proper
17433 canonical types of each dependent type. So after the loop, when
17434 we know the total number of template parms,
17435 end_template_parm_list computes the proper canonical types and
17436 fixes up the dependent types accordingly. */
17438 {
17439 tree parameter;
17442 location_t parm_loc;
17444 /* Parse the template-parameter. */
17449 /* Add it to the list. */
17452 parm_loc,
17453 parameter,
17454 is_non_type,
17455 is_parameter_pack);
17456 else
17457 {
17460 }
17462 /* If the next token is not a `,', we're done. */
17465 /* Otherwise, consume the `,' token. */
17467 }
17470 }
17472 /* Parse a introduction-list.
17474 introduction-list:
17475 introduced-parameter
17476 introduction-list , introduced-parameter
17478 introduced-parameter:
17479 ...[opt] identifier
17481 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
17482 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
17483 WILDCARD_DECL will also have DECL_NAME set and token location in
17484 DECL_SOURCE_LOCATION. */
17486 static tree
17488 {
17492 {
17501 /* Build placeholder. */
17509 /* If the next token is not a `,', we're done. */
17512 /* Otherwise, consume the `,' token. */
17514 }
17516 /* Convert the vec into a TREE_VEC. */
17519 tree parm;
17525 }
17527 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
17528 is an abstract declarator. */
17532 {
17537 }
17539 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
17540 is an abstract declarator. */
17544 {
17548 else
17550 }
17552 /* Returns true if TYPE would declare a constrained constrained-parameter. */
17556 {
17561 }
17563 /* Returns true if PARM declares a constrained-parameter. */
17567 {
17569 }
17571 /* Check that the type parameter is only a declarator-id, and that its
17572 type is not cv-qualified. */
17574 bool
17577 {
17582 {
17585 }
17587 /* Don't allow cv-qualified type parameters. */
17590 {
17593 }
17596 }
17598 /* Finish parsing/processing a template type parameter and checking
17599 various restrictions. */
17603 tree id,
17605 {
17608 else
17610 }
17612 static tree
17614 {
17615 /* FIXME: This should probably be copied, and we may need to adjust
17616 the template parameter depths. */
17626 }
17628 /* Finish parsing/processing a template template parameter by borrowing
17629 the template parameter list from the prototype parameter. */
17631 static tree
17633 tree proto,
17634 tree id,
17636 {
17640 }
17642 /* Create a new non-type template parameter from the given PARM
17643 declarator. */
17645 static tree
17648 {
17654 }
17656 /* Build a constrained template parameter based on the PARMDECL
17657 declarator. The type of PARMDECL is the constrained type, which
17658 refers to the prototype template parameter that ultimately
17659 specifies the type of the declared parameter. */
17661 static tree
17665 {
17671 /* Build the parameter. Return an error if the declarator was invalid. */
17672 tree parm;
17677 parmdecl);
17678 else
17683 /* Finish the parameter decl and create a node attaching the
17684 default argument and constraint. */
17689 }
17691 /* Returns true if the parsed type actually represents the declaration
17692 of a type template-parameter. */
17694 static bool
17696 {
17699 }
17701 /* Returns true if the parsed type actually represents the declaration of
17702 a template template-parameter. */
17704 static bool
17706 {
17709 }
17711 /* Parse a default argument for a type template-parameter.
17712 Note that diagnostics are handled in cp_parser_template_parameter. */
17714 static tree
17716 {
17719 /* Consume the `=' token. */
17724 /* Tell cp_parser_lambda_expression this is a default argument. */
17728 /* Parse the default-argument. */
17731 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17732 NULL);
17736 {
17740 }
17743 }
17745 /* Parse a default argument for a template template-parameter. */
17747 static tree
17749 {
17754 /* Consume the `='. */
17756 /* Parse the id-expression. */
17758 /* save token before parsing the id-expression, for error
17759 reporting */
17761 tree default_argument
17769 /* If the id-expression was a template-id that refers to
17770 a template-class, we already have the declaration here,
17771 so no further lookup is needed. */
17772 ;
17773 else
17774 /* Look up the name. */
17775 default_argument
17777 none_type,
17783 /* See if the default argument is valid. */
17787 }
17789 /* Parse a template-parameter.
17791 template-parameter:
17792 type-parameter
17793 parameter-declaration
17795 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
17796 the parameter. The TREE_PURPOSE is the default value, if any.
17797 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
17798 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
17799 set to true iff this parameter is a parameter pack. */
17801 static tree
17804 {
17807 tree parm;
17809 /* Assume it is a type parameter or a template parameter. */
17811 /* Assume it not a parameter pack. */
17813 /* Peek at the next token. */
17815 /* If it is `template', we have a type-parameter. */
17818 /* If it is `class' or `typename' we do not know yet whether it is a
17819 type parameter or a non-type parameter. Consider:
17821 template <typename T, typename T::X X> ...
17823 or:
17825 template <class C, class D*> ...
17827 Here, the first parameter is a type parameter, and the second is
17828 a non-type parameter. We can tell by looking at the token after
17829 the identifier -- if it is a `,', `=', or `>' then we have a type
17830 parameter. */
17832 {
17833 /* Peek at the token after `class' or `typename'. */
17835 /* If it's an ellipsis, we have a template type parameter
17836 pack. */
17839 /* If it's an identifier, skip it. */
17842 /* Now, see if the token looks like the end of a template
17843 parameter. */
17848 }
17850 /* Otherwise, it is a non-type parameter or a constrained parameter.
17852 [temp.param]
17854 When parsing a default template-argument for a non-type
17855 template-parameter, the first non-nested `>' is taken as the end
17856 of the template parameter-list rather than a greater-than
17857 operator. */
17858 parameter_declarator
17860 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17867 /* If the parameter declaration is marked as a parameter pack, set
17868 *IS_PARAMETER_PACK to notify the caller. */
17873 {
17874 /* Can happen in some cases of erroneous input (c++/34892). */
17876 /* Consume the `...' for better error recovery. */
17878 }
17880 /* The parameter may have been constrained type parameter. */
17883 parameter_declarator,
17884 is_non_type);
17886 // Now we're sure that the parameter is a non-type parameter.
17897 }
17899 /* Parse a type-parameter.
17901 type-parameter:
17902 class identifier [opt]
17903 class identifier [opt] = type-id
17904 typename identifier [opt]
17905 typename identifier [opt] = type-id
17906 template < template-parameter-list > class identifier [opt]
17907 template < template-parameter-list > class identifier [opt]
17908 = id-expression
17910 GNU Extension (variadic templates):
17912 type-parameter:
17913 class ... identifier [opt]
17914 typename ... identifier [opt]
17916 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
17917 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
17918 the declaration of the parameter.
17920 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
17922 static tree
17924 {
17926 tree parameter;
17928 /* Look for a keyword to tell us what kind of parameter this is. */
17934 {
17937 {
17938 tree identifier;
17939 tree default_argument;
17941 /* If the next token is an ellipsis, we have a template
17942 argument pack. */
17944 {
17945 /* Consume the `...' token. */
17950 }
17952 /* If the next token is an identifier, then it names the
17953 parameter. */
17956 else
17959 /* Create the parameter. */
17962 /* If the next token is an `=', we have a default argument. */
17964 {
17965 default_argument
17968 /* Template parameter packs cannot have default
17969 arguments. */
17971 {
17974 "template parameter pack %qD cannot have a "
17976 else
17978 "template parameter packs cannot have "
17981 }
17984 }
17985 else
17988 /* Create the combined representation of the parameter and the
17989 default argument. */
17991 }
17995 {
17996 tree identifier;
17997 tree default_argument;
17999 /* Look for the `<'. */
18001 /* Parse the template-parameter-list. */
18003 /* Look for the `>'. */
18006 /* If template requirements are present, parse them. */
18008 {
18013 }
18015 /* Look for the `class' or 'typename' keywords. */
18017 /* If the next token is an ellipsis, we have a template
18018 argument pack. */
18020 {
18021 /* Consume the `...' token. */
18026 }
18027 /* If the next token is an `=', then there is a
18028 default-argument. If the next token is a `>', we are at
18029 the end of the parameter-list. If the next token is a `,',
18030 then we are at the end of this parameter. */
18034 {
18036 /* Treat invalid names as if the parameter were nameless. */
18039 }
18040 else
18043 /* Create the template parameter. */
18045 identifier);
18047 /* If the next token is an `=', then there is a
18048 default-argument. */
18050 {
18051 default_argument
18054 /* Template parameter packs cannot have default
18055 arguments. */
18057 {
18060 "template parameter pack %qD cannot "
18062 identifier);
18063 else
18067 }
18068 }
18069 else
18072 /* Create the combined representation of the parameter and the
18073 default argument. */
18075 }
18081 }
18084 }
18086 /* Parse a template-id.
18088 template-id:
18089 template-name < template-argument-list [opt] >
18091 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
18092 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
18093 returned. Otherwise, if the template-name names a function, or set
18094 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
18095 names a class, returns a TYPE_DECL for the specialization.
18097 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
18098 uninstantiated templates. */
18100 static tree
18106 {
18107 tree templ;
18108 tree arguments;
18109 tree template_id;
18114 /* If the next token corresponds to a template-id, there is no need
18115 to reparse it. */
18119 {
18122 }
18124 /* Avoid performing name lookup if there is no possibility of
18125 finding a template-id. */
18128 && !cp_parser_nth_token_starts_template_argument_list_p
18130 {
18133 }
18135 /* Remember where the template-id starts. */
18141 /* Parse the template-name. */
18144 check_dependency_p,
18145 is_declaration,
18146 tag_type,
18149 /* Push any access checks inside the firewall we're about to create. */
18155 /* Since we're going to preserve any side-effects from this parse, set up a
18156 firewall to protect our callers from cp_parser_commit_to_tentative_parse
18157 in the template arguments. */
18161 /* If we find the sequence `[:' after a template-name, it's probably
18162 a digraph-typo for `< ::'. Substitute the tokens and check if we can
18163 parse correctly the argument list. */
18170 {
18172 /* Change `:' into `::'. */
18174 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
18175 CPP_LESS. */
18178 /* Parse the arguments. */
18181 {
18182 /* If we couldn't parse an argument list, then we revert our changes
18183 and return simply an error. Maybe this is not a template-id
18184 after all. */
18189 }
18190 /* Otherwise, emit an error about the invalid digraph, but continue
18191 parsing because we got our argument list. */
18194 {
18197 "%<<:%> is an alternate spelling for %<[%>."
18200 {
18202 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
18205 }
18206 }
18207 }
18208 else
18209 {
18210 /* Look for the `<' that starts the template-argument-list. */
18212 {
18215 }
18216 /* Parse the arguments. */
18221 && !template_keyword_p
18224 {
18225 /* This didn't go well. */
18227 {
18228 /* C++20 says that "function-name < a;" is now ill-formed. */
18230 {
18233 "operand of %<<%> is ill-formed in C++20; wrap the "
18235 }
18236 else
18237 /* We expect "f<targs>" to be followed by "(args)". */
18241 /* Purge all subsequent tokens. */
18243 }
18244 else
18248 }
18249 }
18251 /* Set the location to be of the form:
18252 template-name < template-argument-list [opt] >
18253 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
18254 with caret == start at the start of the template-name,
18255 ranging until the closing '>'. */
18256 location_t combined_loc
18259 /* Check for concepts autos where they don't belong. We could
18260 identify types in some cases of identifier TEMPL, looking ahead
18261 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
18262 types. We reject them in functions, but if what we have is an
18263 identifier, even with none_type we can't conclude it's NOT a
18264 type, we have to wait for template substitution. */
18267 /* Build a representation of the specialization. */
18270 TEMPLATE_ID_EXPR,
18274 {
18275 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
18276 template (rather than some instantiation thereof) only if
18277 is not nested within some other construct. For example, in
18278 "template <typename T> void f(T) { A<T>::", A<T> is just an
18279 instantiation of A. */
18280 bool entering_scope
18283 template_id
18285 }
18287 {
18288 /* The caller will decide whether this is a concept check or type
18289 constraint. */
18292 }
18294 {
18298 }
18301 {
18302 /* Some type template in dependent scope. */
18305 TEMPLATE_ID_EXPR,
18308 }
18309 else
18310 {
18311 /* If it's not a class-template or a template-template, it should be
18312 a function-template. */
18318 }
18320 /* If parsing tentatively, replace the sequence of tokens that makes
18321 up the template-id with a CPP_TEMPLATE_ID token. That way,
18322 should we re-parse the token stream, we will not have to repeat
18323 the effort required to do the parse, nor will we issue duplicate
18324 error messages about problems during instantiation of the
18325 template. */
18327 /* Don't do this if we had a parse error in a declarator; re-parsing
18328 might succeed if a name changes meaning (60361). */
18332 {
18333 /* Reset the contents of the START_OF_ID token. */
18337 /* Retrieve any deferred checks. Do not pop this access checks yet
18338 so the memory will not be reclaimed during token replacing below. */
18345 /* Purge all subsequent tokens. */
18348 /* ??? Can we actually assume that, if template_id ==
18349 error_mark_node, we will have issued a diagnostic to the
18350 user, as opposed to simply marking the tentative parse as
18351 failed? */
18354 }
18358 }
18360 /* Like cp_parser_template_id, called in non-type context. */
18362 static tree
18367 {
18372 /* We didn't check the arguments in cp_parser_template_id; do that now. */
18375 }
18377 /* Parse a template-name.
18379 template-name:
18380 identifier
18382 The standard should actually say:
18384 template-name:
18385 identifier
18386 operator-function-id
18388 A defect report has been filed about this issue.
18390 A conversion-function-id cannot be a template name because they cannot
18391 be part of a template-id. In fact, looking at this code:
18393 a.operator K<int>()
18395 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
18396 It is impossible to call a templated conversion-function-id with an
18397 explicit argument list, since the only allowed template parameter is
18398 the type to which it is converting.
18400 If TEMPLATE_KEYWORD_P is true, then we have just seen the
18401 `template' keyword, in a construction like:
18403 T::template f<3>()
18405 In that case `f' is taken to be a template-name, even though there
18406 is no way of knowing for sure.
18408 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
18409 name refers to a set of overloaded functions, at least one of which
18410 is a template, or an IDENTIFIER_NODE with the name of the template,
18411 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
18412 names are looked up inside uninstantiated templates. */
18414 static tree
18421 {
18422 tree identifier;
18423 tree decl;
18426 /* If the next token is `operator', then we have either an
18427 operator-function-id or a conversion-function-id. */
18429 {
18430 /* We don't know whether we're looking at an
18431 operator-function-id or a conversion-function-id. */
18433 /* Try an operator-function-id. */
18435 /* If that didn't work, try a conversion-function-id. */
18437 {
18440 }
18441 }
18442 /* Look for the identifier. */
18443 else
18446 /* If we didn't find an identifier, we don't have a template-id. */
18450 /* If the name immediately followed the `template' keyword, then it
18451 is a template-name. However, if the next token is not `<', then
18452 we do not treat it as a template-name, since it is not being used
18453 as part of a template-id. This enables us to handle constructs
18454 like:
18456 template <typename T> struct S { S(); };
18457 template <typename T> S<T>::S();
18459 correctly. We would treat `S' as a template -- if it were `S<T>'
18460 -- but we do not if there is no `<'. */
18464 {
18465 /* In a declaration, in a dependent context, we pretend that the
18466 "template" keyword was present in order to improve error
18467 recovery. For example, given:
18469 template <typename T> void f(T::X<int>);
18471 we want to treat "X<int>" as a template-id. */
18473 && !template_keyword_p
18475 && check_dependency_p
18477 /* Do not do this for dtors (or ctors), since they never
18478 need the template keyword before their name. */
18480 {
18483 /* Explain what went wrong. */
18485 identifier);
18488 /* If parsing tentatively, find the location of the "<" token. */
18491 /* Parse the template arguments so that we can issue error
18492 messages about them. */
18495 /* Skip tokens until we find a good place from which to
18496 continue parsing. */
18501 /* If parsing tentatively, permanently remove the
18502 template argument list. That will prevent duplicate
18503 error messages from being issued about the missing
18504 "template" keyword. */
18511 }
18513 /* If the "template" keyword is present, then there is generally
18514 no point in doing name-lookup, so we just return IDENTIFIER.
18515 But, if the qualifying scope is non-dependent then we can
18516 (and must) do name-lookup normally. */
18518 {
18524 {
18525 /* We're optimizing away the call to cp_parser_lookup_name, but
18526 we still need to do this. */
18530 }
18531 }
18532 }
18534 /* cp_parser_lookup_name clears OBJECT_TYPE. */
18538 /* Look up the name. */
18540 tag_type,
18543 check_dependency_p,
18549 /* 13.3 [temp.names] A < is interpreted as the delimiter of a
18550 template-argument-list if it follows a name that is not a
18551 conversion-function-id and
18552 - that follows the keyword template or a ~ after a nested-name-specifier or
18553 in a class member access expression, or
18554 - for which name lookup finds the injected-class-name of a class template
18555 or finds any declaration of a template, or
18556 - that is an unqualified name for which name lookup either finds one or
18557 more functions or finds nothing, or
18558 - that is a terminal name in a using-declarator (9.9), in a declarator-id
18559 (9.3.4), or in a type-only context other than a nested-name-specifier
18560 (13.8). */
18562 /* If DECL is a template, then the name was a template-name. */
18564 {
18567 {
18569 tree attr;
18572 else
18575 {
18578 }
18581 {
18584 }
18585 }
18586 }
18587 else
18588 {
18589 /* Look through an overload set for any templates. */
18597 /* "an unqualified name for which name lookup either finds one or more
18598 functions or finds nothing". */
18601 && !scope
18604 {
18605 /* The "more functions" case. Just use the OVERLOAD as normally.
18606 We don't use is_overloaded_fn here to avoid considering
18607 BASELINKs. */
18609 /* Name lookup found one function. */
18611 /* Name lookup found nothing. */
18614 }
18616 /* "in a type-only context" */
18624 {
18625 /* The name does not name a template. */
18628 }
18630 /* Repeat the lookup at instantiation time. */
18632 }
18635 }
18637 /* Parse a template-argument-list.
18639 template-argument-list:
18640 template-argument ... [opt]
18641 template-argument-list , template-argument ... [opt]
18643 Returns a TREE_VEC containing the arguments. */
18645 static tree
18647 {
18652 /* Don't create location wrapper nodes within a template-argument-list. */
18653 auto_suppress_location_wrappers sentinel;
18657 /* Even if the template-id appears in an integral
18658 constant-expression, the contents of the argument list do
18659 not. */
18665 /* Parse the arguments. */
18667 do
18668 {
18670 /* Consume the comma. */
18673 /* Parse the template-argument. */
18676 /* If the next token is an ellipsis, we're expanding a template
18677 argument pack. */
18679 {
18681 {
18685 }
18686 /* Consume the `...' token. */
18689 /* Make the argument into a TYPE_PACK_EXPANSION or
18690 EXPR_PACK_EXPANSION. */
18692 }
18695 }
18710 }
18712 /* Parse a template-argument.
18714 template-argument:
18715 assignment-expression
18716 type-id
18717 id-expression
18719 The representation is that of an assignment-expression, type-id, or
18720 id-expression -- except that the qualified id-expression is
18721 evaluated, so that the value returned is either a DECL or an
18722 OVERLOAD.
18724 Although the standard says "assignment-expression", it forbids
18725 throw-expressions or assignments in the template argument.
18726 Therefore, we use "conditional-expression" instead. */
18728 static tree
18730 {
18731 tree argument;
18737 cp_id_kind idk;
18739 /* There's really no way to know what we're looking at, so we just
18740 try each alternative in order.
18742 [temp.arg]
18744 In a template-argument, an ambiguity between a type-id and an
18745 expression is resolved to a type-id, regardless of the form of
18746 the corresponding template-parameter.
18748 Therefore, we try a type-id first. */
18751 /* If there was no error parsing the type-id but the next token is a
18752 '>>', our behavior depends on which dialect of C++ we're
18753 parsing. In C++98, we probably found a typo for '> >'. But there
18754 are type-id which are also valid expressions. For instance:
18756 struct X { int operator >> (int); };
18757 template <int V> struct Foo {};
18758 Foo<X () >> 5> r;
18760 Here 'X()' is a valid type-id of a function type, but the user just
18761 wanted to write the expression "X() >> 5". Thus, we remember that we
18762 found a valid type-id, but we still try to parse the argument as an
18763 expression to see what happens.
18765 In C++0x, the '>>' will be considered two separate '>'
18766 tokens. */
18770 {
18773 }
18774 else
18775 {
18776 /* If the next token isn't a `,' or a `>', then this argument wasn't
18777 really finished. This means that the argument is not a valid
18778 type-id. */
18781 /* If that worked, we're done. */
18784 }
18785 /* We're still not sure what the argument will be. */
18787 /* Try a template. */
18795 /* If the next token isn't a `,' or a `>', then this argument wasn't
18796 really finished. */
18800 {
18801 /* Figure out what is being referred to. If the id-expression
18802 was for a class template specialization, then we will have a
18803 TYPE_DECL at this point. There is no need to do name lookup
18804 at this point in that case. */
18807 none_type,
18816 }
18818 {
18824 }
18825 /* It must be a non-type argument. In C++17 any constant-expression is
18826 allowed. */
18830 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
18832 -- an integral constant-expression of integral or enumeration
18833 type; or
18835 -- the name of a non-type template-parameter; or
18837 -- the name of an object or function with external linkage...
18839 -- the address of an object or function with external linkage...
18841 -- a pointer to member... */
18842 /* Look for a non-type template parameter. */
18844 {
18856 }
18858 /* If the next token is "&", the argument must be the address of an
18859 object or function with external linkage. */
18862 {
18865 }
18866 /* See if we might have an id-expression. */
18873 {
18876 address_p,
18883 else
18884 {
18885 tree probe;
18888 {
18889 /* Strip the dereference temporarily. */
18892 }
18894 /* If we're in a template, we represent a qualified-id referring
18895 to a static data member as a SCOPE_REF even if the scope isn't
18896 dependent so that we can check access control later. */
18901 {
18902 /* A variable without external linkage might still be a
18903 valid constant-expression, so no error is issued here
18904 if the external-linkage check fails. */
18907 }
18909 /* All overloaded functions are allowed; if the external
18910 linkage test does not pass, an error will be issued
18911 later. */
18912 ;
18916 /* A pointer-to-member. */
18917 ;
18919 ;
18920 else
18924 {
18928 else
18931 }
18932 }
18933 }
18934 /* If the argument started with "&", there are no other valid
18935 alternatives at this point. */
18937 {
18940 }
18942 general_expr:
18943 /* If the argument wasn't successfully parsed as a type-id followed
18944 by '>>', the argument can only be a constant expression now.
18945 Otherwise, we try parsing the constant-expression tentatively,
18946 because the argument could really be a type-id. */
18952 else
18953 {
18954 /* In C++20, we can encounter a braced-init-list. */
18957 {
18960 }
18962 /* With C++17 generalized non-type template arguments we need to handle
18963 lvalue constant expressions, too. */
18966 }
18974 /* We did our best to parse the argument as a non type-id, but that
18975 was the only alternative that matched (albeit with a '>' after
18976 it). We can assume it's just a typo from the user, and a
18977 diagnostic will then be issued. */
18979 }
18981 /* Parse an explicit-instantiation.
18983 explicit-instantiation:
18984 template declaration
18986 Although the standard says `declaration', what it really means is:
18988 explicit-instantiation:
18989 template decl-specifier-seq [opt] declarator [opt] ;
18991 Things like `template int S<int>::i = 5, int S<double>::j;' are not
18992 supposed to be allowed. A defect report has been filed about this
18993 issue.
18995 GNU Extension:
18997 explicit-instantiation:
18998 storage-class-specifier template
18999 decl-specifier-seq [opt] declarator [opt] ;
19000 function-specifier template
19001 decl-specifier-seq [opt] declarator [opt] ; */
19003 static void
19005 {
19007 cp_decl_specifier_seq decl_specifiers;
19012 /* Look for an (optional) storage-class-specifier or
19013 function-specifier. */
19015 {
19016 extension_specifier
19019 extension_specifier
19022 }
19024 /* Look for the `template' keyword. */
19026 /* Let the front end know that we are processing an explicit
19027 instantiation. */
19029 /* [temp.explicit] says that we are supposed to ignore access
19030 control while processing explicit instantiation directives. */
19032 /* Parse a decl-specifier-seq. */
19034 CP_PARSER_FLAGS_OPTIONAL,
19038 cp_omp_declare_simd_data odsd;
19044 /* If there was exactly one decl-specifier, and it declared a class,
19045 and there's no declarator, then we have an explicit type
19046 instantiation. */
19048 {
19051 /* Turn access control back on for names used during
19052 template instantiation. */
19057 }
19058 else
19059 {
19061 tree decl;
19063 /* Parse the declarator. */
19064 declarator
19066 CP_PARSER_FLAGS_NONE,
19077 {
19080 "explicit instantiation shall not use"
19084 "explicit instantiation shall not use"
19088 "explicit instantiation shall not use"
19093 /* Turn access control back on for names used during
19094 template instantiation. */
19096 /* Do the explicit instantiation. */
19098 }
19099 else
19100 {
19102 /* Skip the body of the explicit instantiation. */
19104 }
19105 }
19106 /* We're done with the instantiation. */
19114 }
19116 /* Parse an explicit-specialization.
19118 explicit-specialization:
19119 template < > declaration
19121 Although the standard says `declaration', what it really means is:
19123 explicit-specialization:
19124 template <> decl-specifier [opt] init-declarator [opt] ;
19125 template <> function-definition
19126 template <> explicit-specialization
19127 template <> template-declaration */
19129 static void
19131 {
19134 /* Look for the `template' keyword. */
19136 /* Look for the `<'. */
19138 /* Look for the `>'. */
19140 /* We have processed another parameter list. */
19143 /* [temp]
19145 A template ... explicit specialization ... shall not have C
19146 linkage. */
19149 {
19153 /* Give it C++ linkage to avoid confusing other parts of the
19154 front end. */
19156 }
19158 /* Let the front end know that we are beginning a specialization. */
19160 {
19161 /* If the next keyword is `template', we need to figure out
19162 whether or not we're looking a template-declaration. */
19164 {
19169 else
19171 }
19172 else
19173 /* Parse the dependent declaration. */
19179 }
19181 /* We're done with the specialization. */
19184 /* For the erroneous case of a template with C linkage, we pushed an
19185 implicit C++ linkage scope; exit that scope now. */
19189 /* We're done with this parameter list. */
19191 }
19193 /* Preserve the attributes across a garbage collect (by making it a GC
19194 root), which can occur when parsing a member function. */
19198 /* Parse a type-specifier.
19200 type-specifier:
19201 simple-type-specifier
19202 class-specifier
19203 enum-specifier
19204 elaborated-type-specifier
19205 cv-qualifier
19207 GNU Extension:
19209 type-specifier:
19210 __complex__
19212 Returns a representation of the type-specifier. For a
19213 class-specifier, enum-specifier, or elaborated-type-specifier, a
19214 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
19216 The parser flags FLAGS is used to control type-specifier parsing.
19218 If IS_DECLARATION is TRUE, then this type-specifier is appearing
19219 in a decl-specifier-seq.
19221 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
19222 class-specifier, enum-specifier, or elaborated-type-specifier, then
19223 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
19224 if a type is declared; 2 if it is defined. Otherwise, it is set to
19225 zero.
19227 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
19228 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
19229 is set to FALSE. */
19231 static tree
19233 cp_parser_flags flags,
19238 {
19244 /* Assume this type-specifier does not declare a new type. */
19247 /* And that it does not specify a cv-qualifier. */
19250 /* Peek at the next token. */
19253 /* If we're looking at a keyword, we can use that to guide the
19254 production we choose. */
19257 {
19262 /* Look for the enum-specifier. */
19264 /* If that worked, we're done. */
19266 {
19271 type_spec,
19272 token,
19275 }
19276 else
19279 /* Any of these indicate either a class-specifier, or an
19280 elaborated-type-specifier. */
19287 /* Parse tentatively so that we can back up if we don't find a
19288 class-specifier. */
19292 /* Look for the class-specifier. */
19297 /* If that worked, we're done. */
19299 {
19304 type_spec,
19305 token,
19308 }
19310 /* Fall through. */
19311 elaborated_type_specifier:
19312 /* We're declaring (not defining) a class or enum. */
19316 /* Fall through. */
19318 /* Look for an elaborated-type-specifier. */
19319 type_spec
19320 = (cp_parser_elaborated_type_specifier
19323 is_declaration));
19326 type_spec,
19327 token,
19350 /* The `__complex__' keyword is a GNU extension. */
19356 }
19358 /* Handle simple keywords. */
19360 {
19362 {
19365 }
19367 }
19369 /* If we do not already have a type-specifier, assume we are looking
19370 at a simple-type-specifier. */
19372 decl_specs,
19373 flags);
19375 /* If we didn't find a type-specifier, and a type-specifier was not
19376 optional in this context, issue an error message. */
19378 {
19381 }
19384 }
19386 /* Parse a simple-type-specifier.
19388 simple-type-specifier:
19389 :: [opt] nested-name-specifier [opt] type-name
19390 :: [opt] nested-name-specifier template template-id
19391 char
19392 wchar_t
19393 bool
19394 short
19395 int
19396 long
19397 signed
19398 unsigned
19399 float
19400 double
19401 void
19403 C++11 Extension:
19405 simple-type-specifier:
19406 auto
19407 decltype ( expression )
19408 char16_t
19409 char32_t
19410 __underlying_type ( type-id )
19412 C++17 extension:
19414 nested-name-specifier(opt) template-name
19416 GNU Extension:
19418 simple-type-specifier:
19419 __int128
19420 __typeof__ unary-expression
19421 __typeof__ ( type-id )
19422 __typeof__ ( type-id ) { initializer-list , [opt] }
19424 Concepts Extension:
19426 simple-type-specifier:
19427 constrained-type-specifier
19429 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
19430 appropriately updated. */
19432 static tree
19435 cp_parser_flags flags)
19436 {
19441 /* Peek at the next token. */
19444 /* If we're looking at a keyword, things are easy. */
19446 {
19484 {
19487 /* Check if the alternate "__intN__" form has been used instead of
19488 "__intN". */
19492 }
19521 {
19522 /* The 'auto' might be the placeholder return type for a function decl
19523 with trailing return type. */
19532 {
19534 {
19541 }
19544 {
19547 }
19550 }
19554 {
19557 }
19560 {
19563 }
19564 else
19568 {
19571 "use of %<auto%> in lambda parameter declaration "
19572 "only available with "
19574 }
19577 "use of %<auto%> in parameter declaration "
19578 "only available with "
19582 "use of %<auto%> in parameter declaration "
19584 }
19585 else
19590 /* Since DR 743, decltype can either be a simple-type-specifier by
19591 itself or begin a nested-name-specifier. Parsing it will replace
19592 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
19593 handling below decide what to do. */
19599 /* Consume the `typeof' token. */
19601 /* Parse the operand to `typeof'. */
19603 /* If it is not already a TYPE, take its type. */
19609 token,
19618 token,
19628 token,
19633 }
19635 /* If token is an already-parsed decltype not followed by ::,
19636 it's a simple-type-specifier. */
19639 {
19642 {
19644 token,
19646 /* Remember that we are handling a decltype in order to
19647 implement the resolution of DR 1510 when the argument
19648 isn't instantiation dependent. */
19650 }
19653 }
19655 /* If the type-specifier was for a built-in type, we're done. */
19657 {
19658 /* Record the type. */
19665 type,
19666 token,
19671 /* Consume the token. */
19677 /* There is no valid C++ program where a non-template type is
19678 followed by a "<". That usually indicates that the user thought
19679 that the type was a template. */
19684 }
19686 /* The type-specifier must be a user-defined type. */
19688 {
19694 /* Don't gobble tokens or issue error messages if this is an
19695 optional type-specifier. */
19699 /* Remember current tentative parsing state -- if we know we need
19700 a type, we can give better diagnostics here. */
19705 /* Look for the optional `::' operator. */
19706 global_p
19710 /* Look for the nested-name specifier. */
19711 qualified_p
19718 /* If we have seen a nested-name-specifier, and the next token
19719 is `template', then we are using the template-id production. */
19722 {
19723 /* Look for the template-id. */
19727 none_type,
19729 /* If the template-id did not name a type, we are out of
19730 luck. */
19732 {
19733 /* ...unless we pretend we have seen 'typename'. */
19737 else
19738 {
19741 }
19742 }
19743 }
19744 /* DR 1812: A < following a qualified-id in a typename-specifier
19745 could safely be assumed to begin a template argument list, so
19746 the template keyword should be optional. */
19748 && qualified_p
19749 && typename_p
19751 {
19757 none_type,
19759 /* This is handled below, so back off. */
19770 }
19772 /* Otherwise, look for a type-name. */
19774 {
19782 }
19785 {
19786 /* Try for a type-constraint with template arguments. We check
19787 decl_specs here to avoid trying this for a functional cast. */
19794 none_type,
19797 {
19802 /* Perhaps it's a concept-check expression. */
19804 }
19805 else
19810 }
19813 {
19814 /* Try class template argument deduction or type-constraint without
19815 template arguments. */
19819 {
19820 location_t loc
19823 none_type,
19835 else
19836 {
19841 }
19842 }
19843 else
19845 }
19847 /* If it didn't work out, we don't have a TYPE. */
19852 /* Keep track of all name-lookups performed in class scopes. */
19854 && !global_p
19855 && !qualified_p
19862 token,
19864 }
19866 /* If we didn't get a type-name, issue an error message. */
19868 {
19871 }
19874 {
19875 /* See if TYPE is an Objective-C type, and if so, parse and
19876 accept any protocol references following it. Do this before
19877 the cp_parser_check_for_invalid_template_id() call, because
19878 Objective-C types can be followed by '<...>' which would
19879 enclose protocol names rather than template arguments, and so
19880 everything is fine. */
19883 {
19887 /* Clobber the "unqualified" type previously entered into
19888 DECL_SPECS with the new, improved protocol-qualified version. */
19893 }
19895 /* There is no valid C++ program where a non-template type is
19896 followed by a "<". That usually indicates that the user
19897 thought that the type was a template. */
19899 none_type,
19901 }
19904 }
19906 /* Parse the remainder of a placholder-type-specifier.
19908 placeholder-type-specifier:
19909 type-constraint_opt auto
19910 type-constraint_opt decltype(auto)
19912 The raw form of the constraint is parsed in cp_parser_simple_type_specifier
19913 and passed as TMPL. This function converts TMPL to an actual type-constraint,
19914 parses the placeholder type, and performs some contextual syntactic analysis.
19916 LOC provides the location of the template name.
19918 TENTATIVE is true if the type-specifier parsing is tentative; in that case,
19919 don't give an error if TMPL isn't a valid type-constraint, as the template-id
19920 might actually be a concept-check,
19922 Note that the Concepts TS allows the auto or decltype(auto) to be
19923 omitted in a constrained-type-specifier. */
19925 static tree
19928 {
19934 /* Get the arguments as written for subsequent analysis. */
19937 {
19940 }
19941 else
19942 /* A concept-name with no arguments can't be an expression. */
19947 /* Get the concept and prototype parameter for the constraint. */
19954 /* As per the standard, require auto or decltype(auto), except in some
19955 cases (template parameter lists, -fconcepts-ts enabled). */
19958 {
19962 {
19964 matching_parens parens;
19968 }
19969 }
19971 /* A type constraint constrains a contextually determined type or type
19972 parameter pack. However, the Concepts TS does allow concepts
19973 to introduce non-type and template template parameters. */
19975 {
19978 {
19980 {
19983 }
19985 }
19986 }
19988 /* In a template parameter list, a type-parameter can be introduced
19989 by type-constraints alone. */
19993 /* Diagnose issues placeholder issues. */
19997 {
19999 /* Perhaps it's a concept-check expression (c++/91073). */
20006 /* Fall through. This is an error of omission. */
20007 }
20009 {
20010 /* A trailing return type only allows type-constraints. */
20013 }
20015 /* In a parameter-declaration-clause, a placeholder-type-specifier
20016 results in an invented template parameter. */
20018 {
20020 {
20026 }
20029 }
20031 /* Determine if the type should be deduced using template argument
20032 deduction or decltype deduction. Note that the latter is always
20033 used for type-constraints in trailing return types. */
20038 /* Otherwise, this is the type of a variable or return type. */
20041 else
20043 }
20045 /* Parse a type-name.
20047 type-name:
20048 class-name
20049 enum-name
20050 typedef-name
20051 simple-template-id [in c++0x]
20053 enum-name:
20054 identifier
20056 typedef-name:
20057 identifier
20059 Concepts:
20061 type-name:
20062 concept-name
20063 partial-concept-id
20065 concept-name:
20066 identifier
20068 Returns a TYPE_DECL for the type. */
20070 static tree
20072 {
20073 tree type_decl;
20075 /* We can't know yet whether it is a class-name or not. */
20077 /* Try a class-name. */
20079 typename_keyword_p,
20081 none_type,
20085 /* If it's not a class-name, keep looking. */
20087 {
20089 /* It must be a typedef-name or an enum-name. */
20093 /* It is either a simple-template-id representing an
20094 instantiation of an alias template... */
20098 none_type,
20100 /* Note that this must be an instantiation of an alias template
20101 because [temp.names]/6 says:
20103 A template-id that names an alias template specialization
20104 is a type-name.
20106 Whereas [temp.names]/7 says:
20108 A simple-template-id that names a class template
20109 specialization is a class-name.
20111 With concepts, this could also be a partial-concept-id that
20112 declares a non-type template parameter. */
20117 else
20121 /* ... Or a typedef-name or an enum-name. */
20123 }
20126 }
20128 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
20129 or a concept-name.
20131 enum-name:
20132 identifier
20134 typedef-name:
20135 identifier
20137 concept-name:
20138 identifier
20140 Returns a TYPE_DECL for the type. */
20142 static tree
20144 {
20145 tree type_decl;
20146 tree identifier;
20153 /* Look up the type-name. */
20160 {
20161 /* See if this is an Objective-C type. */
20166 }
20168 /* Issue an error if we did not find a type-name. */
20170 /* In Objective-C, we have the complication that class names are
20171 normally type names and start declarations (eg, the
20172 "NSObject" in "NSObject *object;"), but can be used in an
20173 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
20174 is an expression. So, a classname followed by a dot is not a
20175 valid type-name. */
20178 {
20183 }
20184 /* Remember that the name was used in the definition of the
20185 current class so that we can check later to see if the
20186 meaning would have been different after the class was
20187 entirely defined. */
20193 }
20195 /* Parse an elaborated-type-specifier. Note that the grammar given
20196 here incorporates the resolution to DR68.
20198 elaborated-type-specifier:
20199 class-key :: [opt] nested-name-specifier [opt] identifier
20200 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
20201 enum-key :: [opt] nested-name-specifier [opt] identifier
20202 typename :: [opt] nested-name-specifier identifier
20203 typename :: [opt] nested-name-specifier template [opt]
20204 template-id
20206 GNU extension:
20208 elaborated-type-specifier:
20209 class-key attributes :: [opt] nested-name-specifier [opt] identifier
20210 class-key attributes :: [opt] nested-name-specifier [opt]
20211 template [opt] template-id
20212 enum attributes :: [opt] nested-name-specifier [opt] identifier
20214 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
20215 declared `friend'. If IS_DECLARATION is TRUE, then this
20216 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
20217 something is being declared.
20219 Returns the TYPE specified. */
20221 static tree
20225 {
20227 tree identifier;
20230 tree globalscope;
20233 /* For class and enum types the location of the class-key or enum-key. */
20235 /* For a scoped enum, the 'class' or 'struct' keyword id. */
20238 /* See if we're looking at the `enum' keyword. */
20240 {
20241 /* Consume the `enum' token. */
20243 /* Remember that it's an enumeration type. */
20245 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
20246 enums) is used here. */
20250 {
20258 /* Consume the `struct' or `class' and parse it anyway. */
20260 /* Create a combined location for the whole scoped-enum-key. */
20262 }
20263 else
20266 /* Parse the attributes. */
20268 }
20269 /* Or, it might be `typename'. */
20271 RID_TYPENAME))
20272 {
20273 /* Consume the `typename' token. */
20275 /* Remember that it's a `typename' type. */
20277 }
20278 /* Otherwise it must be a class-key. */
20279 else
20280 {
20285 /* Parse the attributes. */
20287 }
20289 /* Look for the `::' operator. */
20292 /* Look for the nested-name-specifier. */
20293 tree nested_name_specifier;
20295 {
20296 nested_name_specifier
20301 is_declaration);
20304 }
20305 else
20306 /* Even though `typename' is not present, the proposed resolution
20307 to Core Issue 180 says that in `class A<T>::B', `B' should be
20308 considered a type-name, even if `A<T>' is dependent. */
20309 nested_name_specifier
20314 is_declaration);
20315 /* For everything but enumeration types, consider a template-id.
20316 For an enumeration type, consider only a plain identifier. */
20318 {
20320 tree decl;
20322 /* Allow the `template' keyword. */
20324 /* If we didn't see `template', we don't know if there's a
20325 template-id or not. */
20328 /* The `template' keyword must follow a nested-name-specifier. */
20330 {
20334 }
20336 /* Parse the template-id. */
20340 tag_type,
20341 is_declaration);
20342 /* If we didn't find a template-id, look for an ordinary
20343 identifier. */
20345 ;
20346 /* We can get here when cp_parser_template_id, called by
20347 cp_parser_class_name with tag_type == none_type, succeeds
20348 and caches a BASELINK. Then, when called again here,
20349 instead of failing and returning an error_mark_node
20350 returns it (see template/typename17.C in C++11).
20351 ??? Could we diagnose this earlier? */
20353 {
20356 }
20357 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
20358 in effect, then we must assume that, upon instantiation, the
20359 template will correspond to a class. */
20363 typename_type,
20365 /* If the `typename' keyword is in effect and DECL is not a type
20366 decl, then type is non existent. */
20368 ;
20370 {
20374 /* If the next token is a semicolon, this must be a specialization,
20375 instantiation, or friend declaration. Check the scope while we
20376 still know whether or not we had a nested-name-specifier. */
20381 }
20384 }
20387 {
20392 {
20395 }
20397 /* For a `typename', we needn't call xref_tag. */
20403 /* Template parameter lists apply only if we are not within a
20404 function parameter list. */
20405 bool template_parm_lists_apply
20414 /* Look up a qualified name in the usual way. */
20416 {
20417 tree decl;
20418 tree ambiguous_decls;
20421 tag_type,
20428 /* If the lookup was ambiguous, an error will already have been
20429 issued. */
20433 /* If we are parsing friend declaration, DECL may be a
20434 TEMPLATE_DECL tree node here. However, we need to check
20435 whether this TEMPLATE_DECL results in valid code. Consider
20436 the following example:
20438 namespace N {
20439 template <class T> class C {};
20440 }
20441 class X {
20442 template <class T> friend class N::C; // #1, valid code
20443 };
20444 template <class T> class Y {
20445 friend class N::C; // #2, invalid code
20446 };
20448 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
20449 name lookup of `N::C'. We see that friend declaration must
20450 be template for the code to be valid. Note that
20451 processing_template_decl does not work here since it is
20452 always 1 for the above two cases. */
20454 decl = (cp_parser_maybe_treat_template_as_class
20459 {
20461 identifier,
20464 }
20467 {
20471 allow_template);
20475 }
20477 /* Forward declarations of nested types, such as
20479 class C1::C2;
20480 class C1::C2::C3;
20482 are invalid unless all components preceding the final '::'
20483 are complete. If all enclosing types are complete, these
20484 declarations become merely pointless.
20486 Invalid forward declarations of nested types are errors
20487 caught elsewhere in parsing. Those that are pointless arrive
20488 here. */
20496 }
20497 else
20498 {
20499 /* An elaborated-type-specifier sometimes introduces a new type and
20500 sometimes names an existing type. Normally, the rule is that it
20501 introduces a new type only if there is not an existing type of
20502 the same name already in scope. For example, given:
20504 struct S {};
20505 void f() { struct S s; }
20507 the `struct S' in the body of `f' is the same `struct S' as in
20508 the global scope; the existing definition is used. However, if
20509 there were no global declaration, this would introduce a new
20510 local class named `S'.
20512 An exception to this rule applies to the following code:
20514 namespace N { struct S; }
20516 Here, the elaborated-type-specifier names a new type
20517 unconditionally; even if there is already an `S' in the
20518 containing scope this declaration names a new type.
20519 This exception only applies if the elaborated-type-specifier
20520 forms the complete declaration:
20522 [class.name]
20524 A declaration consisting solely of `class-key identifier ;' is
20525 either a redeclaration of the name in the current scope or a
20526 forward declaration of the identifier as a class name. It
20527 introduces the name into the current scope.
20529 We are in this situation precisely when the next token is a `;'.
20531 An exception to the exception is that a `friend' declaration does
20532 *not* name a new type; i.e., given:
20534 struct S { friend struct T; };
20536 `T' is not a new type in the scope of `S'.
20538 Also, `new struct S' or `sizeof (struct S)' never results in the
20539 definition of a new type; a new type can only be declared in a
20540 declaration context. */
20542 TAG_how how;
20545 /* Friends have special name lookup rules. */
20549 CPP_SEMICOLON))
20550 /* This is a `class-key identifier ;' */
20552 else
20556 (template_parm_lists_apply
20559 /* An unqualified name was used to reference this type, so
20560 there were no qualifying templates. */
20570 }
20571 }
20576 /* Allow attributes on forward declarations of classes. */
20578 {
20589 {
20593 }
20596 else
20598 "attributes ignored on elaborated-type-specifier that is "
20600 }
20604 else
20605 {
20606 /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
20607 for alias definition. */
20611 decl_class);
20613 /* Indicate whether this class was declared as a `class' or as a
20614 `struct'. */
20617 }
20619 /* A "<" cannot follow an elaborated type specifier. If that
20620 happens, the user was probably trying to form a template-id. */
20625 }
20627 /* Parse an enum-specifier.
20629 enum-specifier:
20630 enum-head { enumerator-list [opt] }
20631 enum-head { enumerator-list , } [C++0x]
20633 enum-head:
20634 enum-key identifier [opt] enum-base [opt]
20635 enum-key nested-name-specifier identifier enum-base [opt]
20637 enum-key:
20638 enum
20639 enum class [C++0x]
20640 enum struct [C++0x]
20642 enum-base: [C++0x]
20643 : type-specifier-seq
20645 opaque-enum-specifier:
20646 enum-key identifier enum-base [opt] ;
20648 GNU Extensions:
20649 enum-key attributes[opt] identifier [opt] enum-base [opt]
20650 { enumerator-list [opt] }attributes[opt]
20651 enum-key attributes[opt] identifier [opt] enum-base [opt]
20652 { enumerator-list, }attributes[opt] [C++0x]
20654 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
20655 if the token stream isn't an enum-specifier after all. */
20657 static tree
20659 {
20660 tree identifier;
20662 tree prev_scope;
20664 tree attributes;
20675 /* Parse tentatively so that we can back up if we don't find a
20676 enum-specifier. */
20679 /* Caller guarantees that the current token is 'enum', an identifier
20680 possibly follows, and the token after that is an opening brace.
20681 If we don't have an identifier, fabricate an anonymous name for
20682 the enumeration being defined. */
20685 /* Parse the "class" or "struct", which indicates a scoped
20686 enumeration type in C++0x. */
20689 {
20693 /* Consume the `struct' or `class' token. */
20697 }
20701 /* Clear the qualification. */
20706 /* Figure out in what scope the declaration is being placed. */
20712 nested_name_specifier
20720 {
20721 tree name;
20725 enum_type,
20730 input_location);
20732 {
20735 {
20736 /* Are template enums allowed in ISO? */
20740 /* ignore a typename reference, for it will be solved by name
20741 in start_enum. */
20743 }
20744 }
20747 else
20748 {
20753 }
20754 }
20755 else
20756 {
20759 else
20760 {
20766 }
20767 }
20770 /* Check for the `:' that denotes a specified underlying type in C++0x.
20771 Note that a ':' could also indicate a bitfield width, however. */
20773 {
20774 cp_decl_specifier_seq type_specifiers;
20776 /* Consume the `:'. */
20779 auto tdf
20783 /* Parse the type-specifier-seq. */
20789 /* At this point this is surely not elaborated type specifier. */
20798 /* If that didn't work, stop. */
20800 {
20806 }
20807 }
20809 /* Look for the `{' but don't consume it yet. */
20811 {
20813 {
20819 }
20820 /* An opaque-enum-specifier must have a ';' here. */
20823 {
20829 }
20830 }
20836 {
20838 {
20842 }
20845 }
20847 /* Issue an error message if type-definitions are forbidden here. */
20850 else
20851 /* Create the new type. We do this before consuming the opening
20852 brace so the enum will be recorded as being on the line of its
20853 tag (or the 'enum' keyword, if there is no tag). */
20857 /* If the next token is not '{' it is an opaque-enum-specifier or an
20858 elaborated-type-specifier. */
20860 {
20864 {
20865 /* The following catches invalid code such as:
20866 enum class S<int>::E { A, B, C }; */
20874 {
20878 nested_name_specifier);
20880 }
20883 {
20885 "%qT for enum declaration does not name a class "
20888 }
20889 /* If that scope does not contain the scope in which the
20890 class was originally declared, the program is invalid. */
20892 nested_name_specifier))
20893 {
20896 "declaration of %qD in namespace %qD which does not "
20899 else
20901 "declaration of %qD in %qD which does not "
20905 }
20906 /* If that scope is the scope where the declaration is being placed
20907 the program is invalid. */
20911 {
20915 }
20916 }
20921 /* Consume the opening brace. */
20922 matching_braces braces;
20929 {
20933 }
20934 else
20935 {
20941 }
20945 /* If the next token is not '}', then there are some enumerators. */
20947 {
20951 }
20952 else
20953 {
20954 /* We've seen a '{' so we know we're in an enum-specifier.
20955 Commit to any tentative parse to get syntax errors. */
20958 }
20960 /* Consume the final '}'. */
20966 }
20967 else
20968 {
20969 /* If a ';' follows, then it is an opaque-enum-specifier
20970 and additional restrictions apply. */
20972 {
20979 }
20980 }
20982 /* Look for trailing attributes to apply to this enumeration, and
20983 apply them if appropriate. */
20985 {
20988 trailing_attr,
20990 }
20992 /* Finish up the enumeration. */
20994 {
20999 }
21002 {
21004 {
21007 }
21010 }
21012 }
21014 /* Parse an enumerator-list. The enumerators all have the indicated
21015 TYPE.
21017 enumerator-list:
21018 enumerator-definition
21019 enumerator-list , enumerator-definition */
21021 static void
21023 {
21025 {
21026 /* Parse an enumerator-definition. */
21029 /* If the next token is not a ',', we've reached the end of
21030 the list. */
21033 /* Otherwise, consume the `,' and keep going. */
21035 /* If the next token is a `}', there is a trailing comma. */
21037 {
21042 }
21043 }
21044 }
21046 /* Parse an enumerator-definition. The enumerator has the indicated
21047 TYPE.
21049 enumerator-definition:
21050 enumerator
21051 enumerator = constant-expression
21053 enumerator:
21054 identifier
21056 GNU Extensions:
21058 enumerator-definition:
21059 enumerator attributes [opt]
21060 enumerator attributes [opt] = constant-expression */
21062 static void
21064 {
21065 tree identifier;
21066 tree value;
21067 location_t loc;
21069 /* Save the input location because we are interested in the location
21070 of the identifier and not the location of the explicit value. */
21073 /* Look for the identifier. */
21078 /* Parse any specified attributes. */
21081 /* If the next token is an '=', then there is an explicit value. */
21083 {
21084 /* Consume the `=' token. */
21086 /* Parse the value. */
21088 }
21089 else
21092 /* If we are processing a template, make sure the initializer of the
21093 enumerator doesn't contain any bare template parameter pack. */
21097 /* Create the enumerator. */
21099 }
21101 /* Parse a namespace-name.
21103 namespace-name:
21104 original-namespace-name
21105 namespace-alias
21107 Returns the NAMESPACE_DECL for the namespace. */
21109 static tree
21111 {
21112 tree identifier;
21113 tree namespace_decl;
21117 /* Get the name of the namespace. */
21122 /* Look up the identifier in the currently active scope. Look only
21123 for namespaces, due to:
21125 [basic.lookup.udir]
21127 When looking up a namespace-name in a using-directive or alias
21128 definition, only namespace names are considered.
21130 And:
21132 [basic.lookup.qual]
21134 During the lookup of a name preceding the :: scope resolution
21135 operator, object, function, and enumerator names are ignored.
21137 (Note that cp_parser_qualifying_entity only calls this
21138 function if the token after the name is the scope resolution
21139 operator.) */
21141 none_type,
21147 /* If it's not a namespace, issue an error. */
21150 {
21152 {
21153 auto_diagnostic_group d;
21154 name_hint hint;
21158 identifier,
21161 {
21167 }
21168 else
21170 identifier);
21171 }
21172 else
21175 }
21178 }
21180 /* Parse a namespace-definition.
21182 namespace-definition:
21183 named-namespace-definition
21184 unnamed-namespace-definition
21186 named-namespace-definition:
21187 original-namespace-definition
21188 extension-namespace-definition
21190 original-namespace-definition:
21191 namespace identifier { namespace-body }
21193 extension-namespace-definition:
21194 namespace original-namespace-name { namespace-body }
21196 unnamed-namespace-definition:
21197 namespace { namespace-body } */
21199 static void
21201 {
21202 tree identifier;
21212 {
21215 }
21217 /* Look for the `namespace' keyword. */
21218 cp_token* token
21221 /* Parse any specified attributes before the identifier. */
21225 {
21229 RID_INLINE);
21231 {
21235 "definitions only available with %<-std=c++20%> or "
21238 }
21241 {
21246 "standard attributes on namespaces must precede "
21249 /* Parse any attributes specified after the identifier. */
21251 }
21254 {
21255 /* Don't forget that the innermost namespace might have been
21256 marked as inline. Use |= because we cannot overwrite
21257 IS_INLINE in case the outermost namespace is inline, but
21258 there are no nested inlines. */
21261 }
21265 "nested namespace definitions only available with "
21268 /* Nested namespace names can create new namespaces (unlike
21269 other qualified-ids). */
21274 else
21277 }
21289 /* Start the namespace. */
21296 /* Look for the `{' to validate starting the namespace. */
21297 matching_braces braces;
21299 {
21300 /* Parse the body of the namespace. */
21303 /* Look for the final `}'. */
21305 }
21310 /* Pop the nested namespace definitions. */
21313 }
21315 /* Parse a namespace-body.
21317 namespace-body:
21318 declaration-seq [opt] */
21320 static void
21322 {
21324 }
21326 /* Parse a namespace-alias-definition.
21328 namespace-alias-definition:
21329 namespace identifier = qualified-namespace-specifier ; */
21331 static void
21333 {
21334 tree identifier;
21335 tree namespace_specifier;
21339 /* Look for the `namespace' keyword. */
21341 /* Look for the identifier. */
21345 /* Look for the `=' token. */
21348 {
21350 /* Skip the definition. */
21355 }
21357 /* Look for the qualified-namespace-specifier. */
21358 namespace_specifier
21361 /* Look for the `;' token. */
21364 /* Register the alias in the symbol table. */
21366 }
21368 /* Parse a qualified-namespace-specifier.
21370 qualified-namespace-specifier:
21371 :: [opt] nested-name-specifier [opt] namespace-name
21373 Returns a NAMESPACE_DECL corresponding to the specified
21374 namespace. */
21376 static tree
21378 {
21379 /* Look for the optional `::'. */
21383 /* Look for the optional nested-name-specifier. */
21391 }
21393 /* Subroutine of cp_parser_using_declaration. */
21395 static tree
21397 {
21400 {
21401 /* Create the USING_DECL. */
21410 /* Add it to the list of members in this class. */
21412 }
21413 else
21416 }
21418 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
21419 access declaration.
21421 using-declaration:
21422 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
21423 using :: unqualified-id ;
21425 access-declaration:
21426 qualified-id ;
21428 */
21430 static bool
21433 {
21437 tree identifier;
21438 tree qscope;
21443 {
21446 }
21447 else
21448 {
21449 /* Look for the `using' keyword. */
21452 again:
21453 /* Peek at the next token. */
21455 /* See if it's `typename'. */
21457 {
21458 /* Remember that we've seen it. */
21460 /* Consume the `typename' token. */
21462 }
21463 }
21465 /* Look for the optional global scope qualification. */
21466 global_scope_p
21471 /* If we saw `typename', or didn't see `::', then there must be a
21472 nested-name-specifier present. */
21474 {
21480 {
21483 }
21484 }
21485 /* Otherwise, we could be in either of the two productions. In that
21486 case, treat the nested-name-specifier as optional. */
21487 else
21499 /* Something has already gone wrong; there's no need to parse
21500 further. Since an error has occurred, the return value of
21501 cp_parser_parse_definitely will be false, as required. */
21505 /* Parse the unqualified-id. */
21513 {
21518 }
21520 {
21524 "pack expansion in using-declaration only available "
21527 }
21529 /* The function we call to handle a using-declaration is different
21530 depending on what scope we are in. */
21532 ;
21535 /* [namespace.udecl]
21537 A using declaration shall not name a template-id. */
21540 else
21541 {
21545 {
21548 }
21549 }
21553 {
21557 "comma-separated list in using-declaration only available "
21560 }
21562 /* Look for the final `;'. */
21567 "access declarations are deprecated "
21568 "in favour of using-declarations; "
21572 }
21574 /* C++20 using enum declaration.
21576 using-enum-declaration :
21577 using elaborated-enum-specifier ; */
21579 static void
21581 {
21584 /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
21585 breaks one of the motivating examples in using-enum-5.C.
21586 cp_parser_simple_type_specifier seems to be closer to what we actually
21587 want, though that hasn't been properly specified yet. */
21589 /* Consume 'enum'. */
21595 tree type = (cp_parser_simple_type_specifier
21602 {
21605 }
21609 /* The elaborated-enum-specifier shall not name a dependent type and the type
21610 shall have a reachable enum-specifier. */
21624 {
21626 auto_diagnostic_group g;
21630 ;
21633 else
21635 }
21637 /* A using-enum-declaration introduces the enumerator names of the named
21638 enumeration as if by a using-declaration for each enumerator. */
21642 }
21644 /* Parse an alias-declaration.
21646 alias-declaration:
21647 using identifier attribute-specifier-seq [opt] = type-id */
21649 static tree
21651 {
21655 cp_decl_specifier_seq decl_specs;
21659 /* Look for the `using' keyword. */
21660 cp_token *using_token
21682 /* Now we are going to parse the type-id of the declaration. */
21684 /*
21685 [dcl.type]/3 says:
21687 "A type-specifier-seq shall not define a class or enumeration
21688 unless it appears in the type-id of an alias-declaration (7.1.3) that
21689 is not the declaration of a template-declaration."
21691 In other words, if we currently are in an alias template, the
21692 type-id should not define a type.
21694 So let's set parser->type_definition_forbidden_message in that
21695 case; cp_parser_check_type_definition (called by
21696 cp_parser_class_specifier) will then emit an error if a type is
21697 defined in the type-id. */
21699 {
21703 }
21708 /* Restore the error message if need be. */
21714 {
21717 }
21719 /* A typedef-name can also be introduced by an alias-declaration. The
21720 identifier following the using keyword becomes a typedef-name. It has
21721 the same semantics as if it were introduced by the typedef
21722 specifier. In particular, it does not define a new type and it shall
21723 not appear in the type-id. */
21728 {
21731 ds_attribute,
21732 attrs_token);
21733 }
21735 ds_typedef,
21736 using_token);
21738 ds_alias,
21739 using_token);
21746 id_location,
21756 else
21767 /* If decl is a template, return its TEMPLATE_DECL so that it gets
21768 added into the symbol table; otherwise, return the TYPE_DECL. */
21772 {
21776 }
21779 }
21781 /* Parse a using-directive.
21783 using-directive:
21784 attribute-specifier-seq [opt] using namespace :: [opt]
21785 nested-name-specifier [opt] namespace-name ; */
21787 static void
21789 {
21790 tree namespace_decl;
21793 {
21794 /* Error during attribute parsing that resulted in skipping
21795 to next semicolon. */
21798 }
21800 /* Look for the `using' keyword. */
21802 /* And the `namespace' keyword. */
21804 /* Look for the optional `::' operator. */
21806 /* And the optional nested-name-specifier. */
21812 /* Get the namespace being used. */
21815 /* And any specified GNU attributes. */
21819 /* Update the symbol table. */
21822 /* Look for the final `;'. */
21824 }
21826 /* Parse an asm-definition.
21828 asm-qualifier:
21829 volatile
21830 inline
21831 goto
21833 asm-qualifier-list:
21834 asm-qualifier
21835 asm-qualifier-list asm-qualifier
21837 asm-definition:
21838 asm ( string-literal ) ;
21840 GNU Extension:
21842 asm-definition:
21843 asm asm-qualifier-list [opt] ( string-literal ) ;
21844 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
21845 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
21846 : asm-operand-list [opt] ) ;
21847 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
21848 : asm-operand-list [opt]
21849 : asm-clobber-list [opt] ) ;
21850 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
21851 : asm-clobber-list [opt]
21852 : asm-goto-list ) ;
21854 The form with asm-goto-list is valid if and only if the asm-qualifier-list
21855 contains goto, and is the only allowed form in that case. No duplicates are
21856 allowed in an asm-qualifier-list. */
21858 static void
21860 {
21861 tree string;
21866 tree asm_stmt;
21873 /* Look for the `asm' keyword. */
21876 /* In C++20, unevaluated inline assembly is permitted in constexpr
21877 functions. */
21882 "function only available with %<-std=c++20%> or "
21885 /* Handle the asm-qualifier-list. */
21893 {
21897 {
21900 {
21904 }
21905 else
21906 {
21911 }
21917 {
21921 }
21922 else
21931 {
21935 }
21936 else
21951 }
21953 }
21960 {
21963 }
21965 /* Look for the opening `('. */
21968 /* Look for the string. */
21971 {
21975 }
21977 /* If we're allowing GNU extensions, check for the extended assembly
21978 syntax. Unfortunately, the `:' tokens need not be separated by
21979 a space in C, and so, for compatibility, we tolerate that here
21980 too. Doing that means that we have to treat the `::' operator as
21981 two `:' tokens. */
21986 {
21991 /* The extended syntax was used. */
21994 /* Look for outputs. */
21996 {
21997 /* Consume the `:'. */
21999 /* Parse the output-operands. */
22001 CPP_COLON)
22003 CPP_SCOPE)
22005 CPP_CLOSE_PAREN))
22006 {
22010 }
22011 }
22012 /* If the next token is `::', there are no outputs, and the
22013 next token is the beginning of the inputs. */
22015 /* The inputs are coming next. */
22018 /* Look for inputs. */
22021 {
22022 /* Consume the `:' or `::'. */
22024 /* Parse the output-operands. */
22026 CPP_COLON)
22028 CPP_SCOPE)
22030 CPP_CLOSE_PAREN))
22031 {
22035 }
22036 }
22038 /* The clobbers are coming next. */
22041 /* Look for clobbers. */
22044 {
22046 /* Consume the `:' or `::'. */
22048 /* Parse the clobbers. */
22050 CPP_COLON)
22052 CPP_CLOSE_PAREN))
22054 }
22056 /* The labels are coming next. */
22059 /* Look for labels. */
22062 {
22064 /* Consume the `:' or `::'. */
22066 /* Parse the labels. */
22068 }
22072 }
22076 /* Look for the closing `)'. */
22084 {
22085 /* Create the ASM_EXPR. */
22087 {
22090 /* If the extended syntax was not used, mark the ASM_EXPR. */
22092 {
22098 }
22099 }
22100 else
22102 }
22103 }
22105 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
22106 type that comes from the decl-specifier-seq. */
22108 static tree
22110 {
22113 {
22126 }
22129 }
22131 /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
22132 a construct looks like a variable definition but is actually a function
22133 declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
22134 is the declarator for this function declaration. */
22136 static void
22139 {
22140 /* Only warn if we are declaring a function at block scope. */
22144 /* And only if there is no storage class specified. */
22156 /* Don't warn when the whole declarator (not just the declarator-id!)
22157 was parenthesized. That is, don't warn for int(n()) but do warn
22158 for int(f)(). */
22162 tree type;
22164 {
22169 /* If the return type is void there is no ambiguity. */
22172 }
22174 /* Code like long f(); will have null ->type. If we have any
22175 type-specifiers, pretend we've seen int. */
22177 else
22180 auto_diagnostic_group d;
22185 /* The T t() case. */
22187 {
22189 "empty parentheses were disambiguated as a function "
22191 {
22192 /* () means value-initialization (C++03 and up); {} (C++11 and up)
22193 means value-initialization or aggregate-initialization, nothing
22194 means default-initialization. We can only suggest removing the
22195 parentheses/adding {} if T has a default constructor. */
22197 {
22203 {
22207 else
22210 }
22211 }
22212 }
22214 }
22216 /* If we had (...) or the parameter-list wasn't parenthesized,
22217 we're done. */
22221 /* The T t(X()) case. */
22223 {
22225 "parentheses were disambiguated as a function "
22227 {
22229 /* {}-initialization means that we can use an initializer-list
22230 constructor if no default constructor is available, so don't
22231 suggest using {} for classes that have an initializer_list
22232 constructor. */
22234 {
22239 }
22240 else
22241 {
22245 }
22246 }
22247 }
22248 /* The T t(X(), X()) case. */
22250 "parentheses were disambiguated as a function "
22252 {
22255 {
22260 }
22261 }
22262 }
22264 /* If DECLARATOR with DECL_SPECS is a function declarator that has
22265 the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
22266 has the same meaning as in cp_parser_declarator. */
22268 static void
22273 {
22279 {
22287 {
22291 }
22292 }
22293 }
22295 /* Declarators [gram.dcl.decl] */
22297 /* Parse an init-declarator.
22299 init-declarator:
22300 declarator initializer [opt]
22302 GNU Extension:
22304 init-declarator:
22305 declarator asm-specification [opt] attributes [opt] initializer [opt]
22307 function-definition:
22308 decl-specifier-seq [opt] declarator ctor-initializer [opt]
22309 function-body
22310 decl-specifier-seq [opt] declarator function-try-block
22312 GNU Extension:
22314 function-definition:
22315 __extension__ function-definition
22317 TM Extension:
22319 function-definition:
22320 decl-specifier-seq [opt] declarator function-transaction-block
22322 The parser flags FLAGS is used to control type-specifier parsing.
22324 The DECL_SPECIFIERS apply to this declarator. Returns a
22325 representation of the entity declared. If MEMBER_P is TRUE, then
22326 this declarator appears in a class scope. The new DECL created by
22327 this declarator is returned.
22329 The CHECKS are access checks that should be performed once we know
22330 what entity is being declared (and, therefore, what classes have
22331 befriended it).
22333 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
22334 for a function-definition here as well. If the declarator is a
22335 declarator for a function-definition, *FUNCTION_DEFINITION_P will
22336 be TRUE upon return. By that point, the function-definition will
22337 have been completely parsed.
22339 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
22340 is FALSE.
22342 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
22343 parsed declaration if it is an uninitialized single declarator not followed
22344 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
22345 if present, will not be consumed. If returned, this declarator will be
22346 created with SD_INITIALIZED but will not call cp_finish_decl.
22348 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
22349 and there is an initializer, the pointed location_t is set to the
22350 location of the '=' or `(', or '{' in C++11 token introducing the
22351 initializer. */
22353 static tree
22355 cp_parser_flags flags,
22365 {
22369 tree prefix_attributes;
22371 tree asm_specification;
22372 tree initializer;
22374 tree scope;
22376 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
22377 initialized with "= ..", CPP_OPEN_PAREN if initialized with
22378 "(...)". */
22393 /* Assume that this is not the declarator for a function
22394 definition. */
22398 /* Default arguments are only permitted for function parameters. */
22402 /* Defer access checks while parsing the declarator; we cannot know
22403 what names are accessible until we know what is being
22404 declared. */
22409 /* Parse the declarator. */
22410 declarator
22415 /* Gather up the deferred checks. */
22420 /* If the DECLARATOR was erroneous, there's no need to go
22421 further. */
22425 /* Check that the number of template-parameter-lists is OK. */
22435 /* Figure out what scope the entity declared by the DECLARATOR is
22436 located in. `grokdeclarator' sometimes changes the scope, so
22437 we compute it now. */
22440 /* Perform any lookups in the declared type which were thought to be
22441 dependent, but are not in the scope of the declarator. */
22442 decl_specifiers->type
22445 /* If we're allowing GNU extensions, look for an
22446 asm-specification. */
22448 {
22449 /* Look for an asm-specification. */
22452 }
22453 else
22456 /* Gather the attributes that were provided with the
22457 decl-specifiers. */
22460 /* Look for attributes. */
22464 /* Peek at the next token. */
22470 {
22471 /* Handle C++17 deduction guides. Note that class-scope
22472 non-template deduction guides are instead handled in
22473 cp_parser_member_declaration. */
22475 decl_specifiers,
22476 declarator,
22482 /* Check to see if the token indicates the start of a
22483 function-definition. */
22485 {
22487 {
22488 /* If a function-definition should not appear here, issue an
22489 error message. */
22493 }
22495 location_t func_brace_location
22498 /* Neither attributes nor an asm-specification are allowed
22499 on a function-definition. */
22502 "an %<asm%> specification is not allowed "
22506 "attributes are not allowed "
22508 /* This is a function-definition. */
22511 /* Parse the function definition. */
22514 decl_specifiers,
22515 declarator,
22516 prefix_attributes);
22517 else
22518 decl =
22519 (cp_parser_function_definition_from_specifiers_and_declarator
22523 {
22524 /* This is where the prologue starts... */
22527 }
22530 }
22531 }
22533 {
22534 /* A non-template declaration involving a function parameter list
22535 containing an implicit template parameter will be made into a
22536 template. If the resulting declaration is not going to be an
22537 actual function then finish the template scope here to prevent it.
22538 An error message will be issued once we have a decl to talk about.
22540 FIXME probably we should do type deduction rather than create an
22541 implicit template, but the standard currently doesn't allow it. */
22544 }
22546 /* [dcl.dcl]
22548 Only in function declarations for constructors, destructors, type
22549 conversions, and deduction guides can the decl-specifier-seq be omitted.
22551 We explicitly postpone this check past the point where we handle
22552 function-definitions because we tolerate function-definitions
22553 that are missing their return types in some modes. */
22555 {
22559 }
22561 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
22565 {
22577 {
22583 }
22584 }
22585 else
22586 {
22587 /* If the init-declarator isn't initialized and isn't followed by a
22588 `,' or `;', it's not a valid init-declarator. */
22591 {
22594 else
22595 {
22599 }
22600 }
22603 }
22605 /* Because start_decl has side-effects, we should only call it if we
22606 know we're going ahead. By this point, we know that we cannot
22607 possibly be looking at any other construct. */
22610 /* Enter the newly declared entry in the symbol table. If we're
22611 processing a declaration in a class-specifier, we wait until
22612 after processing the initializer. */
22614 {
22622 /* Adjust location of decl if declarator->id_loc is more appropriate:
22623 set, and decl wasn't merged with another decl, in which case its
22624 location would be different from input_location, and more accurate. */
22629 }
22631 /* Enter the SCOPE. That way unqualified names appearing in the
22632 initializer will be looked up in SCOPE. */
22635 /* Perform deferred access control checks, now that we know in which
22636 SCOPE the declared entity resides. */
22638 {
22641 /* If the entity being declared is a function, pretend that we
22642 are in its scope. If it is a `friend', it may have access to
22643 things that would not otherwise be accessible. */
22645 {
22648 }
22650 /* Perform access checks for template parameters. */
22653 /* Perform the access control checks for the declarator and the
22654 decl-specifiers. */
22657 /* Restore the saved value. */
22660 }
22662 /* Parse the initializer. */
22667 {
22669 {
22672 else
22673 {
22674 /* If the declaration was erroneous, we don't really
22675 know what the user intended, so just silently
22676 consume the initializer. */
22683 }
22684 }
22685 else
22686 {
22687 /* We want to record the extra mangling scope for in-class
22688 initializers of class members and initializers of static
22689 data member templates and namespace-scope initializers.
22690 The former involves deferring parsing of the initializer
22691 until end of class as with default arguments. So right
22692 here we only handle the latter two. */
22696 && !member_p
22709 }
22710 }
22712 /* The old parser allows attributes to appear after a parenthesized
22713 initializer. Mark Mitchell proposed removing this functionality
22714 on the GCC mailing lists on 2002-08-13. This parser accepts the
22715 attributes -- but ignores them. Made a permerror in GCC 8. */
22721 {
22724 {
22728 }
22729 }
22731 /* And now complain about a non-function implicit template. */
22736 /* For an in-class declaration, use `grokfield' to create the
22737 declaration. */
22739 {
22741 {
22744 }
22753 }
22755 /* Finish processing the declaration. But, skip member
22756 declarations. */
22758 {
22761 asm_specification,
22762 /* If the initializer is in parentheses, then this is
22763 a direct-initialization, which means that an
22764 `explicit' constructor is OK. Otherwise, an
22765 `explicit' constructor cannot be used. */
22768 }
22771 /* Core issue #226 (C++0x only): A default template-argument
22772 shall not be specified in a friend class template
22773 declaration. */
22782 {
22785 else
22787 }
22794 }
22796 /* Parse a declarator.
22798 declarator:
22799 direct-declarator
22800 ptr-operator declarator
22802 abstract-declarator:
22803 ptr-operator abstract-declarator [opt]
22804 direct-abstract-declarator
22806 GNU Extensions:
22808 declarator:
22809 attributes [opt] direct-declarator
22810 attributes [opt] ptr-operator declarator
22812 abstract-declarator:
22813 attributes [opt] ptr-operator abstract-declarator [opt]
22814 attributes [opt] direct-abstract-declarator
22816 The parser flags FLAGS is used to control type-specifier parsing.
22818 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
22819 detect constructors, destructors, deduction guides, or conversion operators.
22820 It is set to -1 if the declarator is a name, and +1 if it is a
22821 function. Otherwise it is set to zero. Usually you just want to
22822 test for >0, but internally the negative value is used.
22824 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
22825 a decl-specifier-seq unless it declares a constructor, destructor,
22826 or conversion. It might seem that we could check this condition in
22827 semantic analysis, rather than parsing, but that makes it difficult
22828 to handle something like `f()'. We want to notice that there are
22829 no decl-specifiers, and therefore realize that this is an
22830 expression, not a declaration.)
22832 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
22833 the declarator is a direct-declarator of the form "(...)".
22835 MEMBER_P is true iff this declarator is a member-declarator.
22837 FRIEND_P is true iff this declarator is a friend.
22839 STATIC_P is true iff the keyword static was seen. */
22843 cp_parser_declarator_kind dcl_kind,
22844 cp_parser_flags flags,
22848 {
22851 cp_cv_quals cv_quals;
22852 tree class_type;
22855 /* Assume this is not a constructor, destructor, or type-conversion
22856 operator. */
22863 /* Check for the ptr-operator production. */
22865 /* Parse the ptr-operator. */
22871 /* If that worked, then we have a ptr-operator. */
22873 {
22874 /* If a ptr-operator was found, then this declarator was not
22875 parenthesized. */
22878 /* The dependent declarator is optional if we are parsing an
22879 abstract-declarator. */
22883 /* Parse the dependent declarator. */
22889 /* If we are parsing an abstract-declarator, we must handle the
22890 case where the dependent declarator is absent. */
22895 declarator = cp_parser_make_indirect_declarator
22897 }
22898 /* Everything else is a direct-declarator. */
22899 else
22900 {
22903 CPP_OPEN_PAREN);
22907 }
22912 }
22914 /* Parse a direct-declarator or direct-abstract-declarator.
22916 direct-declarator:
22917 declarator-id
22918 direct-declarator ( parameter-declaration-clause )
22919 cv-qualifier-seq [opt]
22920 ref-qualifier [opt]
22921 exception-specification [opt]
22922 direct-declarator [ constant-expression [opt] ]
22923 ( declarator )
22925 direct-abstract-declarator:
22926 direct-abstract-declarator [opt]
22927 ( parameter-declaration-clause )
22928 cv-qualifier-seq [opt]
22929 ref-qualifier [opt]
22930 exception-specification [opt]
22931 direct-abstract-declarator [opt] [ constant-expression [opt] ]
22932 ( abstract-declarator )
22934 Returns a representation of the declarator. DCL_KIND is
22935 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
22936 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
22937 we are parsing a direct-declarator. It is
22938 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
22939 of ambiguity we prefer an abstract declarator, as per
22940 [dcl.ambig.res].
22941 The parser flags FLAGS is used to control type-specifier parsing.
22942 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
22943 as for cp_parser_declarator. */
22947 cp_parser_declarator_kind dcl_kind,
22948 cp_parser_flags flags,
22951 {
22962 {
22963 /* Peek at the next token. */
22966 {
22967 /* This is either a parameter-declaration-clause, or a
22968 parenthesized declarator. When we know we are parsing a
22969 named declarator, it must be a parenthesized declarator
22970 if FIRST is true. For instance, `(int)' is a
22971 parameter-declaration-clause, with an omitted
22972 direct-abstract-declarator. But `((*))', is a
22973 parenthesized abstract declarator. Finally, when T is a
22974 template parameter `(T)' is a
22975 parameter-declaration-clause, and not a parenthesized
22976 named declarator.
22978 We first try and parse a parameter-declaration-clause,
22979 and then try a nested declarator (if FIRST is true).
22981 It is not an error for it not to be a
22982 parameter-declaration-clause, even when FIRST is
22983 false. Consider,
22985 int i (int);
22986 int i (3);
22988 The first is the declaration of a function while the
22989 second is the definition of a variable, including its
22990 initializer.
22992 Having seen only the parenthesis, we cannot know which of
22993 these two alternatives should be selected. Even more
22994 complex are examples like:
22996 int i (int (a));
22997 int i (int (3));
22999 The former is a function-declaration; the latter is a
23000 variable initialization.
23002 Thus again, we try a parameter-declaration-clause, and if
23003 that fails, we back out and return. */
23006 {
23007 tree params;
23012 /* In a member-declarator, the only valid interpretation
23013 of a parenthesis is the start of a
23014 parameter-declaration-clause. (It is invalid to
23015 initialize a static data member with a parenthesized
23016 initializer; only the "=" form of initialization is
23017 permitted.) */
23021 /* Consume the `('. */
23023 matching_parens parens;
23026 {
23027 /* If this is going to be an abstract declarator, we're
23028 in a declarator and we can't have default args. */
23031 }
23035 /* Signal we are in the immediate function context. */
23039 /* Parse the parameter-declaration-clause. */
23040 params
23042 const location_t parens_end
23045 /* Consume the `)'. */
23048 /* If all went well, parse the cv-qualifier-seq,
23049 ref-qualifier and the exception-specification. */
23051 {
23052 cp_cv_quals cv_quals;
23053 cp_virt_specifiers virt_specifiers;
23054 cp_ref_qualifier ref_qual;
23055 tree exception_specification;
23056 tree late_return;
23057 tree attrs;
23060 unsigned char local_variables_forbidden_p
23062 /* 'this' is not allowed in static member functions. */
23072 /* Parse the cv-qualifier-seq. */
23074 /* Parse the ref-qualifier. */
23076 /* Parse the tx-qualifier. */
23082 /* DR 1207: 'this' is in scope after the cv-quals. */
23085 /* If it turned out that this is e.g. a pointer to a
23086 function, we don't want to delay noexcept parsing. */
23090 /* Parse the exception-specification. */
23091 exception_specification
23093 flags);
23097 cp_omp_declare_simd_data odsd;
23099 && declarator
23102 {
23106 }
23108 /* In here, we handle cases where attribute is used after
23109 the function declaration. For example:
23110 void func (int x) __attribute__((vector(..))); */
23113 late_return
23115 requires_clause);
23119 /* Parse the virt-specifier-seq. */
23123 parens_start,
23124 parens_end);
23125 /* Create the function-declarator. */
23127 params,
23128 cv_quals,
23129 virt_specifiers,
23130 ref_qual,
23131 tx_qual,
23132 exception_specification,
23133 late_return,
23134 requires_clause,
23135 parens_loc);
23138 /* Any subsequent parameter lists are to do with
23139 return type, so are not those of the declared
23140 function. */
23146 /* Restore the state of local_variables_forbidden_p. */
23147 parser->local_variables_forbidden_p
23149 }
23151 /* Remove the function parms from scope. */
23155 /* Repeat the main loop. */
23157 }
23159 /* If this is the first, we can try a parenthesized
23160 declarator. */
23162 {
23169 /* Consume the `('. */
23170 matching_parens parens;
23172 /* Parse the nested declarator. */
23175 declarator
23177 ctor_dtor_or_conv_p,
23183 /* Expect a `)'. */
23191 }
23192 /* Otherwise, we must be done. */
23193 else
23195 }
23199 {
23200 /* Parse an array-declarator. */
23210 /* Consume the `['. */
23212 /* Peek at the next token. */
23214 /* If the next token is `]', then there is no
23215 constant-expression. */
23217 {
23219 bounds
23231 {
23232 /* Normally, the array bound must be an integral constant
23233 expression. However, as an extension, we allow VLAs
23234 in function scopes as long as they aren't part of a
23235 parameter declaration. */
23239 }
23242 {
23243 /* Remember this wasn't a constant-expression. */
23246 }
23247 }
23248 else
23250 /* Look for the closing `]'. */
23252 {
23255 }
23260 }
23262 {
23263 {
23264 tree qualifying_scope;
23265 tree unqualified_name;
23266 tree attrs;
23267 special_function_kind sfk;
23272 /* Parse a declarator-id */
23275 {
23278 /* If we see an ellipsis, we should be looking at a
23279 parameter pack. */
23281 {
23282 /* Consume the `...' */
23286 }
23287 }
23290 unqualified_name
23294 {
23298 {
23299 /* Check whether an error occurred. */
23302 /* We already consumed the ellipsis to mark a
23303 parameter pack, but we have no way to report it,
23304 so abort the tentative parse. We will be exiting
23305 immediately anyway. */
23307 }
23308 else
23314 && (qualifying_scope
23316 {
23319 }
23320 }
23325 {
23330 }
23336 {
23337 /* In the declaration of a member of a template class
23338 outside of the class itself, the SCOPE will sometimes
23339 be a TYPENAME_TYPE. For example, given:
23341 template <typename T>
23342 int S<T>::R::i = 3;
23344 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
23345 this context, we must resolve S<T>::R to an ordinary
23346 type, rather than a typename type.
23348 The reason we normally avoid resolving TYPENAME_TYPEs
23349 is that a specialization of `S' might render
23350 `S<T>::R' not a type. However, if `S' is
23351 specialized, then this `i' will not be used, so there
23352 is no harm in resolving the types here. */
23353 tree type;
23355 /* Resolve the TYPENAME_TYPE. */
23358 /* If that failed, the declarator is invalid. */
23360 {
23363 "cannot define member of dependent typedef "
23365 else
23370 }
23372 }
23377 {
23378 tree class_type;
23383 else
23387 {
23391 {
23392 /* We do not attempt to print the declarator
23393 here because we do not have enough
23394 information about its original syntactic
23395 form. */
23399 }
23402 {
23406 "use %<%T::%D%> instead of %<%T::%D%> to "
23408 class_type,
23413 }
23415 }
23418 {
23425 for an unnamed type, even if the type
23426 got a name for linkage purposes. */
23428 /* Handle correctly (c++/19200):
23430 struct S {
23431 struct T{};
23432 friend void S(T);
23433 };
23435 and also:
23437 namespace N {
23438 void S();
23439 }
23441 struct S {
23442 friend void N::S();
23443 }; */
23446 class_type))
23455 }
23456 }
23458 unqualified_name,
23466 /* We're looking for this case in [temp.res]:
23467 A qualified-id is assumed to name a type if [...]
23468 - it is a decl-specifier of the decl-specifier-seq of a
23469 parameter-declaration in a declarator of a function or
23470 function template declaration, ... */
23476 {
23477 /* ...whose declarator-id is qualified. If it isn't, never
23478 assume the parameters to refer to types. */
23481 else
23482 {
23483 /* Now we have something like
23484 template <typename T> int C::x(S::p);
23485 which can be a function template declaration or a
23486 variable template definition. If name lookup for
23487 the declarator-id C::x finds one or more function
23488 templates, assume S::p to name a type. Otherwise,
23489 don't. */
23490 tree decl
23492 none_type,
23500 /* Allow
23501 template<typename T>
23502 A<T>::A(T::type) { } */
23505 qualifying_scope)))
23507 }
23508 }
23509 }
23511 handle_declarator:;
23514 {
23515 /* Any names that appear after the declarator-id for a
23516 member are looked up in the containing scope. */
23518 {
23519 /* But declarations with qualified-ids can't appear in a
23520 function. */
23524 }
23526 }
23530 /* Default args are only allowed on function
23531 declarations. */
23533 else
23537 }
23538 /* We're done. */
23539 else
23541 }
23543 /* For an abstract declarator, we might wind up with nothing at this
23544 point. That's an error; the declarator is not optional. */
23548 {
23549 /* Record overly parenthesized declarator so we can give a
23550 diagnostic about confusing decl/expr disambiguation. */
23552 {
23553 /* If the open and close parens are on different lines, this
23554 is probably a formatting thing, so ignore. */
23559 }
23564 }
23566 /* If we entered a scope, we must exit it now. */
23574 }
23576 /* Parse a ptr-operator.
23578 ptr-operator:
23579 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
23580 * cv-qualifier-seq [opt]
23581 &
23582 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
23583 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
23585 GNU Extension:
23587 ptr-operator:
23588 & cv-qualifier-seq [opt]
23590 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
23591 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
23592 an rvalue reference. In the case of a pointer-to-member, *TYPE is
23593 filled in with the TYPE containing the member. *CV_QUALS is
23594 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
23595 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
23596 Note that the tree codes returned by this function have nothing
23597 to do with the types of trees that will be eventually be created
23598 to represent the pointer or reference type being parsed. They are
23599 just constants with suggestive names. */
23600 static enum tree_code
23605 {
23610 /* Assume that it's not a pointer-to-member. */
23612 /* And that there are no cv-qualifiers. */
23615 /* Peek at the next token. */
23618 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
23628 {
23629 /* Consume the `*', `&' or `&&'. */
23632 /* A `*' can be followed by a cv-qualifier-seq, and so can a
23633 `&', if we are allowing GNU extensions. (The only qualifier
23634 that can legally appear after `&' is `restrict', but that is
23635 enforced during semantic analysis. */
23643 }
23644 else
23645 {
23646 /* Try the pointer-to-member case. */
23648 /* Look for the optional `::' operator. */
23651 /* Look for the nested-name specifier. */
23658 /* If we found it, and the next token is a `*', then we are
23659 indeed looking at a pointer-to-member operator. */
23662 {
23663 /* Indicate that the `*' operator was used. */
23671 else
23672 {
23673 /* The type of which the member is a member is given by the
23674 current SCOPE. */
23676 /* The next name will not be qualified. */
23680 /* Look for optional c++11 attributes. */
23684 /* Look for the optional cv-qualifier-seq. */
23686 }
23687 }
23688 /* If that didn't work we don't have a ptr-operator. */
23691 }
23694 }
23696 /* Parse an (optional) cv-qualifier-seq.
23698 cv-qualifier-seq:
23699 cv-qualifier cv-qualifier-seq [opt]
23701 cv-qualifier:
23702 const
23703 volatile
23705 GNU Extension:
23707 cv-qualifier:
23708 __restrict__
23710 Returns a bitmask representing the cv-qualifiers. */
23712 static cp_cv_quals
23714 {
23718 {
23720 cp_cv_quals cv_qualifier;
23722 /* Peek at the next token. */
23724 /* See if it's a cv-qualifier. */
23726 {
23742 }
23748 {
23753 }
23754 else
23755 {
23758 }
23759 }
23762 }
23764 /* Parse an (optional) ref-qualifier
23766 ref-qualifier:
23767 &
23768 &&
23770 Returns cp_ref_qualifier representing ref-qualifier. */
23772 static cp_ref_qualifier
23774 {
23777 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
23782 {
23787 {
23799 }
23804 {
23807 }
23808 else
23809 {
23812 }
23813 }
23816 }
23818 /* Parse an optional tx-qualifier.
23820 tx-qualifier:
23821 transaction_safe
23822 transaction_safe_dynamic */
23824 static tree
23826 {
23829 {
23834 {
23838 {
23841 {
23844 }
23845 else
23847 }
23848 }
23849 }
23851 }
23853 /* Parse an (optional) virt-specifier-seq.
23855 virt-specifier-seq:
23856 virt-specifier virt-specifier-seq [opt]
23858 virt-specifier:
23859 override
23860 final
23862 Returns a bitmask representing the virt-specifiers. */
23864 static cp_virt_specifiers
23866 {
23870 {
23872 cp_virt_specifiers virt_specifier;
23874 /* Peek at the next token. */
23876 /* See if it's a virt-specifier-qualifier. */
23880 {
23883 }
23885 {
23888 }
23890 {
23892 }
23893 else
23897 {
23902 }
23903 else
23904 {
23907 }
23908 }
23910 }
23912 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
23913 is in scope even though it isn't real. */
23915 void
23917 {
23918 tree this_parm;
23921 {
23922 /* We don't clear this between NSDMIs. Is it already what we want? */
23929 }
23932 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
23934 current_class_ref
23937 }
23939 /* Return true iff our current scope is a non-static data member
23940 initializer. */
23942 bool
23944 {
23945 /* We recognize NSDMI context by the context-less 'this' pointer set up
23946 by the function above. */
23952 }
23954 /* True if we're parsing a function declarator. */
23956 bool
23958 {
23959 /* this_entity is NULL for a function parameter scope while parsing the
23960 declarator; it is set when parsing the body of the function. */
23963 }
23965 /* Parse a late-specified return type, if any. This is not a separate
23966 non-terminal, but part of a function declarator, which looks like
23968 -> trailing-type-specifier-seq abstract-declarator(opt)
23970 Returns the type indicated by the type-id.
23972 In addition to this, parse any queued up #pragma omp declare simd
23973 clauses, and #pragma acc routine clauses.
23975 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
23976 function. */
23978 static tree
23981 {
23985 && declarator
23989 && declarator
23992 /* Peek at the next token. */
23994 /* A late-specified return type is indicated by an initial '->'. */
24003 {
24004 /* Consume the ->. */
24008 }
24010 /* Function declarations may be followed by a trailing
24011 requires-clause. */
24015 declarator->attributes
24019 declarator->attributes
24024 }
24026 /* Parse a declarator-id.
24028 declarator-id:
24029 id-expression
24030 :: [opt] nested-name-specifier [opt] type-name
24032 In the `id-expression' case, the value returned is as for
24033 cp_parser_id_expression if the id-expression was an unqualified-id.
24034 If the id-expression was a qualified-id, then a SCOPE_REF is
24035 returned. The first operand is the scope (either a NAMESPACE_DECL
24036 or TREE_TYPE), but the second is still just a representation of an
24037 unqualified-id. */
24039 static tree
24041 {
24042 tree id;
24043 /* The expression must be an id-expression. Assume that qualified
24044 names are the names of types so that:
24046 template <class T>
24047 int S<T>::R::i = 3;
24049 will work; we must treat `S<T>::R' as the name of a type.
24050 Similarly, assume that qualified names are templates, where
24051 required, so that:
24053 template <class T>
24054 int S<T>::R<T>::i = 3;
24056 will work, too. */
24062 optional_p);
24066 }
24068 /* Parse a type-id.
24070 type-id:
24071 type-specifier-seq abstract-declarator [opt]
24073 The parser flags FLAGS is used to control type-specifier parsing.
24075 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
24077 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24078 i.e. we've just seen "->".
24080 Returns the TYPE specified. */
24082 static tree
24086 {
24087 cp_decl_specifier_seq type_specifier_seq;
24090 /* Parse the type-specifier-seq. */
24093 is_trailing_return,
24101 /* A bare template name as a template argument is a template template
24102 argument, not a placeholder, so fail parsing it as a type argument. */
24103 {
24107 }
24111 /* There might or might not be an abstract declarator. */
24113 /* Look for the declarator. */
24114 abstract_declarator
24121 /* Check to see if there really was a declarator. */
24126 /* The concepts TS allows 'auto' as a type-id. */
24129 /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
24130 outside the template-argument-list context here only for the sake of
24131 diagnostic: grokdeclarator then can emit a better error message for
24132 e.g. using T = auto. */
24138 && !auto_typeid_ok
24139 /* None of the valid uses of 'auto' in C++14 involve the type-id
24140 nonterminal, but it is valid in a trailing-return-type. */
24143 {
24144 /* A type-id with type 'auto' is only ok if the abstract declarator
24145 is a function declarator with a late-specified return type.
24147 A type-id with 'auto' is also valid in a trailing-return-type
24148 in a compound-requirement. */
24155 else
24156 {
24158 {
24161 {
24163 auto_node);
24165 tmpl);
24166 }
24169 auto_node);
24170 else
24172 }
24174 }
24175 }
24178 is_template_arg);
24179 }
24181 /* Wrapper for cp_parser_type_id_1. */
24183 static tree
24186 {
24188 }
24190 /* Wrapper for cp_parser_type_id_1. */
24192 static tree
24194 {
24195 tree r;
24197 parser->type_definition_forbidden_message
24202 {
24205 }
24207 }
24209 /* Wrapper for cp_parser_type_id_1. */
24211 static tree
24213 {
24216 }
24218 /* Parse a type-specifier-seq.
24220 type-specifier-seq:
24221 type-specifier type-specifier-seq [opt]
24223 GNU extension:
24225 type-specifier-seq:
24226 attributes type-specifier-seq [opt]
24228 The parser flags FLAGS is used to control type-specifier parsing.
24230 If IS_DECLARATION is true, we are at the start of a "condition" or
24231 exception-declaration, so we might be followed by a declarator-id.
24233 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24234 i.e. we've just seen "->".
24236 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
24238 static void
24240 cp_parser_flags flags,
24244 {
24248 /* Clear the TYPE_SPECIFIER_SEQ. */
24252 /* In the context of a trailing return type, enum E { } is an
24253 elaborated-type-specifier followed by a function-body, not an
24254 enum-specifier. */
24258 /* Parse the type-specifiers and attributes. */
24260 {
24261 tree type_specifier;
24264 /* Check for attributes first. */
24266 {
24267 /* GNU attributes at the end of a declaration apply to the
24268 declaration as a whole, not to the trailing return type. So look
24269 ahead to see if these attributes are at the end. */
24272 {
24278 }
24279 type_specifier_seq->attributes
24283 }
24285 /* record the token of the beginning of the type specifier seq,
24286 for error reporting purposes*/
24290 /* Look for the type-specifier. */
24292 flags,
24293 type_specifier_seq,
24295 NULL,
24298 {
24299 /* If the first type-specifier could not be found, this is not a
24300 type-specifier-seq at all. */
24302 {
24303 /* Set in_declarator_p to avoid skipping to the semicolon. */
24315 }
24316 /* If subsequent type-specifiers could not be found, the
24317 type-specifier-seq is complete. */
24319 }
24322 /* The standard says that a condition can be:
24324 type-specifier-seq declarator = assignment-expression
24326 However, given:
24328 struct S {};
24329 if (int S = ...)
24331 we should treat the "S" as a declarator, not as a
24332 type-specifier. The standard doesn't say that explicitly for
24333 type-specifier-seq, but it does say that for
24334 decl-specifier-seq in an ordinary declaration. Perhaps it
24335 would be clearer just to allow a decl-specifier-seq here, and
24336 then add a semantic restriction that if any decl-specifiers
24337 that are not type-specifiers appear, the program is invalid. */
24340 }
24341 }
24343 /* Return whether the function currently being declared has an associated
24344 template parameter list. */
24346 static bool
24348 {
24361 }
24363 /* Parse a parameter-declaration-clause.
24365 parameter-declaration-clause:
24366 parameter-declaration-list [opt] ... [opt]
24367 parameter-declaration-list , ...
24369 The parser flags FLAGS is used to control type-specifier parsing.
24371 Returns a representation for the parameter declarations. A return
24372 value of NULL indicates a parameter-declaration-clause consisting
24373 only of an ellipsis. */
24375 static tree
24377 cp_parser_flags flags)
24378 {
24379 tree parameters;
24387 && !processing_template_parmlist
24388 && !processing_explicit_instantiation
24389 /* default_arg_ok_p tracks whether this is a parameter-clause for an
24390 actual function or a random abstract declarator. */
24396 /* Peek at the next token. */
24398 /* Check for trivial parameter-declaration-clauses. */
24400 {
24401 /* Consume the `...' token. */
24404 }
24406 /* There are no parameters. */
24408 /* Check for `(void)', too, which is a special case. */
24412 {
24413 /* Consume the `void' token. */
24415 /* There are no parameters. */
24417 }
24419 /* Parse the parameter-declaration-list. */
24421 /* If a parse error occurred while parsing the
24422 parameter-declaration-list, then the entire
24423 parameter-declaration-clause is erroneous. */
24427 /* Peek at the next token. */
24429 /* If it's a `,', the clause should terminate with an ellipsis. */
24431 {
24432 /* Consume the `,'. */
24434 /* Expect an ellipsis. */
24435 ellipsis_p
24437 }
24438 /* It might also be `...' if the optional trailing `,' was
24439 omitted. */
24441 {
24442 /* Consume the `...' token. */
24444 /* And remember that we saw it. */
24446 }
24447 else
24450 /* Finish the parameter list. */
24455 }
24457 /* Parse a parameter-declaration-list.
24459 parameter-declaration-list:
24460 parameter-declaration
24461 parameter-declaration-list , parameter-declaration
24463 The parser flags FLAGS is used to control type-specifier parsing.
24465 Returns a representation of the parameter-declaration-list, as for
24466 cp_parser_parameter_declaration_clause. However, the
24467 `void_list_node' is never appended to the list. */
24469 static tree
24471 {
24477 /* The special considerations that apply to a function within an
24478 unbraced linkage specifications do not apply to the parameters
24479 to the function. */
24480 saved_in_unbraced_linkage_specification_p
24484 /* Look for more parameters. */
24486 {
24491 /* Parse the parameter. */
24492 parameter
24497 /* We don't know yet if the enclosing context is unavailable or deprecated,
24498 so wait and deal with it in grokparms if appropriate. */
24502 {
24505 PARM,
24510 }
24514 /* If a parse error occurred parsing the parameter declaration,
24515 then the entire parameter-declaration-list is erroneous. */
24517 {
24520 }
24530 {
24534 }
24536 /* Add the new parameter to the list. */
24540 /* If the parameters were parenthesized, it's the case of
24541 T foo(X(x)) which looks like a variable definition but
24542 is a function declaration. */
24546 /* Peek at the next token. */
24549 /* These are for Objective-C++ */
24552 /* The parameter-declaration-list is complete. */
24555 {
24558 /* Peek at the next token. */
24560 /* If it's an ellipsis, then the list is complete. */
24563 /* Otherwise, there must be more parameters. Consume the
24564 `,'. */
24566 /* When parsing something like:
24568 int i(float f, double d)
24570 we can tell after seeing the declaration for "f" that we
24571 are not looking at an initialization of a variable "i",
24572 but rather at the declaration of a function "i".
24574 Due to the fact that the parsing of template arguments
24575 (as specified to a template-id) requires backtracking we
24576 cannot use this technique when inside a template argument
24577 list. */
24581 /* However, a parameter-declaration of the form
24582 "float(f)" (which is a valid declaration of a
24583 parameter "f") can also be interpreted as an
24584 expression (the conversion of "f" to "float"). */
24587 }
24588 else
24589 {
24597 }
24598 }
24600 parser->in_unbraced_linkage_specification_p
24603 /* Reset implicit_template_scope if we are about to leave the function
24604 parameter list that introduced it. Note that for out-of-line member
24605 definitions, there will be one or more class scopes before we get to
24606 the template parameter scope. */
24610 {
24614 {
24617 }
24618 }
24621 }
24623 /* Parse a parameter declaration.
24625 parameter-declaration:
24626 decl-specifier-seq ... [opt] declarator
24627 decl-specifier-seq declarator = assignment-expression
24628 decl-specifier-seq ... [opt] abstract-declarator [opt]
24629 decl-specifier-seq abstract-declarator [opt] = assignment-expression
24631 The parser flags FLAGS is used to control type-specifier parsing.
24633 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
24634 declares a template parameter. (In that case, a non-nested `>'
24635 token encountered during the parsing of the assignment-expression
24636 is not interpreted as a greater-than operator.)
24638 Returns a representation of the parameter, or NULL if an error
24639 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
24640 true iff the declarator is of the form "(p)". */
24644 cp_parser_flags flags,
24647 {
24649 cp_decl_specifier_seq decl_specifiers;
24651 tree default_argument;
24656 /* In a template parameter, `>' is not an operator.
24658 [temp.param]
24660 When parsing a default template-argument for a non-type
24661 template-parameter, the first non-nested `>' is taken as the end
24662 of the template parameter-list rather than a greater-than
24663 operator. */
24665 /* Type definitions may not appear in parameter types. */
24667 parser->type_definition_forbidden_message
24674 /* Parse the declaration-specifiers. */
24677 flags,
24681 /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form
24682 type-constraint opt auto can be used as a decl-specifier of the
24683 decl-specifier-seq of a parameter-declaration of a function declaration
24684 or lambda-expression..." but we must not synthesize an implicit template
24685 type parameter in its declarator. That is, in "void f(auto[auto{10}]);"
24686 we want to synthesize only the first auto. */
24690 /* Complain about missing 'typename' or other invalid type names. */
24695 /* If an error occurred, there's no reason to attempt to parse the
24696 rest of the declaration. */
24698 {
24701 }
24703 /* Peek at the next token. */
24706 /* If the next token is a `)', `,', `=', `>', or `...', then there
24707 is no declarator. However, when variadic templates are enabled,
24708 there may be a declarator following `...'. */
24713 {
24717 }
24718 /* Otherwise, there should be a declarator. */
24719 else
24720 {
24724 /* After seeing a decl-specifier-seq, if the next token is not a
24725 "(" or "{", there is no possibility that the code is a valid
24726 expression. Therefore, if parsing tentatively, we commit at
24727 this point. */
24729 /* In an expression context, having seen:
24731 (int((char ...
24733 we cannot be sure whether we are looking at a
24734 function-type (taking a "char" as a parameter) or a cast
24735 of some object of type "char" to "int". */
24739 {
24741 {
24744 /* This is a CTAD expression, not a parameter declaration. */
24746 }
24747 else
24749 }
24750 /* Parse the declarator. */
24753 CP_PARSER_DECLARATOR_EITHER,
24754 CP_PARSER_FLAGS_NONE,
24756 parenthesized_p,
24761 /* After the declarator, allow more attributes. */
24762 decl_specifiers.attributes
24766 /* If the declarator is a template parameter pack, remember that and
24767 clear the flag in the declarator itself so we don't get errors
24768 from grokdeclarator. */
24770 {
24773 }
24774 }
24776 /* If the next token is an ellipsis, and we have not seen a declarator
24777 name, and if either the type of the declarator contains parameter
24778 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
24779 for, eg, abbreviated integral type names), then we actually have a
24780 parameter pack expansion expression. Otherwise, leave the ellipsis
24781 for a C-style variadic function. */
24784 /* If a function parameter pack was specified and an implicit template
24785 parameter was introduced during cp_parser_parameter_declaration,
24786 change any implicit parameters introduced into packs. */
24791 {
24799 }
24802 {
24813 {
24814 /* Consume the `...'. */
24818 /* Build a pack expansion type */
24823 else
24825 }
24826 }
24828 /* The restriction on defining new types applies only to the type
24829 of the parameter, not to the default argument. */
24832 /* If the next token is `=', then process a default argument. */
24834 {
24839 /* If we are defining a class, then the tokens that make up the
24840 default argument must be saved and processed later. */
24846 /* A constrained-type-specifier may declare a type
24847 template-parameter. */
24849 default_argument
24852 /* A constrained-type-specifier may declare a
24853 template-template-parameter. */
24855 default_argument
24858 /* Outside of a class definition, we can just parse the
24859 assignment-expression. */
24860 else
24861 default_argument
24865 {
24867 "default arguments are only "
24869 }
24871 || template_parameter_pack_p
24874 {
24875 /* Find the name of the parameter pack. */
24882 template_parm_p
24888 else
24890 template_parm_p
24897 }
24898 }
24899 else
24905 /* Generate a location for the parameter, ranging from the start of the
24906 initial token to the end of the final token (using input_location for
24907 the latter, set up by cp_lexer_set_source_position_from_token when
24908 consuming tokens).
24910 If we have a identifier, then use it for the caret location, e.g.
24912 extern int callee (int one, int (*two)(int, int), float three);
24913 ~~~~~~^~~~~~~~~~~~~~
24915 otherwise, reuse the start location for the caret location e.g.:
24917 extern int callee (int one, int (*)(int, int), float three);
24918 ^~~~~~~~~~~~~~~~~
24920 */
24926 input_location);
24929 declarator,
24930 default_argument,
24931 param_loc,
24932 template_parameter_pack_p);
24933 }
24935 /* Parse a default argument and return it.
24937 TEMPLATE_PARM_P is true if this is a default argument for a
24938 non-type template parameter. */
24939 static tree
24941 {
24947 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
24948 set correctly. */
24955 /* Local variable names (and the `this' keyword) may not
24956 appear in a default argument. */
24959 /* Parse the assignment-expression. */
24964 /* The "this" pointer is not valid in a default argument. */
24966 {
24971 }
24972 default_argument
24974 /* Restore the "this" pointer. */
24976 {
24979 }
24988 }
24990 /* Parse a function-body.
24992 function-body:
24993 compound_statement */
24995 static void
24997 {
25001 }
25003 /* Parse a ctor-initializer-opt followed by a function-body. Return
25004 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
25005 is true we are parsing a function-try-block. */
25007 static void
25010 {
25012 const bool check_body_p
25020 {
25023 "function-try-block body of %<constexpr%> constructor only "
25025 else
25027 "function-try-block body of %<constexpr%> function only "
25029 }
25031 /* Begin the function body. */
25033 /* Parse the optional ctor-initializer. */
25036 /* If we're parsing a constexpr constructor definition, we need
25037 to check that the constructor body is indeed empty. However,
25038 before we get to cp_parser_function_body lot of junk has been
25039 generated, so we can't just check that we have an empty block.
25040 Rather we take a snapshot of the outermost block, and check whether
25041 cp_parser_function_body changed its state. */
25043 {
25047 }
25048 /* Parse the function-body. */
25052 /* Finish the function body. */
25054 }
25056 /* Parse an initializer.
25058 initializer:
25059 = initializer-clause
25060 ( expression-list )
25062 Returns an expression representing the initializer. If no
25063 initializer is present, NULL_TREE is returned.
25065 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
25066 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
25067 set to TRUE if there is no initializer present. If there is an
25068 initializer, and it is not a constant-expression, *NON_CONSTANT_P
25069 is set to true; otherwise it is set to false. */
25071 static tree
25074 {
25076 tree init;
25078 /* Peek at the next token. */
25081 /* Let our caller know whether or not this initializer was
25082 parenthesized. */
25084 /* Assume that the initializer is constant. */
25088 {
25089 /* Consume the `='. */
25091 /* Parse the initializer-clause. */
25093 }
25095 {
25100 non_constant_p);
25105 }
25107 {
25112 }
25113 else
25114 {
25115 /* Anything else is an error. */
25118 }
25124 }
25126 /* Parse an initializer-clause.
25128 initializer-clause:
25129 assignment-expression
25130 braced-init-list
25132 Returns an expression representing the initializer.
25134 If the `assignment-expression' production is used the value
25135 returned is simply a representation for the expression.
25137 Otherwise, calls cp_parser_braced_list. */
25139 static cp_expr
25141 {
25142 cp_expr initializer;
25144 /* Assume the expression is constant. */
25147 /* If it is not a `{', then we are looking at an
25148 assignment-expression. */
25150 {
25151 initializer
25154 non_constant_p);
25155 }
25156 else
25160 }
25162 /* Parse a brace-enclosed initializer list.
25164 braced-init-list:
25165 { initializer-list , [opt] }
25166 { designated-initializer-list , [opt] }
25167 { }
25169 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
25170 the elements of the initializer-list (or NULL, if the last
25171 production is used). The TREE_TYPE for the CONSTRUCTOR will be
25172 NULL_TREE. There is no way to detect whether or not the optional
25173 trailing `,' was provided. NON_CONSTANT_P is as for
25174 cp_parser_initializer. */
25176 static cp_expr
25178 {
25179 tree initializer;
25182 /* Consume the `{' token. */
25183 matching_braces braces;
25185 /* Create a CONSTRUCTOR to represent the braced-initializer. */
25187 /* If it's not a `}', then there is a non-trivial initializer. */
25189 {
25191 /* Parse the initializer list. */
25195 /* A trailing `,' token is allowed. */
25198 }
25199 else
25201 /* Now, there should be a trailing `}'. */
25207 /* Build a location of the form:
25208 { ... }
25209 ^~~~~~~
25210 with caret==start at the open brace, finish at the close brace. */
25214 }
25216 /* Consume tokens up to, and including, the next non-nested closing `]'.
25217 Returns true iff we found a closing `]'. */
25219 static bool
25221 {
25225 {
25229 {
25233 /* FALLTHRU */
25235 /* If we've run out of tokens, then there is no closing `]'. */
25244 {
25247 }
25252 }
25254 /* Consume the token. */
25256 }
25257 }
25259 /* Return true if we are looking at an array-designator, false otherwise. */
25261 static bool
25263 {
25264 /* Consume the `['. */
25269 /* Skip tokens until the next token is a closing square bracket.
25270 If we find the closing `]', and the next token is a `=', then
25271 we are looking at an array designator. */
25272 bool array_designator_p
25276 /* Roll back the tokens we skipped. */
25280 }
25282 /* Parse an initializer-list.
25284 initializer-list:
25285 initializer-clause ... [opt]
25286 initializer-list , initializer-clause ... [opt]
25288 C++20 Extension:
25290 designated-initializer-list:
25291 designated-initializer-clause
25292 designated-initializer-list , designated-initializer-clause
25294 designated-initializer-clause:
25295 designator brace-or-equal-initializer
25297 designator:
25298 . identifier
25300 GNU Extension:
25302 initializer-list:
25303 designation initializer-clause ...[opt]
25304 initializer-list , designation initializer-clause ...[opt]
25306 designation:
25307 . identifier =
25308 identifier :
25309 [ constant-expression ] =
25311 Returns a vec of constructor_elt. The VALUE of each elt is an expression
25312 for the initializer. If the INDEX of the elt is non-NULL, it is the
25313 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
25314 as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
25315 are any designators. */
25320 {
25325 /* Assume all of the expressions are constant. */
25331 /* Parse the rest of the list. */
25333 {
25335 tree designator;
25336 tree initializer;
25340 /* Handle the C++20 syntax, '. id ='. */
25348 {
25351 "C++ designated initializers only available with "
25353 /* Consume the `.'. */
25355 /* Consume the identifier. */
25358 /* Consume the `='. */
25360 }
25361 /* Also, if the next token is an identifier and the following one is a
25362 colon, we are looking at the GNU designated-initializer
25363 syntax. */
25368 {
25369 /* Warn the user that they are using an extension. */
25372 /* Consume the identifier. */
25374 /* Consume the `:'. */
25376 }
25377 /* Also handle C99 array designators, '[ const ] ='. */
25381 {
25382 /* In C++11, [ could start a lambda-introducer. */
25388 {
25391 }
25392 else
25393 {
25398 }
25403 && (!require_potential_rvalue_constant_expression
25407 /* Warn the user that they are using an extension. */
25410 }
25411 else
25415 {
25418 }
25422 {
25426 }
25430 /* Parse the initializer. */
25433 /* If any clause is non-constant, so is the entire initializer. */
25437 /* If we have an ellipsis, this is an initializer pack
25438 expansion. */
25440 {
25443 /* Consume the `...'. */
25450 /* Turn the initializer into an initializer expansion. */
25452 }
25454 /* Add it to the vector. */
25457 /* If the next token is not a comma, we have reached the end of
25458 the list. */
25462 /* Peek at the next token. */
25464 /* If the next token is a `}', then we're still done. An
25465 initializer-clause can have a trailing `,' after the
25466 initializer-list and before the closing `}'. */
25470 /* Suppress location wrappers in a long initializer to save memory
25471 (14179). The cutoff is chosen arbitrarily. */
25475 /* Look one level down because it's easy. Looking deeper would require
25476 passing down a nelts pointer, and I don't think multi-level massive
25477 initializers are common enough to justify this. */
25483 /* Consume the `,' token. */
25485 }
25487 /* The same identifier shall not appear in multiple designators
25488 of a designated-initializer-list. */
25490 {
25495 {
25497 {
25499 "%<.%s%> designator used multiple times in "
25503 }
25504 else
25506 }
25510 }
25516 }
25518 /* Classes [gram.class] */
25520 /* Parse a class-name.
25522 class-name:
25523 identifier
25524 template-id
25526 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
25527 to indicate that names looked up in dependent types should be
25528 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
25529 keyword has been used to indicate that the name that appears next
25530 is a template. TAG_TYPE indicates the explicit tag given before
25531 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
25532 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
25533 is the class being defined in a class-head. If ENUM_OK is TRUE,
25534 enum-names are also accepted.
25536 Returns the TYPE_DECL representing the class. */
25538 static tree
25547 {
25548 tree decl;
25551 /* All class-names start with an identifier. */
25554 {
25557 }
25559 /* PARSER->SCOPE can be cleared when parsing the template-arguments
25560 to a template-id, so we save it here. Consider object scope too,
25561 so that make_typename_type below can use it (cp_parser_template_name
25562 considers object scope also). This may happen with code like
25564 p->template A<T>::a()
25566 where we first want to look up A<T>::a in the class of the object
25567 expression, as per [basic.lookup.classref]. */
25569 /* This only checks parser->scope to avoid duplicate errors; if
25570 ->object_type is erroneous, go on to give a parse error. */
25574 /* Any name names a type if we're following the `typename' keyword
25575 in a qualified name where the enclosing scope is type-dependent. */
25580 /* Handle the common case (an identifier, but not a template-id)
25581 efficiently. */
25584 {
25588 /* Look for the identifier. */
25592 /* If the next token isn't an identifier, we are certainly not
25593 looking at a class-name. */
25596 /* If we know this is a type-name, there's no need to look it
25597 up. */
25600 else
25601 {
25602 tree ambiguous_decls;
25603 /* If we already know that this lookup is ambiguous, then
25604 we've already issued an error message; there's no reason
25605 to check again. */
25607 {
25610 }
25611 /* If the next token is a `::', then the name must be a type
25612 name.
25614 [basic.lookup.qual]
25616 During the lookup for a name preceding the :: scope
25617 resolution operator, object, function, and enumerator
25618 names are ignored. */
25621 /* Look up the name. */
25623 tag_type,
25626 check_dependency_p,
25630 {
25634 }
25635 }
25636 }
25637 else
25638 {
25639 /* Try a template-id. */
25641 check_dependency_p,
25642 tag_type,
25643 is_declaration);
25646 }
25650 /* If this is a typename, create a TYPENAME_TYPE. */
25652 {
25657 }
25661 /* Check to see that it is really the name of a class. */
25665 /* Situations like this:
25667 template <typename T> struct A {
25668 typename T::template X<int>::I i;
25669 };
25671 are problematic. Is `T::template X<int>' a class-name? The
25672 standard does not seem to be definitive, but there is no other
25673 valid interpretation of the following `::'. Therefore, those
25674 names are considered class-names. */
25675 {
25679 }
25684 /* In Objective-C 2.0, a classname followed by '.' starts a
25685 dot-syntax expression, and it's not a type-name. */
25697 }
25699 /* Make sure that any member-function parameters are in scope.
25700 For instance, a function's noexcept-specifier can use the function's
25701 parameters:
25703 struct S {
25704 void fn (int p) noexcept(noexcept(p));
25705 };
25707 so we need to make sure name lookup can find them. This is used
25708 when we delay parsing of the noexcept-specifier. */
25710 static void
25712 {
25719 {
25723 }
25724 }
25726 /* Undo the effects of inject_parm_decls. */
25728 static void
25730 {
25733 }
25735 /* Parse a class-specifier.
25737 class-specifier:
25738 class-head { member-specification [opt] }
25740 Returns the TREE_TYPE representing the class. */
25742 static tree
25744 {
25745 tree type;
25759 /* Parse the class-head. */
25762 /* If the class-head was a semantic disaster, skip the entire body
25763 of the class. */
25765 {
25769 }
25771 /* Look for the `{'. */
25772 matching_braces braces;
25774 {
25777 }
25782 /* Issue an error message if type-definitions are forbidden here. */
25784 /* Remember that we are defining one more class. */
25786 /* Inside the class, surrounding template-parameter-lists do not
25787 apply. */
25788 saved_num_template_parameter_lists
25791 /* We are not in a function body. */
25794 /* Or in a loop. */
25797 /* Or in a switch. */
25800 /* We are not immediately inside an extern "lang" block. */
25801 saved_in_unbraced_linkage_specification_p
25805 /* Start the class. */
25807 {
25809 /* SCOPE must be a scope nested inside current scope. */
25813 else
25815 }
25819 /* If the type is erroneous, skip the entire body of the class. */
25821 else
25822 /* Parse the member-specification. */
25825 /* Look for the trailing `}'. */
25827 /* Look for trailing attributes to apply to this class. */
25835 /* We've finished a type definition. Check for the common syntax
25836 error of forgetting a semicolon after the definition. We need to
25837 be careful, as we can't just check for not-a-semicolon and be done
25838 with it; the user might have typed:
25840 class X { } c = ...;
25841 class X { } *p = ...;
25843 and so forth. Instead, enumerate all the possible tokens that
25844 might follow this production; if we don't see one of them, then
25845 complain and silently insert the semicolon. */
25846 {
25851 /* Don't try to parse c++11 attributes here. As per the
25852 grammar, that should be a task for
25853 cp_parser_decl_specifier_seq. */
25857 {
25868 /* While it's legal for type qualifiers and storage class
25869 specifiers to follow type definitions in the grammar, only
25870 compiler testsuites contain code like that. Assume that if
25871 we see such code, then what we're really seeing is a case
25872 like:
25874 class X { }
25875 const <type> var = ...;
25877 or
25879 class Y { }
25880 static <type> func (...) ...
25882 i.e. the qualifier or specifier applies to the next
25883 declaration. To do so, however, we need to look ahead one
25884 more token to see if *that* token is a type specifier.
25886 This code could be improved to handle:
25888 class Z { }
25889 static const <type> var = ...; */
25892 {
25895 /* Handling user-defined types here would be nice, but very
25896 tricky. */
25897 want_semicolon
25900 }
25904 }
25906 /* If we don't have a type, then something is very wrong and we
25907 shouldn't try to do anything clever. Likewise for not seeing the
25908 closing brace. */
25910 {
25911 /* Locate the closing brace. */
25912 cp_token_position prev
25917 /* We want to suggest insertion of a ';' immediately *after* the
25918 closing brace, so, if we can, offset the location by 1 column. */
25925 /* If we successfully offset the location, suggest the fix-it. */
25938 else
25941 /* Unget one token and smash it to look as though we encountered
25942 a semicolon in the input stream. */
25947 }
25948 }
25950 /* If this class is not itself within the scope of another class,
25951 then we need to parse the bodies of all of the queued function
25952 definitions. Note that the queued functions defined in a class
25953 are not always processed immediately following the
25954 class-specifier for that class. Consider:
25956 struct A {
25957 struct B { void f() { sizeof (A); } };
25958 };
25960 If `f' were processed before the processing of `A' were
25961 completed, there would be no way to compute the size of `A'.
25962 Note that the nesting we are interested in here is lexical --
25963 not the semantic nesting given by TYPE_CONTEXT. In particular,
25964 for:
25966 struct A { struct B; };
25967 struct A::B { void f() { } };
25969 there is no need to delay the parsing of `A::B::f'. */
25971 {
25972 tree decl;
25979 {
25980 /* Skip default arguments, NSDMIs, etc, in order to improve
25981 error recovery (c++/71169, c++/71832). */
25985 }
25987 /* In a first pass, parse default arguments to the functions.
25988 Then, in a second pass, parse the bodies of the functions.
25989 This two-phased approach handles cases like:
25991 struct S {
25992 void f() { g(); }
25993 void g(int i = 3);
25994 };
25996 */
25998 {
26000 /* If there are default arguments that have not yet been processed,
26001 take care of them now. */
26003 {
26008 }
26009 /* Make sure that any template parameters are in scope. */
26011 /* Parse the default argument expressions. */
26013 /* Remove any template parameters from the symbol table. */
26015 }
26018 /* If there are noexcept-specifiers that have not yet been processed,
26019 take care of them now. Do this before processing NSDMIs as they
26020 may depend on noexcept-specifiers already having been processed. */
26024 {
26027 {
26032 }
26037 /* Make sure that any template parameters are in scope. */
26040 /* Make sure that any member-function parameters are in scope.
26041 This function doesn't expect ccp to be set. */
26045 /* 'this' is not allowed in static member functions. */
26046 unsigned char local_variables_forbidden_p
26051 /* Now we can parse the noexcept-specifier. */
26057 /* Update the fn's type directly -- it might have escaped
26058 beyond this decl :( */
26060 /* Update any instantiations we've already created. We must
26061 keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
26062 so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
26063 in the pattern. */
26068 /* Restore the state of local_variables_forbidden_p. */
26071 /* The finish_struct call above performed various override checking,
26072 but it skipped unparsed noexcept-specifier operands. Now that we
26073 have resolved them, check again. */
26076 /* Remove any member-function parameters from the symbol table. */
26079 /* Remove any template parameters from the symbol table. */
26081 }
26084 /* Now parse any NSDMIs. */
26086 {
26088 {
26093 }
26096 }
26103 /* Now parse the body of the functions. */
26105 {
26106 /* OpenMP UDRs need to be parsed before all other functions. */
26113 }
26114 else
26118 }
26120 /* Put back any saved access checks. */
26123 /* Restore saved state. */
26127 parser->num_template_parameter_lists
26129 parser->in_unbraced_linkage_specification_p
26133 }
26135 static tree
26137 {
26138 tree ret;
26143 }
26145 /* Parse a class-head.
26147 class-head:
26148 class-key identifier [opt] base-clause [opt]
26149 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
26150 class-key nested-name-specifier [opt] template-id
26151 base-clause [opt]
26153 class-virt-specifier:
26154 final
26156 GNU Extensions:
26157 class-key attributes identifier [opt] base-clause [opt]
26158 class-key attributes nested-name-specifier identifier base-clause [opt]
26159 class-key attributes nested-name-specifier [opt] template-id
26160 base-clause [opt]
26162 Upon return BASES is initialized to the list of base classes (or
26163 NULL, if there are none) in the same form returned by
26164 cp_parser_base_clause.
26166 Returns the TYPE of the indicated class. Sets
26167 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
26168 involving a nested-name-specifier was used, and FALSE otherwise.
26170 Returns error_mark_node if this is not a class-head.
26172 Returns NULL_TREE if the class-head is syntactically valid, but
26173 semantically invalid in a way that means we should skip the entire
26174 body of the class. */
26176 static tree
26179 {
26180 tree nested_name_specifier;
26184 tree attributes;
26185 tree bases;
26195 /* Assume no nested-name-specifier will be present. */
26197 /* Assume no template parameter lists will be used in defining the
26198 type. */
26202 /* Look for the class-key. */
26209 /* Parse the attributes. */
26212 /* If the next token is `::', that is invalid -- but sometimes
26213 people do try to write:
26215 struct ::S {};
26217 Handle this gracefully by accepting the extra qualifier, and then
26218 issuing an error about it later if this really is a
26219 class-head. If it turns out just to be an elaborated type
26220 specifier, remain silent. */
26226 /* Determine the name of the class. Begin by looking for an
26227 optional nested-name-specifier. */
26229 nested_name_specifier
26235 /* If there was a nested-name-specifier, then there *must* be an
26236 identifier. */
26241 {
26243 /* Although the grammar says `identifier', it really means
26244 `class-name' or `template-name'. You are only allowed to
26245 define a class that has already been declared with this
26246 syntax.
26248 The proposed resolution for Core Issue 180 says that wherever
26249 you see `class T::X' you should treat `X' as a type-name.
26251 It is OK to define an inaccessible class; for example:
26253 class A { class B; };
26254 class A::B {};
26256 We do not know if we will see a class-name, or a
26257 template-name. We look for a class-name first, in case the
26258 class-name is a template-id; if we looked for the
26259 template-name first we would stop after the template-name. */
26266 class_type,
26270 /* If that didn't work, ignore the nested-name-specifier. */
26272 {
26278 }
26279 /* If we could not find a corresponding TYPE, treat this
26280 declaration like an unqualified declaration. */
26283 /* Otherwise, count the number of templates used in TYPE and its
26284 containing scopes. */
26285 else
26287 }
26288 /* Otherwise, the identifier is optional. */
26289 else
26290 {
26291 /* We don't know whether what comes next is a template-id,
26292 an identifier, or nothing at all. */
26294 /* Check for a template-id. */
26299 class_key,
26301 /* If that didn't work, it could still be an identifier. */
26303 {
26305 {
26308 }
26309 else
26311 }
26312 else
26313 {
26316 }
26317 }
26322 {
26324 class_key,
26326 }
26329 /* If it's not a `:' or a `{' then we can't really be looking at a
26330 class-head, since a class-head only appears as part of a
26331 class-specifier. We have to detect this situation before calling
26332 xref_tag, since that has irreversible side-effects. */
26334 {
26338 }
26340 /* At this point, we're going ahead with the class-specifier, even
26341 if some other problem occurs. */
26344 {
26349 }
26350 /* Issue the error about the overly-qualified name now. */
26352 {
26357 }
26359 {
26364 }
26366 {
26367 tree scope;
26370 /* [temp.names]: in a qualified-id formed by a class-head-name, the
26371 keyword template shall not appear at the top level. */
26375 /* Reject typedef-names in class heads. */
26377 {
26380 type);
26383 }
26385 /* Figure out in what scope the declaration is being placed. */
26387 /* If that scope does not contain the scope in which the
26388 class was originally declared, the program is invalid. */
26390 {
26393 "declaration of %qD in namespace %qD which does not "
26396 else
26402 }
26403 /* [dcl.meaning]
26405 A declarator-id shall not be qualified except for the
26406 definition of a ... nested class outside of its class
26407 ... [or] the definition or explicit instantiation of a
26408 class member of a namespace outside of its namespace. */
26412 }
26413 /* An explicit-specialization must be preceded by "template <>". If
26414 it is not, try to recover gracefully. */
26417 && !processing_template_parmlist
26419 {
26420 /* Build a location of this form:
26421 struct typename <ARGS>
26422 ^~~~~~~~~~~~~~~~~~~~~~
26423 with caret==start at the start token, and
26424 finishing at the end of the type. */
26425 location_t reported_loc
26427 class_head_start_location,
26433 "an explicit specialization must be preceded by"
26436 /* Take the same action that would have been taken by
26437 cp_parser_explicit_specialization. */
26440 }
26441 /* There must be no "return" statements between this point and the
26442 end of this function; set "type "to the correct return value and
26443 use "goto done;" to return. */
26444 /* Make sure that the right number of template parameters were
26445 present. */
26447 template_id_p,
26450 {
26451 /* If something went wrong, there is no point in even trying to
26452 process the class-definition. */
26455 }
26457 /* Look up the type. */
26459 {
26463 {
26467 }
26468 else
26469 {
26473 /* Check the scope while we still know whether or not we had a
26474 nested-name-specifier. */
26477 }
26480 }
26482 {
26483 tree class_type;
26485 /* Given:
26487 template <typename T> struct S { struct T };
26488 template <typename T> struct S<T>::T { };
26490 we will get a TYPENAME_TYPE when processing the definition of
26491 `S::T'. We need to resolve it to the actual type before we
26492 try to define it. */
26494 {
26499 else
26500 {
26503 }
26504 }
26508 {
26511 }
26514 /* Enter the scope indicated by the nested-name-specifier. */
26516 /* Get the canonical version of this type. */
26518 /* Call push_template_decl if it seems like we should be defining a
26519 template either from the template headers or the type we're
26520 defining, so that we diagnose both extra and missing headers. */
26524 {
26527 {
26530 }
26531 }
26535 }
26537 {
26538 /* If the class was unnamed, create a dummy name. */
26546 }
26548 /* Diagnose class/struct/union mismatches. */
26552 /* Indicate whether this class was declared as a `class' or as a
26553 `struct'. */
26557 /* If this type was already complete, and we see another definition,
26558 that's an error. Likewise if the type is already being defined:
26559 this can happen, eg, when it's defined from within an expression
26560 (c++/84605). */
26563 {
26565 type);
26567 type);
26570 }
26575 {
26576 /* Apply attributes now, before any use of the class as a template
26577 argument in its base list. */
26580 }
26582 /* Associate constraints with the type. */
26586 /* We will have entered the scope containing the class; the names of
26587 base classes should be looked up in that context. For example:
26589 struct A { struct B {}; struct C; };
26590 struct A::C : B {};
26592 is valid. */
26594 /* Get the list of base-classes, if there is one. Defer access checking
26595 until the entire list has been seen, as per [class.access.general]. */
26598 {
26604 }
26605 else
26608 /* If we're really defining a class, process the base classes.
26609 If they're invalid, fail. */
26613 /* Now that all bases have been seen and attached to the class, check
26614 accessibility of the types named in the base-clause. This must be
26615 done relative to the class scope, so that we accept e.g.
26617 struct A { protected: struct B {}; };
26618 struct C : A::B, A {}; // OK: A::B is accessible via base A
26620 as per [class.access.general]. */
26627 done:
26628 /* Leave the scope given by the nested-name-specifier. We will
26629 enter the class scope itself while processing the members. */
26634 {
26637 }
26643 out:
26646 }
26648 /* Parse a class-key.
26650 class-key:
26651 class
26652 struct
26653 union
26655 Returns the kind of class-key specified, or none_type to indicate
26656 error. */
26658 static enum tag_types
26660 {
26664 /* Look for the class-key. */
26669 /* Check to see if the TOKEN is a class-key. */
26674 }
26676 /* Parse a type-parameter-key.
26678 type-parameter-key:
26679 class
26680 typename
26681 */
26683 static void
26685 {
26686 /* Look for the type-parameter-key. */
26690 {
26694 /* typename is not allowed in a template template parameter
26695 by the standard until C++17. */
26697 "ISO C++ forbids typename key in template template parameter;"
26699 }
26700 else
26704 }
26706 /* Parse an (optional) member-specification.
26708 member-specification:
26709 member-declaration member-specification [opt]
26710 access-specifier : member-specification [opt] */
26712 static void
26714 {
26716 {
26720 /* Peek at the next token. */
26722 /* If it's a `}', or EOF then we've seen all the members. */
26728 /* See if this token is a keyword. */
26731 {
26735 /* Consume the access-specifier. */
26737 /* Remember which access-specifier is active. */
26739 /* Look for the `:'. */
26744 /* Accept #pragmas at class scope. */
26746 {
26749 }
26751 /* Otherwise, the next construction must be a
26752 member-declaration. */
26754 }
26755 }
26756 }
26758 /* Parse a member-declaration.
26760 member-declaration:
26761 decl-specifier-seq [opt] member-declarator-list [opt] ;
26762 function-definition ; [opt]
26763 :: [opt] nested-name-specifier template [opt] unqualified-id ;
26764 using-declaration
26765 template-declaration
26766 alias-declaration
26768 member-declarator-list:
26769 member-declarator
26770 member-declarator-list , member-declarator
26772 member-declarator:
26773 declarator pure-specifier [opt]
26774 declarator constant-initializer [opt]
26775 identifier [opt] : constant-expression
26777 GNU Extensions:
26779 member-declaration:
26780 __extension__ member-declaration
26782 member-declarator:
26783 declarator attributes [opt] pure-specifier [opt]
26784 declarator attributes [opt] constant-initializer [opt]
26785 identifier [opt] attributes [opt] : constant-expression
26787 C++0x Extensions:
26789 member-declaration:
26790 static_assert-declaration */
26792 static void
26794 {
26795 cp_decl_specifier_seq decl_specifiers;
26796 tree prefix_attributes;
26797 tree decl;
26806 /* Check for the `__extension__' keyword. */
26808 {
26809 /* Recurse. */
26811 /* Restore the old value of the PEDANTIC flag. */
26815 }
26817 /* Check for a template-declaration. */
26819 {
26820 /* An explicit specialization here is an error condition, and we
26821 expect the specialization handler to detect and report this. */
26825 else
26829 }
26830 /* Check for a template introduction. */
26834 /* Check for a using-declaration. */
26836 {
26838 /* Parse the using-declaration. */
26842 else
26843 {
26844 tree decl;
26848 /* Note that if we actually see the '=' token after the
26849 identifier, cp_parser_alias_declaration commits the
26850 tentative parse. In that case, we really expect an
26851 alias-declaration. Otherwise, we expect a using
26852 declaration. */
26853 alias_decl_expected =
26859 else
26862 }
26864 }
26866 /* Check for @defs. */
26868 {
26873 {
26878 }
26880 }
26882 /* If the next token is `static_assert' we have a static assertion. */
26884 {
26887 }
26891 cp_omp_declare_simd_data odsd;
26895 /* Parse the decl-specifier-seq. */
26898 (CP_PARSER_FLAGS_OPTIONAL
26908 /* Check for an invalid type-name. */
26912 /* If there is no declarator, then the decl-specifier-seq should
26913 specify a type. */
26915 {
26916 /* If there was no decl-specifier-seq, and the next token is a
26917 `;', then we have something like:
26919 struct S { ; };
26921 [class.mem]
26923 Each member-declaration shall declare at least one member
26924 name of the class. */
26926 {
26929 {
26933 }
26934 }
26935 else
26936 {
26937 /* See if this declaration is a friend. */
26939 /* If there were decl-specifiers, check to see if there was
26940 a class-declaration. */
26943 /* Nested classes have already been added to the class, but
26944 a `friend' needs to be explicitly registered. */
26946 {
26947 /* If the `friend' keyword was present, the friend must
26948 be introduced with a class-key. */
26951 "in C++03 a class-key must be used "
26953 /* In this case:
26955 template <typename T> struct A {
26956 friend struct A<T>::B;
26957 };
26959 A<T>::B will be represented by a TYPENAME_TYPE, and
26960 therefore not recognized by check_tag_decl. */
26962 {
26966 }
26967 /* Warn if an attribute cannot appear here, as per
26968 [dcl.attr.grammar]/5. But not when declares_class_or_enum:
26969 we ignore attributes in elaborated-type-specifiers. */
26972 {
26977 "that appertains to a friend declaration that "
26979 }
26982 "friend declaration does not name a class or "
26984 else
26987 }
26988 /* If there is no TYPE, an error message will already have
26989 been issued. */
26991 ;
26992 /* An anonymous aggregate has to be handled specially; such
26993 a declaration really declares a data member (with a
26994 particular type), as opposed to a nested class. */
26996 {
26997 /* C++11 9.5/6. */
27000 "a storage class on an anonymous aggregate "
27003 /* Remove constructors and such from TYPE, now that we
27004 know it is an anonymous aggregate. */
27006 /* And make the corresponding data member. */
27009 /* Add it to the class. */
27011 }
27012 else
27013 cp_parser_check_access_in_redeclaration
27016 }
27017 }
27018 else
27019 {
27022 /* Clear attributes from the decl_specifiers but keep them
27023 around as prefix attributes that apply them to the entity
27024 being declared. */
27032 /* See if these declarations will be friends. */
27035 /* Keep going until we hit the `;' at the end of the
27036 declaration. */
27038 {
27040 tree first_attribute;
27041 tree initializer;
27044 /* Peek at the next token. */
27047 /* The following code wants to know early if it is a bit-field
27048 or some other declaration. Attributes can appear before
27049 the `:' token. Skip over them without consuming any tokens
27050 to peek if they are followed by `:'. */
27055 {
27056 size_t n
27059 }
27061 /* Check for a bitfield declaration. */
27067 {
27068 tree identifier;
27069 tree width;
27071 location_t id_location
27076 else
27079 /* Look for attributes that apply to the bitfield. */
27082 /* Consume the `:' token. */
27085 /* Get the width of the bitfield. */
27089 /* In C++20 and as extension for C++11 and above we allow
27090 default member initializers for bit-fields. */
27095 CPP_OPEN_BRACE)))
27096 {
27097 location_t loc
27102 "default member initializers for bit-fields "
27103 "only available with %<-std=c++20%> or "
27108 {
27112 }
27113 }
27114 else
27115 {
27116 /* Look for attributes that apply to the bitfield after
27117 the `:' token and width. This is where GCC used to
27118 parse attributes in the past, pedwarn if there is
27119 a std attribute. */
27122 "ISO C++ allows bit-field attributes only "
27126 }
27130 /* Remember which attributes are prefix attributes and
27131 which are not. */
27133 /* Combine the attributes. */
27136 /* Create the bitfield declaration. */
27139 identifier,
27140 sfk_none,
27141 id_location)
27145 attributes);
27146 }
27147 else
27148 {
27150 tree asm_specification;
27154 /* We can't delay parsing for friends,
27155 alias-declarations, and typedefs, even though the
27156 standard seems to require it. */
27161 /* Parse the declarator. */
27162 declarator
27164 flags,
27170 /* If something went wrong parsing the declarator, make sure
27171 that we at least consume some tokens. */
27173 {
27174 /* Skip to the end of the statement. */
27176 /* If the next token is not a semicolon, that is
27177 probably because we just skipped over the body of
27178 a function. So, we consume a semicolon if
27179 present, but do not issue an error message if it
27180 is not present. */
27182 CPP_SEMICOLON))
27185 }
27187 /* Handle class-scope non-template C++17 deduction guides. */
27190 declarator,
27194 cp_parser_check_for_definition_in_return_type
27198 /* Look for an asm-specification. */
27200 /* Look for attributes that apply to the declaration. */
27202 /* Remember which attributes are prefix attributes and
27203 which are not. */
27205 /* Combine the attributes. */
27208 /* If it's an `=', then we have a constant-initializer or a
27209 pure-specifier. It is not correct to parse the
27210 initializer before registering the member declaration
27211 since the member declaration should be in scope while
27212 its initializer is processed. However, the rest of the
27213 front end does not yet provide an interface that allows
27214 us to handle this correctly. */
27216 {
27217 /* In [class.mem]:
27219 A pure-specifier shall be used only in the declaration of
27220 a virtual function.
27222 A member-declarator can contain a constant-initializer
27223 only if it declares a static member of integral or
27224 enumeration type.
27226 Therefore, if the DECLARATOR is for a function, we look
27227 for a pure-specifier; otherwise, we look for a
27228 constant-initializer. When we call `grokfield', it will
27229 perform more stringent semantics checks. */
27242 {
27244 /* Don't require a constant rvalue in C++11, since we
27245 might want a reference constant. We'll enforce
27246 constancy later. */
27248 /* Parse the initializer. */
27251 }
27252 else
27253 /* Parse the initializer. */
27255 }
27258 {
27260 declarator->init_loc
27264 else
27266 }
27267 /* Detect invalid bit-field cases such as
27269 int *p : 4;
27270 int &&r : 3;
27272 and similar. */
27274 /* If there were no type specifiers, it was a
27275 constructor. */
27277 {
27278 /* This is called for a decent diagnostic only. */
27287 /* Avoid "extra ;" pedwarns. */
27289 CPP_SEMICOLON))
27292 }
27293 /* Otherwise, there is no initializer. */
27294 else
27297 /* See if we are probably looking at a function
27298 definition. We are certainly not looking at a
27299 member-declarator. Calling `grokfield' has
27300 side-effects, so we must not do it unless we are sure
27301 that we are looking at a member-declarator. */
27304 {
27305 /* The grammar does not allow a pure-specifier to be
27306 used when a member function is defined. (It is
27307 possible that this fact is an oversight in the
27308 standard, since a pure function may be defined
27309 outside of the class-specifier. */
27315 declarator,
27316 attributes);
27319 /* If the member was not a friend, declare it here. */
27322 /* Peek at the next token. */
27324 /* If the next token is a semicolon, consume it. */
27326 {
27327 location_t semicolon_loc
27332 "extra %<;%> after in-class "
27334 }
27336 }
27337 else
27340 /* Create the declaration. */
27345 {
27348 else
27350 }
27351 }
27356 /* Reset PREFIX_ATTRIBUTES. */
27358 {
27363 }
27365 /* If there is any qualification still in effect, clear it
27366 now; we will be starting fresh with the next declarator. */
27370 /* If it's a `,', then there are more declarators. */
27372 {
27375 {
27381 }
27382 }
27383 /* If the next token isn't a `;', then we have a parse error. */
27385 CPP_SEMICOLON))
27386 {
27387 /* The next token might be a ways away from where the
27388 actual semicolon is missing. Find the previous token
27389 and use that for our error position. */
27396 /* Assume that the user meant to provide a semicolon. If
27397 we were to cp_parser_skip_to_end_of_statement, we might
27398 skip to a semicolon inside a member function definition
27399 and issue nonsensical error messages. */
27401 }
27404 {
27405 /* Add DECL to the list of members. */
27407 /* Explicitly include, eg, NSDMIs, for better error
27408 recovery (c++/58650). */
27416 /* Add DECL to the queue of NSDMI to be parsed later. */
27418 }
27422 }
27423 }
27426 out:
27429 }
27431 /* Parse a pure-specifier.
27433 pure-specifier:
27434 = 0
27436 Returns INTEGER_ZERO_NODE if a pure specifier is found.
27437 Otherwise, ERROR_MARK_NODE is returned. */
27439 static tree
27441 {
27444 /* Look for the `=' token. */
27447 /* Look for the `0' token. */
27456 /* Accept = default or = delete in c++0x mode. */
27459 {
27462 }
27464 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
27466 {
27471 }
27473 {
27476 }
27479 }
27481 /* Parse a constant-initializer.
27483 constant-initializer:
27484 = constant-expression
27486 Returns a representation of the constant-expression. */
27488 static tree
27490 {
27491 /* Look for the `=' token. */
27495 /* It is invalid to write:
27497 struct S { static const int i = { 7 }; };
27499 */
27501 {
27504 /* Consume the opening brace. */
27505 matching_braces braces;
27507 /* Skip the initializer. */
27509 /* Look for the trailing `}'. */
27513 }
27516 }
27518 /* Derived classes [gram.class.derived] */
27520 /* Parse a base-clause.
27522 base-clause:
27523 : base-specifier-list
27525 base-specifier-list:
27526 base-specifier ... [opt]
27527 base-specifier-list , base-specifier ... [opt]
27529 Returns a TREE_LIST representing the base-classes, in the order in
27530 which they were declared. The representation of each node is as
27531 described by cp_parser_base_specifier.
27533 In the case that no bases are specified, this function will return
27534 NULL_TREE, not ERROR_MARK_NODE. */
27536 static tree
27538 {
27541 /* Look for the `:' that begins the list. */
27544 /* Scan the base-specifier-list. */
27546 {
27548 tree base;
27551 /* Look for the base-specifier. */
27553 /* Look for the (optional) ellipsis. */
27555 {
27556 /* Consume the `...'. */
27560 }
27562 /* Add BASE to the front of the list. */
27564 {
27566 /* Make this a pack expansion type. */
27570 {
27573 }
27574 }
27575 /* Peek at the next token. */
27577 /* If it's not a comma, then the list is complete. */
27580 /* Consume the `,'. */
27582 }
27584 /* PARSER->SCOPE may still be non-NULL at this point, if the last
27585 base class had a qualified name. However, the next name that
27586 appears is certainly not qualified. */
27592 }
27594 /* Parse a base-specifier.
27596 base-specifier:
27597 :: [opt] nested-name-specifier [opt] class-name
27598 virtual access-specifier [opt] :: [opt] nested-name-specifier
27599 [opt] class-name
27600 access-specifier virtual [opt] :: [opt] nested-name-specifier
27601 [opt] class-name
27603 Returns a TREE_LIST. The TREE_PURPOSE will be one of
27604 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
27605 indicate the specifiers provided. The TREE_VALUE will be a TYPE
27606 (or the ERROR_MARK_NODE) indicating the type that was specified. */
27608 static tree
27610 {
27618 tree type;
27620 /* Process the optional `virtual' and `access-specifier'. */
27622 {
27623 /* Peek at the next token. */
27625 /* Process `virtual'. */
27627 {
27629 /* If `virtual' appears more than once, issue an error. */
27631 {
27635 }
27639 /* Consume the `virtual' token. */
27647 /* If more than one access specifier appears, issue an
27648 error. */
27651 {
27655 }
27659 /* Consume the access-specifier. */
27667 }
27668 }
27669 /* It is not uncommon to see programs mechanically, erroneously, use
27670 the 'typename' keyword to denote (dependent) qualified types
27671 as base classes. */
27673 {
27678 else
27680 "keyword %<typename%> not allowed in this context "
27683 }
27685 /* Look for the optional `::' operator. */
27687 /* Look for the nested-name-specifier. The simplest way to
27688 implement:
27690 [temp.res]
27692 The keyword `typename' is not permitted in a base-specifier or
27693 mem-initializer; in these contexts a qualified name that
27694 depends on a template-parameter is implicitly assumed to be a
27695 type name.
27697 is to pretend that we have seen the `typename' keyword at this
27698 point. */
27704 /* If the base class is given by a qualified name, assume that names
27705 we see are type names or templates, as appropriate. */
27711 /* DR 950 allows decltype as a base-specifier. */
27713 else
27714 {
27715 /* Otherwise, look for the class-name. */
27717 class_scope_p,
27718 template_p,
27719 typename_type,
27724 }
27730 }
27732 /* Exception handling [gram.exception] */
27734 /* Save the tokens that make up the noexcept-specifier for a member-function.
27735 Returns a DEFERRED_PARSE. */
27737 static tree
27739 {
27741 /* We want everything up to, including, the final ')'. */
27745 /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
27746 to carry the information we will need. */
27748 /* Save away the noexcept-specifier; we will process it when the
27749 class is complete. */
27754 }
27756 /* Used for late processing of noexcept-specifiers of member-functions.
27757 DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
27758 we saved for later; parse it now. DECL is the declaration of the
27759 member function. */
27761 static tree
27763 {
27764 /* Make sure we've gotten something that hasn't been parsed yet. */
27769 /* Push the saved tokens for the noexcept-specifier onto the parser's
27770 lexer stack. */
27774 /* Parse the cached noexcept-specifier. */
27775 tree parsed_arg
27777 CP_PARSER_FLAGS_NONE,
27782 /* Revert to the main lexer. */
27785 /* Restore the queue. */
27788 /* And we're done. */
27790 }
27792 /* Perform late checking of overriding function with respect to their
27793 noexcept-specifiers. TYPE is the class and FNDECL is the function
27794 that potentially overrides some virtual function with the same
27795 signature. */
27797 static void
27799 {
27801 tree base_binfo;
27807 {
27816 }
27817 }
27819 /* Parse an (optional) noexcept-specification.
27821 noexcept-specification:
27822 noexcept ( constant-expression ) [opt]
27824 If no noexcept-specification is present, returns NULL_TREE.
27825 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
27826 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
27827 there are no parentheses. CONSUMED_EXPR will be set accordingly.
27828 Otherwise, returns a noexcept specification unless RETURN_COND is true,
27829 in which case a boolean condition is returned instead. The parser flags
27830 FLAGS is used to control parsing. QUALS are qualifiers indicating whether
27831 the (member) function is `const'. */
27833 static tree
27835 cp_parser_flags flags,
27839 {
27843 /* Peek at the next token. */
27846 /* Is it a noexcept-specification? */
27848 {
27849 tree expr;
27851 /* [class.mem]/6 says that a noexcept-specifer (within the
27852 member-specification of the class) is a complete-class context of
27853 a class. So, if the noexcept-specifier has the optional expression,
27854 just save the tokens, and reparse this after we're done with the
27855 class. */
27859 /* No need to delay parsing for a number literal or true/false. */
27871 {
27872 matching_parens parens;
27876 {
27877 /* Types may not be defined in an exception-specification. */
27879 parser->type_definition_forbidden_message
27883 expr
27889 {
27892 }
27894 /* Restore the saved message. */
27896 }
27897 else
27898 {
27901 }
27904 }
27905 else
27906 {
27910 }
27912 /* We cannot build a noexcept-spec right away because this will check
27913 that expr is a constexpr. */
27916 else
27918 }
27919 else
27921 }
27923 /* Parse an (optional) exception-specification.
27925 exception-specification:
27926 throw ( type-id-list [opt] )
27928 Returns a TREE_LIST representing the exception-specification. The
27929 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
27930 control parsing. QUALS are qualifiers indicating whether the (member)
27931 function is `const'. */
27933 static tree
27935 cp_parser_flags flags)
27936 {
27938 tree type_id_list;
27941 /* Peek at the next token. */
27944 /* Is it a noexcept-specification? */
27945 type_id_list
27953 /* If it's not `throw', then there's no exception-specification. */
27959 /* Consume the `throw'. */
27962 /* Look for the `('. */
27963 matching_parens parens;
27966 /* Peek at the next token. */
27968 /* If it's not a `)', then there is a type-id-list. */
27970 {
27971 /* Types may not be defined in an exception-specification. */
27973 parser->type_definition_forbidden_message
27975 /* Parse the type-id-list. */
27977 /* Restore the saved message. */
27981 {
27985 }
27988 "dynamic exception specifications are deprecated in "
27990 }
27991 /* In C++17, throw() is equivalent to noexcept (true). throw()
27992 is deprecated in C++11 and above as well, but is still widely used,
27993 so don't warn about it yet. */
27996 else
27999 /* Look for the `)'. */
28003 }
28005 /* Parse an (optional) type-id-list.
28007 type-id-list:
28008 type-id ... [opt]
28009 type-id-list , type-id ... [opt]
28011 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
28012 in the order that the types were presented. */
28014 static tree
28016 {
28020 {
28022 tree type;
28026 /* Get the next type-id. */
28028 /* Check for invalid 'auto'. */
28030 {
28034 }
28035 /* Parse the optional ellipsis. */
28037 {
28038 /* Consume the `...'. */
28041 /* Turn the type into a pack expansion expression. */
28043 }
28044 /* Add it to the list. */
28046 /* Peek at the next token. */
28048 /* If it is not a `,', we are done. */
28051 /* Consume the `,'. */
28053 }
28056 }
28058 /* Parse a try-block.
28060 try-block:
28061 try compound-statement handler-seq */
28063 static tree
28065 {
28066 tree try_block;
28073 "%<try%> in %<constexpr%> function only "
28083 }
28085 /* Parse a function-try-block.
28087 function-try-block:
28088 try ctor-initializer [opt] function-body handler-seq */
28090 static void
28092 {
28093 tree compound_stmt;
28094 tree try_block;
28096 /* Look for the `try' keyword. */
28099 /* Let the rest of the front end know where we are. */
28101 /* Parse the function-body. */
28102 cp_parser_ctor_initializer_opt_and_function_body
28104 /* We're done with the `try' part. */
28106 /* Parse the handlers. */
28108 /* We're done with the handlers. */
28110 }
28112 /* Parse a handler-seq.
28114 handler-seq:
28115 handler handler-seq [opt] */
28117 static void
28119 {
28121 {
28124 /* Parse the handler. */
28126 /* Peek at the next token. */
28128 /* If it's not `catch' then there are no more handlers. */
28131 }
28132 }
28134 /* Parse a handler.
28136 handler:
28137 catch ( exception-declaration ) compound-statement */
28139 static void
28141 {
28142 tree handler;
28143 tree declaration;
28147 matching_parens parens;
28154 }
28156 /* Parse an exception-declaration.
28158 exception-declaration:
28159 type-specifier-seq declarator
28160 type-specifier-seq abstract-declarator
28161 type-specifier-seq
28162 ...
28164 Returns a VAR_DECL for the declaration, or NULL_TREE if the
28165 ellipsis variant is used. */
28167 static tree
28169 {
28170 cp_decl_specifier_seq type_specifiers;
28174 /* If it's an ellipsis, it's easy to handle. */
28176 {
28177 /* Consume the `...' token. */
28180 }
28182 /* Types may not be defined in exception-declarations. */
28184 parser->type_definition_forbidden_message
28187 /* Parse the type-specifier-seq. */
28192 /* If it's a `)', then there is no declarator. */
28195 else
28197 CP_PARSER_FLAGS_NONE,
28204 /* Restore the saved message. */
28211 }
28213 /* Parse a throw-expression.
28215 throw-expression:
28216 throw assignment-expression [opt]
28218 Returns a THROW_EXPR representing the throw-expression. */
28220 static tree
28222 {
28223 tree expression;
28229 /* Figure out whether or not there is an assignment-expression
28230 following the "throw" keyword. */
28238 else
28241 /* Construct a location e.g.:
28242 throw x
28243 ^~~~~~~
28244 with caret == start at the start of the "throw" token, and
28245 the end at the end of the final token we consumed. */
28251 }
28253 /* Parse a yield-expression.
28255 yield-expression:
28256 co_yield assignment-expression
28257 co_yield braced-init-list
28259 Returns a CO_YIELD_EXPR representing the yield-expression. */
28261 static tree
28263 {
28264 tree expr;
28272 {
28275 /* ??? : probably a moot point? */
28278 }
28279 else
28286 }
28288 /* GNU Extensions */
28290 /* Parse an (optional) asm-specification.
28292 asm-specification:
28293 asm ( string-literal )
28295 If the asm-specification is present, returns a STRING_CST
28296 corresponding to the string-literal. Otherwise, returns
28297 NULL_TREE. */
28299 static tree
28301 {
28303 tree asm_specification;
28305 /* Peek at the next token. */
28307 /* If the next token isn't the `asm' keyword, then there's no
28308 asm-specification. */
28312 /* Consume the `asm' token. */
28314 /* Look for the `('. */
28315 matching_parens parens;
28318 /* Look for the string-literal. */
28321 /* Look for the `)'. */
28325 }
28327 /* Parse an asm-operand-list.
28329 asm-operand-list:
28330 asm-operand
28331 asm-operand-list , asm-operand
28333 asm-operand:
28334 string-literal ( expression )
28335 [ string-literal ] string-literal ( expression )
28337 Returns a TREE_LIST representing the operands. The TREE_VALUE of
28338 each node is the expression. The TREE_PURPOSE is itself a
28339 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
28340 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
28341 is a STRING_CST for the string literal before the parenthesis. Returns
28342 ERROR_MARK_NODE if any of the operands are invalid. */
28344 static tree
28346 {
28351 {
28352 tree string_literal;
28353 tree expression;
28354 tree name;
28357 {
28358 /* Consume the `[' token. */
28360 /* Read the operand name. */
28365 /* Look for the closing `]'. */
28367 }
28368 else
28370 /* Look for the string-literal. */
28373 /* Look for the `('. */
28374 matching_parens parens;
28376 /* Parse the expression. */
28378 /* Look for the `)'. */
28386 /* Add this operand to the list. */
28388 expression,
28389 asm_operands);
28390 /* If the next token is not a `,', there are no more
28391 operands. */
28394 /* Consume the `,'. */
28396 }
28399 }
28401 /* Parse an asm-clobber-list.
28403 asm-clobber-list:
28404 string-literal
28405 asm-clobber-list , string-literal
28407 Returns a TREE_LIST, indicating the clobbers in the order that they
28408 appeared. The TREE_VALUE of each node is a STRING_CST. */
28410 static tree
28412 {
28416 {
28417 tree string_literal;
28419 /* Look for the string literal. */
28421 /* Add it to the list. */
28423 /* If the next token is not a `,', then the list is
28424 complete. */
28427 /* Consume the `,' token. */
28429 }
28432 }
28434 /* Parse an asm-label-list.
28436 asm-label-list:
28437 identifier
28438 asm-label-list , identifier
28440 Returns a TREE_LIST, indicating the labels in the order that they
28441 appeared. The TREE_VALUE of each node is a label. */
28443 static tree
28445 {
28449 {
28452 /* Look for the identifier. */
28455 {
28458 {
28464 }
28465 }
28466 /* If the next token is not a `,', then the list is
28467 complete. */
28470 /* Consume the `,' token. */
28472 }
28475 }
28477 /* Return TRUE iff the next tokens in the stream are possibly the
28478 beginning of a GNU extension attribute. */
28480 static bool
28482 {
28484 }
28486 /* Return TRUE iff the next tokens in the stream are possibly the
28487 beginning of a standard C++-11 attribute specifier. */
28489 static bool
28491 {
28493 }
28495 /* Return TRUE iff the next Nth tokens in the stream are possibly the
28496 beginning of a standard C++-11 attribute specifier. */
28498 static bool
28500 {
28508 }
28510 /* Return TRUE iff the next Nth tokens in the stream are possibly the
28511 beginning of a GNU extension attribute. */
28513 static bool
28515 {
28519 }
28521 /* Return true iff the next tokens can be the beginning of either a
28522 GNU attribute list, or a standard C++11 attribute sequence. */
28524 static bool
28526 {
28529 }
28531 /* Return true iff the next Nth tokens can be the beginning of either
28532 a GNU attribute list, or a standard C++11 attribute sequence. */
28534 static bool
28536 {
28539 }
28541 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
28542 of GNU attributes, or return NULL. */
28544 static tree
28546 {
28550 }
28552 /* Parse an (optional) series of attributes.
28554 attributes:
28555 attributes attribute
28557 attribute:
28558 __attribute__ (( attribute-list [opt] ))
28560 The return value is as for cp_parser_gnu_attribute_list. */
28562 static tree
28564 {
28571 {
28573 tree attribute_list;
28576 /* Peek at the next token. */
28578 /* If it's not `__attribute__', then we're done. */
28582 /* Consume the `__attribute__' keyword. */
28584 /* Look for the two `(' tokens. */
28585 matching_parens outer_parens;
28588 matching_parens inner_parens;
28592 /* Peek at the next token. */
28595 /* Parse the attribute-list. */
28597 else
28598 /* If the next token is a `)', then there is no attribute
28599 list. */
28602 /* Look for the two `)' tokens. */
28610 /* Add these new attributes to the list. */
28612 }
28615 }
28617 /* Parse a GNU attribute-list.
28619 attribute-list:
28620 attribute
28621 attribute-list , attribute
28623 attribute:
28624 identifier
28625 identifier ( identifier )
28626 identifier ( identifier , expression-list )
28627 identifier ( expression-list )
28629 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
28630 to an attribute. The TREE_PURPOSE of each node is the identifier
28631 indicating which attribute is in use. The TREE_VALUE represents
28632 the arguments, if any. */
28634 static tree
28636 {
28640 /* Don't create wrapper nodes within attributes: the
28641 handlers don't know how to handle them. */
28642 auto_suppress_location_wrappers sentinel;
28646 {
28648 tree identifier;
28649 tree attribute;
28651 /* Look for the identifier. We also allow keywords here; for
28652 example `__attribute__ ((const))' is legal. */
28656 {
28659 /* Consume the token, but save it since we need it for the
28660 SIMD enabled function parsing. */
28663 /* Save away the identifier that indicates which attribute
28664 this is. */
28666 /* For keywords, use the canonical spelling, not the
28667 parsed identifier. */
28674 /* Peek at the next token. */
28676 /* If it's an `(', then parse the attribute arguments. */
28678 {
28682 vec = cp_parser_parenthesized_expression_list
28688 else
28689 {
28692 }
28693 /* Save the arguments away. */
28695 }
28698 {
28699 /* Add this attribute to the list. */
28702 }
28705 }
28706 /* Unless EXACTLY_ONE is set look for more attributes.
28707 If the next token isn't a `,', we're done. */
28711 /* Consume the comma and keep going. */
28713 }
28716 /* We built up the list in reverse order. */
28718 }
28720 /* Parse arguments of omp::directive attribute.
28722 ( directive-name ,[opt] clause-list[opt] )
28724 For directive just remember the first/last tokens for subsequent
28725 parsing. */
28727 static void
28729 {
28732 {
28738 }
28741 {
28747 }
28756 }
28758 /* Parse arguments of omp::sequence attribute.
28760 ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
28762 static void
28764 {
28765 matching_parens parens;
28767 do
28768 {
28773 {
28777 }
28782 else
28787 {
28796 }
28800 UNKNOWN_LOCATION);
28803 else
28808 }
28813 }
28815 /* Parse a standard C++11 attribute.
28817 The returned representation is a TREE_LIST which TREE_PURPOSE is
28818 the scoped name of the attribute, and the TREE_VALUE is its
28819 arguments list.
28821 Note that the scoped name of the attribute is itself a TREE_LIST
28822 which TREE_PURPOSE is the namespace of the attribute, and
28823 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
28824 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
28825 and which TREE_PURPOSE is directly the attribute name.
28827 Clients of the attribute code should use get_attribute_namespace
28828 and get_attribute_name to get the actual namespace and name of
28829 attributes, regardless of their being GNU or C++11 attributes.
28831 attribute:
28832 attribute-token attribute-argument-clause [opt]
28834 attribute-token:
28835 identifier
28836 attribute-scoped-token
28838 attribute-scoped-token:
28839 attribute-namespace :: identifier
28841 attribute-namespace:
28842 identifier
28844 attribute-argument-clause:
28845 ( balanced-token-seq )
28847 balanced-token-seq:
28848 balanced-token [opt]
28849 balanced-token-seq balanced-token
28851 balanced-token:
28852 ( balanced-token-seq )
28853 [ balanced-token-seq ]
28854 { balanced-token-seq }. */
28856 static tree
28858 {
28865 /* First, parse name of the attribute, a.k.a attribute-token. */
28882 {
28883 /* We are seeing a scoped attribute token. */
28898 else
28899 {
28903 }
28909 NULL_TREE);
28911 }
28913 {
28917 NULL_TREE);
28918 }
28919 else
28920 {
28923 NULL_TREE);
28924 /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
28925 but no longer: we have to be able to tell [[noreturn]] and
28926 __attribute__((noreturn)) apart. */
28927 /* C++14 deprecated attribute is equivalent to GNU's. */
28930 /* C++17 fallthrough attribute is equivalent to GNU's. */
28933 /* Transactional Memory TS optimize_for_synchronized attribute is
28934 equivalent to GNU transaction_callable. */
28938 /* Transactional Memory attributes are GNU attributes. */
28941 }
28943 /* Now parse the optional argument clause of the attribute. */
28946 {
28951 {
28953 attr_id);
28955 }
28957 }
28959 {
28963 /* Maybe we don't expect to see any arguments for this attribute. */
28967 {
28969 attr_id);
28975 }
28979 /* A GNU attribute that takes an identifier in parameter. */
28982 /* If this is a fake attribute created to handle -Wno-attributes,
28983 we must skip parsing the arguments. */
28985 {
28987 {
28989 {
28992 }
28994 {
29000 }
29001 }
29003 /* For unknown attributes, just skip balanced tokens instead of
29004 trying to parse the arguments. */
29008 }
29010 vec = cp_parser_parenthesized_expression_list
29016 else
29017 {
29019 /* e.g. [[attr()]]. */
29022 attr_id);
29025 }
29029 else
29031 }
29034 }
29036 /* Warn if the attribute ATTRIBUTE appears more than once in the
29037 attribute-list ATTRIBUTES. This used to be enforced for certain
29038 attributes, but the restriction was removed in P2156. Note that
29039 carries_dependency ([dcl.attr.depend]) isn't implemented yet in GCC.
29040 LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
29041 found in ATTRIBUTES. */
29043 static bool
29045 {
29053 {
29058 }
29060 }
29062 /* Parse a list of standard C++-11 attributes.
29064 attribute-list:
29065 attribute [opt]
29066 attribute-list , attribute[opt]
29067 attribute ...
29068 attribute-list , attribute ...
29069 */
29071 static tree
29073 {
29078 {
29084 {
29086 {
29089 }
29090 }
29093 {
29098 else
29099 {
29104 }
29106 }
29110 }
29113 }
29115 /* Parse a standard C++-11 attribute specifier.
29117 attribute-specifier:
29118 [ [ attribute-using-prefix [opt] attribute-list ] ]
29119 alignment-specifier
29121 attribute-using-prefix:
29122 using attribute-namespace :
29124 alignment-specifier:
29125 alignas ( type-id ... [opt] )
29126 alignas ( alignment-expression ... [opt] ). */
29128 static tree
29130 {
29136 {
29143 {
29154 {
29157 "attribute using prefix only available "
29163 }
29164 else
29166 }
29173 else
29174 /* Warn about parsing c++11 attribute in non-c++11 mode, only
29175 when we are sure that we have actually parsed them. */
29177 }
29178 else
29179 {
29180 tree alignas_expr;
29182 /* Look for an alignment-specifier. */
29193 matching_parens parens;
29201 {
29208 }
29213 /* Handle alignas (pack...). */
29215 {
29218 }
29220 /* Something went wrong, so don't build the attribute. */
29224 /* Missing ')' means the code cannot possibly be valid; go ahead
29225 and commit to make sure we issue a hard error. */
29233 /* Build the C++-11 representation of an 'aligned'
29234 attribute. */
29235 attributes
29238 }
29241 }
29243 /* Parse a standard C++-11 attribute-specifier-seq.
29245 attribute-specifier-seq:
29246 attribute-specifier-seq [opt] attribute-specifier
29247 */
29249 static tree
29251 {
29255 /* Don't create wrapper nodes within attributes: the
29256 handlers don't know how to handle them. */
29257 auto_suppress_location_wrappers sentinel;
29260 {
29269 else
29272 }
29275 }
29277 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
29278 return index of the first token after balanced-token, or N on failure. */
29280 static size_t
29282 {
29285 do
29287 {
29291 /* FALLTHRU */
29293 /* Ran out of tokens. */
29315 }
29318 }
29320 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
29321 return index of the first token after the GNU attribute tokens, or N on
29322 failure. */
29324 static size_t
29326 {
29328 {
29340 }
29342 }
29344 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
29345 next token), return index of the first token after the standard C++11
29346 attribute tokens, or N on failure. */
29348 static size_t
29350 {
29352 {
29355 {
29362 }
29365 {
29370 }
29371 else
29373 }
29375 }
29377 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
29378 as the next token), return index of the first token after the attribute
29379 tokens, or N on failure. */
29381 static size_t
29383 {
29387 }
29389 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
29390 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
29391 current value of the PEDANTIC flag, regardless of whether or not
29392 the `__extension__' keyword is present. The caller is responsible
29393 for restoring the value of the PEDANTIC flag. */
29395 static bool
29397 {
29398 /* Save the old value of the PEDANTIC flag. */
29402 {
29403 /* Consume the `__extension__' token. */
29405 /* We're not being pedantic while the `__extension__' keyword is
29406 in effect. */
29410 }
29413 }
29415 /* Parse a label declaration.
29417 label-declaration:
29418 __label__ label-declarator-seq ;
29420 label-declarator-seq:
29421 identifier , label-declarator-seq
29422 identifier */
29424 static void
29426 {
29427 /* Look for the `__label__' keyword. */
29431 {
29432 tree identifier;
29434 /* Look for an identifier. */
29436 /* If we failed, stop. */
29439 /* Declare it as a label. */
29441 /* If the next token is a `;', stop. */
29444 /* Look for the `,' separating the label declarations. */
29446 }
29448 /* Look for the final `;'. */
29450 }
29452 // -------------------------------------------------------------------------- //
29453 // Concept definitions
29455 static tree
29457 {
29458 /* A concept definition is an unevaluated context. */
29459 cp_unevaluated u;
29466 {
29470 }
29473 {
29477 }
29479 processing_constraint_expression_sentinel parsing_constraint;
29484 /* Consume the trailing ';'. Diagnose the problem if it isn't there,
29485 but continue as if it were. */
29489 }
29491 // -------------------------------------------------------------------------- //
29492 // Requires Clause
29494 /* Diagnose an expression that should appear in ()'s within a requires-clause
29495 and suggest where to place those parentheses. */
29497 static void
29499 {
29501 }
29503 static void
29505 {
29510 }
29512 /* Characterizes the likely kind of expression intended by a mis-written
29513 primary constraint. */
29514 enum primary_constraint_error
29515 {
29516 pce_ok,
29517 pce_maybe_operator,
29518 pce_maybe_postfix
29519 };
29521 /* Returns true if the token(s) following a primary-expression in a
29522 constraint-logical-* expression would require parentheses. */
29524 static primary_constraint_error
29526 {
29529 {
29534 {
29535 /* An equal sign may be part of the definition of a function,
29536 and not an assignment operator, when parsing the expression
29537 for a trailing requires-clause. For example:
29539 template<typename T>
29540 struct S {
29541 S() requires C<T> = default;
29542 };
29544 Don't try to reparse this a binary operator. */
29550 }
29552 /* Arithmetic operators. */
29558 /* Bitwise operators. */
29564 /* Relational operators. */
29572 /* Pointer-to-member. */
29575 /* Assignment operators. */
29586 /* Conditional operator */
29588 /* Unenclosed binary or conditional operator. */
29592 {
29593 /* A primary constraint that precedes the parameter-list of a
29594 lambda expression is followed by an open paren.
29596 []<typename T> requires C (T a, T b) { ... }
29598 Don't try to re-parse this as a postfix expression. */
29603 }
29605 {
29606 /* A primary-constraint-expression followed by a '[[' is not a
29607 postfix expression. */
29612 }
29616 /* Unenclosed postfix operator. */
29620 /* A primary constraint that precedes the lambda-declarator of a
29621 lambda expression is followed by trailing return type.
29623 []<typename T> requires C -> void {}
29625 Don't try to re-parse this as a postfix expression in
29626 C++23 and later. In C++20 ( needs to come in between but we
29627 allow it to be omitted with pedwarn. */
29630 /* Unenclosed postfix operator. */
29632 }
29633 }
29635 /* Returns true if the next token begins a unary expression, preceded by
29636 an operator or keyword. */
29638 static bool
29640 {
29643 {
29654 {
29656 {
29672 }
29673 }
29677 }
29680 }
29682 /* Parse a primary expression within a constraint. */
29684 static cp_expr
29686 {
29687 /* If this looks like a unary expression, parse it as such, but diagnose
29688 it as ill-formed; it requires parens. */
29690 {
29694 }
29697 cp_id_kind idk;
29708 {
29709 /* The primary-expression could be part of an unenclosed non-logical
29710 compound expression. */
29712 }
29714 {
29717 }
29719 /* Retry the parse at a lower precedence. If that succeeds, diagnose the
29720 error, but return the expression as if it were valid. */
29725 else
29728 {
29731 }
29733 /* Otherwise, something has gone very wrong, and we can't generate a more
29734 meaningful diagnostic or recover. */
29737 }
29739 /* Parse a constraint-logical-and-expression.
29741 constraint-logical-and-expression:
29742 primary-expression
29743 constraint-logical-and-expression '&&' primary-expression */
29745 static cp_expr
29747 {
29750 {
29754 }
29756 }
29758 /* Parse a constraint-logical-or-expression.
29760 constraint-logical-or-expression:
29761 constraint-logical-and-expression
29762 constraint-logical-or-expression '||' constraint-logical-and-expression */
29764 static cp_expr
29766 {
29769 {
29773 }
29775 }
29777 /* Parse the expression after a requires-clause. This has a different grammar
29778 than that in the concepts TS. */
29780 static tree
29782 {
29783 processing_constraint_expression_sentinel parsing_constraint;
29790 }
29792 /* Parse a expression after a requires clause.
29794 constraint-expression:
29795 logical-or-expression
29797 The required logical-or-expression must be a constant expression. Note
29798 that we don't check that the expression is constepxr here. We defer until
29799 we analyze constraints and then, we only check atomic constraints. */
29801 static tree
29803 {
29804 processing_constraint_expression_sentinel parsing_constraint;
29813 }
29815 /* Optionally parse a requires clause:
29817 requires-clause:
29818 `requires` constraint-logical-or-expression.
29819 [ConceptsTS]
29820 `requires constraint-expression.
29822 LAMBDA_P is true when the requires-clause is parsed before the
29823 parameter-list of a lambda-declarator. */
29825 static tree
29827 {
29828 /* A requires clause is an unevaluated context. */
29829 cp_unevaluated u;
29833 {
29836 {
29838 "%<requires%> only available with "
29840 /* Parse and discard the requires-clause. */
29843 }
29845 }
29849 {
29850 /* An opening brace following the start of a requires-clause is
29851 ill-formed; the user likely forgot the second `requires' that
29852 would start a requires-expression. */
29857 /* Don't consume the `requires', so that it's reused as the start of a
29858 requires-expression. */
29859 }
29860 else
29865 else
29867 }
29869 /*---------------------------------------------------------------------------
29870 Requires expressions
29871 ---------------------------------------------------------------------------*/
29873 /* Parse a requires expression
29875 requirement-expression:
29876 'requires' requirement-parameter-list [opt] requirement-body */
29878 static tree
29880 {
29884 /* Avoid committing to outer tentative parse. */
29887 /* This is definitely a requires-expression. */
29891 {
29892 /* Local parameters are delared as variables within the scope
29893 of the expression. They are not visible past the end of
29894 the expression. Expressions within the requires-expression
29895 are unevaluated. */
29896 struct scope_sentinel
29897 {
29899 {
29902 }
29905 {
29908 }
29911 /* Parse the optional parameter list. */
29913 {
29917 }
29918 else
29921 /* Parse the requirement body. */
29927 }
29929 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
29930 the parm chain. */
29935 {
29936 /* Perform semantic processing now to diagnose any invalid types and
29937 expressions. */
29942 }
29944 }
29946 /* Parse a parameterized requirement.
29948 requirement-parameter-list:
29949 '(' parameter-declaration-clause ')' */
29951 static tree
29953 {
29954 matching_parens parens;
29958 tree parms = (cp_parser_parameter_declaration_clause
29964 /* Modify the declared parameters by removing their context
29965 so they don't refer to the enclosing scope and explicitly
29966 indicating that they are constraint variables. */
29968 {
29973 {
29976 }
29977 }
29980 }
29982 /* Parse the body of a requirement.
29984 requirement-body:
29985 '{' requirement-list '}' */
29986 static tree
29988 {
29989 matching_braces braces;
29999 }
30001 /* Parse a sequence of requirements.
30003 requirement-seq:
30004 requirement
30005 requirement-seq requirement */
30007 static tree
30009 {
30011 do
30012 {
30016 }
30020 /* If there are no valid requirements, this is not a valid expression. */
30024 /* Reverse the order of requirements so they are analyzed in order. */
30026 }
30028 /* Parse a syntactic requirement or type requirement.
30030 requirement:
30031 simple-requirement
30032 compound-requirement
30033 type-requirement
30034 nested-requirement */
30036 static tree
30038 {
30045 else
30047 }
30049 /* Parse a simple requirement.
30051 simple-requirement:
30052 expression ';' */
30054 static tree
30056 {
30067 /* Sometimes we don't get locations, so use the cached token location
30068 as a reasonable approximation. */
30073 {
30076 {
30079 }
30081 {
30085 "if a concept-id is a valid expression; add "
30087 }
30089 }
30092 }
30094 /* Parse a type requirement
30096 type-requirement
30097 nested-name-specifier [opt] required-type-name ';'
30099 required-type-name:
30100 type-name
30101 'template' [opt] simple-template-id */
30103 static tree
30105 {
30109 // Save the scope before parsing name specifiers.
30120 tree type;
30122 {
30131 }
30132 else
30152 }
30154 /* Parse a compound requirement
30156 compound-requirement:
30157 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
30159 static tree
30161 {
30162 /* Parse an expression enclosed in '{ }'s. */
30163 matching_braces braces;
30174 {
30178 }
30180 /* If the expression was invalid, skip the remainder of the requirement. */
30182 {
30186 }
30188 /* Parse the optional noexcept. */
30191 {
30194 }
30196 /* Parse the optional trailing return type. */
30199 {
30205 /* C++20 allows either a type-id or a type-constraint. Parsing
30206 a type-id will subsume the parsing for a type-constraint but
30207 allow for more syntactic forms (e.g., const C<T>*). */
30216 /* Check that we haven't written something like 'const C<T>*'. */
30218 {
30220 {
30225 }
30226 }
30228 /* P1452R2 removed the trailing-return-type option. */
30231 }
30243 }
30245 /* Parse a nested requirement. This is the same as a requires clause.
30247 nested-requirement:
30248 requires-clause */
30250 static tree
30252 {
30264 }
30266 /* Support Functions */
30268 /* Return the appropriate prefer_type argument for lookup_name based on
30269 tag_type. */
30273 {
30275 {
30279 }
30280 }
30282 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
30283 NAME should have one of the representations used for an
30284 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
30285 is returned. If PARSER->SCOPE is a dependent type, then a
30286 SCOPE_REF is returned.
30288 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
30289 returned; the name was already resolved when the TEMPLATE_ID_EXPR
30290 was formed. Abstractly, such entities should not be passed to this
30291 function, because they do not need to be looked up, but it is
30292 simpler to check for this special case here, rather than at the
30293 call-sites.
30295 In cases not explicitly covered above, this function returns a
30296 DECL, OVERLOAD, or baselink representing the result of the lookup.
30297 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
30298 is returned.
30300 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
30301 (e.g., "struct") that was used. In that case bindings that do not
30302 refer to types are ignored.
30304 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
30305 ignored.
30307 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
30308 are ignored.
30310 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
30311 types.
30313 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
30314 TREE_LIST of candidates if name-lookup results in an ambiguity, and
30315 NULL_TREE otherwise. */
30317 static cp_expr
30324 location_t name_location)
30325 {
30326 tree decl;
30329 /* Assume that the lookup will be unambiguous. */
30333 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
30334 no longer valid. Note that if we are parsing tentatively, and
30335 the parse fails, OBJECT_TYPE will be automatically restored. */
30341 /* A template-id has already been resolved; there is no lookup to
30342 do. */
30346 {
30350 }
30352 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
30353 it should already have been checked to make sure that the name
30354 used matches the type being destroyed. */
30356 {
30357 tree type;
30359 /* Figure out to which type this destructor applies. */
30364 else
30366 /* If that's not a class type, there is no destructor. */
30370 /* In a non-static member function, check implicit this->. */
30373 tf_warning_or_error);
30382 }
30384 /* By this point, the NAME should be an ordinary identifier. If
30385 the id-expression was a qualified name, the qualifying scope is
30386 stored in PARSER->SCOPE at this point. */
30389 /* Perform the lookup. */
30391 {
30397 /* If the SCOPE is dependent, the lookup must be deferred until
30398 the template is instantiated -- unless we are explicitly
30399 looking up names in uninstantiated templates. Even then, we
30400 cannot look up the name if the scope is not a class type; it
30401 might, for example, be a template type parameter. */
30406 /* Defer lookup. */
30408 else
30409 {
30412 /* If PARSER->SCOPE is a dependent type, then it must be a
30413 class type, and we must not be checking dependencies;
30414 otherwise, we would have processed this lookup above. So
30415 that PARSER->SCOPE is not considered a dependent base by
30416 lookup_member, we must enter the scope here. */
30420 /* If the PARSER->SCOPE is a template specialization, it
30421 may be instantiated during name lookup. In that case,
30422 errors may be issued. Even if we rollback the current
30423 tentative parse, those errors are valid. */
30428 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
30429 lookup result and the nested-name-specifier nominates a class C:
30430 * if the name specified after the nested-name-specifier, when
30431 looked up in C, is the injected-class-name of C (Clause 9), or
30432 * if the name specified after the nested-name-specifier is the
30433 same as the identifier or the simple-template-id's template-
30434 name in the last component of the nested-name-specifier,
30435 the name is instead considered to name the constructor of
30436 class C. [ Note: for example, the constructor is not an
30437 acceptable lookup result in an elaborated-type-specifier so
30438 the constructor would not be used in place of the
30439 injected-class-name. --end note ] Such a constructor name
30440 shall be used only in the declarator-id of a declaration that
30441 names a constructor or in a using-declaration. */
30451 }
30453 /* If the scope is a dependent type and either we deferred lookup or
30454 we did lookup but didn't find the name, rememeber the name. */
30457 {
30459 {
30460 tree type;
30462 /* The resolution to Core Issue 180 says that `struct
30463 A::B' should be considered a type-name, even if `A'
30464 is dependent. */
30469 }
30473 CPP_CLOSE_PAREN)))
30477 else
30480 is_template);
30481 }
30484 }
30486 {
30487 /* Look up the name in the scope of the OBJECT_TYPE, unless the
30488 OBJECT_TYPE is not a class. */
30490 /* If the OBJECT_TYPE is a template specialization, it may
30491 be instantiated during name lookup. In that case, errors
30492 may be issued. Even if we rollback the current tentative
30493 parse, those errors are valid. */
30495 name,
30498 tf_warning_or_error);
30499 else
30503 /* Look it up in the enclosing context. DR 141: When looking for a
30504 template-name after -> or ., only consider class templates. */
30506 /* DR 141: When looking in the
30507 current enclosing context for a
30508 template-name after -> or ., only
30509 consider class templates. */
30513 /* If we know we're looking for a type (e.g. A in p->A::x),
30514 mock up a typename. */
30517 {
30519 typename_type);
30521 }
30525 }
30526 else
30527 {
30532 }
30534 /* If the lookup failed, let our caller know. */
30538 /* If we have resolved the name of a member declaration, check to
30539 see if the declaration is accessible. When the name resolves to
30540 set of overloaded functions, accessibility is checked when
30541 overload resolution is done. If we have a TREE_LIST, then the lookup
30542 is either ambiguous or it found multiple injected-class-names, the
30543 accessibility of which is trivially satisfied.
30545 During an explicit instantiation, access is not checked at all,
30546 as per [temp.explicit]. */
30549 tf_warning_or_error);
30551 /* Pull out the template from an injected-class-name (or multiple). */
30555 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
30557 {
30560 /* The error message we have to print is too complicated for
30561 cp_parser_error, so we incorporate its actions directly. */
30563 {
30565 name);
30567 }
30569 }
30580 }
30582 /* Like cp_parser_lookup_name, but for use in the typical case where
30583 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
30584 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
30586 static tree
30588 {
30590 none_type,
30595 location);
30596 }
30598 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
30599 the current context, return the TYPE_DECL. If TAG_NAME_P is
30600 true, the DECL indicates the class being defined in a class-head,
30601 or declared in an elaborated-type-specifier.
30603 Otherwise, return DECL. */
30605 static tree
30607 {
30608 /* If the TEMPLATE_DECL is being declared as part of a class-head,
30609 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
30611 struct A {
30612 template <typename T> struct B;
30613 };
30615 template <typename T> struct A::B {};
30617 Similarly, in an elaborated-type-specifier:
30619 namespace N { struct X{}; }
30621 struct A {
30622 template <typename T> friend struct N::X;
30623 };
30625 However, if the DECL refers to a class type, and we are in
30626 the scope of the class, then the name lookup automatically
30627 finds the TYPE_DECL created by build_self_reference rather
30628 than a TEMPLATE_DECL. For example, in:
30630 template <class T> struct S {
30631 S s;
30632 };
30634 there is no need to handle such case. */
30640 }
30642 /* If too many, or too few, template-parameter lists apply to the
30643 declarator, issue an error message. Returns TRUE if all went well,
30644 and FALSE otherwise. */
30646 static bool
30649 location_t declarator_location)
30650 {
30652 {
30654 {
30663 {
30664 /* If the DECLARATOR has the form `X<y>' then it uses one
30665 additional level of template parameters. */
30668 }
30670 return cp_parser_check_template_parameters
30672 declarator);
30673 }
30689 }
30691 }
30693 /* NUM_TEMPLATES were used in the current declaration. If that is
30694 invalid, return FALSE and issue an error messages. Otherwise,
30695 return TRUE. If DECLARATOR is non-NULL, then we are checking a
30696 declarator and we can print more accurate diagnostics. */
30698 static bool
30702 location_t location,
30704 {
30705 /* If there are the same number of template classes and parameter
30706 lists, that's OK. */
30709 /* If there are more, but only one more, and the name ends in an identifier,
30710 then we are declaring a primary template. That's OK too. */
30718 /* If there are more template classes than parameter lists, we have
30719 something like:
30721 template <class T> void S<T>::R<T>::f (); */
30723 {
30733 else
30736 }
30737 /* Otherwise, there are too many template parameter lists. We have
30738 something like:
30740 template <class T> template <class U> void S::f(); */
30743 }
30745 /* Parse an optional `::' token indicating that the following name is
30746 from the global namespace. If so, PARSER->SCOPE is set to the
30747 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
30748 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
30749 Returns the new value of PARSER->SCOPE, if the `::' token is
30750 present, and NULL_TREE otherwise. */
30752 static tree
30754 {
30757 /* Peek at the next token. */
30759 /* If we're looking at a `::' token then we're starting from the
30760 global namespace, not our current location. */
30762 {
30763 /* Consume the `::' token. */
30765 /* Set the SCOPE so that we know where to start the lookup. */
30771 }
30773 {
30777 }
30780 }
30782 /* Returns TRUE if the upcoming token sequence is the start of a
30783 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
30784 declarator is preceded by the `friend' specifier. The parser flags FLAGS
30785 is used to control type-specifier parsing. */
30787 static bool
30790 {
30793 tree nested_name_specifier;
30796 /* The common case is that this is not a constructor declarator, so
30797 try to avoid doing lots of work if at all possible. It's not
30798 valid declare a constructor at function scope. */
30801 /* And only certain tokens can begin a constructor declarator. */
30806 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
30807 declarator-id of a constructor or destructor. */
30811 /* Parse tentatively; we are going to roll back all of the tokens
30812 consumed here. */
30814 /* Assume that we are looking at a constructor declarator. */
30817 /* Look for the optional `::' operator. */
30820 /* Look for the nested-name-specifier. */
30821 nested_name_specifier
30828 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
30831 {
30836 }
30842 /* Outside of a class-specifier, there must be a
30843 nested-name-specifier. Except in C++17 mode, where we
30844 might be declaring a guiding declaration. */
30851 /* If we have a class scope, this is easy; DR 147 says that S::S always
30852 names the constructor, and no other qualified name could. */
30855 {
30865 }
30866 /* If we still think that this might be a constructor-declarator,
30867 look for a class-name. */
30869 {
30870 /* If we have:
30872 template <typename T> struct S {
30873 S();
30874 };
30876 we must recognize that the nested `S' names a class. */
30880 tree type_decl;
30884 none_type,
30891 {
30897 none_type,
30902 else
30904 }
30906 /* If there was no class-name, then this is not a constructor.
30907 Otherwise, if we are in a class-specifier and we aren't
30908 handling a friend declaration, check that its type matches
30909 current_class_type (c++/38313). Note: error_mark_node
30910 is left alone for error recovery purposes. */
30912 && (outside_class_specifier_p
30918 /* If we're still considering a constructor, we have to see a `(',
30919 to begin the parameter-declaration-clause, followed by either a
30920 `)', an `...', or a decl-specifier. We need to check for a
30921 type-specifier to avoid being fooled into thinking that:
30923 S (f) (int);
30925 is a constructor. (It is actually a function named `f' that
30926 takes one parameter (of type `int') and returns a value of type
30927 `S'. */
30935 /* A parameter declaration begins with a decl-specifier,
30936 which is either the "attribute" keyword, a storage class
30937 specifier, or (usually) a type-specifier. */
30939 /* GNU attributes can actually appear both at the start of
30940 a parameter and parenthesized declarator.
30941 S (__attribute__((unused)) int);
30942 is a constructor, but
30943 S (__attribute__((unused)) foo) (int);
30944 is a function declaration. [[attribute]] can appear in the
30945 first form too, but not in the second form. */
30947 {
30948 tree type;
30954 {
30958 }
30960 /* Names appearing in the type-specifier should be looked up
30961 in the scope of the class. */
30965 {
30968 {
30972 {
30975 }
30976 }
30978 }
30980 /* Inside the constructor parameter list, surrounding
30981 template-parameter-lists do not apply. */
30982 saved_num_template_parameter_lists
30986 /* Look for the type-specifier. It's not optional, but its typename
30987 might be. Unless this is a friend declaration; we don't want to
30988 treat
30990 friend S (T::fn)(int);
30992 as a constructor, but with P0634, we might assume a type when
30993 looking for the type-specifier. It is actually a function named
30994 `T::fn' that takes one parameter (of type `int') and returns a
30995 value of type `S'. Constructors can be friends, but they must
30996 use a qualified name.
30998 Parse with an empty set of declaration specifiers since we're
30999 trying to match a decl-specifier-seq of the first parameter.
31000 This must be non-null so that cp_parser_simple_type_specifier
31001 will recognize a constrained placeholder type such as:
31002 'C<int> auto' where C is a type concept. */
31003 cp_decl_specifier_seq ctor_specs;
31013 parser->num_template_parameter_lists
31016 /* Leave the scope of the class. */
31021 }
31022 }
31024 /* We did not really want to consume any tokens. */
31028 }
31030 /* Parse the definition of the function given by the DECL_SPECIFIERS,
31031 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
31032 they must be performed once we are in the scope of the function.
31034 Returns the function defined. */
31036 static tree
31037 cp_parser_function_definition_from_specifiers_and_declarator
31040 tree attributes,
31042 {
31043 tree fn;
31046 /* Begin the function-definition. */
31049 /* The things we're about to see are not directly qualified by any
31050 template headers we've seen thus far. */
31053 /* If there were names looked up in the decl-specifier-seq that we
31054 did not check, check them now. We must wait until we are in the
31055 scope of the function to perform the checks, since the function
31056 might be a friend. */
31060 {
31065 }
31068 {
31069 /* Skip the entire function. */
31072 }
31074 {
31075 /* Seen already, skip it. An error message has already been output. */
31079 /* If this is a function from a class, pop the nested class. */
31082 }
31083 else
31084 {
31085 timevar_id_t tv;
31088 else
31094 }
31097 }
31099 /* Parse the part of a function-definition that follows the
31100 declarator. INLINE_P is TRUE iff this function is an inline
31101 function defined within a class-specifier.
31103 Returns the function defined. */
31105 static tree
31108 {
31109 tree fn;
31114 bool fully_implicit_function_template_p
31117 tree implicit_template_parms
31120 cp_binding_level* implicit_template_scope
31126 /* If the next token is `return', then the code may be trying to
31127 make use of the "named return value" extension that G++ used to
31128 support. */
31131 {
31132 /* Consume the `return' keyword. */
31134 /* Look for the identifier that indicates what value is to be
31135 returned. */
31137 /* Issue an error message. */
31140 /* Skip tokens until we reach the start of the function body. */
31142 {
31149 }
31150 }
31151 /* The `extern' in `extern "C" void f () { ... }' does not apply to
31152 anything declared inside `f'. */
31153 saved_in_unbraced_linkage_specification_p
31156 /* Inside the function, surrounding template-parameter-lists do not
31157 apply. */
31158 saved_num_template_parameter_lists
31162 /* If the next token is `try', `__transaction_atomic', or
31163 `__transaction_relaxed`, then we are looking at either function-try-block
31164 or function-transaction-block. Note that all of these include the
31165 function-body. */
31169 RID_TRANSACTION_RELAXED))
31173 else
31174 cp_parser_ctor_initializer_opt_and_function_body
31177 /* Finish the function. */
31181 && !inline_p
31187 /* Generate code for it, if necessary. */
31189 /* Restore the saved values. */
31190 parser->in_unbraced_linkage_specification_p
31192 parser->num_template_parameter_lists
31196 parser->fully_implicit_function_template_p
31198 parser->implicit_template_parms
31200 parser->implicit_template_scope
31207 }
31209 /* Parse a template-declaration body (following argument list). */
31211 static void
31213 tree parameter_list,
31215 {
31219 /* We just processed one more parameter list. */
31222 /* Get the deferred access checks from the parameter list. These
31223 will be checked once we know what is being declared, as for a
31224 member template the checks must be performed in the scope of the
31225 class containing the member. */
31228 /* Tentatively parse for a new template parameter list, which can either be
31229 the template keyword or a template introduction. */
31238 /* Allow 'concept bool' to be handled as per the TS. */
31240 else
31241 {
31244 checks,
31245 member_p,
31249 /* If this is a member template declaration, let the front
31250 end know. */
31252 {
31257 }
31262 }
31263 /* We are done with the current parameter list. */
31268 /* Finish up. */
31271 /* Check the template arguments for a literal operator template. */
31275 {
31279 else
31280 {
31283 {
31290 /* OK, C++20 string literal operator template. We don't need
31291 to warn in lower dialects here because we will have already
31296 }
31298 {
31307 else
31308 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
31310 "ISO C++ did not adopt string literal operator templa"
31312 }
31313 else
31315 }
31317 {
31320 "template %qD has invalid parameter list; expected "
31321 "non-type template parameter pack %<<char...>%> or "
31323 decl);
31324 else
31326 "template %qD has invalid parameter list; expected "
31328 decl);
31329 }
31330 }
31332 /* Register member declarations. */
31335 /* If DECL is a function template, we must return to parse it later.
31336 (Even though there is no definition, there might be default
31337 arguments that need handling.) */
31341 }
31343 /* Parse a template introduction header for a template-declaration. Returns
31344 false if tentative parse fails. */
31346 static bool
31348 {
31357 /* Look for the optional `::' operator. */
31360 /* Look for the nested-name-specifier. */
31370 /* Look up the concept for which we will be matching
31371 template parameters. */
31382 /* Look for opening brace for introduction. */
31383 matching_braces braces;
31392 /* Build vector of placeholder parameters and grab
31393 matching identifiers. */
31396 /* Look for closing brace for introduction. */
31400 /* The introduction-list shall not be empty. */
31403 {
31404 /* In cp_parser_introduction_list we have already issued an error. */
31406 }
31409 {
31413 }
31415 /* Build and associate the constraint. */
31420 introduction_list,
31421 introduction_loc);
31423 {
31430 member_p);
31432 }
31438 }
31440 /* Parse a normal template-declaration following the template keyword. */
31442 static void
31444 {
31445 tree parameter_list;
31449 /* Look for the `<' token. */
31453 {
31454 /* 14.5.2.2 [temp.mem]
31456 A local class shall not have member templates. */
31461 }
31462 /* [temp]
31464 A template ... shall not have C linkage. */
31466 {
31469 /* Give it C++ linkage to avoid confusing other parts of the
31470 front end. */
31473 }
31474 else
31477 /* We cannot perform access checks on the template parameter
31478 declarations until we know what is being declared, just as we
31479 cannot check the decl-specifier list. */
31482 /* If the next token is `>', then we have an invalid
31483 specialization. Rather than complain about an invalid template
31484 parameter, issue an error message here. */
31486 {
31490 }
31491 else
31492 {
31493 /* Parse the template parameters. */
31495 }
31497 /* Look for the `>'. */
31500 /* Manage template requirements */
31502 {
31507 }
31510 member_p);
31512 /* For the erroneous case of a template with C linkage, we pushed an
31513 implicit C++ linkage scope; exit that scope now. */
31516 }
31518 /* Parse a template-declaration, assuming that the `export' (and
31519 `extern') keywords, if present, has already been scanned. MEMBER_P
31520 is as for cp_parser_template_declaration. */
31522 static bool
31524 {
31526 {
31530 }
31535 }
31537 /* Perform the deferred access checks from a template-parameter-list.
31538 CHECKS is a TREE_LIST of access checks, as returned by
31539 get_deferred_access_checks. */
31541 static void
31542 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
31543 {
31547 }
31549 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
31550 `function-definition' sequence that follows a template header.
31551 If MEMBER_P is true, this declaration appears in a class scope.
31553 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
31554 *FRIEND_P is set to TRUE iff the declaration is a friend. */
31556 static tree
31562 {
31565 cp_decl_specifier_seq decl_specifiers;
31569 /* This function is only used when processing a template
31570 declaration. */
31574 /* Defer access checks until we know what is being declared. */
31577 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
31578 alternative. */
31581 (CP_PARSER_FLAGS_OPTIONAL
31586 cp_omp_declare_simd_data odsd;
31595 /* There are no template typedefs. */
31597 {
31601 }
31603 /* Gather up the access checks that occurred the
31604 decl-specifier-seq. */
31607 /* Check for the declaration of a template class. */
31609 {
31612 {
31613 /* If this is a declaration, but not a definition, associate
31614 any constraints with the type declaration. Constraints
31615 are associated with definitions in cp_parser_class_specifier. */
31621 /* In this case:
31623 struct C {
31624 friend template <typename T> struct A<T>::B;
31625 };
31627 A<T>::B will be represented by a TYPENAME_TYPE, and
31628 therefore not recognized by shadow_tag. */
31630 && !decl
31637 else
31640 /* Perform access checks for template parameters. */
31643 /* Give a helpful diagnostic for
31644 template <class T> struct A { } a;
31645 if we aren't already recovering from an error. */
31648 {
31650 "a class template declaration must not declare "
31654 }
31655 }
31656 }
31658 /* Complain about missing 'typename' or other invalid type names. */
31661 {
31662 /* cp_parser_parse_and_diagnose_invalid_type_name calls
31663 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
31664 the rest of this declaration. */
31667 }
31669 /* If it's not a template class, try for a template function. If
31670 the next token is a `;', then this declaration does not declare
31671 anything. But, if there were errors in the decl-specifiers, then
31672 the error might well have come from an attempted class-specifier.
31673 In that case, there's no need to warn about a missing declarator. */
31677 {
31679 /* We don't delay parsing for friends, though CWG 2510 may change
31680 that. */
31684 flags,
31686 checks,
31688 member_p,
31689 declares_class_or_enum,
31693 /* 7.1.1-1 [dcl.stc]
31695 A storage-class-specifier shall not be specified in an explicit
31696 specialization... */
31698 && explicit_specialization_p
31700 {
31704 }
31708 }
31710 /* Look for a trailing `;' after the declaration. */
31716 out:
31719 /* Clear any current qualification; whatever comes next is the start
31720 of something new. */
31728 }
31730 /* Parse a cast-expression that is not the operand of a unary "&". */
31732 static cp_expr
31734 {
31737 }
31739 /* Parse a functional cast to TYPE. Returns an expression
31740 representing the cast. */
31742 static cp_expr
31744 {
31746 tree expression_list;
31747 cp_expr cast;
31756 {
31766 /* Create a location of the form:
31767 type_name{i, f}
31768 ^~~~~~~~~~~~~~~
31769 with caret == start at the start of the type name,
31770 finishing at the closing brace. */
31775 }
31784 else
31785 {
31788 }
31790 /* Create a location of the form:
31791 float(i)
31792 ^~~~~~~~
31793 with caret == start at the start of the type name,
31794 finishing at the closing paren. */
31798 tf_warning_or_error);
31800 /* [expr.const]/1: In an integral constant expression "only type
31801 conversions to integral or enumeration type can be used". */
31807 NIC_CONSTRUCTOR))
31811 }
31813 /* Save the tokens that make up the body of a member function defined
31814 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
31815 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
31816 specifiers applied to the declaration. Returns the FUNCTION_DECL
31817 for the member function. */
31819 static tree
31823 tree attributes)
31824 {
31827 tree fn;
31830 /* Create the FUNCTION_DECL. */
31834 /* If something went badly wrong, bail out now. */
31836 {
31837 /* If there's a function-body, skip it. */
31842 }
31844 /* Remember it, if there are default args to post process. */
31847 /* Save away the tokens that make up the body of the
31848 function. */
31854 RID_TRANSACTION_ATOMIC))
31855 {
31857 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
31864 {
31870 }
31871 else
31874 {
31878 }
31879 }
31881 /* Handle function try blocks. */
31883 {
31886 }
31887 /* We can have braced-init-list mem-initializers before the fn body. */
31889 {
31892 {
31893 /* cache_group will stop after an un-nested { } pair, too. */
31897 /* variadic mem-inits have ... after the ')'. */
31900 }
31901 }
31903 /* Handle function try blocks. */
31909 /* Save away the inline definition; we will process it when the
31910 class is complete. */
31914 /* We need to know that this was defined in the class, so that
31915 friend templates are handled correctly. */
31918 /* Add FN to the queue of functions to be parsed later. */
31922 }
31924 /* Save the tokens that make up the in-class initializer for a non-static
31925 data member. Returns a DEFERRED_PARSE. */
31927 static tree
31929 {
31931 }
31933 /* Parse a template-argument-list, as well as the trailing ">" (but
31934 not the opening "<"). See cp_parser_template_argument_list for the
31935 return value. */
31937 static tree
31939 {
31940 tree arguments;
31941 tree saved_scope;
31942 tree saved_qualifying_scope;
31943 tree saved_object_scope;
31946 /* [temp.names]
31948 When parsing a template-id, the first non-nested `>' is taken as
31949 the end of the template-argument-list rather than a greater-than
31950 operator. */
31951 saved_greater_than_is_operator_p
31954 /* Parsing the argument list may modify SCOPE, so we save it
31955 here. */
31959 /* We need to evaluate the template arguments, even though this
31960 template-id may be nested within a "sizeof". */
31961 cp_evaluated ev;
31962 /* Parse the template-argument-list itself. */
31966 else
31968 /* Look for the `>' that ends the template-argument-list. If we find
31969 a '>>' instead, it's probably just a typo. */
31971 {
31973 {
31974 /* In C++0x, a `>>' in a template argument list or cast
31975 expression is considered to be two separate `>'
31976 tokens. So, change the current token to a `>', but don't
31977 consume it: it will be consumed later when the outer
31978 template argument list (or cast expression) is parsed.
31979 Note that this replacement of `>' for `>>' is necessary
31980 even if we are parsing tentatively: in the tentative
31981 case, after calling
31982 cp_parser_enclosed_template_argument_list we will always
31983 throw away all of the template arguments and the first
31984 closing `>', either because the template argument list
31985 was erroneous or because we are replacing those tokens
31986 with a CPP_TEMPLATE_ID token. The second `>' (which will
31987 not have been thrown away) is needed either to close an
31988 outer template argument list or to complete a new-style
31989 cast. */
31992 }
31994 {
31995 /* If we're in a nested template argument list, the '>>' has
31996 to be a typo for '> >'. We emit the error message, but we
31997 continue parsing and we push a '>' as next token, so that
31998 the argument list will be parsed correctly. Note that the
31999 global source location is still on the token before the
32000 '>>', so we need to say explicitly where we want it. */
32008 }
32009 else
32010 {
32011 /* If this is not a nested template argument list, the '>>'
32012 is a typo for '>'. Emit an error message and continue.
32013 Same deal about the token location, but here we can get it
32014 right by consuming the '>>' before issuing the diagnostic. */
32017 "spurious %<>>%>, use %<>%> to terminate "
32019 }
32020 }
32021 else
32023 /* The `>' token might be a greater-than operator again now. */
32024 parser->greater_than_is_operator_p
32026 /* Restore the SAVED_SCOPE. */
32032 }
32034 /* MEMBER_FUNCTION is a member function, or a friend. If default
32035 arguments, or the body of the function have not yet been parsed,
32036 parse them now. */
32038 static void
32040 {
32042 /* If this member is a template, get the underlying
32043 FUNCTION_DECL. */
32047 /* There should not be any class definitions in progress at this
32048 point; the bodies of members are only parsed outside of all class
32049 definitions. */
32051 /* While we're parsing the member functions we might encounter more
32052 classes. We want to handle them right away, but we don't want
32053 them getting mixed up with functions that are currently in the
32054 queue. */
32057 /* Make sure that any template parameters are in scope. */
32060 /* If the body of the function has not yet been parsed, parse it
32061 now. */
32063 {
32064 tree function_scope;
32067 /* The function is no longer pending; we are processing it. */
32072 /* If this is a local class, enter the scope of the containing
32073 function. */
32078 /* Push the body of the function onto the lexer stack. */
32081 /* Let the front end know that we going to be defining this
32082 function. */
32086 /* #pragma omp declare reduction needs special parsing. */
32088 {
32093 }
32094 else
32095 /* Now, parse the body of the function. */
32099 /* Leave the scope of the containing function. */
32103 }
32105 /* Remove any template parameters from the symbol table. */
32108 /* Restore the queue. */
32111 }
32113 /* If DECL contains any default args, remember it on the unparsed
32114 functions queue. */
32116 static void
32118 {
32119 tree probe;
32122 probe;
32125 {
32129 }
32131 /* Remember if there is a noexcept-specifier to post process. */
32135 }
32137 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
32138 which is either a FIELD_DECL or PARM_DECL. Parse it and return
32139 the result. For a PARM_DECL, PARMTYPE is the corresponding type
32140 from the parameter-type-list. */
32142 static tree
32145 {
32147 tree parsed_arg;
32153 /* Push the saved tokens for the default argument onto the parser's
32154 lexer stack. */
32160 /* Parse the default argument. */
32171 {
32172 /* In a non-template class, check conversions now. In a template,
32173 we'll wait and instantiate these as needed. */
32176 tf_warning_or_error);
32179 else
32181 }
32183 /* If the token stream has not been completely used up, then
32184 there was extra junk after the end of the default
32185 argument. */
32187 {
32190 else
32192 }
32194 /* Revert to the main lexer. */
32198 }
32200 /* FIELD is a non-static data member with an initializer which we saved for
32201 later; parse it now. */
32203 static void
32205 {
32206 tree def;
32213 NULL_TREE);
32219 }
32221 /* FN is a FUNCTION_DECL which may contains a parameter with an
32222 unparsed DEFERRED_PARSE. Parse the default args now. This function
32223 assumes that the current scope is the scope in which the default
32224 argument should be processed. */
32226 static void
32228 {
32231 /* While we're parsing the default args, we might (due to the
32232 statement expression extension) encounter more classes. We want
32233 to handle them right away, but we don't want them getting mixed
32234 up with default args that are currently in the queue. */
32237 /* Local variable names (and the `this' keyword) may not appear
32238 in a default argument. */
32246 /* Gather the PARM_DECLs into a vec so we can keep track of them when
32247 pushdecl clears DECL_CHAIN. */
32248 releasing_vec parms;
32258 {
32260 tree parsed_arg;
32269 /* This can happen for a friend declaration for a function
32270 already declared with default arguments. */
32273 parsed_arg
32275 default_arg,
32279 /* Update any instantiations we've already created. */
32282 }
32286 /* Restore DECL_CHAINs after clobbering by pushdecl. */
32289 {
32292 }
32296 /* Make sure no default arg is missing. */
32299 /* Restore the state of local_variables_forbidden_p. */
32302 /* Restore the queue. */
32304 }
32306 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
32308 sizeof ... ( identifier )
32310 where the 'sizeof' token has already been consumed. */
32312 static tree
32314 {
32315 /* Consume the `...'. */
32319 matching_parens parens;
32323 else
32331 /* The name is not qualified. */
32350 }
32352 /* Parse the operand of `sizeof' (or a similar operator). Returns
32353 either a TYPE or an expression, depending on the form of the
32354 input. The KEYWORD indicates which kind of expression we have
32355 encountered. */
32357 static tree
32359 {
32366 /* If it's a `...', then we are computing the length of a parameter
32367 pack. */
32372 /* Types cannot be defined in a `sizeof' expression. Save away the
32373 old message. */
32376 parser->type_definition_forbidden_message
32378 parser->type_definition_forbidden_message_arg
32381 /* The restrictions on constant-expressions do not apply inside
32382 sizeof expressions. */
32383 saved_integral_constant_expression_p
32385 saved_non_integral_constant_expression_p
32392 /* Do not actually evaluate the expression. */
32395 /* If it's a `(', then we might be looking at the type-id
32396 construction. */
32398 {
32403 /* We can't be sure yet whether we're looking at a type-id or an
32404 expression. */
32407 matching_parens parens;
32410 /* Note: as a GNU Extension, compound literals are considered
32411 postfix-expressions as they are in C99, so they are valid
32412 arguments to sizeof. See comment in cp_parser_cast_expression
32413 for details. */
32416 else
32417 {
32420 /* Look for the type-id. */
32422 /* Look for the closing `)'. */
32425 }
32427 /* If all went well, then we're done. */
32430 else
32431 {
32432 /* Commit to the tentative_firewall so we get syntax errors. */
32436 }
32437 }
32438 else
32441 /* Go back to evaluating expressions. */
32445 /* And restore the old one. */
32448 parser->integral_constant_expression_p
32450 parser->non_integral_constant_expression_p
32454 }
32456 /* If the current declaration has no declarator, return true. */
32458 static bool
32460 {
32461 /* If the next token is a `;' or a `,' then there is no
32462 declarator. */
32465 }
32467 /* Update the DECL_SPECS to reflect the storage class indicated by
32468 KEYWORD. */
32470 static void
32475 {
32476 cp_storage_class storage_class;
32479 {
32483 }
32485 {
32488 }
32493 {
32496 }
32499 {
32517 }
32521 /* A storage class specifier cannot be applied alongside a typedef
32522 specifier. If there is a typedef specifier present then set
32523 conflicting_specifiers_p which will trigger an error later
32524 on in grokdeclarator. */
32527 }
32529 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
32530 is true, the type is a class or enum definition. */
32532 static void
32534 tree type_spec,
32537 {
32540 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
32541 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
32542 this is what happened. In system headers, we ignore these
32543 declarations so that G++ can work with system headers that are not
32544 C++-safe. */
32546 && !type_definition_p
32557 {
32560 ds_redefined_builtin_type_spec,
32561 token);
32563 {
32567 }
32568 }
32571 else
32572 {
32577 }
32578 }
32580 /* True iff TOKEN is the GNU keyword __thread. */
32582 static bool
32584 {
32587 }
32589 /* Set the location for a declarator specifier and check if it is
32590 duplicated.
32592 DECL_SPECS is the sequence of declarator specifiers onto which to
32593 set the location.
32595 DS is the single declarator specifier to set which location is to
32596 be set onto the existing sequence of declarators.
32598 LOCATION is the location for the declarator specifier to
32599 consider. */
32601 static void
32604 {
32613 {
32617 }
32618 else
32619 {
32621 {
32625 else
32626 {
32629 OPT_Wlong_long,
32631 }
32632 }
32634 {
32638 {
32642 }
32643 else
32644 {
32647 }
32648 }
32649 else
32650 {
32668 "consteval"
32669 };
32673 }
32674 }
32675 }
32677 /* Return true iff the declarator specifier DS is present in the
32678 sequence of declarator specifiers DECL_SPECS. */
32680 bool
32682 cp_decl_spec ds)
32683 {
32690 }
32692 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
32693 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
32695 static bool
32697 {
32699 }
32701 /* Issue an error message indicating that TOKEN_DESC was expected.
32702 If KEYWORD is true, it indicated this function is called by
32703 cp_parser_require_keword and the required token can only be
32704 a indicated keyword.
32706 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
32707 within any error as the location of an "opening" token matching
32708 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
32709 RT_CLOSE_PAREN). */
32711 static void
32713 required_token token_desc,
32715 location_t matching_location)
32716 {
32722 {
32797 }
32800 {
32802 {
32880 }
32881 }
32885 }
32888 /* If the next token is of the indicated TYPE, consume it. Otherwise,
32889 issue an error message indicating that TOKEN_DESC was expected.
32891 Returns the token consumed, if the token had the appropriate type.
32892 Otherwise, returns NULL.
32894 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
32895 within any error as the location of an "opening" token matching
32896 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
32897 RT_CLOSE_PAREN). */
32902 required_token token_desc,
32903 location_t matching_location)
32904 {
32907 else
32908 {
32909 /* Output the MESSAGE -- unless we're parsing tentatively. */
32912 matching_location);
32914 }
32915 }
32917 /* An error message is produced if the next token is not '>'.
32918 All further tokens are skipped until the desired token is
32919 found or '{', '}', ';' or an unbalanced ')' or ']'. */
32921 static void
32923 {
32924 /* Current level of '< ... >'. */
32926 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
32929 /* Are we ready, yet? If not, issue error message. */
32933 /* Skip tokens until the desired token is found. */
32935 {
32936 /* Peek at the next token. */
32938 {
32946 /* C++0x views the `>>' operator as two `>' tokens, but
32947 C++98 does not. */
32950 {
32951 /* We've hit a `>>' where the first `>' closes the
32952 template argument list, and the second `>' is
32953 spurious. Just consume the `>>' and stop; we've
32954 already produced at least one error. */
32957 }
32958 /* Fall through for C++0x, so we handle the second `>' in
32959 the `>>'. */
32964 {
32965 /* We've reached the token we want, consume it and stop. */
32968 }
32987 /* The '>' was probably forgotten, don't look further. */
32992 }
32994 /* Consume this token. */
32996 }
32997 }
32999 /* If the next token is the indicated keyword, consume it. Otherwise,
33000 issue an error message indicating that TOKEN_DESC was expected.
33002 Returns the token consumed, if the token had the appropriate type.
33003 Otherwise, returns NULL. */
33008 required_token token_desc)
33009 {
33013 {
33015 UNKNOWN_LOCATION);
33017 }
33020 }
33022 /* Returns TRUE iff TOKEN is a token that can begin the body of a
33023 function-definition. */
33025 static bool
33027 {
33030 /* A ctor-initializer begins with a `:'. */
33032 /* A function-try-block begins with `try'. */
33034 /* A function-transaction-block begins with `__transaction_atomic'
33035 or `__transaction_relaxed'. */
33038 /* The named return value extension begins with `return'. */
33040 }
33042 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
33043 definition. */
33045 static bool
33047 {
33054 }
33056 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
33057 C++0x) ending a template-argument. */
33059 static bool
33061 {
33069 }
33071 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
33072 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
33074 static bool
33077 {
33083 /* Check for the sequence `<::' in the original code. It would be lexed as
33084 `[:', where `[' is a digraph, and there is no whitespace before
33085 `:'. */
33087 {
33092 }
33094 }
33096 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
33097 or none_type otherwise. */
33099 static enum tag_types
33101 {
33103 {
33113 }
33114 }
33116 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
33117 or none_type otherwise or if the token is null. */
33119 static enum tag_types
33121 {
33126 {
33134 }
33135 }
33137 /* Diagnose redundant enum-keys. */
33139 static void
33142 {
33148 /* Look up the NAME to see if it unambiguously refers to the TYPE. */
33153 /* The enum-key is redundant for uses of the TYPE that are not
33154 declarations and for which name lookup returns just the type
33155 itself. */
33163 {
33164 /* Avoid issuing the diagnostic for apparently redundant (unscoped)
33165 enum tag in shared C/C++ code in files (such as headers) included
33166 in the main source file. */
33169 LRK_MACRO_DEFINITION_LOCATION,
33173 }
33181 }
33183 /* Describes the set of declarations of a struct, class, or class template
33184 or its specializations. Used for -Wmismatched-tags. */
33186 class class_decl_loc_t
33187 {
33192 {
33194 }
33196 /* Constructs an object for a single declaration of a class with
33197 CLASS_KEY at the current location in the current function (or
33198 at another scope). KEY_REDUNDANT is true if the class-key may
33199 be omitted in the current context without an ambiguity with
33200 another symbol with the same name.
33201 DEF_P is true for a class declaration that is a definition.
33202 CURLOC is the associated location. */
33206 {
33209 key_redundant);
33211 }
33213 /* Copy, assign, and destroy the object. Necessary because LOCVEC
33214 isn't safely copyable and assignable and doesn't release storage
33215 on its own. */
33219 { }
33222 {
33230 }
33233 {
33235 }
33237 /* Issues -Wmismatched-tags for a single class. */
33240 /* Issues -Wmismatched-tags for all classes. */
33243 /* Adds TYPE_DECL to the collection of class decls and diagnoses
33244 redundant tags (if -Wredundant-tags is enabled). */
33247 /* Either adds this decl to the collection of class decls
33248 or diagnoses it, whichever is appropriate. */
33254 {
33256 }
33259 {
33261 }
33264 {
33266 }
33269 {
33271 }
33273 /* True if a definition for the class has been seen. */
33275 {
33277 }
33279 /* The location of a single mention of a class type with the given
33280 class-key. */
33281 struct class_key_loc_t
33282 {
33285 { }
33287 /* The function the type is mentioned in. */
33288 tree func;
33289 /* The exact location. */
33290 location_t loc;
33291 /* The class-key used in the mention of the type. */
33292 tag_types class_key;
33293 /* True when the class-key could be omitted at this location
33294 without an ambiguity with another symbol of the same name. */
33296 };
33297 /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
33299 /* LOCVEC index of the definition or UINT_MAX if none exists. */
33301 /* The class-key the class was last declared with or none_type when
33302 it has been declared with a mismatched key. */
33303 tag_types def_class_key;
33305 /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
33306 description above. */
33309 };
33313 /* Issue an error message if the CLASS_KEY does not match the TYPE.
33314 DEF_P is expected to be set for a definition of class TYPE. DECL_P
33315 is set for a declaration of class TYPE and clear for a reference to
33316 it that is not a declaration of it. */
33318 static void
33322 {
33328 {
33332 type))
33336 }
33341 /* Only consider the true class-keys below and ignore typename_type,
33342 etc. that are not C++ class-keys. */
33349 }
33351 /* Returns the template or specialization of one to which the RECORD_TYPE
33352 TYPE corresponds. */
33354 static tree
33356 {
33359 /* Determine the template or its partial specialization to which TYPE
33360 corresponds. */
33369 }
33372 /* Adds the class TYPE to the collection of class decls and diagnoses
33373 redundant tags (if -Wredundant-tags is enabled).
33374 DEF_P is expected to be set for a definition of class TYPE. DECL_P
33375 is set for a (likely, based on syntactic context) declaration of class
33376 TYPE and clear for a reference to it that is not a declaration of it. */
33378 void
33381 {
33384 /* Look up the NAME to see if it unambiguously refers to the TYPE
33385 and set KEY_REDUNDANT if so. */
33390 /* The class-key is redundant for uses of the CLASS_TYPE that are
33391 neither definitions of it nor declarations, and for which name
33392 lookup returns just the type itself. */
33402 {
33403 /* Avoid issuing the diagnostic for apparently redundant struct
33404 and union class-keys in shared C/C++ code in files (such as
33405 headers) included in the main source file. */
33408 LRK_MACRO_DEFINITION_LOCATION,
33412 }
33414 /* Set if a declaration of TYPE has previously been seen or if it must
33415 exist in a precompiled header. */
33419 {
33422 {
33423 /* TYPE_DECL is the first declaration or definition of the type
33424 (outside precompiled headers -- see below). Just create
33425 a new entry for it and return unless it's a declaration
33426 involving a template that may need to be diagnosed by
33427 -Wredundant-tags. */
33431 }
33432 else
33433 {
33434 /* TYPE was previously defined in some unknown precompiled hdeader.
33435 Simply add a record of its definition at an unknown location and
33436 proceed below to add a reference to it at the current location.
33437 (Declarations in precompiled headers that are not definitions
33438 are ignored.) */
33439 tag_types def_key
33444 }
33445 }
33447 /* A prior declaration of TYPE_DECL has been seen. */
33450 {
33457 type);
33458 }
33461 /* Do nothing if this is the first declaration of the type. */
33465 /* Do nothing if the class-key in this declaration matches
33466 the definition. */
33470 def_p);
33471 }
33473 /* Either adds this DECL corresponding to the TYPE_DECL to the collection
33474 of class decls or diagnoses it, whichever is appropriate. */
33476 void
33478 tag_types class_key,
33481 {
33482 /* Reset the CLASS_KEY associated with this type on mismatch.
33483 This is an optimization that lets the diagnostic code skip
33484 over classes that use the same class-key in all declarations. */
33488 /* Set IDXDEF to the index of the vector corresponding to
33489 the definition. */
33493 /* Append a record of this declaration to the vector. */
33495 redundant);
33501 /* As a space optimization diagnose declarations of a class
33502 whose definition has been seen and purge the LOCVEC of
33503 all entries except the definition. */
33506 {
33512 }
33513 else
33514 /* Pop the entry pushed above for this declaration. */
33516 }
33518 /* Issues -Wmismatched-tags for a single class. */
33520 void
33522 {
33526 /* Number of uses of the class. */
33529 /* The class (or template) declaration guiding the decisions about
33530 the diagnostic. For ordinary classes it's the same as THIS. For
33531 uses of instantiations of templates other than their declarations
33532 it points to the record for the declaration of the corresponding
33533 primary template or partial specialization. */
33538 {
33539 /* For implicit instantiations of a primary template look up
33540 the primary or partial specialization and use it as
33541 the expected class-key rather than using the class-key of
33542 the first reference to the instantiation. The primary must
33543 be (and inevitably is) at index zero. */
33547 }
33548 else
33549 {
33550 /* Skip declarations that consistently use the same class-key. */
33553 }
33555 /* Set if a definition for the class has been seen. */
33558 /* The index of the declaration whose class-key this declaration
33559 is expected to match. It's either the class-key of the class
33560 definition if one exists or the first declaration otherwise. */
33563 /* The class-key the class is expected to be declared with: it's
33564 either the key used in its definition or the first declaration
33565 if no definition has been provided.
33566 For implicit instantiations of a primary template it's
33567 the class-key used to declare the primary with. The primary
33568 must be at index zero. */
33572 /* Advance IDX to the first declaration that either is not
33573 a definition or that doesn't match the first declaration
33574 if no definition is provided. */
33579 /* Save the current function before changing it below. */
33581 /* Set the function declaration to print in diagnostic context. */
33589 auto_diagnostic_group d;
33590 /* Issue a warning for the first mismatched declaration.
33591 Avoid using "%#qT" since the class-key for the same type will
33592 be the same regardless of which one was used in the declaraion. */
33596 {
33597 /* Suggest how to avoid the warning for each instance since
33598 the guidance may be different depending on context. */
33600 (key_redundant_p
33603 xpectkstr);
33605 /* Also point to the first declaration or definition that guided
33606 the decision to issue the warning above. */
33608 (def_p
33612 }
33614 /* Issue warnings for the remaining inconsistent declarations. */
33616 {
33618 /* Skip over the declarations that match either the definition
33619 if one was provided or the first declaration. */
33625 /* Set the function declaration to print in diagnostic context. */
33630 /* Suggest how to avoid the warning for each instance since
33631 the guidance may be different depending on context. */
33633 (key_redundant_p
33636 xpectkstr);
33637 }
33639 /* Restore the current function in case it was replaced above. */
33641 }
33643 /* Issues -Wmismatched-tags for all classes. Called at the end
33644 of processing a translation unit, after declarations of all class
33645 types and their uses have been recorded. */
33647 void
33649 {
33650 /* CLASS2LOC should be empty if both -Wmismatched-tags and
33651 -Wredundant-tags are disabled. */
33653 || warn_redundant_tags
33656 /* Save the current function before changing on return. It should
33657 be null at this point. */
33661 {
33662 /* Iterate over the collected class/struct/template declarations. */
33665 {
33669 }
33670 }
33673 }
33675 /* Issue an error message if DECL is redeclared with different
33676 access than its original declaration [class.access.spec/3].
33677 This applies to nested classes, nested class templates and
33678 enumerations [class.mem/1]. */
33680 static void
33682 {
33693 }
33695 /* Look for the `template' keyword, as a syntactic disambiguator.
33696 Return TRUE iff it is present, in which case it will be
33697 consumed. */
33699 static bool
33701 {
33703 {
33704 /* In C++98 the `template' keyword can only be used within templates;
33705 outside templates the parser can always figure out what is a
33706 template and what is not. In C++11, per the resolution of DR 468,
33707 `template' is allowed in cases where it is not strictly necessary. */
33710 {
33713 "in C++98 %<template%> (as a disambiguator) is only "
33715 /* If this part of the token stream is rescanned, the same
33716 error message would be generated. So, we purge the token
33717 from the stream. */
33720 }
33721 else
33722 {
33723 /* Consume the `template' keyword. */
33726 }
33727 }
33729 }
33731 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
33732 set PARSER->SCOPE, and perform other related actions. */
33734 static void
33736 {
33739 /* Get the stored value. */
33741 /* Set the scope from the stored value. */
33746 }
33748 /* Consume tokens up through a non-nested END token. Returns TRUE if we
33749 encounter the end of a block before what we were looking for. */
33751 static bool
33755 {
33757 {
33760 /* Abort a parenthesized expression if we encounter a semicolon. */
33764 /* If we've reached the end of the file, stop. */
33770 /* We've hit the end of an enclosing block, so there's been some
33771 kind of syntax error. */
33774 /* Consume the token. */
33776 /* See if it starts a new group. */
33778 {
33780 /* In theory this should probably check end == '}', but
33781 cp_parser_save_member_function_body needs it to exit
33782 after either '}' or ')' when called with ')'. */
33785 }
33787 {
33791 }
33796 }
33797 }
33799 /* Like above, for caching a default argument or NSDMI. Both of these are
33800 terminated by a non-nested comma, but it can be unclear whether or not a
33801 comma is nested in a template argument list unless we do more parsing.
33802 In order to handle this ambiguity, when we encounter a ',' after a '<'
33803 we try to parse what follows as a parameter-declaration-list (in the
33804 case of a default argument) or a member-declarator (in the case of an
33805 NSDMI). If that succeeds, then we stop caching. */
33807 static tree
33809 {
33814 tree default_argument;
33816 /* Add tokens until we have processed the entire default
33817 argument. We add the range [first_token, token). */
33820 {
33821 /* For list-initialization, this is straightforward. */
33824 }
33826 {
33829 /* Peek at the next token. */
33831 /* What we do depends on what token we have. */
33833 {
33834 /* In valid code, a default argument must be
33835 immediately followed by a `,' `)', or `...'. */
33838 {
33839 /* If we've seen a '<', we might be in a
33840 template-argument-list. Until Core issue 325 is
33841 resolved, we don't know how this situation ought
33842 to be handled, so try to DTRT. We check whether
33843 what comes after the comma is a valid parameter
33844 declaration list. If it is, then the comma ends
33845 the default argument; otherwise the default
33846 argument continues. */
33850 /* Set ITALP so cp_parser_parameter_declaration_list
33851 doesn't decide to commit to this parse. */
33858 {
33859 /* Parse declarators until we reach a non-comma or
33860 somthing that cannot be an initializer.
33861 Just checking whether we're looking at a single
33862 declarator is insufficient. Consider:
33863 int var = tuple<T,U>::x;
33864 The template parameter 'U' looks exactly like a
33865 declarator. */
33866 do
33867 {
33871 CP_PARSER_FLAGS_NONE,
33880 }
33882 /* If we met an '=' or ';' then the original comma
33883 was the end of the NSDMI. Otherwise assume
33884 we're still in the NSDMI. */
33887 }
33888 else
33889 {
33892 tree t = cp_parser_parameter_declaration_list
33897 }
33904 }
33905 /* FALLTHRU */
33908 /* If we run into a non-nested `;', `}', or `]',
33909 then the code is invalid -- but the default
33910 argument is certainly over. */
33915 /* Handle correctly int n = sizeof ... ( p ); */
33918 /* Update DEPTH, if necessary. */
33933 /* This might be the comparison operator, or it might
33934 start a template argument list. */
33941 /* Fall through for C++0x, which treats the `>>'
33942 operator like two `>' tokens in certain
33943 cases. */
33948 {
33949 /* This might be an operator, or it might close a
33950 template argument list. But if a previous '<'
33951 started a template argument list, this will have
33952 closed it, so we can't be in one anymore. */
33956 }
33959 /* If we run out of tokens, issue an error message. */
33967 /* In these cases, we should look for template-ids.
33968 For example, if the default argument is
33969 `X<int, double>()', we need to do name lookup to
33970 figure out whether or not `X' is a template; if
33971 so, the `,' does not end the default argument.
33973 That is not yet done. */
33978 }
33980 /* If we've reached the end, stop. */
33984 /* Add the token to the token block. */
33986 }
33988 /* Create a DEFERRED_PARSE to represent the unparsed default
33989 argument. */
33996 }
33998 /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
34000 location_t
34002 {
34007 }
34009 /* Begin parsing tentatively. We always save tokens while parsing
34010 tentatively so that if the tentative parsing fails we can restore the
34011 tokens. */
34013 static void
34015 {
34016 /* Enter a new parsing context. */
34018 /* Begin saving tokens. */
34020 /* In order to avoid repetitive access control error messages,
34021 access checks are queued up until we are no longer parsing
34022 tentatively. */
34024 }
34026 /* Commit to the currently active tentative parse. */
34028 static void
34030 {
34034 /* Mark all of the levels as committed. */
34037 {
34044 }
34045 }
34047 /* Commit to the topmost currently active tentative parse.
34049 Note that this function shouldn't be called when there are
34050 irreversible side-effects while in a tentative state. For
34051 example, we shouldn't create a permanent entry in the symbol
34052 table, or issue an error message that might not apply if the
34053 tentative parse is aborted. */
34055 static void
34057 {
34062 {
34070 }
34071 }
34073 /* Abort the currently active tentative parse. All consumed tokens
34074 will be rolled back, and no diagnostics will be issued. */
34076 static void
34078 {
34082 /* Now, pretend that we want to see if the construct was
34083 successfully parsed. */
34085 }
34087 /* Stop parsing tentatively. If a parse error has occurred, restore the
34088 token stream. Otherwise, commit to the tokens we have consumed.
34089 Returns true if no error occurred; false otherwise. */
34091 static bool
34093 {
34097 /* Remember whether or not an error occurred, since we are about to
34098 destroy that information. */
34100 /* Remove the topmost context from the stack. */
34103 /* If no parse errors occurred, commit to the tentative parse. */
34105 {
34106 /* Commit to the tokens read tentatively, unless that was
34107 already done. */
34112 }
34113 /* Otherwise, if errors occurred, roll back our state so that things
34114 are just as they were before we began the tentative parse. */
34115 else
34116 {
34119 }
34120 /* Add the context to the front of the free list. */
34125 }
34127 /* Returns true if we are parsing tentatively and are not committed to
34128 this tentative parse. */
34130 static bool
34132 {
34135 }
34137 /* Returns nonzero iff an error has occurred during the most recent
34138 tentative parse. */
34140 static bool
34142 {
34145 }
34147 /* Returns nonzero if GNU extensions are allowed. */
34149 static bool
34151 {
34153 }
34154 \f
34155 /* Objective-C++ Productions */
34158 /* Parse an Objective-C expression, which feeds into a primary-expression
34159 above.
34161 objc-expression:
34162 objc-message-expression
34163 objc-string-literal
34164 objc-encode-expression
34165 objc-protocol-expression
34166 objc-selector-expression
34168 Returns a tree representation of the expression. */
34170 static cp_expr
34172 {
34173 /* Try to figure out what kind of declaration is present. */
34177 {
34187 {
34199 }
34200 /* FALLTHRU */
34206 }
34209 }
34211 /* Parse an Objective-C message expression.
34213 objc-message-expression:
34214 [ objc-message-receiver objc-message-args ]
34216 Returns a representation of an Objective-C message. */
34218 static tree
34220 {
34233 /* Construct a location e.g.
34234 [self func1:5]
34235 ^~~~~~~~~~~~~~
34236 ranging from the '[' to the ']', with the caret at the start. */
34242 }
34244 /* Parse an objc-message-receiver.
34246 objc-message-receiver:
34247 expression
34248 simple-type-specifier
34250 Returns a representation of the type or expression. */
34252 static tree
34254 {
34255 tree rcv;
34257 /* An Objective-C message receiver may be either (1) a type
34258 or (2) an expression. */
34262 /* If that worked out, fine. */
34269 CP_PARSER_FLAGS_NONE);
34276 }
34278 /* Parse the arguments and selectors comprising an Objective-C message.
34280 objc-message-args:
34281 objc-selector
34282 objc-selector-args
34283 objc-selector-args , objc-comma-args
34285 objc-selector-args:
34286 objc-selector [opt] : assignment-expression
34287 objc-selector-args objc-selector [opt] : assignment-expression
34289 objc-comma-args:
34290 assignment-expression
34291 objc-comma-args , assignment-expression
34293 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
34294 selector arguments and TREE_VALUE containing a list of comma
34295 arguments. */
34297 static tree
34299 {
34305 {
34311 /* Detect if we have a unary selector. */
34320 sel_args
34325 }
34327 /* Handle non-selector arguments, if any. */
34329 {
34330 tree arg;
34335 addl_args
34340 }
34343 {
34346 }
34349 }
34351 /* Parse an Objective-C encode expression.
34353 objc-encode-expression:
34354 @encode objc-typename
34356 Returns an encoded representation of the type argument. */
34358 static cp_expr
34360 {
34361 tree type;
34366 matching_parens parens;
34373 {
34377 }
34379 /* This happens if we find @encode(T) (where T is a template
34380 typename or something dependent on a template typename) when
34381 parsing a template. In that case, we can't compile it
34382 immediately, but we rather create an AT_ENCODE_EXPR which will
34383 need to be instantiated when the template is used.
34384 */
34386 {
34390 }
34393 /* Build a location of the form:
34394 @encode(int)
34395 ^~~~~~~~~~~~
34396 with caret==start at the @ token, finishing at the close paren. */
34400 }
34402 /* Parse an Objective-C @defs expression. */
34404 static tree
34406 {
34407 tree name;
34410 matching_parens parens;
34416 }
34418 /* Parse an Objective-C protocol expression.
34420 objc-protocol-expression:
34421 @protocol ( identifier )
34423 Returns a representation of the protocol expression. */
34425 static tree
34427 {
34428 tree proto;
34432 matching_parens parens;
34437 /* Build a location of the form:
34438 @protocol(prot)
34439 ^~~~~~~~~~~~~~~
34440 with caret==start at the @ token, finishing at the close paren. */
34445 }
34447 /* Parse an Objective-C selector expression.
34449 objc-selector-expression:
34450 @selector ( objc-method-signature )
34452 objc-method-signature:
34453 objc-selector
34454 objc-selector-seq
34456 objc-selector-seq:
34457 objc-selector :
34458 objc-selector-seq objc-selector :
34460 Returns a representation of the method selector. */
34462 static tree
34464 {
34471 matching_parens parens;
34477 {
34486 {
34487 /* Detect if we have a unary selector. */
34489 {
34492 }
34493 else
34494 {
34496 }
34497 }
34502 {
34503 sel_seq
34506 sel_seq
34509 }
34510 else
34511 sel_seq
34516 }
34518 finish_selector:
34522 /* Build a location of the form:
34523 @selector(func)
34524 ^~~~~~~~~~~~~~~
34525 with caret==start at the @ token, finishing at the close paren. */
34528 /* TODO: objc_build_selector_expr doesn't always honor the location. */
34531 }
34533 /* Parse a list of identifiers.
34535 objc-identifier-list:
34536 identifier
34537 objc-identifier-list , identifier
34539 Returns a TREE_LIST of identifier nodes. */
34541 static tree
34543 {
34544 tree identifier;
34545 tree list;
34556 {
34563 identifier));
34565 }
34568 }
34570 /* Parse an Objective-C alias declaration.
34572 objc-alias-declaration:
34573 @compatibility_alias identifier identifier ;
34575 This function registers the alias mapping with the Objective-C front end.
34576 It returns nothing. */
34578 static void
34580 {
34588 }
34590 /* Parse an Objective-C class forward-declaration.
34592 objc-class-declaration:
34593 @class objc-identifier-list ;
34595 The function registers the forward declarations with the Objective-C
34596 front end. It returns nothing. */
34598 static void
34600 {
34603 {
34604 tree id;
34614 else
34616 }
34618 }
34620 /* Parse a list of Objective-C protocol references.
34622 objc-protocol-refs-opt:
34623 objc-protocol-refs [opt]
34625 objc-protocol-refs:
34626 < objc-identifier-list >
34628 Returns a TREE_LIST of identifiers, if any. */
34630 static tree
34632 {
34636 {
34640 }
34643 }
34645 /* Parse a Objective-C visibility specification. */
34647 static void
34649 {
34653 {
34668 }
34670 /* Eat '@private'/'@protected'/'@public'. */
34672 }
34674 /* Parse an Objective-C method type. Return 'true' if it is a class
34675 (+) method, and 'false' if it is an instance (-) method. */
34679 {
34682 else
34684 }
34686 /* Parse an Objective-C protocol qualifier. */
34688 static tree
34690 {
34703 {
34708 }
34711 }
34713 /* Parse an Objective-C typename. */
34715 static tree
34717 {
34721 {
34724 matching_parens parens;
34728 /* An ObjC type name may consist of just protocol qualifiers, in which
34729 case the type shall default to 'id'. */
34731 {
34734 /* If the type could not be parsed, an error has already
34735 been produced. For error recovery, behave as if it had
34736 not been specified, which will use the default type
34737 'id'. */
34739 {
34741 /* We need to skip to the closing parenthesis as
34742 cp_parser_type_id() does not seem to do it for
34743 us. */
34748 }
34749 }
34753 }
34756 }
34758 /* Check to see if TYPE refers to an Objective-C selector name. */
34760 static bool
34762 {
34768 }
34770 /* Parse an Objective-C selector. */
34772 static tree
34774 {
34778 {
34781 }
34783 /* C++ operator names are allowed to appear in ObjC selectors. */
34785 {
34798 }
34799 }
34801 /* Parse an Objective-C params list. */
34803 static tree
34805 {
34811 {
34821 /* Detect if we have a unary selector. */
34824 {
34827 }
34831 {
34832 /* Something went quite wrong. There should be a colon
34833 here, but there is not. Stop parsing parameters. */
34835 }
34837 /* New ObjC allows attributes on parameters too. */
34842 params
34845 type_name,
34846 identifier,
34847 parm_attr));
34850 }
34853 {
34856 }
34858 /* We allow tail attributes for the method. */
34860 {
34868 }
34871 {
34874 }
34876 }
34878 /* Parse the non-keyword Objective-C params. */
34880 static tree
34883 {
34889 {
34891 tree parm;
34897 {
34902 }
34904 /* TODO: parse attributes for tail parameters. */
34914 }
34916 /* We allow tail attributes for the method. */
34918 {
34920 {
34925 }
34926 else
34927 /* We have an error, but parse the attributes, so that we can
34928 carry on. */
34934 }
34937 }
34939 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
34941 static void
34943 {
34946 /* If the next token is `extern' and the following token is a string
34947 literal, then we have a linkage specification. */
34949 && cp_parser_is_pure_string_literal
34952 /* Handle #pragma, if any. */
34955 /* Allow stray semicolons. */
34958 /* Mark methods as optional or required, when building protocols. */
34960 {
34963 }
34965 {
34968 }
34971 /* Other stray characters must generate errors. */
34973 {
34977 }
34978 /* Finally, try to parse a block-declaration, or a function-definition. */
34979 else
34981 }
34983 /* Parse a method signature. */
34985 static tree
34987 {
35003 }
35005 static bool
35007 {
35008 tree tattr;
35013 /* If the attributes are followed by a method introducer, this is not allowed.
35014 Dump the attributes and flag the situation. */
35019 /* Otherwise, the attributes introduce some interstitial code, possibly so
35020 rewind to allow that check. */
35023 }
35025 /* Parse an Objective-C method prototype list. */
35027 static void
35029 {
35033 {
35035 {
35040 else
35044 {
35048 }
35051 }
35057 OPT_Wattributes,
35059 else
35060 /* Allow for interspersed non-ObjC++ code. */
35064 }
35068 else
35072 }
35074 /* Parse an Objective-C method definition list. */
35076 static void
35078 {
35080 {
35084 {
35087 }
35089 {
35092 }
35094 {
35098 tree attribute;
35102 else
35103 {
35107 /* For historical reasons, we accept an optional semicolon. */
35113 tree meth
35117 }
35118 }
35119 /* The following case will be removed once @synthesize is
35120 completely implemented. */
35131 else
35132 /* Allow for interspersed non-ObjC++ code. */
35134 }
35137 }
35139 /* Parse Objective-C ivars. */
35141 static void
35143 {
35154 {
35155 cp_decl_specifier_seq declspecs;
35157 tree prefix_attributes;
35165 CP_PARSER_FLAGS_OPTIONAL,
35169 /* auto, register, static, extern, mutable. */
35171 {
35174 }
35176 /* thread_local. */
35178 {
35181 }
35183 /* typedef. */
35185 {
35188 }
35193 /* Keep going until we hit the `;' at the end of the
35194 declaration. */
35196 {
35201 /* Check for a (possibly unnamed) bitfield declaration. */
35209 {
35210 /* Get the name of the bitfield. */
35215 eat_colon:
35217 /* Get the width of the bitfield. */
35218 width
35220 }
35221 else
35222 {
35223 /* Parse the declarator. */
35224 declarator
35226 CP_PARSER_FLAGS_NONE,
35232 }
35234 /* Look for attributes that apply to the ivar. */
35236 /* Remember which attributes are prefix attributes and
35237 which are not. */
35239 /* Combine the attributes. */
35243 /* Create the bitfield declaration. */
35246 else
35251 /* Add the instance variable. */
35255 /* Reset PREFIX_ATTRIBUTES. */
35257 {
35262 }
35267 {
35270 }
35272 }
35276 }
35281 /* Do not consume the RID_AT_END, so it will be read again as terminating
35282 the @interface of @implementation. */
35286 /* For historical reasons, we accept an optional semicolon. */
35289 }
35291 /* Parse an Objective-C protocol declaration. */
35293 static void
35295 {
35301 {
35306 }
35308 /* See if we have a forward declaration or a definition. */
35311 /* Try a forward declaration first. */
35313 {
35315 {
35316 tree id;
35326 else
35328 }
35330 }
35332 /* Ok, we got a full-fledged definition (or at least should). */
35333 else
35334 {
35339 }
35340 }
35342 /* Parse an Objective-C superclass or category. */
35344 static void
35349 {
35355 {
35358 }
35360 {
35361 matching_parens parens;
35364 /* If there is no category name, and this is an @interface, we
35365 have a class extension. */
35367 {
35370 }
35371 else
35375 }
35376 }
35378 /* Parse an Objective-C class interface. */
35380 static void
35382 {
35390 {
35391 /* It's hard to recover because even if valid @interface stuff
35392 is to follow, we can't compile it (or validate it) if we
35393 don't even know which class it refers to. Let's assume this
35394 was a stray '@interface' token in the stream and skip it.
35395 */
35397 }
35402 /* We have either a class or a category on our hands. */
35405 else
35406 {
35408 /* Handle instance variable declarations, if any. */
35411 }
35414 }
35416 /* Parse an Objective-C class implementation. */
35418 static void
35420 {
35427 {
35428 /* It's hard to recover because even if valid @implementation
35429 stuff is to follow, we can't compile it (or validate it) if
35430 we don't even know which class it refers to. Let's assume
35431 this was a stray '@implementation' token in the stream and
35432 skip it.
35433 */
35435 }
35439 /* We have either a class or a category on our hands. */
35442 else
35443 {
35445 /* Handle instance variable declarations, if any. */
35448 }
35451 }
35453 /* Consume the @end token and finish off the implementation. */
35455 static void
35457 {
35460 }
35462 /* Parse an Objective-C declaration. */
35464 static void
35466 {
35467 /* Try to figure out what kind of declaration is present. */
35472 {
35488 }
35491 {
35514 }
35515 }
35517 /* Parse an Objective-C try-catch-finally statement.
35519 objc-try-catch-finally-stmt:
35520 @try compound-statement objc-catch-clause-seq [opt]
35521 objc-finally-clause [opt]
35523 objc-catch-clause-seq:
35524 objc-catch-clause objc-catch-clause-seq [opt]
35526 objc-catch-clause:
35527 @catch ( objc-exception-declaration ) compound-statement
35529 objc-finally-clause:
35530 @finally compound-statement
35532 objc-exception-declaration:
35533 parameter-declaration
35534 '...'
35536 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
35538 Returns NULL_TREE.
35540 PS: This function is identical to c_parser_objc_try_catch_finally_statement
35541 for C. Keep them in sync. */
35543 static tree
35545 {
35546 location_t location;
35547 tree stmt;
35552 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
35553 node, lest it get absorbed into the surrounding block. */
35559 {
35563 matching_parens parens;
35569 {
35570 /* We have "@catch (...)" (where the '...' are literally
35571 what is in the code). Skip the '...'.
35572 parameter_declaration is set to NULL_TREE, and
35573 objc_being_catch_clauses() knows that that means
35574 '...'. */
35577 }
35578 else
35579 {
35580 /* We have "@catch (NSException *exception)" or something
35581 like that. Parse the parameter declaration. */
35586 else
35591 }
35594 else
35595 {
35596 /* If there was no open parenthesis, we are recovering from
35597 an error, and we are trying to figure out what mistake
35598 the user has made. */
35600 /* If there is an immediate closing parenthesis, the user
35601 probably forgot the opening one (ie, they typed "@catch
35602 NSException *e)". Parse the closing parenthesis and keep
35603 going. */
35607 /* If these is no immediate closing parenthesis, the user
35608 probably doesn't know that parenthesis are required at
35609 all (ie, they typed "@catch NSException *e"). So, just
35610 forget about the closing parenthesis and keep going. */
35611 }
35615 }
35617 {
35620 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
35621 node, lest it get absorbed into the surrounding block. */
35625 }
35628 }
35630 /* Parse an Objective-C synchronized statement.
35632 objc-synchronized-stmt:
35633 @synchronized ( expression ) compound-statement
35635 Returns NULL_TREE. */
35637 static tree
35639 {
35640 location_t location;
35647 matching_parens parens;
35652 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
35653 node, lest it get absorbed into the surrounding block. */
35658 }
35660 /* Parse an Objective-C throw statement.
35662 objc-throw-stmt:
35663 @throw assignment-expression [opt] ;
35665 Returns a constructed '@throw' statement. */
35667 static tree
35669 {
35681 }
35683 /* Parse an Objective-C statement. */
35685 static tree
35687 {
35688 /* Try to figure out what kind of declaration is present. */
35692 {
35703 }
35706 }
35708 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
35709 look ahead to see if an objc keyword follows the attributes. This
35710 is to detect the use of prefix attributes on ObjC @interface and
35711 @protocol. */
35713 static bool
35715 {
35720 {
35724 else
35727 }
35730 }
35732 /* This routine is a minimal replacement for
35733 c_parser_struct_declaration () used when parsing the list of
35734 types/names or ObjC++ properties. For example, when parsing the
35735 code
35737 @property (readonly) int a, b, c;
35739 this function is responsible for parsing "int a, int b, int c" and
35740 returning the declarations as CHAIN of DECLs.
35742 TODO: Share this code with cp_parser_objc_class_ivars. It's very
35743 similar parsing. */
35744 static tree
35746 {
35748 cp_decl_specifier_seq declspecs;
35750 tree prefix_attributes;
35753 CP_PARSER_FLAGS_NONE,
35760 /* auto, register, static, extern, mutable. */
35762 {
35765 }
35767 /* thread_local. */
35769 {
35772 }
35774 /* typedef. */
35776 {
35779 }
35784 /* Keep going until we hit the `;' at the end of the declaration. */
35786 {
35791 /* Parse the declarator. */
35793 CP_PARSER_FLAGS_NONE,
35796 /* Look for attributes that apply to the ivar. */
35798 /* Remember which attributes are prefix attributes and
35799 which are not. */
35801 /* Combine the attributes. */
35811 /* Reset PREFIX_ATTRIBUTES. */
35813 {
35818 }
35825 {
35828 }
35829 else
35831 }
35833 }
35835 /* Parse an Objective-C @property declaration. The syntax is:
35837 objc-property-declaration:
35838 '@property' objc-property-attributes[opt] struct-declaration ;
35840 objc-property-attributes:
35841 '(' objc-property-attribute-list ')'
35843 objc-property-attribute-list:
35844 objc-property-attribute
35845 objc-property-attribute-list, objc-property-attribute
35847 objc-property-attribute
35848 'getter' = identifier
35849 'setter' = identifier
35850 'readonly'
35851 'readwrite'
35852 'assign'
35853 'retain'
35854 'copy'
35855 'nonatomic'
35857 For example:
35858 @property NSString *name;
35859 @property (readonly) id object;
35860 @property (retain, nonatomic, getter=getTheName) id name;
35861 @property int a, b, c;
35863 PS: This function is identical to
35864 c_parser_objc_at_property_declaration for C. Keep them in sync. */
35865 static void
35867 {
35868 /* Parse the optional attribute list.
35870 A list of parsed, but not verified, attributes. */
35876 /* Parse the optional attribute list... */
35878 {
35879 /* Eat the '('. */
35880 matching_parens parens;
35885 /* Allow empty @property attribute lists, but with a warning. */
35887 location_t attr_comb;
35889 {
35893 }
35894 else
35896 {
35903 {
35910 }
35921 /* Account for accepting the 'class' keyword in this context. */
35923 else
35927 enum objc_property_attribute_kind prop_kind
35929 property_attribute_info *prop
35933 tree meth_name;
35935 {
35940 attr_name);
35941 else
35949 {
35952 attr_name);
35955 }
35963 {
35966 attr_name);
35969 }
35971 /* Get the end of the method name, and consume the name. */
35974 /* Because method names may contain C++ keywords, we have a
35975 routine to fetch them (this also consumes the token). */
35979 {
35981 {
35983 attr_end);
35987 }
35988 else
35989 {
35993 }
35995 attr_end);
35996 }
35997 else
35999 attr_end);
36001 /* Updated location including all that was successfully
36002 parsed. */
36005 }
36007 /* If we see a comma here, then keep going - even if we already
36008 saw a syntax error. For simple mistakes e.g. (asign, getter=x)
36009 this makes a more useful output and avoid spurious warnings
36010 about missing attributes that are, in fact, specified after the
36011 one with the syntax error. */
36014 else
36016 }
36022 }
36024 /* 'properties' is the list of properties that we read. Usually a
36025 single one, but maybe more (eg, in "@property int a, b, c;" there
36026 are three).
36027 TODO: Update this parsing so that it accepts (erroneous) bitfields so
36028 that we can issue a meaningful and consistent (between C/C++) error
36029 message from objc_add_property_declaration (). */
36036 else
36037 {
36038 /* Comma-separated properties are chained together in reverse order;
36039 add them one by one. */
36043 prop_attr_list);
36044 }
36047 }
36049 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
36051 objc-synthesize-declaration:
36052 @synthesize objc-synthesize-identifier-list ;
36054 objc-synthesize-identifier-list:
36055 objc-synthesize-identifier
36056 objc-synthesize-identifier-list, objc-synthesize-identifier
36058 objc-synthesize-identifier
36059 identifier
36060 identifier = identifier
36062 For example:
36063 @synthesize MyProperty;
36064 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
36066 PS: This function is identical to c_parser_objc_at_synthesize_declaration
36067 for C. Keep them in sync.
36068 */
36069 static void
36071 {
36073 location_t loc;
36078 {
36082 {
36085 }
36087 {
36091 {
36094 }
36095 }
36096 else
36101 else
36103 }
36106 }
36108 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
36110 objc-dynamic-declaration:
36111 @dynamic identifier-list ;
36113 For example:
36114 @dynamic MyProperty;
36115 @dynamic MyProperty, AnotherProperty;
36117 PS: This function is identical to c_parser_objc_at_dynamic_declaration
36118 for C. Keep them in sync.
36119 */
36120 static void
36122 {
36124 location_t loc;
36129 {
36130 tree property;
36133 {
36136 }
36140 else
36142 }
36145 }
36147 \f
36148 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
36150 /* Returns name of the next clause.
36151 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
36152 the token is not consumed. Otherwise appropriate pragma_omp_clause is
36153 returned and the token is consumed. */
36155 static pragma_omp_clause
36157 {
36173 {
36178 {
36389 }
36390 }
36396 }
36398 /* Validate that a clause of the given type does not already exist. */
36400 static void
36403 {
36406 }
36408 /* OpenMP 2.5:
36409 variable-list:
36410 identifier
36411 variable-list , identifier
36413 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
36414 colon). An opening parenthesis will have been consumed by the caller.
36416 If KIND is nonzero, create the appropriate node and install the decl
36417 in OMP_CLAUSE_DECL and add the node to the head of the list.
36419 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
36420 return the list created.
36422 COLON can be NULL if only closing parenthesis should end the list,
36423 or pointer to bool which will receive false if the list is terminated
36424 by closing parenthesis or true if the list is terminated by colon.
36426 The optional ALLOW_DEREF argument is true if list items can use the deref
36427 (->) operator. */
36429 struct omp_dim
36430 {
36432 location_t loc;
36436 };
36438 static tree
36442 {
36448 {
36451 }
36453 {
36461 {
36467 }
36471 {
36472 cp_id_kind idk;
36475 }
36476 else
36477 {
36484 {
36489 }
36493 else
36496 {
36502 }
36503 }
36507 ;
36509 {
36511 {
36513 /* The OpenACC cache directive explicitly only allows "array
36514 elements or subarrays". */
36516 {
36520 }
36521 /* FALLTHROUGH. */
36525 start_component_ref:
36527 || (allow_deref
36529 {
36530 cpp_ttype ttype
36533 location_t loc
36538 decl
36542 }
36543 /* FALLTHROUGH. */
36552 {
36560 {
36563 /* Later handling is not prepared to see through these. */
36565 }
36567 parser->colon_corrects_to_scope_p
36570 {
36573 }
36574 else
36575 {
36576 /* Look for `:'. */
36578 {
36583 }
36586 else
36589 CPP_CLOSE_SQUARE))
36590 {
36592 /* Later handling is not prepared to see through these. */
36594 }
36595 }
36596 /* Look for the closing `]'. */
36598 RT_CLOSE_SQUARE))
36599 {
36604 }
36607 }
36612 && !array_section_p
36614 || (allow_deref
36616 CPP_DEREF))))
36617 {
36619 {
36623 }
36625 }
36626 else
36633 }
36636 {
36640 {
36641 depend_lvalue:
36645 }
36646 else
36648 }
36654 }
36655 else
36658 get_comma:
36662 }
36668 {
36672 }
36675 {
36678 /* Try to resync to an unnested comma. Copied from
36679 cp_parser_parenthesized_expression_list. */
36680 skip_comma:
36689 }
36692 }
36694 /* Similarly, but expect leading and trailing parenthesis. This is a very
36695 common case for omp clauses. */
36697 static tree
36700 {
36703 allow_deref);
36705 }
36707 /* OpenACC 2.0:
36708 copy ( variable-list )
36709 copyin ( variable-list )
36710 copyout ( variable-list )
36711 create ( variable-list )
36712 delete ( variable-list )
36713 present ( variable-list )
36715 OpenACC 2.6:
36716 no_create ( variable-list )
36717 attach ( variable-list )
36718 detach ( variable-list ) */
36720 static tree
36722 tree list)
36723 {
36726 {
36768 }
36776 }
36778 /* OpenACC 2.0:
36779 deviceptr ( variable-list ) */
36781 static tree
36783 {
36787 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
36788 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
36789 variable-list must only allow for pointer variables. */
36792 {
36799 }
36802 }
36804 /* OpenACC 2.5:
36805 auto
36806 finalize
36807 independent
36808 nohost
36809 seq */
36811 static tree
36813 tree list)
36814 {
36821 }
36823 /* OpenACC:
36824 num_gangs ( expression )
36825 num_workers ( expression )
36826 vector_length ( expression ) */
36828 static tree
36831 {
36834 matching_parens parens;
36842 {
36847 }
36855 }
36857 /* OpenACC:
36859 gang [( gang-arg-list )]
36860 worker [( [num:] int-expr )]
36861 vector [( [length:] int-expr )]
36863 where gang-arg is one of:
36865 [num:] int-expr
36866 static: size-expr
36868 and size-expr may be:
36870 *
36871 int-expr
36872 */
36874 static tree
36876 omp_clause_code kind,
36878 {
36887 {
36888 matching_parens parens;
36891 do
36892 {
36896 /* Gang static argument. */
36899 {
36907 {
36910 }
36912 /* Check for the '*' argument. */
36916 CPP_CLOSE_PAREN)))
36917 {
36922 {
36925 }
36927 }
36928 }
36929 /* Worker num: argument and vector length: arguments. */
36933 {
36936 }
36938 /* Now collect the actual argument. */
36940 {
36943 }
36955 {
36958 }
36960 }
36965 }
36979 cleanup_error:
36982 }
36984 /* OpenACC 2.0:
36985 tile ( size-expr-list ) */
36987 static tree
36989 {
36993 /* Collapse and tile are mutually exclusive. (The spec doesn't say
36994 so, but the spec authors never considered such a case and have
36995 differing opinions on what it might mean, including 'not
36996 allowed'.) */
36999 clause_loc);
37004 do
37005 {
37012 {
37015 }
37016 else
37020 }
37023 /* Consume the trailing ')'. */
37031 }
37033 /* OpenACC 2.0
37034 Parse wait clause or directive parameters. */
37036 static tree
37038 {
37048 {
37050 {
37053 }
37055 }
37062 {
37066 {
37069 else
37070 {
37077 }
37078 }
37079 }
37082 }
37084 /* OpenACC:
37085 wait [( int-expr-list )] */
37087 static tree
37089 {
37094 else
37095 {
37101 }
37104 }
37106 /* OpenMP 3.0:
37107 collapse ( constant-expression ) */
37109 static tree
37111 {
37113 location_t loc;
37114 HOST_WIDE_INT n;
37117 matching_parens parens;
37135 {
37138 }
37147 }
37149 /* OpenMP 2.5:
37150 default ( none | shared )
37152 OpenMP 5.1:
37153 default ( private | firstprivate )
37155 OpenACC:
37156 default ( none | present ) */
37158 static tree
37161 {
37163 tree c;
37165 matching_parens parens;
37169 {
37172 }
37174 {
37179 {
37206 }
37209 }
37210 else
37211 {
37212 invalid_kind:
37215 else
37218 }
37235 }
37237 /* OpenMP 3.1:
37238 final ( expression ) */
37240 static tree
37242 {
37245 matching_parens parens;
37264 }
37266 /* OpenMP 2.5:
37267 if ( expression )
37269 OpenMP 4.5:
37270 if ( directive-name-modifier : expression )
37272 directive-name-modifier:
37273 parallel | task | taskloop | target data | target | target update
37274 | target enter data | target exit data
37276 OpenMP 5.0:
37277 directive-name-modifier:
37278 ... | simd | cancel */
37280 static tree
37283 {
37287 matching_parens parens;
37292 {
37308 {
37311 {
37324 else
37325 {
37326 location_t loc
37331 }
37334 {
37336 {
37341 }
37343 {
37344 location_t loc
37348 }
37349 }
37350 }
37351 }
37353 {
37355 {
37358 }
37359 else
37360 {
37362 {
37363 location_t loc
37366 }
37368 }
37369 }
37370 }
37382 {
37385 {
37388 {
37400 }
37402 p);
37404 }
37406 {
37409 else
37412 }
37415 {
37419 }
37420 }
37428 }
37430 /* OpenMP 3.1:
37431 mergeable */
37433 static tree
37436 {
37437 tree c;
37440 location);
37445 }
37447 /* OpenMP 2.5:
37448 nowait */
37450 static tree
37453 {
37454 tree c;
37461 }
37463 /* OpenMP 2.5:
37464 num_threads ( expression ) */
37466 static tree
37468 location_t location)
37469 {
37472 matching_parens parens;
37492 }
37494 /* OpenMP 4.5:
37495 num_tasks ( expression )
37497 OpenMP 5.1:
37498 num_tasks ( strict : expression ) */
37500 static tree
37502 location_t location)
37503 {
37506 matching_parens parens;
37513 {
37516 {
37520 }
37521 }
37540 }
37542 /* OpenMP 4.5:
37543 grainsize ( expression )
37545 OpenMP 5.1:
37546 grainsize ( strict : expression ) */
37548 static tree
37550 location_t location)
37551 {
37554 matching_parens parens;
37561 {
37564 {
37568 }
37569 }
37588 }
37590 /* OpenMP 4.5:
37591 priority ( expression ) */
37593 static tree
37595 location_t location)
37596 {
37599 matching_parens parens;
37619 }
37621 /* OpenMP 4.5:
37622 hint ( expression ) */
37624 static tree
37626 {
37629 matching_parens parens;
37636 {
37644 }
37657 }
37659 /* OpenMP 5.1:
37660 filter ( integer-expression ) */
37662 static tree
37664 {
37667 matching_parens parens;
37685 }
37687 /* OpenMP 4.5:
37688 defaultmap ( tofrom : scalar )
37690 OpenMP 5.0:
37691 defaultmap ( implicit-behavior [ : variable-category ] ) */
37693 static tree
37695 location_t location)
37696 {
37700 enum omp_clause_defaultmap_kind category
37703 matching_parens parens;
37710 {
37711 invalid_behavior:
37713 "%<tofrom%>, %<firstprivate%>, %<none%> "
37716 }
37717 else
37718 {
37721 }
37724 {
37728 else
37735 else
37744 else
37751 else
37760 else
37766 }
37770 {
37775 {
37776 invalid_category:
37780 }
37785 {
37789 else
37796 else
37803 else
37809 }
37812 }
37822 {
37829 {
37844 }
37847 p);
37848 else
37852 }
37859 out_err:
37864 }
37866 /* OpenMP 5.0:
37867 order ( concurrent )
37869 OpenMP 5.1:
37870 order ( order-modifier : concurrent )
37872 order-modifier:
37873 reproducible
37874 unconstrained */
37876 static tree
37878 {
37884 matching_parens parens;
37890 {
37897 else
37898 {
37902 }
37905 }
37907 {
37910 }
37911 else
37912 {
37915 }
37917 {
37920 }
37932 out_err:
37937 }
37939 /* OpenMP 5.0:
37940 bind ( teams | parallel | thread ) */
37942 static tree
37944 location_t location)
37945 {
37946 tree c;
37950 matching_parens parens;
37955 {
37956 invalid:
37960 }
37961 else
37962 {
37965 }
37976 /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
37982 out_err:
37987 }
37989 /* OpenMP 2.5:
37990 ordered
37992 OpenMP 4.5:
37993 ordered ( constant-expression ) */
37995 static tree
37998 {
38000 HOST_WIDE_INT n;
38006 {
38007 matching_parens parens;
38024 {
38026 "ordered argument needs positive constant integer "
38029 }
38030 }
38036 }
38038 /* OpenMP 2.5:
38039 reduction ( reduction-operator : variable-list )
38041 reduction-operator:
38042 One of: + * - & ^ | && ||
38044 OpenMP 3.1:
38046 reduction-operator:
38047 One of: + * - & ^ | && || min max
38049 OpenMP 4.0:
38051 reduction-operator:
38052 One of: + * - & ^ | && ||
38053 id-expression
38055 OpenMP 5.0:
38056 reduction ( reduction-modifier, reduction-operator : variable-list )
38057 in_reduction ( reduction-operator : variable-list )
38058 task_reduction ( reduction-operator : variable-list ) */
38060 static tree
38063 {
38073 {
38076 {
38079 }
38082 {
38090 {
38093 }
38094 }
38095 }
38098 {
38108 }
38112 else
38113 {
38124 {
38154 }
38155 else
38156 {
38158 resync_fail:
38163 }
38164 }
38170 NULL);
38172 {
38179 }
38182 }
38184 /* OpenMP 2.5:
38185 schedule ( schedule-kind )
38186 schedule ( schedule-kind , expression )
38188 schedule-kind:
38189 static | dynamic | guided | runtime | auto
38191 OpenMP 4.5:
38192 schedule ( schedule-modifier : schedule-kind )
38193 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
38195 schedule-modifier:
38196 simd
38197 monotonic
38198 nonmonotonic */
38200 static tree
38202 {
38206 matching_parens parens;
38214 {
38223 else
38229 {
38232 }
38233 else
38234 {
38237 }
38238 }
38243 {
38248 {
38269 }
38270 }
38275 else
38281 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
38283 {
38287 }
38290 {
38305 else
38310 }
38322 invalid_kind:
38324 resync_fail:
38329 }
38331 /* OpenMP 3.0:
38332 untied */
38334 static tree
38337 {
38338 tree c;
38345 }
38347 /* OpenMP 4.0:
38348 inbranch
38349 notinbranch */
38351 static tree
38354 {
38359 }
38361 /* OpenMP 4.0:
38362 parallel
38363 for
38364 sections
38365 taskgroup */
38367 static tree
38371 {
38375 }
38377 /* OpenMP 4.5:
38378 nogroup */
38380 static tree
38383 {
38388 }
38390 /* OpenMP 4.5:
38391 simd
38392 threads */
38394 static tree
38398 {
38403 }
38405 /* OpenMP 4.0:
38406 num_teams ( expression )
38408 OpenMP 5.1:
38409 num_teams ( expression : expression ) */
38411 static tree
38413 location_t location)
38414 {
38417 matching_parens parens;
38428 {
38432 }
38449 }
38451 /* OpenMP 4.0:
38452 thread_limit ( expression ) */
38454 static tree
38456 location_t location)
38457 {
38460 matching_parens parens;
38480 }
38482 /* OpenMP 4.0:
38483 aligned ( variable-list )
38484 aligned ( variable-list : constant-expression ) */
38486 static tree
38488 {
38492 matching_parens parens;
38500 {
38510 }
38516 }
38518 /* OpenMP 5.0:
38519 allocate ( variable-list )
38520 allocate ( expression : variable-list )
38522 OpenMP 5.1:
38523 allocate ( allocator-modifier : variable-list )
38524 allocate ( allocator-modifier , allocator-modifier : variable-list )
38526 allocator-modifier:
38527 allocator ( expression )
38528 align ( expression ) */
38530 static tree
38532 {
38536 matching_parens parens;
38546 {
38552 matching_parens parens2;
38556 {
38560 }
38561 else
38562 {
38566 }
38570 {
38573 }
38577 }
38578 else
38581 {
38587 }
38590 {
38597 }
38598 else
38599 {
38603 }
38610 {
38613 }
38616 }
38618 /* OpenMP 2.5:
38619 lastprivate ( variable-list )
38621 OpenMP 5.0:
38622 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
38624 static tree
38626 {
38634 {
38639 {
38643 }
38644 }
38653 }
38655 /* OpenMP 4.0:
38656 linear ( variable-list )
38657 linear ( variable-list : expression )
38659 OpenMP 4.5:
38660 linear ( modifier ( variable-list ) )
38661 linear ( modifier ( variable-list ) : expression ) */
38663 static tree
38666 {
38671 matching_parens parens;
38676 {
38688 else
38690 }
38695 else
38696 {
38705 }
38708 {
38713 {
38724 {
38727 }
38730 }
38741 }
38744 {
38747 }
38750 }
38752 /* OpenMP 4.0:
38753 safelen ( constant-expression ) */
38755 static tree
38757 location_t location)
38758 {
38761 matching_parens parens;
38780 }
38782 /* OpenMP 4.0:
38783 simdlen ( constant-expression ) */
38785 static tree
38787 location_t location)
38788 {
38791 matching_parens parens;
38810 }
38812 /* OpenMP 4.5:
38813 vec:
38814 identifier [+/- integer]
38815 vec , identifier [+/- integer]
38816 */
38818 static tree
38820 tree list)
38821 {
38825 {
38828 }
38831 {
38838 else
38839 {
38840 t = cp_parser_lookup_name_simple
38845 id_loc);
38846 }
38852 {
38855 }
38859 {
38862 }
38866 {
38869 }
38872 add_to_vector:
38874 {
38878 }
38885 }
38888 {
38894 }
38896 }
38898 /* OpenMP 5.0:
38899 detach ( event-handle ) */
38901 static tree
38903 {
38904 matching_parens parens;
38920 else
38921 {
38924 else
38929 }
38942 }
38944 /* OpenMP 5.0:
38945 iterators ( iterators-definition )
38947 iterators-definition:
38948 iterator-specifier
38949 iterator-specifier , iterators-definition
38951 iterator-specifier:
38952 identifier = range-specification
38953 iterator-type identifier = range-specification
38955 range-specification:
38956 begin : end
38957 begin : end : step */
38959 static tree
38961 {
38965 matching_parens parens;
38969 bool saved_colon_corrects_to_scope_p
38971 bool saved_colon_doesnt_start_class_def_p
38974 do
38975 {
38976 tree iter_type;
38980 else
38981 {
38984 parser->type_definition_forbidden_message
38990 }
38994 {
38997 }
39017 {
39020 }
39035 {
39038 }
39040 }
39044 parser->colon_doesnt_start_class_def_p
39054 }
39056 /* OpenMP 5.0:
39057 affinity ( [aff-modifier :] variable-list )
39058 aff-modifier:
39059 iterator ( iterators-definition ) */
39061 static tree
39063 {
39066 matching_parens parens;
39071 {
39076 CPP_OPEN_PAREN)));
39078 {
39081 }
39083 {
39087 {
39095 }
39096 }
39097 }
39101 {
39104 {
39109 }
39110 }
39112 }
39114 /* OpenMP 4.0:
39115 depend ( depend-kind : variable-list )
39117 depend-kind:
39118 in | out | inout
39120 OpenMP 4.5:
39121 depend ( source )
39123 depend ( sink : vec )
39125 OpenMP 5.0:
39126 depend ( depend-modifier , depend-kind: variable-list )
39128 depend-kind:
39129 in | out | inout | mutexinoutset | depobj
39131 depend-modifier:
39132 iterator ( iterators-definition ) */
39134 static tree
39136 {
39140 matching_parens parens;
39144 do
39145 {
39153 {
39158 }
39173 else
39176 }
39183 {
39188 }
39191 {
39201 }
39207 {
39213 }
39214 else
39215 {
39220 {
39224 else
39226 }
39229 {
39234 }
39235 }
39238 invalid_kind:
39240 resync_fail:
39247 }
39249 /* OpenMP 4.0:
39250 map ( map-kind : variable-list )
39251 map ( variable-list )
39253 map-kind:
39254 alloc | to | from | tofrom
39256 OpenMP 4.5:
39257 map-kind:
39258 alloc | to | from | tofrom | release | delete
39260 map ( always [,] map-kind: variable-list )
39262 OpenMP 5.0:
39263 map ( [map-type-modifier[,] ...] map-kind: variable-list )
39265 map-type-modifier:
39266 always | close */
39268 static tree
39270 {
39281 {
39283 {
39286 }
39289 pos++;
39290 pos++;
39291 }
39296 {
39299 {
39302 }
39306 {
39308 {
39315 }
39317 }
39319 {
39321 {
39328 }
39330 }
39331 else
39332 {
39334 "modifier other than %<always%> or %<close%>"
39341 }
39344 }
39348 {
39362 else
39363 {
39369 }
39372 }
39375 {
39379 }
39388 }
39390 /* OpenMP 4.0:
39391 device ( expression )
39393 OpenMP 5.0:
39394 device ( [device-modifier :] integer-expression )
39396 device-modifier:
39397 ancestor | device_num */
39399 static tree
39401 location_t location)
39402 {
39406 matching_parens parens;
39412 {
39416 {
39419 /* A requires directive with the reverse_offload clause must be
39420 specified. */
39422 {
39424 "preceded by %<requires%> directive "
39428 }
39429 }
39431 ;
39432 else
39433 {
39437 }
39440 }
39459 }
39461 /* OpenMP 4.0:
39462 dist_schedule ( static )
39463 dist_schedule ( static , expression ) */
39465 static tree
39467 location_t location)
39468 {
39471 matching_parens parens;
39482 {
39493 }
39497 /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
39498 "dist_schedule", location); */
39504 invalid_kind:
39506 resync_fail:
39511 }
39513 /* OpenMP 4.0:
39514 proc_bind ( proc-bind-kind )
39516 proc-bind-kind:
39517 primary | master | close | spread
39518 where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
39520 static tree
39522 location_t location)
39523 {
39524 tree c;
39531 {
39543 else
39545 }
39546 else
39555 location);
39560 invalid_kind:
39562 resync_fail:
39567 }
39569 /* OpenMP 5.0:
39570 device_type ( host | nohost | any ) */
39572 static tree
39574 location_t location)
39575 {
39576 tree c;
39583 {
39593 else
39595 }
39596 else
39604 /* check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE_TYPE, "device_type",
39605 location); */
39610 invalid_kind:
39612 resync_fail:
39617 }
39619 /* OpenACC:
39620 async [( int-expr )] */
39622 static tree
39624 {
39631 {
39632 matching_parens parens;
39641 }
39651 }
39653 /* Parse all OpenACC clauses. The set clauses allowed by the directive
39654 is a bitmask in MASK. Return the list of clauses found. */
39656 static tree
39660 {
39664 /* Don't create location wrapper nodes within OpenACC clauses. */
39665 auto_suppress_location_wrappers sentinel;
39668 {
39669 location_t here;
39670 pragma_omp_clause c_kind;
39671 omp_clause_code code;
39682 {
39689 clauses);
39742 clauses);
39747 clauses);
39765 clauses);
39770 clauses);
39783 clauses);
39790 clauses);
39796 clauses);
39804 clauses);
39808 clauses
39815 clauses);
39824 clauses);
39830 OMP_CLAUSE_VECTOR,
39837 clauses);
39846 OMP_CLAUSE_WORKER,
39852 }
39857 {
39858 /* Remove the invalid clause(s) from the list to avoid
39859 confusing the rest of the compiler. */
39862 }
39863 }
39865 saw_error:
39872 }
39874 /* Parse all OpenMP clauses. The set clauses allowed by the directive
39875 is a bitmask in MASK. Return the list of clauses found.
39876 FINISH_P set if finish_omp_clauses should be called.
39877 NESTED non-zero if clauses should be terminated by closing paren instead
39878 of end of pragma. If it is 2, additionally commas are required in between
39879 the clauses. */
39881 static tree
39885 {
39890 /* Don't create location wrapper nodes within OpenMP clauses. */
39891 auto_suppress_location_wrappers sentinel;
39894 {
39895 pragma_omp_clause c_kind;
39903 /* OpenMP 5.1 allows optional comma in between directive-name and
39904 clauses everywhere, but as we aren't done with OpenMP 5.0
39905 implementation yet, let's allow it for now only in C++11
39906 attributes. */
39908 {
39913 "clauses in %<simd%> trait should be separated "
39915 }
39921 {
39938 clauses);
39957 clauses);
39977 clauses);
39982 clauses);
39987 clauses);
39996 clauses
40042 clauses);
40046 clauses
40058 clauses);
40062 clauses
40064 OMP_CLAUSE_TASK_REDUCTION,
40080 clauses);
40085 OMP_CLAUSE_NOTINBRANCH,
40094 {
40095 clause_not_first:
40099 }
40129 clauses);
40130 else
40142 clauses);
40164 {
40169 }
40225 clauses
40231 clauses
40239 }
40244 {
40245 /* Remove the invalid clause(s) from the list to avoid
40246 confusing the rest of the compiler. */
40249 }
40250 }
40251 saw_error:
40255 {
40258 else
40260 }
40262 }
40264 /* OpenMP 2.5:
40265 structured-block:
40266 statement
40268 In practice, we're also interested in adding the statement to an
40269 outer node. So it is convenient if we work around the fact that
40270 cp_parser_statement calls add_stmt. */
40272 static unsigned
40274 {
40277 /* Only move the values to IN_OMP_BLOCK if they weren't false.
40278 This preserves the "not within loop or switch" style error messages
40279 for nonsense cases like
40280 void foo() {
40281 #pragma omp single
40282 break;
40283 }
40284 */
40289 }
40291 static void
40293 {
40295 }
40297 static tree
40299 {
40308 }
40310 /* OpenMP 5.0:
40311 # pragma omp allocate (list) [allocator(allocator)] */
40313 static void
40315 {
40320 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
40327 {
40328 matching_parens parens;
40336 {
40341 }
40342 }
40350 }
40352 /* OpenMP 2.5:
40353 # pragma omp atomic new-line
40354 expression-stmt
40356 expression-stmt:
40357 x binop= expr | x++ | ++x | x-- | --x
40358 binop:
40359 +, *, -, /, &, ^, |, <<, >>
40361 where x is an lvalue expression with scalar type.
40363 OpenMP 3.1:
40364 # pragma omp atomic new-line
40365 update-stmt
40367 # pragma omp atomic read new-line
40368 read-stmt
40370 # pragma omp atomic write new-line
40371 write-stmt
40373 # pragma omp atomic update new-line
40374 update-stmt
40376 # pragma omp atomic capture new-line
40377 capture-stmt
40379 # pragma omp atomic capture new-line
40380 capture-block
40382 read-stmt:
40383 v = x
40384 write-stmt:
40385 x = expr
40386 update-stmt:
40387 expression-stmt | x = x binop expr
40388 capture-stmt:
40389 v = expression-stmt
40390 capture-block:
40391 { v = x; update-stmt; } | { update-stmt; v = x; }
40393 OpenMP 4.0:
40394 update-stmt:
40395 expression-stmt | x = x binop expr | x = expr binop x
40396 capture-stmt:
40397 v = update-stmt
40398 capture-block:
40399 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
40401 OpenMP 5.1:
40402 # pragma omp atomic compare new-line
40403 conditional-update-atomic
40405 # pragma omp atomic compare capture new-line
40406 conditional-update-capture-atomic
40408 conditional-update-atomic:
40409 cond-expr-stmt | cond-update-stmt
40410 cond-expr-stmt:
40411 x = expr ordop x ? expr : x;
40412 x = x ordop expr ? expr : x;
40413 x = x == e ? d : x;
40414 cond-update-stmt:
40415 if (expr ordop x) { x = expr; }
40416 if (x ordop expr) { x = expr; }
40417 if (x == e) { x = d; }
40418 ordop:
40419 <, >
40420 conditional-update-capture-atomic:
40421 v = cond-expr-stmt
40422 { v = x; cond-expr-stmt }
40423 { cond-expr-stmt v = x; }
40424 { v = x; cond-update-stmt }
40425 { cond-update-stmt v = x; }
40426 if (x == e) { x = d; } else { v = x; }
40427 { r = x == e; if (r) { x = d; } }
40428 { r = x == e; if (r) { x = d; } else { v = x; } }
40430 where x, r and v are lvalue expressions with scalar type,
40431 expr, e and d are expressions with scalar type and e might be
40432 the same as v. */
40434 static void
40436 {
40453 {
40454 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
40463 {
40468 enum omp_memory_order new_memory_order
40484 {
40488 }
40496 {
40497 matching_parens parens;
40504 {
40514 }
40517 {
40521 else
40523 }
40524 else
40534 }
40546 {
40550 }
40551 else
40552 {
40555 "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
40556 "%<seq_cst%>, %<acq_rel%>, %<release%>, "
40558 }
40560 {
40562 {
40563 /* OpenACC permits 'update capture'. */
40570 else
40572 }
40574 {
40577 else
40579 }
40581 {
40584 else
40586 }
40588 {
40591 else
40593 }
40595 {
40598 else
40600 }
40603 }
40604 }
40606 }
40612 {
40616 else
40618 }
40620 {
40624 }
40626 {
40629 }
40631 {
40634 }
40638 {
40639 omp_requires_mask
40644 {
40654 {
40664 }
40668 }
40669 }
40670 else
40672 {
40675 {
40679 }
40685 {
40689 }
40695 }
40697 memory_order
40702 {
40712 else
40717 {
40718 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
40719 opcode. */
40724 }
40728 {
40731 }
40735 else
40736 {
40744 {
40748 }
40749 }
40752 }
40754 restart:
40756 {
40759 matching_parens parens;
40763 tree cmp_expr;
40766 else
40774 {
40780 }
40782 ;
40784 {
40788 }
40791 {
40793 "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
40796 }
40807 {
40810 }
40815 else
40828 {
40830 {
40833 }
40835 {
40840 }
40841 else
40843 }
40848 {
40853 }
40854 else
40855 {
40856 bad_if:
40860 }
40863 {
40867 {
40871 }
40899 /* Signal to c_finish_omp_atomic that in
40900 if (x == e) { x = d; } else { v = x; }
40901 case the store to v should be conditional. */
40903 }
40905 {
40908 }
40914 }
40918 {
40925 /* FALLTHROUGH */
40937 /* FALLTHROUGH */
40954 /* Undo effects of boolean_increment for post {in,de}crement. */
40956 /* FALLTHRU */
40960 {
40961 /* Undo effects of boolean_increment. */
40963 {
40964 /* This is pre or post increment. */
40969 && !structured_block
40975 }
40976 }
40977 /* FALLTHRU */
40980 {
40983 }
40985 {
41020 {
41024 }
41027 {
41033 {
41038 }
41040 {
41054 {
41056 {
41061 }
41062 else
41064 }
41069 || !structured_block
41070 || v
41076 {
41078 {
41084 }
41085 }
41093 {
41097 cond_expr:
41099 bool saved_colon_corrects_to_scope_p
41103 parser->colon_corrects_to_scope_p
41108 {
41110 {
41112 {
41116 }
41118 {
41119 opcode
41123 }
41124 }
41125 else
41126 {
41129 {
41130 opcode
41135 }
41136 }
41137 }
41139 "invalid form of "
41142 }
41146 }
41151 {
41158 }
41162 }
41166 {
41169 {
41177 }
41179 {
41184 }
41228 }
41231 {
41233 "invalid form of "
41236 }
41247 {
41249 {
41251 "invalid form of "
41254 }
41256 }
41262 }
41269 }
41270 stmt_done:
41272 {
41285 }
41287 {
41291 }
41292 done:
41294 {
41297 }
41305 invalid_compare:
41307 /* FALLTHRU */
41308 saw_error:
41313 {
41317 {
41321 }
41322 }
41323 }
41326 /* OpenMP 2.5:
41327 # pragma omp barrier new-line */
41329 static void
41331 {
41334 }
41336 /* OpenMP 2.5:
41337 # pragma omp critical [(name)] new-line
41338 structured-block
41340 OpenMP 4.5:
41341 # pragma omp critical [(name) [hint(expression)]] new-line
41342 structured-block */
41344 #define OMP_CRITICAL_CLAUSE_MASK \
41345 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
41347 static tree
41349 {
41353 {
41354 matching_parens parens;
41370 }
41377 }
41379 /* OpenMP 5.0:
41380 # pragma omp depobj ( depobj ) depobj-clause new-line
41382 depobj-clause:
41383 depend (dependence-type : locator)
41384 destroy
41385 update (dependence-type)
41387 dependence-type:
41388 in
41389 out
41390 inout
41391 mutexinout */
41393 static void
41395 {
41397 matching_parens parens;
41399 {
41402 }
41414 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
41419 {
41425 {
41426 /* Don't create location wrapper nodes within the depend clause. */
41427 auto_suppress_location_wrappers sentinel;
41433 }
41437 {
41438 matching_parens c_parens;
41440 {
41441 location_t c2_loc
41444 {
41457 }
41459 {
41463 }
41469 }
41470 else
41472 }
41473 }
41475 {
41478 }
41482 }
41485 /* OpenMP 2.5:
41486 # pragma omp flush flush-vars[opt] new-line
41488 flush-vars:
41489 ( variable-list )
41491 OpenMP 5.0:
41492 # pragma omp flush memory-order-clause new-line */
41494 static void
41496 {
41498 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
41504 {
41515 else
41517 "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
41520 }
41522 {
41525 "%<flush%> list specified together with memory order "
41528 }
41532 }
41534 /* Helper function, to parse omp for increment expression. */
41536 static tree
41538 {
41543 {
41546 }
41549 {
41561 }
41563 /* If decl is an iterator, preserve LHS and RHS of the relational
41564 expr until finish_omp_for. */
41575 }
41577 /* Helper function, to parse omp for increment expression. */
41579 static tree
41581 {
41585 cp_id_kind idk;
41589 {
41598 }
41607 {
41612 }
41619 {
41623 }
41636 do
41637 {
41644 {
41646 {
41649 else
41652 }
41653 else
41658 }
41659 }
41663 {
41669 }
41670 else
41674 }
41676 /* Parse the initialization statement of an OpenMP for loop.
41678 Return true if the resulting construct should have an
41679 OMP_CLAUSE_PRIVATE added to it. */
41681 static tree
41689 {
41695 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
41697 init-expr:
41698 var = lb
41699 integer-type var = lb
41700 random-access-iterator-type var = lb
41701 pointer-type var = lb
41702 */
41703 cp_decl_specifier_seq type_specifiers;
41705 /* First, try to parse as an initialized declaration. See
41706 cp_parser_condition, from whence the bulk of this is copied. */
41714 {
41715 /* If parsing a type specifier seq succeeded, then this
41716 MUST be a initialized declaration. */
41721 CP_PARSER_DECLARATOR_NAMED,
41722 CP_PARSER_FLAGS_NONE,
41734 else
41735 {
41745 {
41747 CPP_OPEN_PAREN))
41750 else
41751 /* Trigger an error. */
41756 }
41760 {
41768 {
41771 auto_node);
41776 }
41779 asm_specification,
41780 LOOKUP_ONLYCONVERTING);
41783 {
41786 }
41787 else
41788 {
41791 {
41793 /* Move lambda DECL_EXPRs to FOR_BLOCK. */
41795 {
41799 {
41803 }
41805 }
41807 {
41812 }
41813 }
41814 }
41816 }
41817 else
41818 {
41819 /* Consume '='. */
41823 non_class:
41826 else
41829 asm_specification,
41830 LOOKUP_ONLYCONVERTING);
41831 }
41835 }
41836 }
41837 else
41838 {
41839 cp_id_kind idk;
41840 /* If parsing a type specifier sequence failed, then
41841 this MUST be a simple expression. */
41847 && decl
41850 {
41861 {
41866 }
41871 }
41873 && decl
41876 {
41877 tree rhs;
41886 tf_warning_or_error));
41889 }
41890 else
41891 {
41896 {
41900 }
41901 }
41902 }
41904 }
41906 /* Helper for cp_parser_omp_for_loop, handle one range-for loop. */
41908 void
41912 {
41917 {
41921 /* do_auto_deduction doesn't mess with template init-lists. */
41923 {
41926 {
41932 }
41934 }
41941 }
41946 /* If an error happened previously do nothing or else a lot of
41947 unhelpful errors would be issued. */
41949 else
41950 {
41951 tree range_temp;
41955 /* Can't bind a reference to an array of runtime bound. */
41957 else
41958 {
41964 LOOKUP_ONLYCONVERTING);
41967 }
41970 }
41981 LOOKUP_ONLYCONVERTING);
41983 /* The new for initialization statement. */
41991 else
41992 {
41995 }
41998 LOOKUP_ONLYCONVERTING);
42000 /* The new for condition. */
42003 else
42009 /* The new increment expression. */
42012 else
42015 tf_warning_or_error);
42020 {
42023 }
42028 {
42033 {
42038 }
42039 }
42043 {
42049 }
42056 {
42059 }
42061 }
42063 /* Helper for cp_parser_omp_for_loop, finalize part of range for
42064 inside of the collapsed body. */
42066 void
42068 {
42076 {
42080 }
42082 /* The declaration is initialized with *__begin inside the loop body. */
42087 LOOKUP_ONLYCONVERTING);
42090 }
42092 /* Return true if next tokens contain a standard attribute that contains
42093 omp::directive (DIRECTIVE). */
42095 static bool
42098 {
42106 {
42113 }
42118 location_t last_loc
42127 {
42129 {
42133 cnt++;
42137 {
42141 }
42142 }
42143 }
42145 {
42148 }
42150 {
42152 "%<[[omp::directive(%s)]]%> must be the only specified "
42156 }
42161 }
42163 /* Parse an OpenMP structured block sequence. KIND is the corresponding
42164 separating directive. */
42166 static tree
42169 {
42175 {
42188 kind == PRAGMA_OMP_SCAN
42193 }
42197 }
42200 /* OpenMP 5.0:
42202 scan-loop-body:
42203 { structured-block scan-directive structured-block } */
42205 static void
42207 {
42210 matching_braces braces;
42220 {
42230 {
42237 }
42239 {
42242 }
42243 else
42248 }
42249 else
42255 clauses);
42259 }
42261 /* Parse the restricted form of the for statement allowed by OpenMP. */
42263 static tree
42266 {
42268 tree orig_decl;
42271 location_t loc_first;
42274 releasing_vec for_block;
42283 {
42286 }
42289 {
42292 }
42299 {
42305 }
42307 {
42310 {
42312 "%<linear%> clause may not be specified together "
42315 }
42316 else
42318 }
42332 {
42335 location_t loc;
42338 {
42342 }
42345 /* Don't create location wrapper nodes within an OpenMP "for"
42346 statement. */
42347 auto_suppress_location_wrappers sentinel;
42349 matching_parens parens;
42357 {
42358 /* Save tokens so that we can put them back. */
42361 /* Look for ':' that is not nested in () or {}. */
42362 bool is_range_for
42365 CPP_COLON,
42366 /*consume_paren=*/
42369 /* Roll back the tokens we skipped. */
42373 {
42374 bool saved_colon_corrects_to_scope_p
42377 /* A colon is used in range-based for. */
42380 /* Parse the declaration. */
42382 /*function_definition_allowed_p=*/
42384 parser->colon_corrects_to_scope_p
42396 {
42398 {
42404 }
42405 else
42407 }
42411 "%<ordered%> clause with parameter on "
42415 }
42416 }
42418 add_private_clause
42424 {
42427 {
42433 }
42434 else
42436 }
42444 {
42449 {
42453 }
42456 {
42457 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
42461 {
42464 }
42465 else
42466 {
42469 }
42471 }
42472 else
42473 {
42478 }
42479 }
42482 {
42483 tree c;
42485 {
42494 decl);
42499 decl);
42500 }
42502 {
42507 else
42512 {
42515 /* For linear, signal that we need to fill up
42516 the so far unknown linear step. */
42519 }
42520 }
42521 }
42530 {
42531 /* If decl is an iterator, preserve the operator on decl
42532 until finish_omp_for. */
42534 && ((processing_template_decl
42539 else
42542 }
42544 parse_close_paren:
42555 {
42558 }
42560 {
42564 }
42571 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
42572 in between the collapsed for loops to be still considered perfectly
42573 nested. Hopefully the final version clarifies this.
42574 For now handle (multiple) {'s and empty statements. */
42577 {
42581 {
42583 bracecount++;
42584 }
42588 else
42589 {
42596 }
42597 }
42600 {
42603 }
42604 }
42609 /* Note that we saved the original contents of this flag when we entered
42610 the structured block, and so we don't need to re-save it here. */
42613 /* Note that the grammar doesn't call for a structured block here,
42614 though the loop as a whole is a structured block. */
42616 {
42622 }
42623 else
42627 else
42631 else
42636 else
42641 {
42643 {
42645 nbraces--;
42646 }
42649 else
42650 {
42652 {
42655 }
42660 }
42661 }
42664 {
42668 else
42670 }
42673 }
42675 /* Helper function for OpenMP parsing, split clauses and call
42676 finish_omp_clauses on each of the set of clauses afterwards. */
42678 static void
42681 {
42687 i == C_OMP_CLAUSE_SPLIT_TARGET
42689 }
42691 /* OpenMP 5.0:
42692 #pragma omp loop loop-clause[optseq] new-line
42693 for-loop */
42695 #define OMP_LOOP_CLAUSE_MASK \
42696 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
42697 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
42698 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
42699 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
42700 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
42701 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
42703 static tree
42707 {
42718 {
42721 }
42733 }
42735 /* OpenMP 4.0:
42736 #pragma omp simd simd-clause[optseq] new-line
42737 for-loop */
42739 #define OMP_SIMD_CLAUSE_MASK \
42740 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
42741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
42742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
42743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
42744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
42745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
42746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
42747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
42748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
42749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
42750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
42752 static tree
42756 {
42767 {
42771 OMP_CLAUSE_ORDERED);
42773 {
42775 "%<ordered%> clause with parameter may not be specified "
42778 }
42779 }
42791 }
42793 /* OpenMP 2.5:
42794 #pragma omp for for-clause[optseq] new-line
42795 for-loop
42797 OpenMP 4.0:
42798 #pragma omp for simd for-simd-clause[optseq] new-line
42799 for-loop */
42801 #define OMP_FOR_CLAUSE_MASK \
42802 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
42803 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
42804 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
42805 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
42806 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
42807 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
42808 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
42809 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
42810 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
42811 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
42812 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
42814 static tree
42818 {
42825 /* parallel for{, simd} disallows nowait clause, but for
42826 target {teams distribute ,}parallel for{, simd} it should be accepted. */
42829 /* Composite distribute parallel for{, simd} disallows ordered clause. */
42834 {
42839 {
42863 }
42864 }
42866 {
42869 }
42871 /* Composite distribute parallel for disallows linear clause. */
42878 {
42881 }
42893 }
42898 /* OpenMP 2.5:
42899 # pragma omp master new-line
42900 structured-block */
42902 static tree
42906 {
42914 {
42919 {
42939 }
42940 }
42942 {
42945 }
42948 {
42952 }
42953 else
42958 }
42960 /* OpenMP 5.1:
42961 # pragma omp masked masked-clauses new-line
42962 structured-block */
42964 #define OMP_MASKED_CLAUSE_MASK \
42965 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
42967 static tree
42971 {
42980 {
42985 {
43006 }
43007 }
43009 {
43012 }
43017 {
43020 }
43024 clauses);
43025 }
43027 /* OpenMP 2.5:
43028 # pragma omp ordered new-line
43029 structured-block
43031 OpenMP 4.5:
43032 # pragma omp ordered ordered-clauses new-line
43033 structured-block */
43035 #define OMP_ORDERED_CLAUSE_MASK \
43036 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
43037 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
43039 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
43040 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
43042 static bool
43045 {
43049 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
43055 {
43060 {
43062 {
43065 }
43067 {
43069 "%<depend%> clause may only be used in compound "
43073 }
43074 tree clauses
43076 OMP_ORDERED_DEPEND_CLAUSE_MASK,
43080 }
43081 }
43083 tree clauses
43094 }
43096 /* OpenMP 2.5:
43098 section-scope:
43099 { section-sequence }
43101 section-sequence:
43102 section-directive[opt] structured-block
43103 section-sequence section-directive structured-block */
43105 static tree
43107 {
43112 matching_braces braces;
43119 != PRAGMA_OMP_SECTION
43121 {
43123 PRAGMA_OMP_SECTION);
43126 }
43129 {
43139 {
43143 }
43145 {
43148 }
43151 PRAGMA_OMP_SECTION);
43154 }
43165 }
43167 /* OpenMP 2.5:
43168 # pragma omp sections sections-clause[optseq] newline
43169 sections-scope */
43171 #define OMP_SECTIONS_CLAUSE_MASK \
43172 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43173 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43174 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43175 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43176 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43177 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43179 static tree
43182 {
43194 {
43197 }
43204 }
43206 /* OpenMP 2.5:
43207 # pragma omp parallel parallel-clause[optseq] new-line
43208 structured-block
43209 # pragma omp parallel for parallel-for-clause[optseq] new-line
43210 structured-block
43211 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
43212 structured-block
43214 OpenMP 4.0:
43215 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
43216 structured-block */
43218 #define OMP_PARALLEL_CLAUSE_MASK \
43219 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43220 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43221 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43222 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
43223 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43224 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
43225 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43226 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
43227 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43228 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
43230 static tree
43234 {
43241 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
43247 {
43255 if_p);
43259 if_p);
43262 block);
43267 }
43268 /* When combined with distribute, parallel has to be followed by for.
43269 #pragma omp target parallel is allowed though. */
43273 {
43277 }
43279 {
43283 {
43297 block);
43300 /* masked does have just filter clause, but during gimplification
43301 isn't represented by a gimplification omp context, so for
43302 #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
43303 so that
43304 #pragma omp parallel masked
43305 #pragma omp taskloop simd lastprivate (x)
43306 isn't confused with
43307 #pragma omp parallel masked taskloop simd lastprivate (x) */
43311 }
43313 {
43327 block);
43330 /* master doesn't have any clauses and during gimplification
43331 isn't represented by a gimplification omp context, so for
43332 #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
43333 so that
43334 #pragma omp parallel master
43335 #pragma omp taskloop simd lastprivate (x)
43336 isn't confused with
43337 #pragma omp parallel master taskloop simd lastprivate (x) */
43341 }
43343 {
43358 block);
43363 }
43365 {
43368 }
43370 {
43380 block);
43383 }
43384 }
43386 {
43389 }
43394 {
43397 }
43406 }
43408 /* OpenMP 2.5:
43409 # pragma omp single single-clause[optseq] new-line
43410 structured-block */
43412 #define OMP_SINGLE_CLAUSE_MASK \
43413 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43414 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43415 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
43416 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43417 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43419 static tree
43421 {
43432 }
43434 /* OpenMP 5.1:
43435 # pragma omp scope scope-clause[optseq] new-line
43436 structured-block */
43438 #define OMP_SCOPE_CLAUSE_MASK \
43439 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43440 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43441 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43443 static tree
43445 {
43456 }
43458 /* OpenMP 3.0:
43459 # pragma omp task task-clause[optseq] new-line
43460 structured-block */
43462 #define OMP_TASK_CLAUSE_MASK \
43463 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43464 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
43465 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
43466 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43467 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43468 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43469 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
43470 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
43471 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
43472 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
43473 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43474 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
43475 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
43476 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
43478 static tree
43480 {
43492 }
43494 /* OpenMP 3.0:
43495 # pragma omp taskwait new-line
43497 OpenMP 5.0:
43498 # pragma omp taskwait taskwait-clause[opt] new-line */
43500 #define OMP_TASKWAIT_CLAUSE_MASK \
43501 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
43503 static void
43505 {
43506 tree clauses
43511 {
43518 }
43519 else
43521 }
43523 /* OpenMP 3.1:
43524 # pragma omp taskyield new-line */
43526 static void
43528 {
43531 }
43533 /* OpenMP 4.0:
43534 # pragma omp taskgroup new-line
43535 structured-block
43537 OpenMP 5.0:
43538 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
43540 #define OMP_TASKGROUP_CLAUSE_MASK \
43541 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43542 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
43544 static tree
43546 {
43547 tree clauses
43552 if_p),
43553 clauses);
43554 }
43557 /* OpenMP 2.5:
43558 # pragma omp threadprivate (variable-list) */
43560 static void
43562 {
43563 tree vars;
43569 }
43571 /* OpenMP 4.0:
43572 # pragma omp cancel cancel-clause[optseq] new-line */
43574 #define OMP_CANCEL_CLAUSE_MASK \
43575 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
43576 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
43577 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
43578 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
43579 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
43581 static void
43583 {
43587 }
43589 /* OpenMP 4.0:
43590 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
43592 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
43593 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
43594 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
43595 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
43596 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
43598 static bool
43601 {
43602 tree clauses;
43606 {
43611 {
43614 }
43615 }
43617 {
43621 }
43624 {
43629 else
43633 }
43636 OMP_CANCELLATION_POINT_CLAUSE_MASK,
43638 pragma_tok);
43641 }
43643 /* OpenMP 4.0:
43644 #pragma omp distribute distribute-clause[optseq] new-line
43645 for-loop */
43647 #define OMP_DISTRIBUTE_CLAUSE_MASK \
43648 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43649 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43650 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43651 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
43652 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43653 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
43654 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
43656 static tree
43660 {
43669 {
43677 else
43680 {
43686 {
43690 else
43693 }
43699 else
43713 }
43714 }
43716 {
43719 }
43724 {
43727 }
43739 }
43741 /* OpenMP 4.0:
43742 # pragma omp teams teams-clause[optseq] new-line
43743 structured-block */
43745 #define OMP_TEAMS_CLAUSE_MASK \
43746 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
43751 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
43752 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43753 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
43755 static tree
43759 {
43768 {
43772 {
43798 }
43800 {
43826 }
43827 }
43829 {
43832 }
43837 {
43840 }
43850 }
43852 /* OpenMP 4.0:
43853 # pragma omp target data target-data-clause[optseq] new-line
43854 structured-block */
43856 #define OMP_TARGET_DATA_CLAUSE_MASK \
43857 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
43858 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
43859 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43860 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
43861 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
43863 static tree
43865 {
43866 tree clauses
43872 {
43875 {
43893 "%<#pragma omp target data%> with map-type other "
43894 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
43898 }
43903 }
43906 {
43909 "%<#pragma omp target data%> must contain at least "
43910 "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
43913 }
43924 }
43926 /* OpenMP 4.5:
43927 # pragma omp target enter data target-enter-data-clause[optseq] new-line
43928 structured-block */
43930 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
43931 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
43932 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
43933 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43934 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
43935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43937 static bool
43940 {
43943 {
43948 {
43951 }
43952 }
43954 {
43958 }
43961 {
43967 }
43969 tree clauses
43975 {
43978 {
43992 "%<#pragma omp target enter data%> with map-type other "
43996 }
43998 }
44001 {
44004 "%<#pragma omp target enter data%> must contain at least "
44007 }
44015 }
44017 /* OpenMP 4.5:
44018 # pragma omp target exit data target-enter-data-clause[optseq] new-line
44019 structured-block */
44021 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
44022 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44023 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44024 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44025 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44026 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44028 static bool
44031 {
44034 {
44039 {
44042 }
44043 }
44045 {
44049 }
44052 {
44058 }
44060 tree clauses
44066 {
44069 {
44084 "%<#pragma omp target exit data%> with map-type other "
44085 "than %<from%>, %<release%> or %<delete%> on %<map%>"
44089 }
44091 }
44094 {
44097 "%<#pragma omp target exit data%> must contain at least "
44100 }
44108 }
44110 /* OpenMP 4.0:
44111 # pragma omp target update target-update-clause[optseq] new-line */
44113 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
44114 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
44115 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
44116 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44117 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44118 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44119 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44121 static bool
44124 {
44126 {
44132 }
44134 tree clauses
44139 {
44141 "%<#pragma omp target update%> must contain at least one "
44144 }
44152 }
44154 /* OpenMP 4.0:
44155 # pragma omp target target-clause[optseq] new-line
44156 structured-block */
44158 #define OMP_TARGET_CLAUSE_MASK \
44159 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44160 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44161 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44162 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44163 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
44164 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
44165 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
44166 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
44167 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44168 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
44169 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
44170 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR))
44172 static bool
44175 {
44177 omp_requires_mask
44181 {
44193 {
44201 {
44202 tree stmt;
44204 {
44207 OMP_TARGET_CLAUSE_MASK,
44212 OMP_TARGET_CLAUSE_MASK,
44217 OMP_TARGET_CLAUSE_MASK,
44222 }
44224 }
44229 {
44233 if_p);
44238 if_p);
44243 if_p);
44247 }
44253 /* For combined target teams, ensure the num_teams and
44254 thread_limit clause expressions are evaluated on the host,
44255 before entering the target construct. */
44264 {
44267 tf_none);
44274 OMP_CLAUSE_FIRSTPRIVATE);
44279 }
44284 }
44286 {
44289 }
44291 {
44295 }
44297 {
44300 }
44302 {
44305 }
44307 {
44310 }
44311 }
44313 {
44316 }
44323 {
44329 }
44338 }
44340 /* OpenACC 2.0:
44341 # pragma acc cache (variable-list) new-line
44342 */
44344 static tree
44346 {
44347 /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
44348 clauses. */
44349 auto_suppress_location_wrappers sentinel;
44365 }
44367 /* OpenACC 2.0:
44368 # pragma acc data oacc-data-clause[optseq] new-line
44369 structured-block */
44371 #define OACC_DATA_CLAUSE_MASK \
44372 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44373 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44374 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44375 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44376 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44377 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
44378 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44379 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44380 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44381 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
44383 static tree
44385 {
44398 }
44400 /* OpenACC 2.0:
44401 # pragma acc host_data <clauses> new-line
44402 structured-block */
44404 #define OACC_HOST_DATA_CLAUSE_MASK \
44405 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
44406 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44407 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
44409 static tree
44411 {
44424 }
44426 /* OpenACC 2.0:
44427 # pragma acc declare oacc-data-clause[optseq] new-line
44428 */
44430 #define OACC_DECLARE_CLAUSE_MASK \
44431 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44432 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44433 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44434 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44435 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44436 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
44437 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
44438 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
44440 static tree
44442 {
44452 {
44456 }
44459 {
44463 {
44467 }
44470 {
44482 {
44484 "%qD must be a global variable in "
44486 decl);
44489 }
44494 {
44498 }
44500 {
44502 "invalid use of %<extern%> variable %qD "
44506 }
44508 {
44510 "invalid use of %<global%> variable %qD "
44514 }
44516 }
44519 /* This seems to ignore the existence of cleanup scopes?
44520 What is the meaning for local extern decls? The local
44521 extern is in this scope, but it is referring to a decl that
44522 is namespace scope. */
44525 {
44528 }
44530 {
44532 "%qD must be a variable declared in the same scope as "
44536 }
44541 {
44546 }
44549 {
44550 tree id;
44553 /* We need to mark the aliased decl, as that is the entity
44554 that is being referred to. This won't work for
44555 dependent variables, but it didn't work for them before
44556 DECL_LOCAL_DECL_P was a thing either. But then
44557 dependent local extern variable decls are as rare as
44558 hen's teeth. */
44565 else
44571 {
44574 {
44577 {
44581 }
44582 }
44583 }
44584 }
44585 }
44598 }
44600 /* OpenACC 2.0:
44601 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
44603 or
44605 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
44607 LOC is the location of the #pragma token.
44608 */
44610 #define OACC_ENTER_DATA_CLAUSE_MASK \
44611 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44612 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44613 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44614 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44615 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44616 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44618 #define OACC_EXIT_DATA_CLAUSE_MASK \
44619 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44620 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44621 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44622 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
44623 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
44624 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
44625 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44627 static tree
44630 {
44639 {
44644 }
44651 else
44656 {
44660 }
44668 }
44670 /* OpenACC 2.0:
44671 # pragma acc loop oacc-loop-clause[optseq] new-line
44672 structured-block */
44674 #define OACC_LOOP_CLAUSE_MASK \
44675 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
44676 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
44677 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
44678 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
44679 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
44680 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
44681 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
44682 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
44683 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
44684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
44686 static tree
44689 {
44698 {
44704 }
44713 }
44715 /* OpenACC 2.0:
44716 # pragma acc kernels oacc-kernels-clause[optseq] new-line
44717 structured-block
44719 or
44721 # pragma acc parallel oacc-parallel-clause[optseq] new-line
44722 structured-block
44724 OpenACC 2.6:
44726 # pragma acc serial oacc-serial-clause[optseq] new-line
44727 */
44729 #define OACC_KERNELS_CLAUSE_MASK \
44730 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44731 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44732 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44733 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44734 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44735 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44736 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
44737 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44738 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44739 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
44741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
44742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
44743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
44744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44746 #define OACC_PARALLEL_CLAUSE_MASK \
44747 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44751 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44752 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44753 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
44754 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44755 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
44756 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44757 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44758 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
44759 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
44760 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
44761 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
44762 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
44763 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
44764 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44766 #define OACC_SERIAL_CLAUSE_MASK \
44767 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44768 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44769 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44770 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44771 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44772 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44773 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
44774 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44775 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44776 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44777 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
44778 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
44779 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
44780 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
44781 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44783 static tree
44786 {
44787 omp_clause_mask mask;
44790 {
44808 }
44811 {
44815 {
44818 tree clauses;
44823 }
44824 }
44833 }
44835 /* OpenACC 2.0:
44836 # pragma acc update oacc-update-clause[optseq] new-line
44837 */
44839 #define OACC_UPDATE_CLAUSE_MASK \
44840 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44841 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
44842 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
44843 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44844 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
44845 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
44847 static tree
44849 {
44856 {
44858 "%<#pragma acc update%> must contain at least one "
44861 }
44869 }
44871 /* OpenACC 2.0:
44872 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
44874 LOC is the location of the #pragma token.
44875 */
44877 #define OACC_WAIT_CLAUSE_MASK \
44878 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
44880 static tree
44882 {
44896 }
44898 /* OpenMP 4.0:
44899 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
44901 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
44902 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
44903 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
44904 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
44905 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
44906 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
44907 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
44909 static void
44913 {
44915 cp_omp_declare_simd_data data;
44917 {
44925 /* It is safe to take the address of a local variable; it will only be
44926 used while this scope is live. */
44928 }
44930 {
44932 "%<#pragma omp declare %s%> followed by "
44937 }
44939 /* Store away all pragma tokens. */
44948 {
44952 {
44965 }
44970 "%<#pragma omp declare %s%> not immediately followed by "
44975 }
44976 }
44988 /* OpenMP 5.0:
44990 trait-selector:
44991 trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
44993 trait-score:
44994 score(score-expression) */
44996 static tree
44998 {
45000 do
45001 {
45002 tree selector;
45006 else
45007 {
45010 }
45021 {
45048 }
45050 {
45052 {
45054 {
45057 }
45058 else
45059 {
45065 }
45066 }
45071 }
45081 {
45083 {
45087 }
45089 matching_parens parens;
45097 {
45104 {
45108 matching_parens parens2;
45116 {
45128 else
45131 }
45132 }
45133 else
45137 }
45140 {
45141 tree t;
45143 do
45144 {
45147 {
45155 "constant integer expression or string "
45157 else
45159 }
45160 else
45165 else
45167 }
45173 {
45177 }
45178 else
45179 {
45182 }
45185 do
45186 {
45190 {
45193 }
45196 else
45197 {
45201 }
45207 else
45209 }
45215 {
45222 else
45224 }
45225 else
45230 {
45232 "selector may not be specified in "
45235 }
45236 properties
45238 OMP_DECLARE_SIMD_CLAUSE_MASK,
45243 }
45249 }
45253 {
45256 }
45262 else
45264 }
45268 }
45270 /* OpenMP 5.0:
45272 trait-set-selector[,trait-set-selector[,...]]
45274 trait-set-selector:
45275 trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
45277 trait-set-selector-name:
45278 constructor
45279 device
45280 implementation
45281 user */
45283 static tree
45286 {
45288 do
45289 {
45292 setp
45295 {
45314 }
45316 {
45320 }
45328 matching_braces braces;
45332 tree selectors
45335 {
45338 }
45346 else
45348 }
45354 }
45356 /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
45357 that into "omp declare variant base" attribute. */
45359 static tree
45361 tree attrs)
45362 {
45363 matching_parens parens;
45365 {
45366 fail:
45369 }
45374 cp_expr varid
45382 tree variant;
45389 else
45390 {
45391 tree ambiguous_decls;
45399 }
45403 {
45405 variant
45413 }
45419 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45430 {
45433 }
45445 {
45447 match_loc);
45456 }
45461 }
45464 /* Finalize #pragma omp declare simd clauses after direct declarator has
45465 been parsed, and put that into "omp declare simd" attribute. */
45467 static tree
45469 {
45475 {
45480 }
45485 {
45496 {
45497 /* For now only in C++ attributes, do it always for OpenMP 5.1.
45498 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45499 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
45500 cp_lexer_consume_token (parser->lexer); */
45504 pragma_tok);
45512 }
45513 else
45514 {
45516 attrs
45518 }
45520 }
45524 {
45530 {
45532 {
45539 {
45547 else
45550 }
45556 {
45558 "unknown OpenMP directive name in "
45561 }
45565 {
45567 "OpenMP directive other than %<declare simd%> "
45568 "or %<declare variant%> appertains to a "
45571 }
45574 {
45576 "mixing OpenMP directives with attribute and "
45579 }
45584 {
45587 }
45589 cp_token tok = {};
45597 tok = {};
45602 tok = {};
45614 /* Move the current source position to that of the first token
45615 in the new lexer. */
45625 {
45633 pragma_tok);
45637 cl);
45642 }
45643 else
45644 {
45646 attrs
45648 attrs);
45649 }
45652 }
45654 }
45655 else
45657 }
45663 }
45665 /* Helper for cp_parser_omp_declare_target, handle one to or link clause
45666 on #pragma omp declare target. Return false if errors were reported. */
45668 static bool
45670 {
45673 tree id;
45675 {
45678 }
45679 else
45682 {
45684 "%qD specified both in declare target %<link%> and %<to%>"
45687 }
45689 {
45696 {
45699 {
45703 }
45704 }
45705 }
45709 {
45713 {
45716 }
45717 }
45719 {
45723 {
45726 }
45727 }
45729 }
45731 /* OpenMP 4.0:
45732 # pragma omp declare target new-line
45733 declarations and definitions
45734 # pragma omp end declare target new-line
45736 OpenMP 4.5:
45737 # pragma omp declare target ( extended-list ) new-line
45739 # pragma omp declare target declare-target-clauses[seq] new-line */
45741 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
45742 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
45743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
45744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE))
45746 static void
45748 {
45753 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45757 clauses
45761 {
45763 clauses);
45766 }
45767 else
45768 {
45769 struct omp_declare_target_attr a
45774 }
45779 {
45792 device_type);
45793 }
45797 }
45799 static void
45801 {
45805 {
45808 }
45810 {
45814 {
45817 }
45820 else
45821 {
45825 }
45826 }
45827 else
45828 {
45832 }
45836 "%<#pragma omp end declare target%> without corresponding "
45838 else
45839 {
45840 omp_declare_target_attr
45843 {
45846 "%<declare target%> in attribute syntax terminated "
45848 else
45850 "%<declare target%> in pragma syntax terminated "
45852 }
45853 }
45854 }
45856 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
45857 expression and optional initializer clause of
45858 #pragma omp declare reduction. We store the expression(s) as
45859 either 3, 6 or 7 special statements inside of the artificial function's
45860 body. The first two statements are DECL_EXPRs for the artificial
45861 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
45862 expression that uses those variables.
45863 If there was any INITIALIZER clause, this is followed by further statements,
45864 the fourth and fifth statements are DECL_EXPRs for the artificial
45865 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
45866 constructor variant (first token after open paren is not omp_priv),
45867 then the sixth statement is a statement with the function call expression
45868 that uses the OMP_PRIV and optionally OMP_ORIG variable.
45869 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
45870 to initialize the OMP_PRIV artificial variable and there is seventh
45871 statement, a DECL_EXPR of the OMP_PRIV statement again. */
45873 static bool
45875 {
45887 tree combiner;
45902 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45910 {
45913 }
45916 {
45918 matching_parens parens;
45924 {
45927 }
45943 {
45947 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
45951 == CPP_CLOSE_PAREN
45954 {
45958 }
45963 }
45964 else
45965 {
45967 /* Don't create location wrapper nodes here. */
45968 auto_suppress_location_wrappers sentinel;
45983 {
45988 }
45990 tree arg;
46003 }
46016 }
46020 UNKNOWN_LOCATION);
46023 }
46025 /* OpenMP 4.0
46026 #pragma omp declare reduction (reduction-id : typename-list : expression) \
46027 initializer-clause[opt] new-line
46029 initializer-clause:
46030 initializer (omp_priv initializer)
46031 initializer (function-name (argument-list)) */
46033 static void
46036 {
46046 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
46053 {
46085 }
46097 /* Types may not be defined in declare reduction type list. */
46100 parser->type_definition_forbidden_message
46106 saved_colon_doesnt_start_class_def_p
46111 {
46115 ;
46133 else
46138 else
46140 }
46142 /* Restore the saved message. */
46145 parser->colon_doesnt_start_class_def_p
46150 {
46151 fail:
46154 }
46160 {
46161 tree fntype
46164 NULL_TREE);
46181 {
46185 }
46191 {
46194 }
46196 {
46198 {
46204 }
46211 }
46212 else
46213 {
46216 /* We should never meet a matched duplicate decl. */
46218 }
46223 else
46226 {
46229 }
46237 else
46238 {
46242 }
46247 {
46255 }
46263 }
46267 done:
46268 /* Free any declarators allocated. */
46270 }
46272 /* OpenMP 4.0
46273 #pragma omp declare simd declare-simd-clauses[optseq] new-line
46274 #pragma omp declare reduction (reduction-id : typename-list : expression) \
46275 initializer-clause[opt] new-line
46276 #pragma omp declare target new-line
46278 OpenMP 5.0
46279 #pragma omp declare variant (identifier) match (context-selector) */
46281 static bool
46284 {
46286 {
46291 {
46296 }
46298 {
46303 }
46306 {
46309 context);
46311 }
46313 {
46316 }
46318 {
46322 }
46323 }
46328 }
46330 /* OpenMP 5.0
46331 #pragma omp requires clauses[optseq] new-line */
46333 static bool
46335 {
46341 {
46342 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46351 {
46366 {
46369 matching_parens parens;
46371 {
46373 {
46378 this_req
46381 this_req
46384 this_req
46386 }
46388 {
46390 "expected %<seq_cst%>, %<relaxed%> or "
46393 {
46400 CPP_CLOSE_PAREN))
46403 }
46404 }
46405 else
46412 /*consume_paren=*/
46416 {
46419 }
46420 }
46422 }
46423 else
46424 {
46426 "%<unified_shared_memory%>, "
46427 "%<dynamic_allocators%>, "
46428 "%<reverse_offload%> "
46432 }
46439 {
46441 {
46448 }
46450 {
46454 }
46457 {
46460 this_req
46462 (omp_requires_mask
46464 }
46468 "lexically after first %<atomic%> construct "
46471 omp_requires_mask
46474 }
46475 }
46477 }
46483 }
46486 /* OpenMP 5.1:
46487 #pragma omp nothing new-line */
46489 static void
46491 {
46493 }
46496 /* OpenMP 5.1
46497 #pragma omp error clauses[optseq] new-line */
46499 static bool
46502 {
46511 {
46512 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46528 };
46536 {
46539 }
46541 {
46546 }
46550 matching_parens parens;
46552 {
46554 {
46558 else
46560 tf_warning_or_error,
46561 LOOKUP_NORMAL);
46562 }
46563 else
46564 {
46566 {
46574 }
46576 {
46581 {
46588 CPP_CLOSE_PAREN))
46591 }
46592 }
46593 else
46595 }
46601 /*consume_paren=*/
46605 {
46607 {
46610 }
46611 else
46613 }
46615 {
46617 {
46620 }
46621 else
46623 }
46624 }
46625 else
46627 }
46637 {
46639 {
46643 }
46644 tree fndecl
46653 }
46660 {
46664 }
46668 else
46672 }
46674 /* OpenMP 4.5:
46675 #pragma omp taskloop taskloop-clause[optseq] new-line
46676 for-loop
46678 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
46679 for-loop */
46681 #define OMP_TASKLOOP_CLAUSE_MASK \
46682 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46683 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46685 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46686 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
46687 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
46688 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
46689 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46690 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
46691 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46692 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
46693 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
46694 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
46695 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
46696 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46697 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46698 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
46700 static tree
46704 {
46711 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
46712 clause. */
46717 {
46722 {
46746 }
46747 }
46749 {
46752 }
46757 {
46760 }
46767 if_p);
46773 }
46776 /* OpenACC 2.0:
46777 # pragma acc routine oacc-routine-clause[optseq] new-line
46778 function-definition
46780 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
46781 */
46783 #define OACC_ROUTINE_CLAUSE_MASK \
46784 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
46785 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
46786 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
46787 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
46788 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
46790 /* Parse the OpenACC routine pragma. This has an optional '( name )'
46791 component, which must resolve to a declared namespace-scope
46792 function. The clauses are either processed directly (for a named
46793 function), or defered until the immediatley following declaration
46794 is parsed. */
46796 static void
46799 {
46801 /* The checking for "another pragma following this one" in the "no optional
46802 '( name )'" case makes sure that we dont re-enter. */
46805 cp_oacc_routine_data data;
46811 /* It is safe to take the address of a local variable; it will only be
46812 used while this scope is live. */
46815 /* Look for optional '( name )'. */
46817 {
46818 matching_parens parens;
46821 /* We parse the name as an id-expression. If it resolves to
46822 anything other than a non-overloaded function at namespace
46823 scope, it's an error. */
46839 {
46843 }
46845 data.clauses
46849 /* The clauses are in reverse order; fix that to make later diagnostic
46850 emission easier. */
46856 {
46861 }
46863 /* Perhaps we should use the same rule as declarations in different
46864 namespaces? */
46866 {
46871 }
46874 {
46878 }
46882 }
46884 {
46885 /* Store away all pragma tokens. */
46893 /* Emit a helpful diagnostic if there's another pragma following this
46894 one. */
46896 {
46899 /* ..., and then just keep going. */
46901 }
46903 /* We only have to consider the pragma_external case here. */
46908 else
46911 }
46912 }
46914 /* Finalize #pragma acc routine clauses after direct declarator has
46915 been parsed. */
46917 static tree
46919 {
46924 {
46926 "%<#pragma acc routine%> not immediately followed by "
46929 }
46945 /* The clauses are in reverse order; fix that to make later diagnostic
46946 emission easier. */
46949 /* Later, cp_finalize_oacc_routine will process the clauses. */
46953 }
46955 /* Apply any saved OpenACC routine clauses to a just-parsed
46956 declaration. */
46958 static void
46960 {
46962 {
46963 /* Keep going if we're in error reporting mode. */
46969 {
46971 {
46973 "%<#pragma acc routine%> not immediately followed by"
46977 }
46981 }
46983 int compatible
46988 {
46991 }
46993 {
46994 }
46995 else
46996 {
46998 {
47007 }
47009 /* Set the routine's level of parallelism. */
47013 /* Add an "omp declare target" attribute. */
47018 }
47019 }
47020 }
47022 /* Main entry point to OpenMP statement pragmas. */
47024 static void
47026 {
47027 tree stmt;
47032 {
47060 if_p);
47080 if_p);
47085 if_p);
47090 if_p);
47095 if_p);
47100 if_p);
47105 if_p);
47117 if_p);
47131 if_p);
47136 if_p);
47140 }
47143 }
47144 \f
47145 /* Transactional Memory parsing routines. */
47147 /* Parse a transaction attribute.
47149 txn-attribute:
47150 attribute
47151 [ [ identifier ] ]
47153 We use this instead of cp_parser_attributes_opt for transactions to avoid
47154 the pedwarn in C++98 mode. */
47156 static tree
47158 {
47173 {
47177 /* For keywords, use the canonical spelling,
47178 not the parsed identifier. */
47182 }
47183 else
47187 error1:
47190 }
47192 /* Parse a __transaction_atomic or __transaction_relaxed statement.
47194 transaction-statement:
47195 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
47196 compound-statement
47197 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
47198 */
47200 static tree
47202 {
47213 else
47214 {
47218 }
47220 /* Parse a noexcept specification. */
47224 {
47225 /* cancel-and-throw is unimplemented. */
47228 }
47229 else
47231 CP_PARSER_FLAGS_NONE,
47236 /* Keep track if we're in the lexical scope of an outer transaction. */
47248 }
47250 /* Parse a __transaction_atomic or __transaction_relaxed expression.
47252 transaction-expression:
47253 __transaction_atomic txn-noexcept-spec[opt] ( expression )
47254 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
47255 */
47257 static tree
47259 {
47272 keyword == RID_TRANSACTION_RELAXED
47286 /* Set this early. This might mean that we allow transaction_cancel in
47287 an expression that we find out later actually has to be a constexpr.
47288 However, we expect that cxx_constant_value will be able to deal with
47289 this; also, if the noexcept has no constexpr, then what we parse next
47290 really is a transaction's body. */
47293 /* Parse a noexcept specification. */
47295 CP_PARSER_FLAGS_NONE,
47302 {
47303 matching_parens parens;
47310 }
47311 else
47312 {
47313 /* The only expression that is available got parsed for the noexcept
47314 already. noexcept is true then. */
47317 }
47326 }
47328 /* Parse a function-transaction-block.
47330 function-transaction-block:
47331 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
47332 function-body
47333 __transaction_atomic txn-attribute[opt] function-try-block
47334 __transaction_relaxed ctor-initializer[opt] function-body
47335 __transaction_relaxed function-try-block
47336 */
47338 static void
47340 {
47355 else
47356 {
47360 }
47368 else
47369 cp_parser_ctor_initializer_opt_and_function_body
47375 }
47377 /* Parse a __transaction_cancel statement.
47379 cancel-statement:
47380 __transaction_cancel txn-attribute[opt] ;
47381 __transaction_cancel txn-attribute[opt] throw-expression ;
47383 ??? Cancel and throw is not yet implemented. */
47385 static tree
47387 {
47393 RT_TRANSACTION_CANCEL);
47400 /* ??? Parse cancel-and-throw here. */
47405 {
47409 }
47411 {
47415 }
47417 {
47420 {
47426 }
47427 }
47429 {
47433 }
47439 }
47440 \f
47441 /* The parser. */
47445 \f
47446 /* Special handling for the first token or line in the file. The first
47447 thing in the file might be #pragma GCC pch_preprocess, which loads a
47448 PCH file, which is a GC collection point. So we need to handle this
47449 first pragma without benefit of an existing lexer structure.
47451 Always returns one token to the caller in *FIRST_TOKEN. This is
47452 either the true first token of the file, or the first token after
47453 the initial pragma. */
47455 static void
47457 {
47465 {
47469 }
47471 /* Skip to the end of the pragma. */
47473 {
47476 do
47479 }
47481 /* Now actually load the PCH file. */
47485 /* Read one more token to return to our caller. We have to do this
47486 after reading the PCH file in, since its pointers have to be
47487 live. */
47489 }
47491 /* Parse a pragma GCC ivdep. */
47493 static bool
47495 {
47498 }
47500 /* Parse a pragma GCC unroll. */
47502 static unsigned short
47504 {
47514 {
47516 " assignment-expression that evaluates to a non-negative"
47519 }
47520 else
47521 {
47525 }
47528 }
47530 /* Normal parsing of a pragma token. Here we can (and must) use the
47531 regular lexer. */
47533 static bool
47535 {
47538 tree stmt;
47549 {
47557 {
47568 }
47573 {
47584 }
47589 {
47600 }
47605 {
47617 }
47622 {
47634 }
47639 {
47651 }
47670 {
47676 }
47684 {
47690 }
47698 {
47703 }
47709 {
47715 }
47723 {
47729 }
47770 {
47772 "%<#pragma omp requires%> may only be used at file or "
47776 }
47808 "%<#pragma omp scan%> may only be used in "
47814 "%<#pragma omp section%> may only be used in "
47819 {
47821 {
47825 }
47831 {
47835 }
47836 else
47842 {
47845 }
47848 }
47851 {
47853 {
47857 }
47858 const unsigned short unroll
47864 {
47868 }
47869 else
47875 {
47878 }
47881 }
47888 bad_stmt:
47891 }
47895 }
47897 /* The interface the pragma parsers have to the lexer. */
47899 enum cpp_ttype
47901 {
47913 else
47914 {
47918 }
47921 }
47923 \f
47924 /* External interface. */
47926 /* Parse one entire translation unit. */
47928 void
47930 {
47938 /* cp_lexer_new_main is called before doing any GC allocation
47939 because tokenization might load a PCH file. */
47950 }
47952 /* Create an identifier for a generic parameter type (a synthesized
47953 template parameter implied by `auto' or a concept identifier). */
47956 static tree
47958 {
47962 }
47964 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
47965 (creating a new template parameter list if necessary). Returns the newly
47966 created template type parm. */
47968 static tree
47970 {
47971 /* A requires-clause is not a function and cannot have placeholders. */
47973 {
47976 }
47980 /* We are either continuing a function template that already contains implicit
47981 template parameters, creating a new fully-implicit function template, or
47982 extending an existing explicit function template with implicit template
47983 parameters. */
47991 {
47995 }
47996 else
47997 {
47998 /* Roll back to the existing template parameter scope (in the case of
47999 extending an explicit function template) or introduce a new template
48000 parameter scope ahead of the function parameter scope (or class scope
48001 in the case of out-of-line member definitions). The function scope is
48002 added back after template parameter synthesis below. */
48007 {
48010 }
48012 {
48013 /* If not defining a class, then any class scope is a scope level in
48014 an out-of-line member definition. In this case simply wind back
48015 beyond the first such scope to inject the template parameter list.
48016 Otherwise wind back to the class being defined. The latter can
48017 occur in class member friend declarations such as:
48019 class A {
48020 void foo (auto);
48021 };
48022 class B {
48023 friend void A::foo (auto);
48024 };
48026 The template parameter list synthesized for the friend declaration
48027 must be injected in the scope of 'B'. This can also occur in
48028 erroneous cases such as:
48030 struct A {
48031 struct B {
48032 void foo (auto);
48033 };
48034 void B::foo (auto) {}
48035 };
48037 Here the attempted definition of 'B::foo' within 'A' is ill-formed
48038 but, nevertheless, the template parameter list synthesized for the
48039 declarator should be injected into the scope of 'A' as if the
48040 ill-formed template was specified explicitly. */
48043 {
48046 }
48047 }
48053 {
48054 /* Introduce a new template parameter list for implicit template
48055 parameters. */
48059 parser->implicit_template_scope
48066 }
48067 else
48068 {
48069 /* Synthesize implicit template parameters at the end of the explicit
48070 template parameter list. */
48077 parser->implicit_template_parms
48079 }
48080 }
48082 /* Synthesize a new template parameter and track the current template
48083 parameter chain with implicit_template_parms. */
48087 tree synth_tmpl_parm;
48090 /* Synthesize the type template parameter. */
48098 /* Attach the constraint to the parm before processing. */
48101 tree new_parm
48103 input_location,
48104 node,
48108 /* Mark the synthetic declaration "virtual". This is used when
48109 comparing template-heads to determine if whether an abbreviated
48110 function template is equivalent to an explicit template.
48112 Note that DECL_ARTIFICIAL is used elsewhere for template parameters. */
48115 // Chain the new parameter to the list of implicit parameters.
48117 parser->implicit_template_parms
48119 else
48124 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
48127 /* If creating a fully implicit function template, start the new implicit
48128 template parameter list with this synthesized type, otherwise grow the
48129 current template parameter list. */
48132 {
48138 }
48139 else
48140 {
48145 }
48147 /* If the new parameter was constrained, we need to add that to the
48148 constraints in the template parameter list. */
48150 {
48154 }
48159 }
48161 /* Finish the declaration of a fully implicit function template. Such a
48162 template has no explicit template parameter list so has not been through the
48163 normal template head and tail processing. synthesize_implicit_template_parm
48164 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
48165 provided if the declaration is a class member such that its template
48166 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
48167 form is returned. Otherwise NULL_TREE is returned. */
48169 static tree
48171 {
48176 {
48180 }
48192 }
48194 /* Like finish_fully_implicit_template, but to be used in error
48195 recovery, rearranging scopes so that we restore the state we had
48196 before synthesize_implicit_template_parm inserted the implement
48197 template parms scope. */
48199 static void
48201 {
48206 {
48215 }
48216 else
48222 }
48224 /* Helper function for diagnostics that have complained about things
48225 being used with 'extern "C"' linkage.
48227 Attempt to issue a note showing where the 'extern "C"' linkage began. */
48229 void
48231 {
48235 }