| blob | 0bd585257261b0abbd917be193118b0bc5c76b26 |
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_UNIQUE_PTR
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 }
7896 /* We should never get here. */
7899 }
7901 /* Helper function for cp_parser_parenthesized_expression_list and
7902 cp_parser_postfix_open_square_expression. Parse a single element
7903 of parenthesized expression list. */
7905 static cp_expr
7910 {
7914 /* Parse the next assignment-expression. */
7916 {
7917 /* A braced-init-list. */
7923 }
7925 {
7931 }
7932 else
7938 /* If we have an ellipsis, then this is an expression expansion. */
7941 {
7942 /* Consume the `...'. */
7945 /* Build the argument pack. */
7947 }
7949 }
7951 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
7952 by cp_parser_builtin_offsetof. We're looking for
7954 postfix-expression [ expression ]
7955 postfix-expression [ braced-init-list ] (C++11)
7956 postfix-expression [ expression-list[opt] ] (C++23)
7958 FOR_OFFSETOF is set if we're being called in that context, which
7959 changes how we deal with integer constant expressions. */
7961 static tree
7963 tree postfix_expression,
7966 {
7972 /* Consume the `[' token. */
7978 /* Parse the index expression. */
7979 /* ??? For offsetof, there is a question of what to allow here. If
7980 offsetof is not being used in an integral constant expression context,
7981 then we *could* get the right answer by computing the value at runtime.
7982 If we are in an integral constant expression context, then we might
7983 could accept any constant expression; hard to say without analysis.
7984 Rather than open the barn door too wide right away, allow only integer
7985 constant expressions here. */
7988 else
7989 {
7994 {
7996 {
7997 cp_expr expr
7999 /*cast_p=*/
8001 /*allow_exp_p=*/
8003 /*fold_expr_p=*/
8005 /*non_cst_p=*/
8006 NULL);
8013 else
8016 /* If the next token isn't a `,', then we are done. */
8021 {
8024 }
8026 /* Otherwise, consume the `,' and keep going. */
8028 }
8031 }
8033 {
8038 }
8039 else
8043 }
8047 /* Look for the closing `]'. */
8050 /* Build the ARRAY_REF. */
8053 tf_warning_or_error
8056 /* When not doing offsetof, array references are not permitted in
8057 constant-expressions. */
8063 }
8065 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8066 dereference of incomplete type, returns true if error_mark_node should
8067 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8068 and *DEPENDENT_P. */
8070 bool
8073 {
8074 /* In a template, be permissive by treating an object expression
8075 of incomplete type as dependent (after a pedwarn). */
8076 diagnostic_t kind = (processing_template_decl
8080 {
8092 /* Don't emit any diagnostic for OVERLOADs. */
8096 /* Avoid clobbering e.g. DECLs. */
8100 }
8112 {
8115 }
8117 }
8119 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8120 by cp_parser_builtin_offsetof. We're looking for
8122 postfix-expression . template [opt] id-expression
8123 postfix-expression . pseudo-destructor-name
8124 postfix-expression -> template [opt] id-expression
8125 postfix-expression -> pseudo-destructor-name
8127 FOR_OFFSETOF is set if we're being called in that context. That sorta
8128 limits what of the above we'll actually accept, but nevermind.
8129 TOKEN_TYPE is the "." or "->" token, which will already have been
8130 removed from the stream. */
8132 static tree
8135 cp_expr postfix_expression,
8137 location_t location)
8138 {
8139 tree name;
8145 /* If this is a `->' operator, dereference the pointer. */
8148 tf_warning_or_error);
8149 /* Check to see whether or not the expression is type-dependent and
8150 not the current instantiation. */
8152 /* The identifier following the `->' or `.' is not qualified. */
8158 /* Enter the scope corresponding to the type of the object
8159 given by the POSTFIX_EXPRESSION. */
8161 {
8163 /* According to the standard, no expression should ever have
8164 reference type. Unfortunately, we do not currently match
8165 the standard in this respect in that our internal representation
8166 of an expression may have reference type even when the standard
8167 says it does not. Therefore, we have to manually obtain the
8168 underlying type here. */
8170 /* The type of the POSTFIX_EXPRESSION must be complete. */
8171 /* Unlike the object expression in other contexts, *this is not
8172 required to be of complete type for purposes of class member
8173 access (5.2.5) outside the member function body. */
8177 {
8183 }
8186 {
8187 /* Let the name lookup machinery know that we are processing a
8188 class member access expression. */
8190 /* If something went wrong, we want to be able to discern that case,
8191 as opposed to the case where there was no SCOPE due to the type
8192 of expression being dependent. */
8195 /* If the SCOPE was erroneous, make the various semantic analysis
8196 functions exit quickly -- and without issuing additional error
8197 messages. */
8200 }
8201 }
8204 {
8206 /* If we don't have a (type-dependent) object of class type, use
8207 typeof to figure out the type of the object. */
8211 }
8213 /* Assume this expression is not a pseudo-destructor access. */
8216 /* If the SCOPE is a scalar type, then, if this is a valid program,
8217 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8218 is type dependent, it can be pseudo-destructor-name or something else.
8219 Try to parse it as pseudo-destructor-name first. */
8221 {
8222 tree s;
8223 tree type;
8226 /* Parse the pseudo-destructor-name. */
8235 {
8237 postfix_expression
8240 }
8241 }
8244 {
8245 /* If the SCOPE is not a scalar type, we are looking at an
8246 ordinary class member access expression, rather than a
8247 pseudo-destructor-name. */
8250 /* Parse the id-expression. */
8251 name = (cp_parser_id_expression
8258 /* In general, build a SCOPE_REF if the member name is qualified.
8259 However, if the name was not dependent and has already been
8260 resolved; there is no need to build the SCOPE_REF. For example;
8262 struct X { void f(); };
8263 template <typename T> void f(T* t) { t->X::f(); }
8265 Even though "t" is dependent, "X::f" is not and has been resolved
8266 to a BASELINK; there is no need to include scope information. */
8268 /* But we do need to remember that there was an explicit scope for
8269 virtual function calls. */
8273 /* If the name is a template-id that names a type, we will get a
8274 TYPE_DECL here. That is invalid code. */
8276 {
8279 }
8280 else
8281 {
8283 {
8285 {
8289 }
8290 else
8293 name,
8294 template_p);
8298 }
8300 adjust_result_of_qualified_name_lookup
8302 postfix_expression
8304 template_p,
8305 tf_warning_or_error);
8306 /* Build a location e.g.:
8307 ptr->access_expr
8308 ~~~^~~~~~~~~~~~~
8309 where the caret is at the deref token, ranging from
8310 the start of postfix_expression to the end of the access expr. */
8311 location_t combined_loc
8314 }
8315 }
8317 /* We no longer need to look up names in the scope of the object on
8318 the left-hand side of the `.' or `->' operator. */
8321 /* Outside of offsetof, these operators may not appear in
8322 constant-expressions. */
8324 && (cp_parser_non_integral_constant_expression
8329 }
8331 /* Parse a parenthesized expression-list.
8333 expression-list:
8334 assignment-expression
8335 expression-list, assignment-expression
8337 attribute-list:
8338 expression-list
8339 identifier
8340 identifier, expression-list
8342 CAST_P is true if this expression is the target of a cast.
8344 ALLOW_EXPANSION_P is true if this expression allows expansion of an
8345 argument pack.
8347 WRAP_LOCATIONS_P is true if expressions within this list for which
8348 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8349 their source locations.
8351 Returns a vector of trees. Each element is a representation of an
8352 assignment-expression. NULL is returned if the ( and or ) are
8353 missing. An empty, but allocated, vector is returned on no
8354 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8355 if we are parsing an attribute list for an attribute that wants a
8356 plain identifier argument, normal_attr for an attribute that wants
8357 an expression, or non_attr if we aren't parsing an attribute list. If
8358 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8359 not all of the expressions in the list were constant.
8360 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8361 will be written to with the location of the closing parenthesis. If
8362 an error occurs, it may or may not be written to. */
8372 {
8378 /* Assume all the expressions will be constant. */
8382 matching_parens parens;
8388 /* Within a parenthesized expression, a `>' token is always
8389 the greater-than operator. */
8390 saved_greater_than_is_operator_p
8396 /* Consume expressions until there are no more. */
8399 {
8400 /* At the beginning of attribute lists, check to see if the
8401 next token is an identifier. */
8404 {
8407 /* Consume the identifier. */
8409 /* Save the identifier. */
8411 }
8412 else
8413 {
8414 expr
8416 allow_expansion_p,
8417 fold_expr_p,
8418 non_constant_p);
8423 /* Add it to the list. We add error_mark_node
8424 expressions to the list, so that we can still tell if
8425 the correct form for a parenthesized expression-list
8426 is found. That gives better errors. */
8431 }
8433 /* After the first item, attribute lists look the same as
8434 expression lists. */
8437 get_comma:;
8438 /* If the next token isn't a `,', then we are done. */
8442 /* Otherwise, consume the `,' and keep going. */
8444 }
8450 {
8453 skip_comma:;
8454 /* We try and resync to an unnested comma, as that will give the
8455 user better diagnostics. */
8463 {
8464 parser->greater_than_is_operator_p
8467 }
8468 }
8470 parser->greater_than_is_operator_p
8477 }
8479 /* Parse a pseudo-destructor-name.
8481 pseudo-destructor-name:
8482 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
8483 :: [opt] nested-name-specifier template template-id :: ~ type-name
8484 :: [opt] nested-name-specifier [opt] ~ type-name
8486 If either of the first two productions is used, sets *SCOPE to the
8487 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
8488 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
8489 or ERROR_MARK_NODE if the parse fails. */
8491 static void
8493 tree object,
8496 {
8499 /* Handle ~auto. */
8503 {
8506 "%<~auto%> only available with "
8513 }
8515 /* Assume that things will not work out. */
8518 /* Look for the optional `::' operator. */
8520 /* Look for the optional nested-name-specifier. */
8521 nested_name_specifier_p
8528 /* Now, if we saw a nested-name-specifier, we might be doing the
8529 second production. */
8532 {
8533 /* Consume the `template' keyword. */
8535 /* Parse the template-id. */
8539 class_type,
8541 /* Look for the `::' token. */
8543 }
8544 /* If the next token is not a `~', then there might be some
8545 additional qualification. */
8547 {
8548 /* At this point, we're looking for "type-name :: ~". The type-name
8549 must not be a class-name, since this is a pseudo-destructor. So,
8550 it must be either an enum-name, or a typedef-name -- both of which
8551 are just identifiers. So, we peek ahead to check that the "::"
8552 and "~" tokens are present; if they are not, then we can avoid
8553 calling type_name. */
8557 {
8560 }
8562 /* Look for the type-name. */
8567 /* Look for the `::' token. */
8569 }
8570 else
8573 /* Look for the `~'. */
8576 /* Once we see the ~, this has to be a pseudo-destructor. */
8580 /* Look for the type-name again. We are not responsible for
8581 checking that it matches the first type-name. */
8583 }
8585 /* Parse a unary-expression.
8587 unary-expression:
8588 postfix-expression
8589 ++ cast-expression
8590 -- cast-expression
8591 await-expression
8592 unary-operator cast-expression
8593 sizeof unary-expression
8594 sizeof ( type-id )
8595 alignof ( type-id ) [C++0x]
8596 new-expression
8597 delete-expression
8599 GNU Extensions:
8601 unary-expression:
8602 __extension__ cast-expression
8603 __alignof__ unary-expression
8604 __alignof__ ( type-id )
8605 alignof unary-expression [C++0x]
8606 __real__ cast-expression
8607 __imag__ cast-expression
8608 && identifier
8609 sizeof ( type-id ) { initializer-list , [opt] }
8610 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
8611 __alignof__ ( type-id ) { initializer-list , [opt] }
8613 ADDRESS_P is true iff the unary-expression is appearing as the
8614 operand of the `&' operator. CAST_P is true if this expression is
8615 the target of a cast.
8617 Returns a representation of the expression. */
8619 static cp_expr
8622 {
8626 /* Peek at the next token. */
8628 /* Some keywords give away the kind of expression. */
8630 {
8634 {
8637 {
8645 /* Consume the token. */
8647 /* Parse the operand. */
8650 /* Construct a location e.g. :
8651 alignof (expr)
8652 ^~~~~~~~~~~~~~
8653 with start == caret at the start of the "alignof"/"sizeof"
8654 token, with the endpoint at the final closing paren. */
8655 location_t compound_loc
8661 else
8662 {
8663 /* ISO C++ defines alignof only with types, not with
8664 expressions. So pedwarn if alignof is used with a non-
8665 type expression. However, __alignof__ is ok. */
8668 "ISO C++ does not allow %<alignof%> "
8673 }
8674 /* For SIZEOF_EXPR, just issue diagnostics, but keep
8675 SIZEOF_EXPR with the original operand. */
8677 {
8679 {
8681 {
8684 error_mark_node));
8686 }
8687 else
8692 }
8693 }
8698 }
8710 {
8711 /* The saved value of the PEDANTIC flag. */
8713 tree expr;
8715 /* Save away the PEDANTIC flag. */
8717 /* Parse the cast-expression. */
8719 /* Restore the PEDANTIC flag. */
8723 }
8727 {
8728 tree expression;
8730 /* Consume the `__real__' or `__imag__' token. */
8732 /* Parse the cast-expression. */
8734 /* Create the complete representation. */
8738 expression,
8739 tf_warning_or_error);
8740 }
8748 {
8749 tree expr;
8758 matching_parens parens;
8762 parser->type_definition_forbidden_message
8765 saved_integral_constant_expression_p
8767 saved_non_integral_constant_expression_p
8771 saved_greater_than_is_operator_p
8783 parser->greater_than_is_operator_p
8786 parser->integral_constant_expression_p
8788 parser->non_integral_constant_expression_p
8795 /* Construct a location of the form:
8796 noexcept (expr)
8797 ^~~~~~~~~~~~~~~
8798 with start == caret, finishing at the close-paren. */
8799 location_t noexcept_loc
8803 noexcept_loc);
8804 }
8807 {
8808 tree expr;
8811 /* Consume the `co_await' token. */
8813 /* Parse its cast-expression. */
8818 /* Handle [expr.await]. */
8820 }
8824 }
8825 }
8827 /* Look for the `:: new' and `:: delete', which also signal the
8828 beginning of a new-expression, or delete-expression,
8829 respectively. If the next token is `::', then it might be one of
8830 these. */
8832 {
8835 /* See if the token after the `::' is one of the keywords in
8836 which we're interested. */
8838 /* If it's `new', we have a new-expression. */
8841 /* Similarly, for `delete'. */
8844 }
8846 /* Look for a unary operator. */
8848 /* The `++' and `--' operators can be handled similarly, even though
8849 they are not technically unary-operators in the grammar. */
8851 {
8856 /* Handle the GNU address-of-label extension. */
8859 {
8860 tree identifier;
8861 tree expression;
8864 /* Consume the '&&' token. */
8866 /* Look for the identifier. */
8868 /* Construct a location of the form:
8869 &&label
8870 ^~~~~~~
8871 with caret==start at the "&&", finish at the end of the label. */
8872 location_t combined_loc
8874 /* Create an expression representing the address. */
8877 NIC_ADDR_LABEL))
8880 }
8881 }
8883 {
8884 cp_expr cast_expression;
8890 /* Consume the operator token. */
8894 /* Parse the cast-expression. */
8895 cast_expression
8900 pidk);
8902 /* Make a location:
8903 OP_TOKEN CAST_EXPRESSION
8904 ^~~~~~~~~~~~~~~~~~~~~~~~~
8905 with start==caret at the operator token, and
8906 extending to the end of the cast_expression. */
8909 /* Now, build an appropriate representation. */
8911 {
8915 RO_UNARY_STAR,
8916 complain);
8917 /* TODO: build_x_indirect_ref does not always honor the
8918 location, so ensure it is set. */
8924 /* Fall through. */
8927 cast_expression,
8928 complain);
8929 /* TODO: build_x_unary_op does not always honor the location,
8930 so ensure it is set. */
8938 /* Fall through. */
8940 /* Immediately fold negation of a constant, unless the constant is 0
8941 (since -0 == 0) or it would overflow. */
8943 {
8944 tree stripped_expr
8949 {
8952 stripped_expr);
8954 {
8957 }
8958 }
8959 }
8960 /* Fall through. */
8969 }
8973 non_constant_p))
8977 }
8981 decltype_p,
8982 pidk);
8983 }
8985 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
8986 unary-operator, the corresponding tree code is returned. */
8988 static enum tree_code
8990 {
8992 {
9013 }
9014 }
9016 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9017 Returns a representation of the expression. */
9019 static tree
9021 {
9024 /* Consume the __builtin_has_attribute token. */
9027 matching_parens parens;
9031 /* Types cannot be defined in a `sizeof' expression. Save away the
9032 old message. */
9036 parser->type_definition_forbidden_message
9038 parser->type_definition_forbidden_message_arg
9041 /* The restrictions on constant-expressions do not apply inside
9042 sizeof expressions. */
9043 bool saved_integral_constant_expression_p
9045 bool saved_non_integral_constant_expression_p
9049 /* Do not actually evaluate the expression. */
9055 /* We can't be sure yet whether we're looking at a type-id or an
9056 expression. */
9061 /* Look for the type-id. */
9067 /* If the type-id production did not work out, then we must be
9068 looking at an expression. */
9074 /* Go back to evaluating expressions. */
9078 /* And restore the old one. */
9081 parser->integral_constant_expression_p
9083 parser->non_integral_constant_expression_p
9086 /* Consume the comma if it's there. */
9088 {
9092 }
9094 /* Parse the attribute specification. */
9098 {
9104 else
9105 {
9106 /* Fold constant expressions used in attributes first. */
9109 /* Finally, see if OPER has been declared with ATTR. */
9111 }
9114 }
9115 else
9116 {
9119 }
9121 /* Construct a location e.g. :
9122 __builtin_has_attribute (oper, attr)
9123 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9124 with start == caret at the start of the built-in token,
9125 and with the endpoint at the final closing paren. */
9126 location_t compound_loc
9133 }
9135 /* Parse a new-expression.
9137 new-expression:
9138 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9139 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9141 Returns a representation of the expression. */
9143 static tree
9145 {
9148 tree type;
9151 tree ret;
9155 /* Look for the optional `::' operator. */
9156 global_scope_p
9160 /* Look for the `new' operator. */
9162 /* There's no easy way to tell a new-placement from the
9163 `( type-id )' construct. */
9165 /* Look for a new-placement. */
9167 /* If that didn't work out, there's no new-placement. */
9169 {
9173 }
9175 /* If the next token is a `(', then we have a parenthesized
9176 type-id. */
9178 {
9182 /* Consume the `('. */
9183 matching_parens parens;
9186 /* Parse the type-id. */
9187 parser->type_definition_forbidden_message
9189 {
9192 }
9195 /* Look for the closing `)'. */
9198 /* There should not be a direct-new-declarator in this production,
9199 but GCC used to allowed this, so we check and emit a sensible error
9200 message for this case. */
9202 {
9208 }
9209 }
9210 /* Otherwise, there must be a new-type-id. */
9211 else
9214 /* If the next token is a `(' or '{', then we have a new-initializer. */
9219 else
9222 /* A new-expression may not appear in an integral constant
9223 expression. */
9226 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9227 of a new-type-id or type-id of a new-expression, the new-expression shall
9228 contain a new-initializer of the form ( assignment-expression )".
9229 Additionally, consistently with the spirit of DR 1467, we want to accept
9230 'new auto { 2 }' too. */
9236 {
9238 "initialization of new-expression for type %<auto%> "
9241 }
9242 else
9243 {
9244 /* Construct a location e.g.:
9245 ptr = new int[100]
9246 ^~~~~~~~~~~~
9247 with caret == start at the start of the "new" token, and the end
9248 at the end of the final token we consumed. */
9251 /* Create a representation of the new-expression. */
9254 }
9262 }
9264 /* Parse a new-placement.
9266 new-placement:
9267 ( expression-list )
9269 Returns the same representation as for an expression-list. */
9273 {
9276 /* Parse the expression-list. */
9277 expression_list = (cp_parser_parenthesized_expression_list
9286 }
9288 /* Parse a new-type-id.
9290 new-type-id:
9291 type-specifier-seq new-declarator [opt]
9293 Returns the TYPE allocated. If the new-type-id indicates an array
9294 type, *NELTS is set to the number of elements in the last array
9295 bound; the TYPE will not include the last array bound. */
9297 static tree
9299 {
9300 cp_decl_specifier_seq type_specifier_seq;
9306 /* The type-specifier sequence must not contain type definitions.
9307 (It cannot contain declarations of new types either, but if they
9308 are not definitions we will catch that because they are not
9309 complete.) */
9311 parser->type_definition_forbidden_message
9313 /* Parse the type-specifier-seq. */
9318 /* Restore the old message. */
9324 /* Parse the new-declarator. */
9327 /* Determine the number of elements in the last array dimension, if
9328 any. */
9330 /* Skip down to the last array dimension. */
9335 {
9338 }
9343 {
9346 }
9349 {
9358 else
9360 }
9363 }
9365 /* Parse an (optional) new-declarator.
9367 new-declarator:
9368 ptr-operator new-declarator [opt]
9369 direct-new-declarator
9371 Returns the declarator. */
9375 {
9378 cp_cv_quals cv_quals;
9380 /* We don't know if there's a ptr-operator next, or not. */
9382 /* Look for a ptr-operator. */
9384 /* If that worked, look for more new-declarators. */
9386 {
9389 /* Parse another optional declarator. */
9392 declarator = cp_parser_make_indirect_declarator
9396 }
9398 /* If the next token is a `[', there is a direct-new-declarator. */
9403 }
9405 /* Parse a direct-new-declarator.
9407 direct-new-declarator:
9408 [ expression ]
9409 direct-new-declarator [constant-expression]
9411 */
9415 {
9420 {
9421 tree expression;
9424 /* Look for the opening `['. */
9430 else
9432 /* The standard requires that the expression have integral
9433 type. DR 74 adds enumeration types. We believe that the
9434 real intent is that these expressions be handled like the
9435 expression in a `switch' condition, which also allows
9436 classes with a single conversion to integral or
9437 enumeration type. */
9439 {
9440 expression
9442 expression,
9445 {
9447 "expression in new-declarator must have integral "
9450 }
9451 }
9453 /* Look for the closing `]'. */
9456 /* Add this bound to the declarator. */
9459 /* If the next token is not a `[', then there are no more
9460 bounds. */
9464 }
9467 }
9469 /* Parse a new-initializer.
9471 new-initializer:
9472 ( expression-list [opt] )
9473 braced-init-list
9475 Returns a representation of the expression-list. */
9479 {
9483 {
9484 tree t;
9491 }
9492 else
9493 expression_list = (cp_parser_parenthesized_expression_list
9499 }
9501 /* Parse a delete-expression.
9503 delete-expression:
9504 :: [opt] delete cast-expression
9505 :: [opt] delete [ ] cast-expression
9507 Returns a representation of the expression. */
9509 static tree
9511 {
9514 tree expression;
9517 /* Look for the optional `::' operator. */
9518 global_scope_p
9522 /* Look for the `delete' keyword. */
9524 /* See if the array syntax is in use. */
9526 {
9527 /* Consume the `[' token. */
9529 /* Look for the `]' token. */
9531 /* Remember that this is the `[]' construct. */
9533 }
9534 else
9537 /* Parse the cast-expression. */
9540 /* A delete-expression may not appear in an integral constant
9541 expression. */
9545 /* Construct a location e.g.:
9546 delete [ ] ptr
9547 ^~~~~~~~~~~~~~
9548 with caret == start at the start of the "delete" token, and
9549 the end at the end of the final token we consumed. */
9556 }
9558 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9559 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9560 0 otherwise. */
9562 static int
9564 {
9567 {
9609 /* In ((type ()) () the last () isn't a valid cast-expression,
9610 so the whole must be parsed as postfix-expression. */
9615 /* '[' may start a primary-expression in obj-c++ and in C++11,
9616 as a lambda-expression, eg, '(void)[]{}'. */
9623 /* '++' and '--' may or may not start a cast-expression:
9625 struct T { void operator++(int); };
9626 void f() { (T())++; }
9628 vs
9630 int a;
9631 (int)++a; */
9636 }
9637 }
9639 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
9640 in the order: const_cast, static_cast, reinterpret_cast.
9642 Don't suggest dynamic_cast.
9644 Return the first legal cast kind found, or NULL otherwise. */
9648 {
9649 tree trial;
9651 /* Reuse the parser logic by attempting to build the various kinds of
9652 cast, with "complain" disabled.
9653 Identify the first such cast that is valid. */
9655 /* Don't attempt to run such logic within template processing. */
9659 /* First try const_cast. */
9664 /* If that fails, try static_cast. */
9669 /* Finally, try reinterpret_cast. */
9671 tf_none);
9675 /* No such cast possible. */
9677 }
9679 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
9680 suggesting how to convert a C-style cast of the form:
9682 (DST_TYPE)ORIG_EXPR
9684 to a C++-style cast.
9686 The primary range of RICHLOC is asssumed to be that of the original
9687 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
9688 of the parens in the C-style cast. */
9690 static void
9693 tree dst_type)
9694 {
9695 /* This function is non-trivial, so bail out now if the warning isn't
9696 going to be emitted. */
9700 /* Try to find a legal C++ cast, trying them in order:
9701 const_cast, static_cast, reinterpret_cast. */
9706 /* Replace the open paren with "CAST_SUGGESTION<". */
9707 pretty_printer pp;
9712 /* Replace the close paren with "> (". */
9715 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
9717 }
9720 /* Parse a cast-expression.
9722 cast-expression:
9723 unary-expression
9724 ( type-id ) cast-expression
9726 ADDRESS_P is true iff the unary-expression is appearing as the
9727 operand of the `&' operator. CAST_P is true if this expression is
9728 the target of a cast.
9730 Returns a representation of the expression. */
9732 static cp_expr
9735 {
9736 /* If it's a `(', then we might be looking at a cast. */
9738 {
9744 /* There's no way to know yet whether or not this is a cast.
9745 For example, `(int (3))' is a unary-expression, while `(int)
9746 3' is a cast. So, we resort to parsing tentatively. */
9748 /* Types may not be defined in a cast. */
9750 parser->type_definition_forbidden_message
9752 /* Consume the `('. */
9753 matching_parens parens;
9758 /* A very tricky bit is that `(struct S) { 3 }' is a
9759 compound-literal (which we permit in C++ as an extension).
9760 But, that construct is not a cast-expression -- it is a
9761 postfix-expression. (The reason is that `(struct S) { 3 }.i'
9762 is legal; if the compound-literal were a cast-expression,
9763 you'd need an extra set of parentheses.) But, if we parse
9764 the type-id, and it happens to be a class-specifier, then we
9765 will commit to the parse at that point, because we cannot
9766 undo the action that is done when creating a new class. So,
9767 then we cannot back up and do a postfix-expression.
9769 Another tricky case is the following (c++/29234):
9771 struct S { void operator () (); };
9773 void foo ()
9774 {
9775 ( S()() );
9776 }
9778 As a type-id we parse the parenthesized S()() as a function
9779 returning a function, groktypename complains and we cannot
9780 back up in this case either.
9782 Therefore, we scan ahead to the closing `)', and check to see
9783 if the tokens after the `)' can start a cast-expression. Otherwise
9784 we are dealing with an unary-expression, a postfix-expression
9785 or something else.
9787 Yet another tricky case, in C++11, is the following (c++/54891):
9789 (void)[]{};
9791 The issue is that usually, besides the case of lambda-expressions,
9792 the parenthesized type-id cannot be followed by '[', and, eg, we
9793 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
9794 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
9795 we don't commit, we try a cast-expression, then an unary-expression.
9797 Save tokens so that we can put them back. */
9800 /* We may be looking at a cast-expression. */
9803 cast_expression
9806 /* Roll back the tokens we skipped. */
9808 /* If we aren't looking at a cast-expression, simulate an error so
9809 that the call to cp_parser_error_occurred below returns true. */
9812 else
9813 {
9816 /* Look for the type-id. */
9818 /* Look for the closing `)'. */
9823 }
9825 /* Restore the saved message. */
9828 /* At this point this can only be either a cast or a
9829 parenthesized ctor such as `(T ())' that looks like a cast to
9830 function returning T. */
9832 {
9833 /* Only commit if the cast-expression doesn't start with
9834 '++', '--', or '[' in C++11. */
9842 pidk);
9845 {
9846 /* Warn about old-style casts, if so requested. */
9851 {
9857 }
9859 /* Only type conversions to integral or enumeration types
9860 can be used in constant-expressions. */
9863 NIC_CAST))
9866 /* Perform the cast. */
9867 /* Make a location:
9868 (TYPE) EXPR
9869 ^~~~~~~~~~~
9870 with start==caret at the open paren, extending to the
9871 end of "expr". */
9873 open_paren_loc,
9877 }
9878 }
9879 else
9881 }
9883 /* If we get here, then it's not a cast, so it must be a
9884 unary-expression. */
9887 }
9889 /* Parse a binary expression of the general form:
9891 pm-expression:
9892 cast-expression
9893 pm-expression .* cast-expression
9894 pm-expression ->* cast-expression
9896 multiplicative-expression:
9897 pm-expression
9898 multiplicative-expression * pm-expression
9899 multiplicative-expression / pm-expression
9900 multiplicative-expression % pm-expression
9902 additive-expression:
9903 multiplicative-expression
9904 additive-expression + multiplicative-expression
9905 additive-expression - multiplicative-expression
9907 shift-expression:
9908 additive-expression
9909 shift-expression << additive-expression
9910 shift-expression >> additive-expression
9912 relational-expression:
9913 shift-expression
9914 relational-expression < shift-expression
9915 relational-expression > shift-expression
9916 relational-expression <= shift-expression
9917 relational-expression >= shift-expression
9919 GNU Extension:
9921 relational-expression:
9922 relational-expression <? shift-expression
9923 relational-expression >? shift-expression
9925 equality-expression:
9926 relational-expression
9927 equality-expression == relational-expression
9928 equality-expression != relational-expression
9930 and-expression:
9931 equality-expression
9932 and-expression & equality-expression
9934 exclusive-or-expression:
9935 and-expression
9936 exclusive-or-expression ^ and-expression
9938 inclusive-or-expression:
9939 exclusive-or-expression
9940 inclusive-or-expression | exclusive-or-expression
9942 logical-and-expression:
9943 inclusive-or-expression
9944 logical-and-expression && inclusive-or-expression
9946 logical-or-expression:
9947 logical-and-expression
9948 logical-or-expression || logical-and-expression
9950 All these are implemented with a single function like:
9952 binary-expression:
9953 simple-cast-expression
9954 binary-expression <token> binary-expression
9956 CAST_P is true if this expression is the target of a cast.
9958 The binops_by_token map is used to get the tree codes for each <token> type.
9959 binary-expressions are associated according to a precedence table. */
9961 #define TOKEN_PRECEDENCE(token) \
9962 (((token->type == CPP_GREATER \
9963 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
9964 && !parser->greater_than_is_operator_p) \
9965 ? PREC_NOT_OPERATOR \
9966 : binops_by_token[token->type].prec)
9968 static cp_expr
9974 {
9975 cp_parser_expression_stack stack;
9978 cp_parser_expression_stack_entry current;
9979 cp_expr rhs;
9983 tree overload;
9985 /* Parse the first expression. */
9996 {
9997 /* Get an operator token. */
10003 {
10005 "%<>>%> operator is treated"
10009 }
10014 /* This is a fold-expression; handle it later. */
10017 /* Popping an entry off the stack means we completed a subexpression:
10018 - either we found a token which is not an operator (`>' where it is not
10019 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10020 will happen repeatedly;
10021 - or, we found an operator which has lower priority. This is the case
10022 where the recursive descent *ascends*, as in `3 * 4 + 5' after
10023 parsing `3 * 4'. */
10025 {
10028 else
10030 }
10032 get_rhs:
10036 /* We used the operator token. */
10039 /* For "false && x" or "true || x", x will never be executed;
10040 disable warnings while evaluating it. */
10045 {
10048 }
10050 /* Extract another operand. It may be the RHS of this expression
10051 or the LHS of a new, higher priority expression. */
10056 /* Get another operator token. Look up its precedence to avoid
10057 building a useless (immediately popped) stack entry for common
10058 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10065 {
10066 /* ... and prepare to parse the RHS of the new, higher priority
10067 expression. Since precedence levels on the stack are
10068 monotonically increasing, we do not have to care about
10069 stack overflows. */
10078 pop:
10080 /* If the stack is not empty, we have parsed into LHS the right side
10081 (`4' in the example above) of an expression we had suspended.
10082 We can use the information on the stack to recover the LHS (`3')
10083 from the stack together with the tree code (`MULT_EXPR'), and
10084 the precedence of the higher level subexpression
10085 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10086 which will be used to actually build the additive expression. */
10091 }
10093 /* Undo the disabling of warnings done above. */
10095 {
10098 }
10103 /* Avoid warning for !!x == y. */
10108 /* Avoid warning for !b == y where b is boolean. */
10112 /* Avoid warning for !!b == y where b is boolean. */
10125 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10126 ERROR_MARK for everything that is not a binary expression.
10127 This makes warn_about_parentheses miss some warnings that
10128 involve unary operators. For unary expressions we should
10129 pass the correct tree_code unless the unary expression was
10130 surrounded by parentheses.
10131 */
10135 {
10138 else
10139 {
10142 current.lhs
10145 == tcc_comparison
10149 }
10150 }
10151 else
10152 {
10158 /* TODO: build_x_binary_op doesn't always honor the location. */
10160 }
10163 /* If the binary operator required the use of an overloaded operator,
10164 then this expression cannot be an integral constant-expression.
10165 An overloaded operator can be used even if both operands are
10166 otherwise permissible in an integral constant-expression if at
10167 least one of the operands is of enumeration type. */
10171 NIC_OVERLOADED))
10173 }
10176 }
10178 static cp_expr
10183 {
10186 }
10188 /* Parse the `? expression : assignment-expression' part of a
10189 conditional-expression. The LOGICAL_OR_EXPR is the
10190 logical-or-expression that started the conditional-expression.
10191 Returns a representation of the entire conditional-expression.
10193 This routine is used by cp_parser_assignment_expression.
10195 ? expression : assignment-expression
10197 GNU Extensions:
10199 ? : assignment-expression */
10201 static tree
10203 {
10205 cp_expr assignment_expr;
10209 /* Consume the `?' token. */
10214 {
10217 /* Implicit true clause. */
10219 c_inhibit_evaluation_warnings +=
10222 }
10223 else
10224 {
10227 /* Parse the expression. */
10228 c_inhibit_evaluation_warnings +=
10231 c_inhibit_evaluation_warnings +=
10235 }
10237 /* The next token should be a `:'. */
10239 /* Parse the assignment-expression. */
10241 c_inhibit_evaluation_warnings -=
10244 /* Make a location:
10245 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10246 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10247 with the caret at the "?", ranging from the start of
10248 the logical_or_expr to the end of the assignment_expr. */
10253 /* Build the conditional-expression. */
10255 expr,
10256 assignment_expr,
10257 tf_warning_or_error);
10258 }
10260 /* Parse an assignment-expression.
10262 assignment-expression:
10263 conditional-expression
10264 logical-or-expression assignment-operator assignment_expression
10265 throw-expression
10266 yield-expression
10268 CAST_P is true if this expression is the target of a cast.
10269 DECLTYPE_P is true if this expression is the operand of decltype.
10271 Returns a representation for the expression. */
10273 static cp_expr
10276 {
10277 cp_expr expr;
10279 /* If the next token is the `throw' keyword, then we're looking at
10280 a throw-expression. */
10283 /* If the next token is the `co_yield' keyword, then we're looking at
10284 a yield-expression. */
10287 /* Otherwise, it must be that we are looking at a
10288 logical-or-expression. */
10289 else
10290 {
10291 /* Parse the binary expressions (logical-or-expression). */
10293 decltype_p,
10295 /* If the next token is a `?' then we're actually looking at a
10296 conditional-expression. */
10299 else
10300 {
10303 /* If it's an assignment-operator, we're using the second
10304 production. */
10305 enum tree_code assignment_operator
10308 {
10311 /* Parse the right-hand side of the assignment. */
10318 /* An assignment may not appear in a
10319 constant-expression. */
10321 NIC_ASSIGNMENT))
10323 /* Build the assignment expression. Its default
10324 location:
10325 LHS = RHS
10326 ~~~~^~~~~
10327 is the location of the '=' token as the
10328 caret, ranging from the start of the lhs to the
10329 end of the rhs. */
10334 assignment_operator,
10335 rhs,
10337 /* TODO: build_x_modify_expr doesn't honor the location,
10338 so we must set it here. */
10340 }
10341 }
10342 }
10345 }
10347 /* Parse an (optional) assignment-operator.
10349 assignment-operator: one of
10350 = *= /= %= += -= >>= <<= &= ^= |=
10352 GNU Extension:
10354 assignment-operator: one of
10355 <?= >?=
10357 If the next token is an assignment operator, the corresponding tree
10358 code is returned, and the token is consumed. For example, for
10359 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
10360 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
10361 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
10362 operator, ERROR_MARK is returned. */
10364 static enum tree_code
10366 {
10370 /* Peek at the next token. */
10374 {
10420 /* Nothing else is an assignment operator. */
10422 }
10424 /* An operator followed by ... is a fold-expression, handled elsewhere. */
10429 /* If it was an assignment operator, consume it. */
10434 }
10436 /* Parse an expression.
10438 expression:
10439 assignment-expression
10440 expression , assignment-expression
10442 CAST_P is true if this expression is the target of a cast.
10443 DECLTYPE_P is true if this expression is the immediate operand of decltype,
10444 except possibly parenthesized or on the RHS of a comma (N3276).
10445 WARN_COMMA_P is true if a comma should be diagnosed.
10447 Returns a representation of the expression. */
10449 static cp_expr
10452 {
10457 {
10458 cp_expr assignment_expression;
10460 /* Parse the next assignment-expression. */
10461 assignment_expression
10464 /* We don't create a temporary for a call that is the immediate operand
10465 of decltype or on the RHS of a comma. But when we see a comma, we
10466 need to create a temporary for a call on the LHS. */
10471 assignment_expression
10475 /* If this is the first assignment-expression, we can just
10476 save it away. */
10479 else
10480 {
10481 /* Create a location with caret at the comma, ranging
10482 from the start of the LHS to the end of the RHS. */
10487 assignment_expression,
10490 }
10491 /* If the next token is not a comma, or we're in a fold-expression, then
10492 we are done with the expression. */
10496 /* Consume the `,'. */
10499 {
10500 /* [depr.comma.subscript]: A comma expression appearing as
10501 the expr-or-braced-init-list of a subscripting expression
10502 is deprecated. A parenthesized comma expression is not
10503 deprecated. */
10505 "top-level comma expression in array subscript "
10508 }
10510 /* A comma operator cannot appear in a constant-expression. */
10513 }
10516 }
10518 /* Parse a constant-expression.
10520 constant-expression:
10521 conditional-expression
10523 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
10524 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
10525 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
10526 is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
10527 greater than 1, this isn't really a constant-expression, only a
10528 potentially constant-evaluated expression. If STRICT_P is true,
10529 only parse a conditional-expression, otherwise parse an
10530 assignment-expression. See below for rationale. */
10532 static cp_expr
10537 {
10541 cp_expr expression;
10543 /* It might seem that we could simply parse the
10544 conditional-expression, and then check to see if it were
10545 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
10546 one that the compiler can figure out is constant, possibly after
10547 doing some simplifications or optimizations. The standard has a
10548 precise definition of constant-expression, and we must honor
10549 that, even though it is somewhat more restrictive.
10551 For example:
10553 int i[(2, 3)];
10555 is not a legal declaration, because `(2, 3)' is not a
10556 constant-expression. The `,' operator is forbidden in a
10557 constant-expression. However, GCC's constant-folding machinery
10558 will fold this operation to an INTEGER_CST for `3'. */
10560 /* Save the old settings. */
10562 saved_allow_non_integral_constant_expression_p
10565 /* We are now parsing a constant-expression. */
10567 parser->allow_non_integral_constant_expression_p
10571 /* A manifestly constant-evaluated expression is evaluated even in an
10572 unevaluated operand. */
10575 /* Although the grammar says "conditional-expression", when not STRICT_P,
10576 we parse an "assignment-expression", which also permits
10577 "throw-expression" and the use of assignment operators. In the case
10578 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
10579 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
10580 actually essential that we look for an assignment-expression.
10581 For example, cp_parser_initializer_clauses uses this function to
10582 determine whether a particular assignment-expression is in fact
10583 constant. */
10585 {
10586 /* Parse the binary expressions (logical-or-expression). */
10589 /* If the next token is a `?' then we're actually looking at
10590 a conditional-expression; otherwise we're done. */
10593 }
10594 else
10596 /* Restore the old settings. */
10597 parser->integral_constant_expression_p
10599 parser->allow_non_integral_constant_expression_p
10602 {
10603 /* Require an rvalue constant expression here; that's what our
10604 callers expect. Reference constant expressions are handled
10605 separately in e.g. cp_parser_template_argument. */
10614 }
10617 parser->non_integral_constant_expression_p
10621 }
10623 /* Parse __builtin_offsetof.
10625 offsetof-expression:
10626 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
10628 offsetof-member-designator:
10629 id-expression
10630 | offsetof-member-designator "." id-expression
10631 | offsetof-member-designator "[" expression "]"
10632 | offsetof-member-designator "->" id-expression */
10634 static cp_expr
10636 {
10638 tree type;
10639 cp_expr expr;
10640 cp_id_kind dummy;
10642 location_t finish_loc;
10644 /* We're about to accept non-integral-constant things, but will
10645 definitely yield an integral constant expression. Save and
10646 restore these values around our local parsing. */
10652 /* Consume the "__builtin_offsetof" token. */
10654 /* Consume the opening `('. */
10655 matching_parens parens;
10657 /* Parse the type-id. */
10659 {
10661 parser->type_definition_forbidden_message
10665 }
10666 /* Look for the `,'. */
10670 /* Build the (type *)null that begins the traditional offsetof macro. */
10671 tree object_ptr
10675 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
10679 {
10682 {
10684 /* offsetof-member-designator "[" expression "]" */
10690 /* offsetof-member-designator "->" identifier */
10693 /* FALLTHRU */
10696 /* offsetof-member-designator "." identifier */
10704 /* Consume the ")" token. */
10710 /* Error. We know the following require will fail, but
10711 that gives the proper error message. */
10716 }
10717 }
10719 success:
10720 /* Make a location of the form:
10721 __builtin_offsetof (struct s, f)
10722 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
10723 with caret at the type-id, ranging from the start of the
10724 "_builtin_offsetof" token to the close paren. */
10726 /* The result will be an INTEGER_CST, so we need to explicitly
10727 preserve the location. */
10730 failure:
10736 }
10738 /* Parse a trait expression.
10740 Returns a representation of the expression, the underlying type
10741 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
10743 static cp_expr
10745 {
10746 cp_trait_kind kind;
10752 {
10870 }
10872 /* Get location of initial token. */
10875 /* Consume the token. */
10878 matching_parens parens;
10881 {
10884 }
10890 {
10893 {
10896 }
10900 }
10902 {
10904 {
10908 {
10911 }
10915 }
10917 }
10922 /* Construct a location of the form:
10923 __is_trivially_copyable(_Tp)
10924 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
10925 with start == caret, finishing at the close-paren. */
10928 /* Complete the trait expression, which may mean either processing
10929 the trait expr now or saving it for template instantiation. */
10931 {
10940 }
10941 }
10943 /* Parse a lambda expression.
10945 lambda-expression:
10946 lambda-introducer lambda-declarator [opt] compound-statement
10947 lambda-introducer < template-parameter-list > requires-clause [opt]
10948 lambda-declarator [opt] compound-statement
10950 Returns a representation of the expression. */
10952 static cp_expr
10954 {
10956 tree type;
10964 {
10965 /* C++20 allows lambdas in unevaluated context, but one in the type of a
10966 non-type parameter is nonsensical.
10968 Distinguish a lambda in the parameter type from a lambda in the
10969 default argument by looking at local_variables_forbidden_p, which is
10970 only set in default arguments. */
10972 {
10977 }
10978 }
10980 {
10982 {
10984 "lambda-expression in unevaluated context"
10987 }
10989 }
10991 {
10993 {
10997 }
10999 }
11001 /* We may be in the middle of deferred access check. Disable
11002 it now. */
11015 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11018 /* Now that we've started the type, add the capture fields for any
11019 explicit captures. */
11022 {
11023 /* Inside the class, surrounding template-parameter-lists do not apply. */
11024 unsigned int saved_num_template_parameter_lists
11028 bool fully_implicit_function_template_p
11032 bool auto_is_implicit_function_template_parm_p
11043 /* The body of a lambda in a discarded statement is not discarded. */
11047 /* Similarly the body of a lambda in immediate function context is not
11048 in immediate function context. */
11052 /* By virtue of defining a local class, a lambda expression has access to
11053 the private variables of enclosing classes. */
11064 {
11066 }
11068 {
11071 }
11073 /* The capture list was built up in reverse order; fix that now. */
11088 parser->fully_implicit_function_template_p
11092 parser->auto_is_implicit_function_template_parm_p
11094 }
11096 /* This field is only used during parsing of the lambda. */
11099 /* This lambda shouldn't have any proxies left at this point. */
11101 /* And now that we're done, push proxies for an enclosing lambda. */
11104 /* Update the lambda expression to a range. */
11111 else
11119 }
11121 /* Parse the beginning of a lambda expression.
11123 lambda-introducer:
11124 [ lambda-capture [opt] ]
11126 LAMBDA_EXPR is the current representation of the lambda expression. */
11128 static void
11130 {
11131 /* Need commas after the first capture. */
11134 /* Eat the leading `['. */
11137 /* Record default capture mode. "[&" "[=" "[&," "[=," */
11147 {
11153 }
11158 {
11160 tree capture_id;
11161 tree capture_init_expr;
11165 enum capture_kind_type
11166 {
11167 BY_COPY,
11168 BY_REFERENCE
11169 };
11173 {
11176 }
11180 else
11183 /* Possibly capture `this'. */
11185 {
11195 this_identifier);
11196 else
11201 }
11203 /* Possibly capture `*this'. */
11206 {
11210 "%<*this%> capture only available with "
11217 this_identifier);
11218 else
11223 }
11225 /* But reject `&this'. */
11228 {
11234 }
11236 /* Remember whether we want to capture as a reference or not. */
11238 {
11241 }
11246 {
11250 "pack init-capture only available with "
11254 }
11256 /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11259 {
11264 }
11266 /* Get the identifier. */
11271 /* Would be nice to have a cp_parser_skip_to_closing_x for general
11272 delimiters, but I modified this to stop on unnested ']' as well. It
11273 was already changed to stop on unnested '}', so the
11274 "closing_parenthesis" name is no more misleading with my change. */
11275 {
11281 }
11283 /* Find the initializer for this capture. */
11287 {
11289 /* An explicit initializer exists. */
11292 "lambda capture initializers "
11298 {
11301 }
11304 }
11305 else
11306 {
11309 /* Turn the identifier into an id-expression. */
11310 capture_init_expr
11315 {
11318 }
11321 {
11324 capture_init_expr);
11329 }
11332 {
11335 capture_init_expr))
11339 }
11341 capture_init_expr
11342 = finish_id_expression
11344 capture_init_expr,
11358 {
11363 {
11364 /* If what follows is an initializer, the second '...' is
11365 invalid. But for cases like [...xs...], the first one
11366 is invalid. */
11373 }
11374 }
11375 }
11379 {
11384 capture_id);
11388 "capture of %qD redundant with by-reference capture "
11390 }
11392 /* Check for duplicates.
11393 Optimize for the zero or one explicit captures cases and only create
11394 the hash_set after adding second capture. */
11402 else
11403 {
11406 }
11410 else
11413 explicit_init_p);
11415 /* If there is any qualification still in effect, clear it
11416 now; we will be starting fresh with the next capture. */
11420 }
11423 }
11425 /* Parse the (optional) middle of a lambda expression.
11427 lambda-declarator:
11428 ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
11429 lambda-specifiers (C++23)
11431 lambda-specifiers:
11432 decl-specifier-seq [opt] noexcept-specifier [opt]
11433 attribute-specifier-seq [opt] trailing-return-type [opt]
11435 LAMBDA_EXPR is the current representation of the lambda expression. */
11437 static bool
11439 {
11440 /* 5.1.1.4 of the standard says:
11441 If a lambda-expression does not include a lambda-declarator, it is as if
11442 the lambda-declarator were ().
11443 This means an empty parameter list, no attributes, and no exception
11444 specification. */
11455 cp_decl_specifier_seq lambda_specs;
11457 /* A lambda op() is const unless explicitly 'mutable'. */
11460 /* The template-parameter-list is optional, but must begin with
11461 an opening angle if present. */
11463 {
11466 "lambda templates are only available with "
11470 "lambda templates are only available with "
11478 /* We may have a constrained generic lambda; parse the requires-clause
11479 immediately after the template-parameter-list and combine with any
11480 shorthand constraints present. */
11483 {
11488 }
11490 /* We just processed one more parameter list. */
11492 }
11494 /* Committee discussion supports allowing attributes here. */
11497 /* The parameter-declaration-clause is optional (unless
11498 template-parameter-list was given), but must begin with an
11499 opening parenthesis if present. */
11501 {
11503 /* For C++20, before parsing the parameter list check if there is
11504 a consteval specifier in the corresponding decl-specifier-seq. */
11506 {
11509 {
11512 {
11515 }
11516 }
11517 }
11519 matching_parens parens;
11527 /* Parse parameters. */
11528 param_list
11529 = cp_parser_parameter_declaration_clause
11532 /* Default arguments shall not be specified in the
11533 parameter-declaration-clause of a lambda-declarator. */
11538 OPT_Wc__14_extensions,
11543 }
11547 /* In the decl-specifier-seq of the lambda-declarator, each
11548 decl-specifier shall either be mutable or constexpr. */
11552 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
11556 {
11558 "parameter declaration before lambda declaration "
11559 "specifiers only optional with %<-std=c++2b%> or "
11562 }
11565 {
11571 }
11575 {
11577 "parameter declaration before lambda transaction "
11578 "qualifier only optional with %<-std=c++2b%> or "
11581 }
11583 /* Parse optional exception specification. */
11584 exception_spec
11588 {
11590 "parameter declaration before lambda exception "
11591 "specification only optional with %<-std=c++2b%> or "
11594 }
11596 /* GCC 8 accepted attributes here, and this is the place for standard C++11
11597 attributes that appertain to the function type. */
11600 else
11603 /* Parse optional trailing return type. */
11605 {
11608 "parameter declaration before lambda trailing "
11609 "return type only optional with %<-std=c++2b%> or "
11613 }
11615 /* Also allow GNU attributes at the very end of the declaration, the usual
11616 place for GNU attributes. */
11621 {
11622 /* Parse optional trailing requires clause. */
11625 /* The function parameters must be in scope all the way until after the
11626 trailing-return-type in case of decltype. */
11628 }
11630 /* Create the function call operator.
11632 Messing with declarators like this is no uglier than building up the
11633 FUNCTION_DECL by hand, and this is less likely to get out of sync with
11634 other code. */
11635 {
11636 cp_decl_specifier_seq return_type_specs;
11638 tree fco;
11645 {
11649 else
11651 "lambda only available with %<-std=c++17%> or "
11653 }
11664 VIRT_SPEC_UNSPECIFIED,
11665 REF_QUAL_NONE,
11666 tx_qual,
11667 exception_spec,
11668 return_type,
11669 trailing_requires_clause,
11670 UNKNOWN_LOCATION);
11674 declarator,
11677 {
11680 /* Give the object parameter a different name. */
11683 }
11685 {
11689 }
11698 }
11699 }
11701 /* Parse the body of a lambda expression, which is simply
11703 compound-statement
11705 but which requires special handling.
11706 LAMBDA_EXPR is the current representation of the lambda expression. */
11708 static void
11710 {
11712 unsigned char local_variables_forbidden_p
11716 /* The body of a lambda-expression is not a subexpression of the enclosing
11717 expression. */
11718 cp_evaluated ev;
11722 else
11723 /* Still increment function_depth so that we don't GC in the
11724 middle of an expression. */
11732 /* Clear this in case we're in the middle of a default argument. */
11736 {
11741 /* Originally C++11 required us to peek for 'return expr'; and
11742 process it specially here to deduce the return type. N3638
11743 removed the need for that. */
11747 }
11754 else
11756 }
11758 /* Statements [gram.stmt.stmt] */
11760 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
11762 static void
11764 {
11768 /* A concept is never expanded normally. */
11774 }
11776 struct cp_omp_attribute_data
11777 {
11780 c_omp_directive_kind kind;
11781 };
11783 /* Handle omp::directive and omp::sequence attributes in ATTRS
11784 (if any) at the start of a statement or in attribute-declaration. */
11786 static tree
11788 {
11799 {
11800 cnt++;
11802 {
11808 {
11810 "mixing OpenMP directives with attribute and pragma "
11814 }
11817 {
11825 else
11828 }
11834 {
11836 "unknown OpenMP directive name in %<omp::directive%>"
11839 }
11842 {
11843 /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
11844 depend clause. */
11853 }
11855 {
11856 /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
11860 paren_depth++;
11862 paren_depth--;
11873 {
11876 }
11877 }
11882 }
11883 cp_omp_attribute_data v = {};
11886 }
11887 else
11900 {
11905 }
11906 else
11907 {
11909 {
11912 }
11913 }
11916 {
11918 "OpenMP construct among %<omp::directive%> attributes"
11919 " requires all %<omp::directive%> attributes on the"
11922 }
11924 {
11926 "multiple OpenMP standalone directives among"
11927 " %<omp::directive%> attributes must be all within the"
11930 }
11936 {
11938 "standalone OpenMP directives in %<omp::directive%> attribute"
11941 }
11943 {
11947 {
11949 "mixing OpenMP directives with attribute and pragma "
11952 }
11953 }
11957 tokens++;
11962 {
11969 cp_token tok = {};
11977 tok = {};
11982 }
11983 cp_token tok = {};
11995 /* Move the current source position to that of the first token in the
11996 new lexer. */
11999 }
12001 /* Handle omp::directive and omp::sequence attributes in *PATTRS
12002 (if any) at the start or after declaration-id of a declaration. */
12004 static void
12008 {
12019 {
12021 {
12028 {
12036 else
12039 }
12049 {
12051 {
12054 }
12056 {
12058 "mixing OpenMP directives with attribute and "
12061 }
12062 }
12063 }
12064 }
12067 {
12072 else
12075 }
12080 {
12089 }
12091 }
12093 /* Parse a statement.
12095 statement:
12096 labeled-statement
12097 expression-statement
12098 compound-statement
12099 selection-statement
12100 iteration-statement
12101 jump-statement
12102 declaration-statement
12103 try-block
12105 C++11:
12107 statement:
12108 labeled-statement
12109 attribute-specifier-seq (opt) expression-statement
12110 attribute-specifier-seq (opt) compound-statement
12111 attribute-specifier-seq (opt) selection-statement
12112 attribute-specifier-seq (opt) iteration-statement
12113 attribute-specifier-seq (opt) jump-statement
12114 declaration-statement
12115 attribute-specifier-seq (opt) try-block
12117 init-statement:
12118 expression-statement
12119 simple-declaration
12120 alias-declaration
12122 TM Extension:
12124 statement:
12125 atomic-statement
12127 IN_COMPOUND is true when the statement is nested inside a
12128 cp_parser_compound_statement; this matters for certain pragmas.
12130 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12131 is a (possibly labeled) if statement which is not enclosed in braces
12132 and has an else clause. This is used to implement -Wparentheses.
12134 CHAIN is a vector of if-else-if conditions. */
12136 static void
12140 {
12147 restart:
12150 /* There is no statement yet. */
12157 /* In obj-c++, seeing '[[' might be the either the beginning of
12158 c++11 attributes, or a nested objc-message-expression. So
12159 let's parse the c++11 attributes tentatively. */
12165 {
12168 }
12171 /* Peek at the next token. */
12177 {
12181 {
12208 }
12214 {
12216 std_attrs);
12218 }
12219 }
12222 /* Remember the location of the first token in the statement. */
12226 /* If this is a keyword, then that will often determine what kind of
12227 statement we have. */
12229 {
12233 {
12236 /* Looks like a labeled-statement with a case label.
12237 Parse the label, and then use tail recursion to parse
12238 the statement. */
12266 /* Objective-C++ exception-handling constructs. */
12282 /* This must be a namespace alias definition. */
12284 {
12285 /* Attributes should be parsed as part of the
12286 declaration, so let's un-parse them. */
12289 }
12307 /* It might be a keyword like `int' that can start a
12308 declaration-statement. */
12310 }
12311 }
12313 {
12314 /* If the next token is a `:', then we are looking at a
12315 labeled-statement. */
12318 {
12319 /* Looks like a labeled-statement with an ordinary label.
12320 Parse the label, and then use tail recursion to parse
12321 the statement. */
12327 }
12328 }
12329 /* Anything that starts with a `{' must be a compound-statement. */
12331 {
12334 }
12335 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
12336 a statement all its own. */
12338 {
12339 do_pragma:;
12342 /* Only certain OpenMP pragmas are attached to statements, and thus
12343 are considered statements themselves. All others are not. In
12344 the context of a compound, accept the pragma as a "statement" and
12345 return so that we can check for a close brace. Otherwise we
12346 require a real statement and must go back and read one. */
12354 {
12356 {
12363 }
12366 }
12374 }
12376 {
12379 }
12381 /* Everything else must be a declaration-statement or an
12382 expression-statement. Try for the declaration-statement
12383 first, unless we are looking at a `;', in which case we know that
12384 we have an expression-statement. */
12386 {
12388 {
12390 /* Attributes should be parsed as part of the declaration,
12391 so let's un-parse them. */
12396 /* Try to parse the declaration-statement. */
12399 /* If that worked, we're done. */
12402 /* It didn't work, restore the post-attribute position. */
12404 {
12407 {
12412 i++;
12414 {
12420 /* Don't handle OpenMP attribs on keywords that
12421 always start a declaration statement but don't
12422 accept attribute before it and therefore
12423 the tentative cp_parser_declaration_statement
12424 fails to parse because of that. */
12429 }
12432 {
12434 std_attrs
12435 = cp_parser_handle_statement_omp_attributes
12441 }
12442 }
12443 }
12444 }
12445 /* All preceding labels have been parsed at this point. */
12451 /* Look for an expression-statement instead. */
12454 /* Handle [[fallthrough]];. */
12456 {
12457 /* The next token after the fallthrough attribute is ';'. */
12459 {
12460 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12462 IFN_FALLTHROUGH,
12465 }
12466 else
12470 }
12471 }
12473 /* Set the line number for the statement. */
12477 /* Allow "[[fallthrough]];", but warn otherwise. */
12480 OPT_Wattributes,
12482 }
12484 /* Append ATTR to attribute list ATTRS. */
12486 static tree
12488 {
12494 }
12496 /* Parse the label for a labeled-statement, i.e.
12498 identifier :
12499 case constant-expression :
12500 default :
12502 GNU Extension:
12503 case constant-expression ... constant-expression : statement
12505 When a label is parsed without errors, the label is added to the
12506 parse tree by the finish_* functions, so this function doesn't
12507 have to return the label. */
12509 static void
12511 {
12516 /* The next token should be an identifier. */
12520 {
12523 }
12525 /* Remember whether this case or a user-defined label is allowed to fall
12526 through to. */
12531 {
12533 {
12537 /* Consume the `case' token. */
12539 /* Parse the constant-expression. */
12546 {
12547 /* Consume the `...' token. */
12553 /* We don't need to emit warnings here, as the common code
12554 will do this for us. */
12555 }
12556 else
12560 {
12563 {
12566 }
12567 }
12568 else
12571 expr);
12572 }
12576 /* Consume the `default' token. */
12580 {
12583 {
12586 }
12587 }
12588 else
12593 /* Anything else must be an ordinary label. */
12598 }
12600 /* Require the `:' token. */
12603 /* An ordinary label may optionally be followed by attributes.
12604 However, this is only permitted if the attributes are then
12605 followed by a semicolon. This is because, for backward
12606 compatibility, when parsing
12607 lab: __attribute__ ((unused)) int i;
12608 we want the attribute to attach to "i", not "lab". */
12611 {
12612 tree attrs;
12616 /* And fallthrough always binds to the expression-statement. */
12621 ;
12622 else
12624 }
12630 }
12632 /* Parse an expression-statement.
12634 expression-statement:
12635 expression [opt] ;
12637 Returns the new EXPR_STMT -- or NULL_TREE if the expression
12638 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
12639 indicates whether this expression-statement is part of an
12640 expression statement. */
12642 static tree
12644 {
12649 /* There might be attribute fallthrough. */
12652 /* If the next token is a ';', then there is no expression
12653 statement. */
12655 {
12659 {
12662 }
12663 }
12665 /* Handle [[fallthrough]];. */
12667 {
12668 /* The next token after the fallthrough attribute is ';'. */
12670 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12673 else
12677 }
12679 /* Allow "[[fallthrough]];", but warn otherwise. */
12684 /* Give a helpful message for "A<T>::type t;" and the like. */
12687 {
12694 {
12695 /* A::A a; */
12700 }
12701 }
12703 /* Consume the final `;'. */
12708 /* This is the final expression statement of a statement
12709 expression. */
12715 }
12717 /* Parse a compound-statement.
12719 compound-statement:
12720 { statement-seq [opt] }
12722 GNU extension:
12724 compound-statement:
12725 { label-declaration-seq [opt] statement-seq [opt] }
12727 label-declaration-seq:
12728 label-declaration
12729 label-declaration-seq label-declaration
12731 Returns a tree representing the statement. */
12733 static tree
12736 {
12737 tree compound_stmt;
12738 matching_braces braces;
12740 /* Consume the `{'. */
12747 /* Begin the compound-statement. */
12749 /* If the next keyword is `__label__' we have a label declaration. */
12752 /* Parse an (optional) statement-seq. */
12758 /* Consume the `}'. */
12761 /* Finish the compound-statement. */
12765 }
12767 /* Parse an (optional) statement-seq.
12769 statement-seq:
12770 statement
12771 statement-seq [opt] statement */
12773 static void
12775 {
12776 /* Scan statements until there aren't any more. */
12778 {
12781 /* If we are looking at a `}', then we have run out of
12782 statements; the same is true if we have reached the end
12783 of file, or have stumbled upon a stray '@end'. */
12790 /* If we are in a compound statement and find 'else' then
12791 something went wrong. */
12793 {
12796 else
12797 {
12800 }
12801 }
12803 /* Parse the statement. */
12805 }
12806 }
12808 /* Return true if this is the C++20 version of range-based-for with
12809 init-statement. */
12811 static bool
12813 {
12816 /* Save tokens so that we can put them back. */
12819 /* There has to be an unnested ; followed by an unnested :. */
12822 CPP_SEMICOLON,
12826 /* We found the semicolon, eat it now. */
12829 /* Now look for ':' that is not nested in () or {}. */
12832 CPP_COLON,
12835 out:
12836 /* Roll back the tokens we skipped. */
12840 }
12842 /* Return true if we're looking at (init; cond), false otherwise. */
12844 static bool
12846 {
12847 /* Save tokens so that we can put them back. */
12850 /* Look for ';' that is not nested in () or {}. */
12853 CPP_SEMICOLON,
12856 /* Roll back the tokens we skipped. */
12860 }
12862 /* Parse a selection-statement.
12864 selection-statement:
12865 if ( init-statement [opt] condition ) statement
12866 if ( init-statement [opt] condition ) statement else statement
12867 switch ( init-statement [opt] condition ) statement
12869 Returns the new IF_STMT or SWITCH_STMT.
12871 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12872 is a (possibly labeled) if statement which is not enclosed in
12873 braces and has an else clause. This is used to implement
12874 -Wparentheses.
12876 CHAIN is a vector of if-else-if conditions. This is used to implement
12877 -Wduplicated-cond. */
12879 static tree
12882 {
12885 token_indent_info guard_tinfo;
12890 /* Peek at the next token. */
12894 /* See what kind of keyword it is. */
12897 {
12900 {
12901 tree statement;
12902 tree condition;
12907 RID_CONSTEXPR))
12908 {
12913 "%<if constexpr%> only available with "
12915 }
12918 {
12920 RID_CONSTEVAL))
12924 RID_CONSTEVAL))
12925 {
12928 }
12929 }
12931 {
12935 "%<if consteval%> only available with "
12946 {
12949 }
12955 {
12956 location_t before_loc
12962 }
12966 /* If the next token is `else', parse the else-clause. */
12968 RID_ELSE))
12969 {
12973 /* Consume the `else' keyword. */
12979 {
12983 }
12987 guard_tinfo);
12990 {
12991 location_t before_loc
12996 }
12999 }
13003 {
13007 }
13011 }
13013 /* Look for the `('. */
13014 matching_parens parens;
13016 {
13019 }
13021 /* Begin the selection-statement. */
13023 {
13026 }
13027 else
13030 /* Parse the optional init-statement. */
13032 {
13033 tree decl;
13036 OPT_Wc__17_extensions,
13037 "init-statement in selection statements only available "
13040 /* A non-empty init-statement can have arbitrary side
13041 effects. */
13044 }
13046 /* Parse the condition. */
13048 /* Look for the `)'. */
13054 {
13058 /* Add the condition. */
13065 /* Parse the then-clause. */
13069 /* Outside a template, the non-selected branch of a constexpr
13070 if is a 'discarded statement', i.e. unevaluated. */
13075 {
13078 }
13081 guard_tinfo);
13088 {
13092 }
13094 /* If the next token is `else', parse the else-clause. */
13096 RID_ELSE))
13097 {
13101 {
13104 }
13106 guard_tinfo
13108 /* Consume the `else' keyword. */
13111 {
13113 RID_IF)
13115 {
13116 /* We've got "if (COND) else if (COND2)". Start
13117 the condition chain and add COND as the first
13118 element. */
13122 {
13123 /* Wrap it in a NOP_EXPR so that we can set the
13124 location of the condition. */
13126 condition);
13129 }
13130 }
13132 RID_IF))
13133 /* This is if-else without subsequent if. Zap the
13134 condition chain; we would have already warned at
13135 this point. */
13137 }
13139 /* Parse the else-clause. */
13145 /* If we are currently parsing a then-clause, then
13146 IF_P will not be NULL. We set it to true to
13147 indicate that this if statement has an else clause.
13148 This may trigger the Wparentheses warning below
13149 when we get back up to the parent if statement. */
13154 {
13158 }
13159 }
13160 else
13161 {
13162 /* This if statement does not have an else clause. If
13163 NESTED_IF is true, then the then-clause has an if
13164 statement which does have an else clause. We warn
13165 about the potential ambiguity. */
13168 "suggest explicit braces to avoid ambiguous"
13171 /* We don't need the condition chain anymore. */
13173 }
13175 /* Now we're all done with the if-statement. */
13177 }
13178 else
13179 {
13183 /* Add the condition. */
13186 /* Parse the body of the switch-statement. */
13192 guard_tinfo);
13196 /* Now we're all done with the switch-statement. */
13198 }
13201 }
13207 }
13208 }
13210 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
13211 If we have seen at least one decl-specifier, and the next token is not
13212 a parenthesis (after "int (" we might be looking at a functional cast)
13213 neither we are dealing with a concept-check expression then we must be
13214 looking at a declaration. */
13216 static void
13219 {
13228 }
13230 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
13231 The declarator shall not specify a function or an array. Returns
13232 TRUE if the declarator is valid, FALSE otherwise. */
13234 static bool
13237 location_t loc)
13238 {
13242 {
13247 else
13255 }
13256 else
13258 }
13260 /* Parse a condition.
13262 condition:
13263 expression
13264 type-specifier-seq declarator = initializer-clause
13265 type-specifier-seq declarator braced-init-list
13267 GNU Extension:
13269 condition:
13270 type-specifier-seq declarator asm-specification [opt]
13271 attributes [opt] = assignment-expression
13273 Returns the expression that should be tested. */
13275 static tree
13277 {
13278 cp_decl_specifier_seq type_specifiers;
13282 /* Try the declaration first. */
13284 /* New types are not allowed in the type-specifier-seq for a
13285 condition. */
13287 parser->type_definition_forbidden_message
13289 /* Parse the type-specifier-seq. */
13291 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
13294 /* Restore the saved message. */
13297 /* Gather the attributes that were provided with the
13298 decl-specifiers. */
13303 /* If all is well, we might be looking at a declaration. */
13305 {
13306 tree decl;
13307 tree asm_specification;
13308 tree attributes;
13313 /* Parse the declarator. */
13315 CP_PARSER_FLAGS_NONE,
13321 /* Parse the attributes. */
13323 /* Parse the asm-specification. */
13325 /* If the next token is not an `=' or '{', then we might still be
13326 looking at an expression. For example:
13328 if (A(a).x)
13330 looks like a decl-specifier-seq and a declarator -- but then
13331 there is no `=', so this is an expression. */
13336 /* If we did see an `=' or '{', then we are looking at a declaration
13337 for sure. */
13339 {
13340 tree pushed_scope;
13347 /* Create the declaration. */
13354 /* Parse the initializer. */
13356 {
13360 }
13362 {
13363 /* Consume the `='. */
13367 }
13368 else
13369 {
13372 }
13376 /* Process the initializer. */
13379 asm_specification,
13380 flags);
13386 }
13387 }
13388 /* If we didn't even get past the declarator successfully, we are
13389 definitely not looking at a declaration. */
13390 else
13393 /* Otherwise, we are looking at an expression. */
13395 }
13397 /* Parses a for-statement or range-for-statement until the closing ')',
13398 not included. */
13400 static tree
13402 {
13406 /* Begin the for-statement. */
13409 /* Maybe parse the optional init-statement in a range-based for loop. */
13411 /* Checked for diagnostic purposes only. */
13413 {
13414 tree dummy;
13417 {
13419 OPT_Wc__20_extensions,
13420 "range-based %<for%> loops with initializer only "
13423 }
13424 }
13426 /* Parse the initialization. */
13432 else
13434 }
13436 static tree
13439 {
13440 /* Normal for loop */
13443 tree stmt;
13446 /* The init-statement has already been parsed in
13447 cp_parser_init_statement, so no work is needed here. */
13450 /* If there's a condition, process it. */
13454 {
13458 }
13460 {
13464 }
13466 /* Look for the `;'. */
13469 /* If there's an expression, process it. */
13475 }
13477 /* Tries to parse a range-based for-statement:
13479 range-based-for:
13480 decl-specifier-seq declarator : expression
13482 The decl-specifier-seq declarator and the `:' are already parsed by
13483 cp_parser_init_statement. If processing_template_decl it returns a
13484 newly created RANGE_FOR_STMT; if not, it is converted to a
13485 regular FOR_STMT. */
13487 static tree
13490 {
13497 /* Get the range declaration momentarily out of the way so that
13498 the range expression doesn't clash with it. */
13500 {
13502 {
13504 /* For decomposition declaration get all of the corresponding
13505 declarations out of the way. */
13509 {
13515 {
13521 }
13522 }
13523 }
13525 {
13530 }
13531 }
13534 {
13537 }
13538 else
13541 /* Put the range declaration(s) back into scope. */
13543 {
13547 }
13549 /* finish_omp_for has its own code for the following, so just
13550 return the range_expr instead. */
13554 /* If in template, STMT is converted to a normal for-statement
13555 at instantiation. If not, it is done just ahead. */
13557 {
13567 /* do_auto_deduction doesn't mess with template init-lists. */
13570 }
13571 else
13572 {
13576 unroll);
13577 }
13579 }
13581 /* Subroutine of cp_convert_range_for: given the initializer expression,
13582 builds up the range temporary. */
13584 static tree
13586 {
13587 /* Find out the type deduced by the declaration
13588 `auto &&__range = range_expr'. */
13593 /* Create the __range variable. */
13600 }
13602 /* Used by cp_parser_range_for in template context: we aren't going to
13603 do a full conversion yet, but we still need to resolve auto in the
13604 type of the for-range-declaration if present. This is basically
13605 a shortcut version of cp_convert_range_for. */
13607 static void
13609 {
13612 {
13615 iter_type = (cp_parser_perform_range_for_lookup
13618 {
13620 iter_type);
13622 RO_UNARY_STAR,
13623 tf_warning_or_error);
13626 tf_warning_or_error,
13627 adc_variable_type);
13628 }
13629 }
13630 }
13632 /* Warns when the loop variable should be changed to a reference type to
13633 avoid unnecessary copying. I.e., from
13635 for (const auto x : range)
13637 where range returns a reference, to
13639 for (const auto &x : range)
13641 if this version doesn't make a copy.
13643 This function also warns when the loop variable is initialized with
13644 a value of a different type resulting in a copy:
13646 int arr[10];
13647 for (const double &x : arr)
13649 DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
13650 This function is never called when processing_template_decl is on. */
13652 static void
13654 {
13666 {
13668 {
13669 auto_diagnostic_group d;
13671 "loop variable %qD of type %qT binds to a temporary "
13674 {
13676 TYPE_QUAL_CONST);
13681 }
13682 }
13684 }
13688 /* Since small trivially copyable types are cheap to copy, we suppress the
13689 warning for them. 64B is a common size of a cache line. */
13696 /* If we could initialize the reference directly, it wouldn't involve any
13697 copies. */
13701 auto_diagnostic_group d;
13705 {
13709 }
13710 }
13712 /* Converts a range-based for-statement into a normal
13713 for-statement, as per the definition.
13715 for (RANGE_DECL : RANGE_EXPR)
13716 BLOCK
13718 should be equivalent to:
13720 {
13721 auto &&__range = RANGE_EXPR;
13722 for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
13723 __begin != __end;
13724 ++__begin)
13725 {
13726 RANGE_DECL = *__begin;
13727 BLOCK
13728 }
13729 }
13731 If RANGE_EXPR is an array:
13732 BEGIN_EXPR = __range
13733 END_EXPR = __range + ARRAY_SIZE(__range)
13734 Else if RANGE_EXPR has a member 'begin' or 'end':
13735 BEGIN_EXPR = __range.begin()
13736 END_EXPR = __range.end()
13737 Else:
13738 BEGIN_EXPR = begin(__range)
13739 END_EXPR = end(__range);
13741 If __range has a member 'begin' but not 'end', or vice versa, we must
13742 still use the second alternative (it will surely fail, however).
13743 When calling begin()/end() in the third alternative we must use
13744 argument dependent lookup, but always considering 'std' as an associated
13745 namespace. */
13747 tree
13751 {
13759 /* If an error happened previously do nothing or else a lot of
13760 unhelpful errors would be issued. */
13762 else
13763 {
13764 tree range_temp;
13768 /* Can't bind a reference to an array of runtime bound. */
13770 else
13771 {
13776 LOOKUP_ONLYCONVERTING);
13778 }
13781 }
13783 /* The new for initialization statement. */
13785 iter_type);
13791 LOOKUP_ONLYCONVERTING);
13801 LOOKUP_ONLYCONVERTING);
13805 /* The new for condition. */
13812 /* The new increment expression. */
13815 tf_warning_or_error);
13821 /* The declaration is initialized with *__begin inside the loop body. */
13823 tf_warning_or_error);
13826 LOOKUP_ONLYCONVERTING);
13833 }
13835 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
13836 We need to solve both at the same time because the method used
13837 depends on the existence of members begin or end.
13838 Returns the type deduced for the iterator expression. */
13840 static tree
13842 {
13844 {
13847 }
13850 {
13855 }
13857 {
13858 /* If RANGE is an array, we will use pointer arithmetic. */
13861 range,
13865 }
13866 else
13867 {
13868 /* If it is not an array, we must do a bit of magic. */
13878 tf_warning_or_error);
13881 tf_warning_or_error);
13884 {
13885 /* Use the member functions. */
13888 }
13889 else
13890 {
13891 /* Use global functions with ADL. */
13892 releasing_vec vec;
13897 tf_warning_or_error);
13899 tf_warning_or_error);
13901 tf_warning_or_error);
13903 tf_warning_or_error);
13904 }
13906 /* Last common checks. */
13908 {
13909 /* If one of the expressions is an error do no more checks. */
13912 }
13915 /* Can happen, when, eg, in a template context, Koenig lookup
13916 can't resolve begin/end (c++/58503). */
13918 else
13919 {
13921 /* The unqualified type of the __begin and __end temporaries should
13922 be the same, as required by the multiple auto declaration. */
13924 {
13931 /* P0184R0 allows __begin and __end to have different types,
13932 but make sure they are comparable so we can give a better
13934 else
13938 }
13940 }
13941 }
13942 }
13944 /* Helper function for cp_parser_perform_range_for_lookup.
13945 Builds a tree for RANGE.IDENTIFIER(). */
13947 static tree
13949 {
13957 releasing_vec vec;
13961 tf_warning_or_error);
13963 }
13965 /* Parse an iteration-statement.
13967 iteration-statement:
13968 while ( condition ) statement
13969 do statement while ( expression ) ;
13970 for ( init-statement condition [opt] ; expression [opt] )
13971 statement
13973 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
13975 static tree
13978 {
13981 tree statement;
13983 token_indent_info guard_tinfo;
13985 /* Peek at the next token. */
13992 /* Remember whether or not we are already within an iteration
13993 statement. */
13996 /* See what kind of keyword it is. */
13999 {
14001 {
14002 tree condition;
14004 /* Begin the while-statement. */
14006 /* Look for the `('. */
14007 matching_parens parens;
14009 /* Parse the condition. */
14012 /* Look for the `)'. */
14014 /* Parse the dependent statement. */
14020 /* We're done with the while-statement. */
14022 }
14026 {
14027 tree expression;
14029 /* Begin the do-statement. */
14031 /* Parse the body of the do-statement. */
14038 /* Look for the `while' keyword. */
14040 /* Look for the `('. */
14041 matching_parens parens;
14043 /* Parse the expression. */
14045 /* We're done with the do-statement. */
14047 /* Look for the `)'. */
14049 /* Look for the `;'. */
14051 }
14055 {
14056 /* Look for the `('. */
14057 matching_parens parens;
14062 /* Look for the `)'. */
14065 /* Parse the body of the for-statement. */
14072 /* We're done with the for-statement. */
14074 }
14081 }
14084 }
14086 /* Parse an init-statement or the declarator of a range-based-for.
14087 Returns true if a range-based-for declaration is seen.
14089 init-statement:
14090 expression-statement
14091 simple-declaration
14092 alias-declaration */
14094 static bool
14096 {
14097 /* If the next token is a `;', then we have an empty
14098 expression-statement. Grammatically, this is also a
14099 simple-declaration, but an invalid one, because it does not
14100 declare anything. Therefore, if we did not handle this case
14101 specially, we would issue an error message about an invalid
14102 declaration. */
14104 {
14108 /* A colon is used in range-based for. */
14111 /* We're going to speculatively look for a declaration, falling back
14112 to an expression, if necessary. */
14116 {
14122 OPT_Wc__23_extensions,
14123 "alias-declaration in init-statement only "
14125 }
14126 else
14127 /* Parse the declaration. */
14130 decl);
14133 {
14134 /* It is a range-for, consume the ':'. */
14139 OPT_Wc__11_extensions,
14140 "range-based %<for%> loops only available with "
14142 }
14144 /* The ';' is not consumed yet because we told
14145 cp_parser_simple_declaration not to. */
14150 /* If the tentative parse failed, then we shall need to look for an
14151 expression-statement. */
14152 }
14153 /* If we are here, it is an expression-statement. */
14156 }
14158 /* Parse a jump-statement.
14160 jump-statement:
14161 break ;
14162 continue ;
14163 return expression [opt] ;
14164 return braced-init-list ;
14165 coroutine-return-statement;
14166 goto identifier ;
14168 GNU extension:
14170 jump-statement:
14171 goto * expression ;
14173 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
14175 static tree
14177 {
14183 /* Peek at the next token. */
14188 /* See what kind of keyword it is. */
14191 {
14195 {
14212 }
14218 {
14222 /* Fall through. */
14232 }
14238 {
14239 tree expr;
14243 {
14247 }
14250 else
14251 /* If the next token is a `;', then there is no
14252 expression. */
14254 /* Build the return-statement, check co-return first, since type
14255 deduction is not valid there. */
14260 else
14262 /* Look for the final `;'. */
14264 }
14271 {
14275 }
14277 /* Create the goto-statement. */
14279 {
14280 /* Issue a warning about this use of a GNU extension. */
14282 /* Consume the '*' token. */
14284 /* Parse the dependent expression. */
14286 }
14287 else
14289 /* Look for the final `;'. */
14296 }
14299 }
14301 /* Parse a declaration-statement.
14303 declaration-statement:
14304 block-declaration */
14306 static void
14308 {
14311 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14314 /* Parse the block-declaration. */
14317 /* Free any declarators allocated. */
14319 }
14321 /* Some dependent statements (like `if (cond) statement'), are
14322 implicitly in their own scope. In other words, if the statement is
14323 a single statement (as opposed to a compound-statement), it is
14324 none-the-less treated as if it were enclosed in braces. Any
14325 declarations appearing in the dependent statement are out of scope
14326 after control passes that point. This function parses a statement,
14327 but ensures that is in its own scope, even if it is not a
14328 compound-statement.
14330 If IF_P is not NULL, *IF_P is set to indicate whether the statement
14331 is a (possibly labeled) if statement which is not enclosed in
14332 braces and has an else clause. This is used to implement
14333 -Wparentheses.
14335 CHAIN is a vector of if-else-if conditions. This is used to implement
14336 -Wduplicated-cond.
14338 Returns the new statement. */
14340 static tree
14344 {
14345 tree statement;
14348 token_indent_info body_tinfo
14354 /* Mark if () ; with a special NOP_EXPR. */
14356 {
14367 }
14368 /* if a compound is opened, we simply parse the statement directly. */
14371 /* If the token is not a `{', then we must take special action. */
14372 else
14373 {
14374 /* Create a compound-statement. */
14376 /* Parse the dependent-statement. */
14379 /* Finish the dummy compound-statement. */
14381 }
14383 token_indent_info next_tinfo
14392 /* Return the statement. */
14394 }
14396 /* For some dependent statements (like `while (cond) statement'), we
14397 have already created a scope. Therefore, even if the dependent
14398 statement is a compound-statement, we do not want to create another
14399 scope. */
14401 static void
14404 {
14405 /* If the token is a `{', then we must take special action. */
14407 {
14408 token_indent_info body_tinfo
14414 token_indent_info next_tinfo
14423 }
14424 else
14425 {
14426 /* Avoid calling cp_parser_compound_statement, so that we
14427 don't create a new scope. Do everything else by hand. */
14428 matching_braces braces;
14430 /* If the next keyword is `__label__' we have a label declaration. */
14433 /* Parse an (optional) statement-seq. */
14436 }
14437 }
14439 /* Modules */
14441 /* Parse a module-name,
14442 identifier
14443 module-name . identifier
14444 header-name
14446 Returns a pointer to module object, NULL. */
14450 {
14453 {
14457 }
14462 {
14465 }
14468 {
14470 {
14473 }
14484 }
14487 }
14489 /* Named module-declaration
14490 __module ; PRAGMA_EOL
14491 __module private ; PRAGMA_EOL (unimplemented)
14492 [__export] __module module-name attr-spec-seq-opt ; PRAGMA_EOL
14493 */
14495 static module_parse
14498 {
14499 /* We're a pseudo pragma. */
14504 {
14508 }
14511 {
14512 /* Start global module fragment. */
14517 }
14522 {
14531 "private module fragment only permitted in purview"
14533 else
14534 {
14537 }
14538 }
14540 {
14541 /* Neither the first declaration, nor in a GMF. */
14544 skip_eol:
14546 }
14547 else
14548 {
14558 }
14561 }
14563 /* Import-declaration
14564 [__export] __import module-name attr-spec-seq-opt ; PRAGMA_EOL */
14566 static void
14569 {
14570 /* We're a pseudo pragma. */
14578 {
14581 note_lexer:
14583 " disambiguation, to prevent this being considered a"
14585 skip_eol:
14587 }
14589 {
14592 }
14593 else
14594 {
14606 /* Module-purview imports must not be from source inclusion
14607 [cpp.import]/7 */
14620 }
14621 }
14623 /* export-declaration.
14625 export declaration
14626 export { declaration-seq-opt } */
14628 static void
14630 {
14649 {
14656 }
14657 else
14658 {
14659 /* Explicitly check if the next tokens might be a
14660 module-directive line, so we can give a clearer error message
14661 about why the directive will be rejected. */
14668 }
14671 }
14673 /* Declarations [gram.dcl.dcl] */
14675 /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
14676 is the top-level declaration sequence. That affects whether we
14677 deal with module-preamble.
14679 declaration-seq:
14680 declaration
14681 declaration-seq declaration */
14683 static void
14685 {
14687 {
14693 else
14695 }
14696 }
14698 /* Parse a declaration.
14700 declaration:
14701 block-declaration
14702 function-definition
14703 template-declaration
14704 explicit-instantiation
14705 explicit-specialization
14706 linkage-specification
14707 namespace-definition
14709 C++17:
14710 deduction-guide
14712 modules:
14713 (all these are only allowed at the outermost level, check
14714 that semantically, for better diagnostics)
14715 module-declaration
14716 module-export-declaration
14717 module-import-declaration
14718 export-declaration
14720 GNU extension:
14722 declaration:
14723 __extension__ declaration */
14725 static void
14727 {
14730 /* Check for the `__extension__' keyword. */
14732 {
14733 /* Parse the qualified declaration. */
14735 /* Restore the PEDANTIC flag. */
14739 }
14741 /* Try to figure out what kind of declaration is present. */
14747 {
14749 /* A declaration consisting of a single semicolon is invalid
14750 * before C++11. Allow it unless we're being pedantic. */
14754 }
14758 CPP_SEMICOLON))
14759 {
14764 {
14767 std_attrs);
14769 {
14772 {
14774 CPP_PRAGMA));
14776 }
14778 }
14779 }
14787 }
14789 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14794 /* Conditionally, allow attributes to precede a linkage specification. */
14796 {
14804 {
14806 /* We might have already been here. */
14808 {
14816 }
14819 }
14820 else
14821 {
14824 }
14825 }
14826 /* If we already had some attributes, and we've added more, then prepend.
14827 Otherwise attributes just contains any that we just read. */
14829 {
14833 }
14835 /* If the next token is `extern' and the following token is a string
14836 literal, then we have a linkage specification. */
14840 /* If the next token is `template', then we have either a template
14841 declaration, an explicit instantiation, or an explicit
14842 specialization. */
14844 {
14845 /* `template <>' indicates a template specialization. */
14849 /* `template <' indicates a template declaration. */
14852 /* Anything else must be an explicit instantiation. */
14853 else
14855 }
14856 /* If the next token is `export', it's new-style modules or
14857 old-style template. */
14859 {
14862 else
14864 }
14868 {
14875 else
14877 }
14878 /* If the next token is `extern', 'static' or 'inline' and the one
14879 after that is `template', we have a GNU extended explicit
14880 instantiation directive. */
14887 /* If the next token is `namespace', check for a named or unnamed
14888 namespace definition. */
14897 /* An unnamed namespace definition. */
14901 /* An inline (associated) namespace definition. */
14905 /* Objective-C++ declaration/definition. */
14912 /* At this point we may have a template declared by a concept
14913 introduction. */
14918 else
14919 /* Try to parse a block-declaration, or a function-definition. */
14922 /* Free any declarators allocated. */
14924 }
14926 /* Parse a namespace-scope declaration. */
14928 static void
14930 {
14934 /* A top-level declaration can consist solely of a #pragma. A
14935 nested declaration cannot, so this is done here and not in
14936 cp_parser_declaration. (A #pragma at block scope is
14937 handled in cp_parser_statement.) */
14939 else
14940 /* Parse the declaration itself. */
14942 }
14944 /* Parse a block-declaration.
14946 block-declaration:
14947 simple-declaration
14948 asm-definition
14949 namespace-alias-definition
14950 using-declaration
14951 using-directive
14953 GNU Extension:
14955 block-declaration:
14956 __extension__ block-declaration
14958 C++0x Extension:
14960 block-declaration:
14961 static_assert-declaration
14963 If STATEMENT_P is TRUE, then this block-declaration is occurring as
14964 part of a declaration-statement. */
14966 static void
14969 {
14972 /* Check for the `__extension__' keyword. */
14974 {
14975 /* Parse the qualified declaration. */
14977 /* Restore the PEDANTIC flag. */
14981 }
14983 /* Peek at the next token to figure out which kind of declaration is
14984 present. */
14988 /* If the next keyword is `asm', we have an asm-definition. */
14990 {
14994 }
14995 /* If the next keyword is `namespace', we have a
14996 namespace-alias-definition. */
14999 /* If the next keyword is `using', we have a
15000 using-declaration, a using-directive, or an alias-declaration. */
15002 {
15007 /* If the token after `using' is `namespace', then we have a
15008 using-directive. */
15014 /* If the second token after 'using' is '=', then we have an
15015 alias-declaration. */
15021 /* Otherwise, it's a using-declaration. */
15022 else
15025 }
15026 /* If the next keyword is `__label__' we have a misplaced label
15027 declaration. */
15029 {
15033 /* If the next token is now a `;', consume it. */
15036 }
15037 /* If the next token is `static_assert' we have a static assertion. */
15040 /* If the next tokens after attributes is `using namespace', then we have
15041 a using-directive. */
15044 RID_USING)
15046 RID_NAMESPACE))
15047 {
15051 }
15052 /* Anything else must be a simple-declaration. */
15053 else
15056 }
15058 /* Parse a simple-declaration.
15060 simple-declaration:
15061 decl-specifier-seq [opt] init-declarator-list [opt] ;
15062 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15063 brace-or-equal-initializer ;
15065 init-declarator-list:
15066 init-declarator
15067 init-declarator-list , init-declarator
15069 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
15070 function-definition as a simple-declaration.
15072 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15073 parsed declaration if it is an uninitialized single declarator not followed
15074 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15075 if present, will not be consumed. */
15077 static void
15081 {
15082 cp_decl_specifier_seq decl_specifiers;
15091 /* Defer access checks until we know what is being declared; the
15092 checks for names appearing in the decl-specifier-seq should be
15093 done as if we were in the scope of the thing being declared. */
15096 /* Parse the decl-specifier-seq. We have to keep track of whether
15097 or not the decl-specifier-seq declares a named class or
15098 enumeration type, since that is the only case in which the
15099 init-declarator-list is allowed to be empty.
15101 [dcl.dcl]
15103 In a simple-declaration, the optional init-declarator-list can be
15104 omitted only when declaring a class or enumeration, that is when
15105 the decl-specifier-seq contains either a class-specifier, an
15106 elaborated-type-specifier, or an enum-specifier. */
15108 CP_PARSER_FLAGS_OPTIONAL,
15111 /* We no longer need to defer access checks. */
15114 cp_omp_declare_simd_data odsd;
15120 /* In a block scope, a valid declaration must always have a
15121 decl-specifier-seq. By not trying to parse declarators, we can
15122 resolve the declaration/expression ambiguity more quickly. */
15125 {
15128 }
15130 /* If the next two tokens are both identifiers, the code is
15131 erroneous. The usual cause of this situation is code like:
15133 T t;
15135 where "T" should name a type -- but does not. */
15138 {
15139 /* If parsing tentatively, we should commit; we really are
15140 looking at a declaration. */
15142 /* Give up. */
15144 }
15148 /* Look for C++17 decomposition declaration. */
15156 {
15157 tree decl
15159 maybe_range_for_decl,
15162 /* The next token should be either a `,' or a `;'. */
15164 /* If it's a `;', we are done. */
15168 {
15172 }
15173 /* Anything else is an error. */
15174 else
15175 {
15176 /* If we have already issued an error message we don't need
15177 to issue another one. */
15182 /* Skip tokens until we reach the end of the statement. */
15184 /* If the next token is now a `;', consume it. */
15188 }
15189 }
15190 else
15193 tree last_type;
15195 /* NULL_TREE if both variable and function declaration are allowed,
15196 error_mark_node if function declaration are not allowed and
15197 a FUNCTION_DECL that should be diagnosed if it is followed by
15198 variable declarations. */
15199 tree auto_function_declaration;
15202 auto_specifier_p
15206 /* Keep going until we hit the `;' at the end of the simple
15207 declaration. */
15210 CPP_SEMICOLON))
15211 {
15214 tree decl;
15218 {
15219 /* If we are processing next declarator, comma is expected */
15224 {
15228 }
15229 }
15230 else
15233 /* Parse the init-declarator. */
15235 CP_PARSER_FLAGS_NONE,
15238 function_definition_allowed_p,
15240 declares_class_or_enum,
15242 maybe_range_for_decl,
15245 /* If an error occurred while parsing tentatively, exit quickly.
15246 (That usually happens when in the body of a function; each
15247 statement is treated as a declaration-statement until proven
15248 otherwise.) */
15253 {
15254 /* If the init-declarator-list contains more than one
15255 init-declarator, they shall all form declarations of
15256 variables. */
15258 auto_function_declaration
15262 {
15264 "non-variable %qD in declaration with more than one "
15269 }
15270 }
15274 {
15278 {
15279 /* If the list of declarators contains more than one declarator,
15280 the type of each declared variable is determined as described
15281 above. If the type deduced for the template parameter U is not
15282 the same in each deduction, the program is ill-formed. */
15287 }
15288 else
15290 }
15292 /* Handle function definitions specially. */
15294 {
15295 /* If the next token is a `,', then we are probably
15296 processing something like:
15298 void f() {}, *p;
15300 which is erroneous. */
15302 {
15305 "mixing"
15307 }
15308 /* Otherwise, we're done with the list of declarators. */
15309 else
15310 {
15314 }
15315 }
15318 /* The next token should be either a `,' or a `;'. */
15320 /* If it's a `,', there are more declarators to come. */
15323 /* If it's a `;', we are done. */
15327 {
15332 }
15333 /* Anything else is an error. */
15334 else
15335 {
15336 /* If we have already issued an error message we don't need
15337 to issue another one. */
15342 /* Skip tokens until we reach the end of the statement. */
15344 /* If the next token is now a `;', consume it. */
15348 }
15349 /* After the first time around, a function-definition is not
15350 allowed -- even if it was OK at first. For example:
15352 int i, f() {}
15354 is not valid. */
15356 }
15358 /* Issue an error message if no declarators are present, and the
15359 decl-specifier-seq does not itself declare a class or
15360 enumeration: [dcl.dcl]/3. */
15362 {
15364 {
15368 /* Ensure an error is issued anyway when finish_decltype_type,
15369 called via cp_parser_decl_specifier_seq, returns a class or
15370 an enumeration (c++/51786). */
15373 }
15374 /* Perform any deferred access checks. */
15376 }
15378 /* Consume the `;'. */
15379 finish:
15383 {
15389 }
15391 done:
15394 }
15396 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
15397 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15398 initializer ; */
15400 static tree
15405 {
15410 /* Parse the identifier-list. */
15414 {
15422 }
15426 {
15432 else
15433 {
15436 }
15437 }
15441 "structured bindings only available with "
15444 tree pushed_scope;
15451 NULL_TREE);
15458 cp_expr e;
15459 cp_decl_specifier_seq decl_specs;
15464 {
15468 else
15469 {
15472 }
15473 tree elt_pushed_scope;
15479 {
15480 /* Ensure we've diagnosed redeclaration if we aren't creating
15481 a new VAR_DECL. */
15484 }
15485 else
15489 }
15492 {
15495 }
15499 {
15507 || (is_direct_init
15510 {
15514 }
15517 {
15522 }
15523 }
15525 {
15527 /* Ensure DECL_VALUE_EXPR is created for all the decls but
15528 the underlying DECL. */
15530 }
15536 {
15539 }
15542 }
15544 /* Parse a decl-specifier-seq.
15546 decl-specifier-seq:
15547 decl-specifier-seq [opt] decl-specifier
15548 decl-specifier attribute-specifier-seq [opt] (C++11)
15550 decl-specifier:
15551 storage-class-specifier
15552 type-specifier
15553 function-specifier
15554 friend
15555 typedef
15557 GNU Extension:
15559 decl-specifier:
15560 attributes
15562 Concepts Extension:
15564 decl-specifier:
15565 concept
15567 Set *DECL_SPECS to a representation of the decl-specifier-seq.
15569 The parser flags FLAGS is used to control type-specifier parsing.
15571 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
15572 flags:
15574 1: one of the decl-specifiers is an elaborated-type-specifier
15575 (i.e., a type declaration)
15576 2: one of the decl-specifiers is an enum-specifier or a
15577 class-specifier (i.e., a type definition)
15579 */
15581 static void
15583 cp_parser_flags flags,
15586 {
15590 cp_decl_spec ds;
15592 /* Clear DECL_SPECS. */
15595 /* Assume no class or enumeration type is declared. */
15598 /* Keep reading specifiers until there are no more to read. */
15600 {
15605 /* Peek at the next token. */
15608 /* Save the first token of the decl spec list for error
15609 reporting. */
15612 /* Handle attributes. */
15615 {
15616 /* Parse the attributes. */
15619 /* In a sequence of declaration specifiers, c++11 attributes
15620 appertain to the type that precede them. In that case
15621 [dcl.spec]/1 says:
15623 The attribute-specifier-seq affects the type only for
15624 the declaration it appears in, not other declarations
15625 involving the same type.
15627 But for now let's force the user to position the
15628 attribute either at the beginning of the declaration or
15629 after the declarator-id, which would clearly mean that it
15630 applies to the declarator. */
15632 {
15634 /* The c++11 attribute is at the beginning of the
15635 declaration. It appertains to the entity being
15637 else
15638 {
15640 {
15641 /* This is an attribute following a
15642 class-specifier. */
15647 }
15648 else
15649 {
15650 decl_specs->std_attributes
15654 }
15656 }
15657 }
15659 decl_specs->attributes
15664 }
15665 /* Assume we will find a decl-specifier keyword. */
15667 /* If the next token is an appropriate keyword, we can simply
15668 add it to the list. */
15670 {
15671 /* decl-specifier:
15672 friend
15673 constexpr
15674 constinit */
15677 {
15682 }
15683 else
15684 {
15686 /* Consume the token. */
15688 }
15713 /* Warn for concept as a decl-specifier. We'll rewrite these as
15714 concept declarations later. */
15716 {
15721 else
15724 }
15726 /* In C++20 a concept definition is just 'concept name = expr;'
15727 Support that syntax as a TS extension by pretending we've seen
15728 the 'bool' specifier. */
15732 {
15736 }
15739 /* function-specifier:
15740 inline
15741 virtual
15742 explicit */
15749 /* decl-specifier:
15750 typedef */
15753 /* Consume the token. */
15759 /* A constructor declarator cannot appear in a typedef. */
15761 /* The "typedef" keyword can only occur in a declaration; we
15762 may as well commit at this point. */
15769 /* storage-class-specifier:
15770 auto
15771 register
15772 static
15773 extern
15774 mutable
15776 GNU Extension:
15777 thread */
15780 {
15781 /* Consume the token. */
15784 /* Complain about `auto' as a storage specifier, if
15785 we're complaining about C++0x compatibility. */
15789 "%<auto%> changes meaning in C++11; "
15792 /* Set the storage class anyway. */
15794 token);
15795 }
15796 else
15797 /* C++0x auto type-specifier. */
15805 /* Consume the token. */
15808 token);
15811 /* Consume the token. */
15817 /* We did not yet find a decl-specifier yet. */
15820 }
15838 /* Constructors are a special case. The `S' in `S()' is not a
15839 decl-specifier; it is the beginning of the declarator. */
15840 constructor_p
15841 = (!found_decl_spec
15842 && constructor_possible_p
15843 && (cp_parser_constructor_declarator_p
15845 ds_friend))));
15847 /* If we don't have a DECL_SPEC yet, then we must be looking at
15848 a type-specifier. */
15850 {
15853 tree type_spec;
15858 type_spec
15860 decl_specs,
15866 /* If this type-specifier referenced a user-defined type
15867 (a typedef, class-name, etc.), then we can't allow any
15868 more such type-specifiers henceforth.
15870 [dcl.spec]
15872 The longest sequence of decl-specifiers that could
15873 possibly be a type name is taken as the
15874 decl-specifier-seq of a declaration. The sequence shall
15875 be self-consistent as described below.
15877 [dcl.type]
15879 As a general rule, at most one type-specifier is allowed
15880 in the complete decl-specifier-seq of a declaration. The
15881 only exceptions are the following:
15883 -- const or volatile can be combined with any other
15884 type-specifier.
15886 -- signed or unsigned can be combined with char, long,
15887 short, or int.
15889 -- ..
15891 Example:
15893 typedef char* Pc;
15894 void g (const int Pc);
15896 Here, Pc is *not* part of the decl-specifier seq; it's
15897 the declarator. Therefore, once we see a type-specifier
15898 (other than a cv-qualifier), we forbid any additional
15899 user-defined types. We *do* still allow things like `int
15900 int' to be considered a decl-specifier-seq, and issue the
15901 error message later. */
15904 /* A constructor declarator cannot follow a type-specifier. */
15906 {
15914 }
15915 }
15917 /* If we still do not have a DECL_SPEC, then there are no more
15918 decl-specifiers. */
15923 {
15927 "standard attributes must precede the decl-specifiers to "
15928 "apply to the declaration, or follow them to apply to "
15930 }
15933 /* After we see one decl-specifier, further decl-specifiers are
15934 always optional. */
15936 }
15938 /* Don't allow a friend specifier with a class definition. */
15943 }
15945 /* Parse an (optional) storage-class-specifier.
15947 storage-class-specifier:
15948 auto
15949 register
15950 static
15951 extern
15952 mutable
15954 GNU Extension:
15956 storage-class-specifier:
15957 thread
15959 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
15961 static tree
15963 {
15965 {
15969 /* Fall through for C++98. */
15977 /* Consume the token. */
15982 }
15983 }
15985 /* Parse an (optional) function-specifier.
15987 function-specifier:
15988 inline
15989 virtual
15990 explicit
15992 C++20 Extension:
15993 explicit(constant-expression)
15995 Returns an IDENTIFIER_NODE corresponding to the keyword used.
15996 Updates DECL_SPECS, if it is non-NULL. */
15998 static tree
16001 {
16004 {
16010 /* 14.5.2.3 [temp.mem]
16012 A member function template shall not be virtual. */
16016 else
16021 {
16023 /* If we see '(', it's C++20 explicit(bool). */
16024 tree expr;
16026 {
16027 matching_parens parens;
16030 /* New types are not allowed in an explicit-specifier. */
16033 parser->type_definition_forbidden_message
16038 "%<explicit(bool)%> only available with %<-std=c++20%> "
16041 /* Parse the constant-expression. */
16044 /* Restore the saved message. */
16047 }
16048 else
16049 /* The explicit-specifier explicit without a constant-expression is
16050 equivalent to the explicit-specifier explicit(true). */
16053 /* [dcl.fct.spec]
16054 "the constant-expression, if supplied, shall be a contextually
16055 converted constant expression of type bool." */
16057 /* We could evaluate it -- mark the decl as appropriate. */
16063 /* The expression was value-dependent. Remember it so that we can
16064 substitute it later. */
16067 }
16071 }
16073 /* Consume the token. */
16075 }
16077 /* Parse a linkage-specification.
16079 linkage-specification:
16080 extern string-literal { declaration-seq [opt] }
16081 extern string-literal declaration */
16083 static void
16085 {
16086 tree linkage;
16088 /* Look for the `extern' keyword. */
16089 cp_token *extern_token
16092 /* Look for the string-literal. */
16096 /* Transform the literal into an identifier. If the literal is a
16097 wide-character string, or contains embedded NULs, then we can't
16098 handle it as the user wants. */
16101 {
16103 /* Assume C++ linkage. */
16105 }
16106 else
16109 /* We're now using the new linkage. */
16112 /* Preserve the location of the innermost linkage specification,
16113 tracking the locations of nested specifications via a local. */
16114 location_t saved_location
16116 /* Construct a location ranging from the start of the "extern" to
16117 the end of the string-literal, with the caret at the start, e.g.:
16118 extern "C" {
16119 ^~~~~~~~~~
16120 */
16121 parser->innermost_linkage_specification_location
16126 /* If the next token is a `{', then we're using the first
16127 production. */
16129 {
16133 /* Consume the `{' token. */
16134 matching_braces braces;
16136 /* Parse the declarations. */
16138 /* Look for the closing `}'. */
16140 }
16141 /* Otherwise, there's just one declaration. */
16142 else
16143 {
16146 saved_in_unbraced_linkage_specification_p
16150 parser->in_unbraced_linkage_specification_p
16152 }
16154 /* We're done with the linkage-specification. */
16157 /* Restore location of parent linkage specification, if any. */
16159 }
16161 /* Parse a static_assert-declaration.
16163 static_assert-declaration:
16164 static_assert ( constant-expression , string-literal ) ;
16165 static_assert ( constant-expression ) ; (C++17)
16167 If MEMBER_P, this static_assert is a class member. */
16169 static void
16171 {
16172 cp_expr condition;
16173 location_t token_loc;
16174 tree message;
16177 /* Peek at the `static_assert' token so we can keep track of exactly
16178 where the static assertion started. */
16181 /* Look for the `static_assert' keyword. */
16183 RT_STATIC_ASSERT))
16186 /* We know we are in a static assertion; commit to any tentative
16187 parse. */
16191 /* Parse the `(' starting the static assertion condition. */
16192 matching_parens parens;
16195 /* Parse the constant-expression. Allow a non-constant expression
16196 here in order to give better diagnostics in finish_static_assert. */
16197 condition =
16203 {
16206 "%<static_assert%> without a message "
16208 /* Eat the ')' */
16213 }
16214 else
16215 {
16216 /* Parse the separating `,'. */
16219 /* Parse the string-literal message. */
16224 /* A `)' completes the static assertion. */
16230 }
16232 /* A semicolon terminates the declaration. */
16235 /* Get the location for the static assertion. Use that of the
16236 condition if available, otherwise, use that of the "static_assert"
16237 token. */
16242 /* Complete the static assertion, which may mean either processing
16243 the static assert now or saving it for template instantiation. */
16246 }
16248 /* Parse the expression in decltype ( expression ). */
16250 static tree
16253 {
16255 tree expr;
16257 /* First, try parsing an id-expression. */
16268 {
16271 cp_id_kind idk;
16275 /* Lookup the name we got back from the id-expression. */
16280 /* A template without args is not a complete id-expression. */
16289 {
16290 /* Complete lookup of the id-expression. */
16291 expr = (finish_id_expression
16304 /* We found an id-expression, but it was something that we
16305 should not have found. This is an error, not something
16306 we can recover from, so note that we found an
16307 id-expression and we'll recover as gracefully as
16308 possible. */
16310 }
16315 /* We have an id-expression. */
16317 }
16320 {
16321 /* Abort the id-expression parse. */
16324 /* Parsing tentatively, again. */
16327 /* Parse a class member access. */
16335 /* We have an id-expression. */
16337 }
16340 /* We have parsed the complete id-expression or member access. */
16342 else
16343 {
16344 /* Abort our attempt to parse an id-expression or member access
16345 expression. */
16348 /* Parse a full expression. */
16351 }
16354 }
16356 /* Parse a `decltype' type. Returns the type.
16358 decltype-specifier:
16359 decltype ( expression )
16360 C++14:
16361 decltype ( auto ) */
16363 static tree
16365 {
16370 {
16371 /* Already parsed. */
16374 }
16376 /* Look for the `decltype' token. */
16380 /* Parse the opening `('. */
16381 matching_parens parens;
16385 /* Since we're going to preserve any side-effects from this parse, set up a
16386 firewall to protect our callers from cp_parser_commit_to_tentative_parse
16387 in the expression. */
16390 /* If in_declarator_p, a reparse as an expression might succeed (60361).
16391 Otherwise, commit now for better diagnostics. */
16402 {
16403 /* decltype (auto) */
16406 {
16408 "%<decltype(auto)%> type specifier only available with "
16411 }
16412 }
16413 else
16414 {
16415 /* decltype (expression) */
16417 /* Types cannot be defined in a `decltype' expression. Save away the
16418 old message and set the new one. */
16420 parser->type_definition_forbidden_message
16423 /* The restrictions on constant-expressions do not apply inside
16424 decltype expressions. */
16425 bool saved_integral_constant_expression_p
16427 bool saved_non_integral_constant_expression_p
16431 /* Within a parenthesized expression, a `>' token is always
16432 the greater-than operator. */
16433 bool saved_greater_than_is_operator_p
16437 /* Do not actually evaluate the expression. */
16440 /* Do not warn about problems with the expression. */
16446 /* Go back to evaluating expressions. */
16450 /* The `>' token might be the end of a template-id or
16451 template-parameter-list now. */
16452 parser->greater_than_is_operator_p
16455 /* Restore the old message and the integral constant expression
16456 flags. */
16458 parser->integral_constant_expression_p
16460 parser->non_integral_constant_expression_p
16462 }
16464 /* Parse to the closing `)'. */
16466 {
16470 }
16472 /* If we got a parse error while tentative, bail out now. */
16474 {
16477 }
16480 /* Build auto. */
16482 else
16484 tf_warning_or_error);
16486 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
16487 it again. */
16504 }
16506 /* Special member functions [gram.special] */
16508 /* Parse a conversion-function-id.
16510 conversion-function-id:
16511 operator conversion-type-id
16513 Returns an IDENTIFIER_NODE representing the operator. */
16515 static tree
16517 {
16518 tree type;
16519 tree saved_scope;
16520 tree saved_qualifying_scope;
16521 tree saved_object_scope;
16524 /* Look for the `operator' token. */
16527 /* When we parse the conversion-type-id, the current scope will be
16528 reset. However, we need that information in able to look up the
16529 conversion function later, so we save it here. */
16533 /* We must enter the scope of the class so that the names of
16534 entities declared within the class are available in the
16535 conversion-type-id. For example, consider:
16537 struct S {
16538 typedef int I;
16539 operator I();
16540 };
16542 S::operator I() { ... }
16544 In order to see that `I' is a type-name in the definition, we
16545 must be in the scope of `S'. */
16548 /* Parse the conversion-type-id. */
16550 /* Leave the scope of the class, if any. */
16553 /* Restore the saved scope. */
16557 /* If the TYPE is invalid, indicate failure. */
16561 }
16563 /* Parse a conversion-type-id:
16565 conversion-type-id:
16566 type-specifier-seq conversion-declarator [opt]
16568 Returns the TYPE specified. */
16570 static tree
16572 {
16573 tree attributes;
16574 cp_decl_specifier_seq type_specifiers;
16576 tree type_specified;
16579 /* Parse the attributes. */
16583 parser->type_definition_forbidden_message
16586 /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
16587 optional in conversion-type-id. */
16595 /* If that didn't work, stop. */
16598 /* Parse the conversion-declarator. */
16606 /* Don't give this error when parsing tentatively. This happens to
16607 work because we always parse this definitively once. */
16610 {
16612 {
16615 }
16619 }
16622 }
16624 /* Parse an (optional) conversion-declarator.
16626 conversion-declarator:
16627 ptr-operator conversion-declarator [opt]
16629 */
16633 {
16636 cp_cv_quals cv_quals;
16638 /* We don't know if there's a ptr-operator next, or not. */
16640 /* Try the ptr-operator. */
16643 /* If it worked, look for more conversion-declarators. */
16645 {
16648 /* Parse another optional declarator. */
16651 declarator = cp_parser_make_indirect_declarator
16655 }
16658 }
16660 /* Parse an (optional) ctor-initializer.
16662 ctor-initializer:
16663 : mem-initializer-list */
16665 static void
16667 {
16668 /* If the next token is not a `:', then there is no
16669 ctor-initializer. */
16671 {
16672 /* Do default initialization of any bases and members. */
16676 }
16678 /* Consume the `:' token. */
16680 /* And the mem-initializer-list. */
16682 }
16684 /* Parse a mem-initializer-list.
16686 mem-initializer-list:
16687 mem-initializer ... [opt]
16688 mem-initializer ... [opt] , mem-initializer-list */
16690 static void
16692 {
16697 /* Let the semantic analysis code know that we are starting the
16698 mem-initializer-list. */
16703 /* Loop through the list. */
16705 {
16706 tree mem_initializer;
16709 /* Parse the mem-initializer. */
16711 /* If the next token is a `...', we're expanding member initializers. */
16717 {
16718 /* Consume the `...'. */
16722 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
16723 can be expanded but members cannot. */
16726 {
16731 }
16733 /* Construct the pack expansion type. */
16736 }
16739 {
16743 }
16744 /* Look for a target constructor. */
16748 {
16751 {
16755 }
16757 }
16758 /* Add it to the list, unless it was erroneous. */
16760 {
16763 }
16764 /* If the next token is not a `,', we're done. */
16767 /* Consume the `,' token. */
16769 }
16771 /* Perform semantic analysis. */
16774 }
16776 /* Parse a mem-initializer.
16778 mem-initializer:
16779 mem-initializer-id ( expression-list [opt] )
16780 mem-initializer-id braced-init-list
16782 GNU extension:
16784 mem-initializer:
16785 ( expression-list [opt] )
16787 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
16788 class) or FIELD_DECL (for a non-static data member) to initialize;
16789 the TREE_VALUE is the expression-list. An empty initialization
16790 list is represented by void_list_node. */
16792 static tree
16794 {
16795 tree mem_initializer_id;
16796 tree expression_list;
16797 tree member;
16800 /* Find out what is being initialized. */
16802 {
16806 }
16807 else
16808 {
16812 }
16818 {
16825 }
16826 else
16827 {
16839 }
16852 /* We can't attach the source location of this initializer directly to
16853 the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
16854 within the TREE_TYPE of the list node. */
16855 location_t loc
16862 }
16864 /* Parse a mem-initializer-id.
16866 mem-initializer-id:
16867 :: [opt] nested-name-specifier [opt] class-name
16868 decltype-specifier (C++11)
16869 identifier
16871 Returns a TYPE indicating the class to be initialized for the first
16872 production (and the second in C++11). Returns an IDENTIFIER_NODE
16873 indicating the data member to be initialized for the last production. */
16875 static tree
16877 {
16881 tree id;
16885 /* `typename' is not allowed in this context ([temp.res]). */
16887 {
16889 "keyword %<typename%> not allowed in this context (a qualified "
16892 }
16893 /* Look for the optional `::' operator. */
16894 global_scope_p
16898 /* Look for the optional nested-name-specifier. The simplest way to
16899 implement:
16901 [temp.res]
16903 The keyword `typename' is not permitted in a base-specifier or
16904 mem-initializer; in these contexts a qualified name that
16905 depends on a template-parameter is implicitly assumed to be a
16906 type name.
16908 is to assume that we have seen the `typename' keyword at this
16909 point. */
16910 nested_name_specifier_p
16919 /* If there is a `::' operator or a nested-name-specifier, then we
16920 are definitely looking for a class-name. */
16925 typename_type,
16929 /* Otherwise, we could also be looking for an ordinary identifier. */
16932 /* Try a decltype-specifier. */
16934 else
16935 /* Otherwise, try a class-name. */
16939 none_type,
16943 /* If we found one, we're done. */
16946 /* Otherwise, look for an ordinary identifier. */
16948 }
16950 /* Overloading [gram.over] */
16952 /* Parse an operator-function-id.
16954 operator-function-id:
16955 operator operator
16957 Returns an IDENTIFIER_NODE for the operator which is a
16958 human-readable spelling of the identifier, e.g., `operator +'. */
16960 static cp_expr
16962 {
16964 /* Look for the `operator' keyword. */
16967 /* And then the name of the operator itself. */
16969 }
16971 /* Return an identifier node for a user-defined literal operator.
16972 The suffix identifier is chained to the operator name identifier. */
16974 tree
16976 {
16977 tree identifier;
16985 }
16987 /* Parse an operator.
16989 operator:
16990 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
16991 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
16992 || ++ -- , ->* -> () []
16994 GNU Extensions:
16996 operator:
16997 <? >? <?= >?=
16999 Returns an IDENTIFIER_NODE for the operator which is a
17000 human-readable spelling of the identifier, e.g., `operator +'. */
17002 static cp_expr
17004 {
17009 /* Peek at the next token. */
17014 /* Figure out which operator we have. */
17019 {
17021 {
17022 /* The keyword should be either `new', `delete' or `co_await'. */
17029 else
17032 /* Consume the `new', `delete' or co_await token. */
17035 /* Peek at the next token. */
17037 /* If it's a `[' token then this is the array variant of the
17038 operator. */
17041 {
17042 /* Consume the `[' token. */
17044 /* Look for the `]' token. */
17049 }
17052 }
17215 /* Consume the `?'. */
17217 /* Look for the matching `:'. */
17223 {
17224 /* Consume the `('. */
17225 matching_parens parens;
17227 /* Look for the matching `)'. */
17234 }
17237 /* Consume the `['. */
17239 /* Look for the matching `]'. */
17250 /* FALLTHRU */
17259 {
17260 cp_expr str;
17261 tree string_tree;
17267 /* Consume the string. */
17273 {
17277 }
17278 else
17279 {
17281 /* Look for the suffix identifier. */
17284 {
17287 }
17289 {
17293 }
17294 else
17295 {
17298 }
17299 }
17304 {
17307 }
17310 {
17313 }
17315 {
17318 }
17319 /* Generate a location of the form:
17320 "" _suffix_identifier
17321 ^~~~~~~~~~~~~~~~~~~~~
17322 with caret == start at the start token, finish at the end of the
17323 suffix identifier. */
17324 location_t combined_loc
17327 }
17330 /* Anything else is an error. */
17332 }
17334 /* If we have selected an identifier, we need to consume the
17335 operator token. */
17337 {
17341 }
17342 /* Otherwise, no valid operator name was present. */
17343 else
17344 {
17347 }
17351 }
17353 /* Parse a template-declaration.
17355 template-declaration:
17356 export [opt] template < template-parameter-list > declaration
17358 If MEMBER_P is TRUE, this template-declaration occurs within a
17359 class-specifier.
17361 The grammar rule given by the standard isn't correct. What
17362 is really meant is:
17364 template-declaration:
17365 export [opt] template-parameter-list-seq
17366 decl-specifier-seq [opt] init-declarator [opt] ;
17367 export [opt] template-parameter-list-seq
17368 function-definition
17370 template-parameter-list-seq:
17371 template-parameter-list-seq [opt]
17372 template < template-parameter-list >
17374 Concept Extensions:
17376 template-parameter-list-seq:
17377 template < template-parameter-list > requires-clause [opt]
17379 requires-clause:
17380 requires logical-or-expression */
17382 static void
17384 {
17385 /* Check for `export'. */
17387 {
17388 /* Consume the `export' token. */
17390 /* Warn that this use of export is deprecated. */
17395 else
17397 }
17400 }
17402 /* Parse a template-parameter-list.
17404 template-parameter-list:
17405 template-parameter
17406 template-parameter-list , template-parameter
17408 Returns a TREE_LIST. Each node represents a template parameter.
17409 The nodes are connected via their TREE_CHAINs. */
17411 static tree
17413 {
17416 /* Don't create wrapper nodes within a template-parameter-list,
17417 since we don't want to have different types based on the
17418 spelling location of constants and decls within them. */
17419 auto_suppress_location_wrappers sentinel;
17423 /* The loop below parses the template parms. We first need to know
17424 the total number of template parms to be able to compute proper
17425 canonical types of each dependent type. So after the loop, when
17426 we know the total number of template parms,
17427 end_template_parm_list computes the proper canonical types and
17428 fixes up the dependent types accordingly. */
17430 {
17431 tree parameter;
17434 location_t parm_loc;
17436 /* Parse the template-parameter. */
17441 /* Add it to the list. */
17444 parm_loc,
17445 parameter,
17446 is_non_type,
17447 is_parameter_pack);
17448 else
17449 {
17452 }
17454 /* If the next token is not a `,', we're done. */
17457 /* Otherwise, consume the `,' token. */
17459 }
17462 }
17464 /* Parse a introduction-list.
17466 introduction-list:
17467 introduced-parameter
17468 introduction-list , introduced-parameter
17470 introduced-parameter:
17471 ...[opt] identifier
17473 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
17474 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
17475 WILDCARD_DECL will also have DECL_NAME set and token location in
17476 DECL_SOURCE_LOCATION. */
17478 static tree
17480 {
17484 {
17493 /* Build placeholder. */
17501 /* If the next token is not a `,', we're done. */
17504 /* Otherwise, consume the `,' token. */
17506 }
17508 /* Convert the vec into a TREE_VEC. */
17511 tree parm;
17517 }
17519 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
17520 is an abstract declarator. */
17524 {
17529 }
17531 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
17532 is an abstract declarator. */
17536 {
17540 else
17542 }
17544 /* Returns true if TYPE would declare a constrained constrained-parameter. */
17548 {
17553 }
17555 /* Returns true if PARM declares a constrained-parameter. */
17559 {
17561 }
17563 /* Check that the type parameter is only a declarator-id, and that its
17564 type is not cv-qualified. */
17566 bool
17569 {
17574 {
17577 }
17579 /* Don't allow cv-qualified type parameters. */
17582 {
17585 }
17588 }
17590 /* Finish parsing/processing a template type parameter and checking
17591 various restrictions. */
17595 tree id,
17597 {
17600 else
17602 }
17604 static tree
17606 {
17607 /* FIXME: This should probably be copied, and we may need to adjust
17608 the template parameter depths. */
17618 }
17620 /* Finish parsing/processing a template template parameter by borrowing
17621 the template parameter list from the prototype parameter. */
17623 static tree
17625 tree proto,
17626 tree id,
17628 {
17632 }
17634 /* Create a new non-type template parameter from the given PARM
17635 declarator. */
17637 static tree
17640 {
17646 }
17648 /* Build a constrained template parameter based on the PARMDECL
17649 declarator. The type of PARMDECL is the constrained type, which
17650 refers to the prototype template parameter that ultimately
17651 specifies the type of the declared parameter. */
17653 static tree
17657 {
17663 /* Build the parameter. Return an error if the declarator was invalid. */
17664 tree parm;
17669 parmdecl);
17670 else
17675 /* Finish the parameter decl and create a node attaching the
17676 default argument and constraint. */
17681 }
17683 /* Returns true if the parsed type actually represents the declaration
17684 of a type template-parameter. */
17686 static bool
17688 {
17691 }
17693 /* Returns true if the parsed type actually represents the declaration of
17694 a template template-parameter. */
17696 static bool
17698 {
17701 }
17703 /* Parse a default argument for a type template-parameter.
17704 Note that diagnostics are handled in cp_parser_template_parameter. */
17706 static tree
17708 {
17711 /* Consume the `=' token. */
17716 /* Tell cp_parser_lambda_expression this is a default argument. */
17720 /* Parse the default-argument. */
17723 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17724 NULL);
17728 {
17732 }
17735 }
17737 /* Parse a default argument for a template template-parameter. */
17739 static tree
17741 {
17746 /* Consume the `='. */
17748 /* Parse the id-expression. */
17750 /* save token before parsing the id-expression, for error
17751 reporting */
17753 tree default_argument
17761 /* If the id-expression was a template-id that refers to
17762 a template-class, we already have the declaration here,
17763 so no further lookup is needed. */
17764 ;
17765 else
17766 /* Look up the name. */
17767 default_argument
17769 none_type,
17775 /* See if the default argument is valid. */
17779 }
17781 /* Parse a template-parameter.
17783 template-parameter:
17784 type-parameter
17785 parameter-declaration
17787 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
17788 the parameter. The TREE_PURPOSE is the default value, if any.
17789 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
17790 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
17791 set to true iff this parameter is a parameter pack. */
17793 static tree
17796 {
17799 tree parm;
17801 /* Assume it is a type parameter or a template parameter. */
17803 /* Assume it not a parameter pack. */
17805 /* Peek at the next token. */
17807 /* If it is `template', we have a type-parameter. */
17810 /* If it is `class' or `typename' we do not know yet whether it is a
17811 type parameter or a non-type parameter. Consider:
17813 template <typename T, typename T::X X> ...
17815 or:
17817 template <class C, class D*> ...
17819 Here, the first parameter is a type parameter, and the second is
17820 a non-type parameter. We can tell by looking at the token after
17821 the identifier -- if it is a `,', `=', or `>' then we have a type
17822 parameter. */
17824 {
17825 /* Peek at the token after `class' or `typename'. */
17827 /* If it's an ellipsis, we have a template type parameter
17828 pack. */
17831 /* If it's an identifier, skip it. */
17834 /* Now, see if the token looks like the end of a template
17835 parameter. */
17840 }
17842 /* Otherwise, it is a non-type parameter or a constrained parameter.
17844 [temp.param]
17846 When parsing a default template-argument for a non-type
17847 template-parameter, the first non-nested `>' is taken as the end
17848 of the template parameter-list rather than a greater-than
17849 operator. */
17850 parameter_declarator
17852 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17859 /* If the parameter declaration is marked as a parameter pack, set
17860 *IS_PARAMETER_PACK to notify the caller. */
17865 {
17866 /* Can happen in some cases of erroneous input (c++/34892). */
17868 /* Consume the `...' for better error recovery. */
17870 }
17872 /* The parameter may have been constrained type parameter. */
17875 parameter_declarator,
17876 is_non_type);
17878 // Now we're sure that the parameter is a non-type parameter.
17889 }
17891 /* Parse a type-parameter.
17893 type-parameter:
17894 class identifier [opt]
17895 class identifier [opt] = type-id
17896 typename identifier [opt]
17897 typename identifier [opt] = type-id
17898 template < template-parameter-list > class identifier [opt]
17899 template < template-parameter-list > class identifier [opt]
17900 = id-expression
17902 GNU Extension (variadic templates):
17904 type-parameter:
17905 class ... identifier [opt]
17906 typename ... identifier [opt]
17908 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
17909 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
17910 the declaration of the parameter.
17912 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
17914 static tree
17916 {
17918 tree parameter;
17920 /* Look for a keyword to tell us what kind of parameter this is. */
17926 {
17929 {
17930 tree identifier;
17931 tree default_argument;
17933 /* If the next token is an ellipsis, we have a template
17934 argument pack. */
17936 {
17937 /* Consume the `...' token. */
17942 }
17944 /* If the next token is an identifier, then it names the
17945 parameter. */
17948 else
17951 /* Create the parameter. */
17954 /* If the next token is an `=', we have a default argument. */
17956 {
17957 default_argument
17960 /* Template parameter packs cannot have default
17961 arguments. */
17963 {
17966 "template parameter pack %qD cannot have a "
17968 else
17970 "template parameter packs cannot have "
17973 }
17976 }
17977 else
17980 /* Create the combined representation of the parameter and the
17981 default argument. */
17983 }
17987 {
17988 tree identifier;
17989 tree default_argument;
17991 /* Look for the `<'. */
17993 /* Parse the template-parameter-list. */
17995 /* Look for the `>'. */
17998 /* If template requirements are present, parse them. */
18000 {
18005 }
18007 /* Look for the `class' or 'typename' keywords. */
18009 /* If the next token is an ellipsis, we have a template
18010 argument pack. */
18012 {
18013 /* Consume the `...' token. */
18018 }
18019 /* If the next token is an `=', then there is a
18020 default-argument. If the next token is a `>', we are at
18021 the end of the parameter-list. If the next token is a `,',
18022 then we are at the end of this parameter. */
18026 {
18028 /* Treat invalid names as if the parameter were nameless. */
18031 }
18032 else
18035 /* Create the template parameter. */
18037 identifier);
18039 /* If the next token is an `=', then there is a
18040 default-argument. */
18042 {
18043 default_argument
18046 /* Template parameter packs cannot have default
18047 arguments. */
18049 {
18052 "template parameter pack %qD cannot "
18054 identifier);
18055 else
18059 }
18060 }
18061 else
18064 /* Create the combined representation of the parameter and the
18065 default argument. */
18067 }
18073 }
18076 }
18078 /* Parse a template-id.
18080 template-id:
18081 template-name < template-argument-list [opt] >
18083 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
18084 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
18085 returned. Otherwise, if the template-name names a function, or set
18086 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
18087 names a class, returns a TYPE_DECL for the specialization.
18089 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
18090 uninstantiated templates. */
18092 static tree
18098 {
18099 tree templ;
18100 tree arguments;
18101 tree template_id;
18106 /* If the next token corresponds to a template-id, there is no need
18107 to reparse it. */
18111 {
18114 }
18116 /* Avoid performing name lookup if there is no possibility of
18117 finding a template-id. */
18120 && !cp_parser_nth_token_starts_template_argument_list_p
18122 {
18125 }
18127 /* Remember where the template-id starts. */
18133 /* Parse the template-name. */
18136 check_dependency_p,
18137 is_declaration,
18138 tag_type,
18141 /* Push any access checks inside the firewall we're about to create. */
18147 /* Since we're going to preserve any side-effects from this parse, set up a
18148 firewall to protect our callers from cp_parser_commit_to_tentative_parse
18149 in the template arguments. */
18153 /* If we find the sequence `[:' after a template-name, it's probably
18154 a digraph-typo for `< ::'. Substitute the tokens and check if we can
18155 parse correctly the argument list. */
18162 {
18164 /* Change `:' into `::'. */
18166 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
18167 CPP_LESS. */
18170 /* Parse the arguments. */
18173 {
18174 /* If we couldn't parse an argument list, then we revert our changes
18175 and return simply an error. Maybe this is not a template-id
18176 after all. */
18181 }
18182 /* Otherwise, emit an error about the invalid digraph, but continue
18183 parsing because we got our argument list. */
18186 {
18189 "%<<:%> is an alternate spelling for %<[%>."
18192 {
18194 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
18197 }
18198 }
18199 }
18200 else
18201 {
18202 /* Look for the `<' that starts the template-argument-list. */
18204 {
18207 }
18208 /* Parse the arguments. */
18213 && !template_keyword_p
18216 {
18217 /* This didn't go well. */
18219 {
18220 /* C++20 says that "function-name < a;" is now ill-formed. */
18222 {
18225 "operand of %<<%> is ill-formed in C++20; wrap the "
18227 }
18228 else
18229 /* We expect "f<targs>" to be followed by "(args)". */
18233 /* Purge all subsequent tokens. */
18235 }
18236 else
18240 }
18241 }
18243 /* Set the location to be of the form:
18244 template-name < template-argument-list [opt] >
18245 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
18246 with caret == start at the start of the template-name,
18247 ranging until the closing '>'. */
18248 location_t combined_loc
18251 /* Check for concepts autos where they don't belong. We could
18252 identify types in some cases of identifier TEMPL, looking ahead
18253 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
18254 types. We reject them in functions, but if what we have is an
18255 identifier, even with none_type we can't conclude it's NOT a
18256 type, we have to wait for template substitution. */
18259 /* Build a representation of the specialization. */
18262 TEMPLATE_ID_EXPR,
18266 {
18267 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
18268 template (rather than some instantiation thereof) only if
18269 is not nested within some other construct. For example, in
18270 "template <typename T> void f(T) { A<T>::", A<T> is just an
18271 instantiation of A. */
18272 bool entering_scope
18275 template_id
18277 }
18279 {
18280 /* The caller will decide whether this is a concept check or type
18281 constraint. */
18284 }
18286 {
18290 }
18293 {
18294 /* Some type template in dependent scope. */
18297 TEMPLATE_ID_EXPR,
18300 }
18301 else
18302 {
18303 /* If it's not a class-template or a template-template, it should be
18304 a function-template. */
18310 }
18312 /* If parsing tentatively, replace the sequence of tokens that makes
18313 up the template-id with a CPP_TEMPLATE_ID token. That way,
18314 should we re-parse the token stream, we will not have to repeat
18315 the effort required to do the parse, nor will we issue duplicate
18316 error messages about problems during instantiation of the
18317 template. */
18319 /* Don't do this if we had a parse error in a declarator; re-parsing
18320 might succeed if a name changes meaning (60361). */
18324 {
18325 /* Reset the contents of the START_OF_ID token. */
18329 /* Retrieve any deferred checks. Do not pop this access checks yet
18330 so the memory will not be reclaimed during token replacing below. */
18337 /* Purge all subsequent tokens. */
18340 /* ??? Can we actually assume that, if template_id ==
18341 error_mark_node, we will have issued a diagnostic to the
18342 user, as opposed to simply marking the tentative parse as
18343 failed? */
18346 }
18350 }
18352 /* Like cp_parser_template_id, called in non-type context. */
18354 static tree
18359 {
18364 /* We didn't check the arguments in cp_parser_template_id; do that now. */
18367 }
18369 /* Parse a template-name.
18371 template-name:
18372 identifier
18374 The standard should actually say:
18376 template-name:
18377 identifier
18378 operator-function-id
18380 A defect report has been filed about this issue.
18382 A conversion-function-id cannot be a template name because they cannot
18383 be part of a template-id. In fact, looking at this code:
18385 a.operator K<int>()
18387 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
18388 It is impossible to call a templated conversion-function-id with an
18389 explicit argument list, since the only allowed template parameter is
18390 the type to which it is converting.
18392 If TEMPLATE_KEYWORD_P is true, then we have just seen the
18393 `template' keyword, in a construction like:
18395 T::template f<3>()
18397 In that case `f' is taken to be a template-name, even though there
18398 is no way of knowing for sure.
18400 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
18401 name refers to a set of overloaded functions, at least one of which
18402 is a template, or an IDENTIFIER_NODE with the name of the template,
18403 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
18404 names are looked up inside uninstantiated templates. */
18406 static tree
18413 {
18414 tree identifier;
18415 tree decl;
18418 /* If the next token is `operator', then we have either an
18419 operator-function-id or a conversion-function-id. */
18421 {
18422 /* We don't know whether we're looking at an
18423 operator-function-id or a conversion-function-id. */
18425 /* Try an operator-function-id. */
18427 /* If that didn't work, try a conversion-function-id. */
18429 {
18432 }
18433 }
18434 /* Look for the identifier. */
18435 else
18438 /* If we didn't find an identifier, we don't have a template-id. */
18442 /* If the name immediately followed the `template' keyword, then it
18443 is a template-name. However, if the next token is not `<', then
18444 we do not treat it as a template-name, since it is not being used
18445 as part of a template-id. This enables us to handle constructs
18446 like:
18448 template <typename T> struct S { S(); };
18449 template <typename T> S<T>::S();
18451 correctly. We would treat `S' as a template -- if it were `S<T>'
18452 -- but we do not if there is no `<'. */
18456 {
18457 /* In a declaration, in a dependent context, we pretend that the
18458 "template" keyword was present in order to improve error
18459 recovery. For example, given:
18461 template <typename T> void f(T::X<int>);
18463 we want to treat "X<int>" as a template-id. */
18465 && !template_keyword_p
18467 && check_dependency_p
18469 /* Do not do this for dtors (or ctors), since they never
18470 need the template keyword before their name. */
18472 {
18475 /* Explain what went wrong. */
18477 identifier);
18480 /* If parsing tentatively, find the location of the "<" token. */
18483 /* Parse the template arguments so that we can issue error
18484 messages about them. */
18487 /* Skip tokens until we find a good place from which to
18488 continue parsing. */
18493 /* If parsing tentatively, permanently remove the
18494 template argument list. That will prevent duplicate
18495 error messages from being issued about the missing
18496 "template" keyword. */
18503 }
18505 /* If the "template" keyword is present, then there is generally
18506 no point in doing name-lookup, so we just return IDENTIFIER.
18507 But, if the qualifying scope is non-dependent then we can
18508 (and must) do name-lookup normally. */
18510 {
18516 {
18517 /* We're optimizing away the call to cp_parser_lookup_name, but
18518 we still need to do this. */
18522 }
18523 }
18524 }
18526 /* cp_parser_lookup_name clears OBJECT_TYPE. */
18530 /* Look up the name. */
18532 tag_type,
18535 check_dependency_p,
18541 /* 13.3 [temp.names] A < is interpreted as the delimiter of a
18542 template-argument-list if it follows a name that is not a
18543 conversion-function-id and
18544 - that follows the keyword template or a ~ after a nested-name-specifier or
18545 in a class member access expression, or
18546 - for which name lookup finds the injected-class-name of a class template
18547 or finds any declaration of a template, or
18548 - that is an unqualified name for which name lookup either finds one or
18549 more functions or finds nothing, or
18550 - that is a terminal name in a using-declarator (9.9), in a declarator-id
18551 (9.3.4), or in a type-only context other than a nested-name-specifier
18552 (13.8). */
18554 /* If DECL is a template, then the name was a template-name. */
18556 {
18559 {
18561 tree attr;
18564 else
18567 {
18570 }
18573 {
18576 }
18577 }
18578 }
18579 else
18580 {
18581 /* Look through an overload set for any templates. */
18589 /* "an unqualified name for which name lookup either finds one or more
18590 functions or finds nothing". */
18593 && !scope
18596 {
18597 /* The "more functions" case. Just use the OVERLOAD as normally.
18598 We don't use is_overloaded_fn here to avoid considering
18599 BASELINKs. */
18601 /* Name lookup found one function. */
18603 /* Name lookup found nothing. */
18606 }
18608 /* "in a type-only context" */
18616 {
18617 /* The name does not name a template. */
18620 }
18622 /* Repeat the lookup at instantiation time. */
18624 }
18627 }
18629 /* Parse a template-argument-list.
18631 template-argument-list:
18632 template-argument ... [opt]
18633 template-argument-list , template-argument ... [opt]
18635 Returns a TREE_VEC containing the arguments. */
18637 static tree
18639 {
18644 /* Don't create location wrapper nodes within a template-argument-list. */
18645 auto_suppress_location_wrappers sentinel;
18649 /* Even if the template-id appears in an integral
18650 constant-expression, the contents of the argument list do
18651 not. */
18657 /* Parse the arguments. */
18659 do
18660 {
18662 /* Consume the comma. */
18665 /* Parse the template-argument. */
18668 /* If the next token is an ellipsis, we're expanding a template
18669 argument pack. */
18671 {
18673 {
18677 }
18678 /* Consume the `...' token. */
18681 /* Make the argument into a TYPE_PACK_EXPANSION or
18682 EXPR_PACK_EXPANSION. */
18684 }
18687 }
18702 }
18704 /* Parse a template-argument.
18706 template-argument:
18707 assignment-expression
18708 type-id
18709 id-expression
18711 The representation is that of an assignment-expression, type-id, or
18712 id-expression -- except that the qualified id-expression is
18713 evaluated, so that the value returned is either a DECL or an
18714 OVERLOAD.
18716 Although the standard says "assignment-expression", it forbids
18717 throw-expressions or assignments in the template argument.
18718 Therefore, we use "conditional-expression" instead. */
18720 static tree
18722 {
18723 tree argument;
18729 cp_id_kind idk;
18731 /* There's really no way to know what we're looking at, so we just
18732 try each alternative in order.
18734 [temp.arg]
18736 In a template-argument, an ambiguity between a type-id and an
18737 expression is resolved to a type-id, regardless of the form of
18738 the corresponding template-parameter.
18740 Therefore, we try a type-id first. */
18743 /* If there was no error parsing the type-id but the next token is a
18744 '>>', our behavior depends on which dialect of C++ we're
18745 parsing. In C++98, we probably found a typo for '> >'. But there
18746 are type-id which are also valid expressions. For instance:
18748 struct X { int operator >> (int); };
18749 template <int V> struct Foo {};
18750 Foo<X () >> 5> r;
18752 Here 'X()' is a valid type-id of a function type, but the user just
18753 wanted to write the expression "X() >> 5". Thus, we remember that we
18754 found a valid type-id, but we still try to parse the argument as an
18755 expression to see what happens.
18757 In C++0x, the '>>' will be considered two separate '>'
18758 tokens. */
18762 {
18765 }
18766 else
18767 {
18768 /* If the next token isn't a `,' or a `>', then this argument wasn't
18769 really finished. This means that the argument is not a valid
18770 type-id. */
18773 /* If that worked, we're done. */
18776 }
18777 /* We're still not sure what the argument will be. */
18779 /* Try a template. */
18787 /* If the next token isn't a `,' or a `>', then this argument wasn't
18788 really finished. */
18792 {
18793 /* Figure out what is being referred to. If the id-expression
18794 was for a class template specialization, then we will have a
18795 TYPE_DECL at this point. There is no need to do name lookup
18796 at this point in that case. */
18799 none_type,
18808 }
18810 {
18816 }
18817 /* It must be a non-type argument. In C++17 any constant-expression is
18818 allowed. */
18822 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
18824 -- an integral constant-expression of integral or enumeration
18825 type; or
18827 -- the name of a non-type template-parameter; or
18829 -- the name of an object or function with external linkage...
18831 -- the address of an object or function with external linkage...
18833 -- a pointer to member... */
18834 /* Look for a non-type template parameter. */
18836 {
18848 }
18850 /* If the next token is "&", the argument must be the address of an
18851 object or function with external linkage. */
18854 {
18857 }
18858 /* See if we might have an id-expression. */
18865 {
18868 address_p,
18875 else
18876 {
18877 tree probe;
18880 {
18881 /* Strip the dereference temporarily. */
18884 }
18886 /* If we're in a template, we represent a qualified-id referring
18887 to a static data member as a SCOPE_REF even if the scope isn't
18888 dependent so that we can check access control later. */
18893 {
18894 /* A variable without external linkage might still be a
18895 valid constant-expression, so no error is issued here
18896 if the external-linkage check fails. */
18899 }
18901 /* All overloaded functions are allowed; if the external
18902 linkage test does not pass, an error will be issued
18903 later. */
18904 ;
18908 /* A pointer-to-member. */
18909 ;
18911 ;
18912 else
18916 {
18919 tf_warning_or_error);
18920 else
18923 }
18924 }
18925 }
18926 /* If the argument started with "&", there are no other valid
18927 alternatives at this point. */
18929 {
18932 }
18934 general_expr:
18935 /* If the argument wasn't successfully parsed as a type-id followed
18936 by '>>', the argument can only be a constant expression now.
18937 Otherwise, we try parsing the constant-expression tentatively,
18938 because the argument could really be a type-id. */
18944 else
18945 {
18946 /* In C++20, we can encounter a braced-init-list. */
18949 {
18952 }
18954 /* With C++17 generalized non-type template arguments we need to handle
18955 lvalue constant expressions, too. */
18958 }
18966 /* We did our best to parse the argument as a non type-id, but that
18967 was the only alternative that matched (albeit with a '>' after
18968 it). We can assume it's just a typo from the user, and a
18969 diagnostic will then be issued. */
18971 }
18973 /* Parse an explicit-instantiation.
18975 explicit-instantiation:
18976 template declaration
18978 Although the standard says `declaration', what it really means is:
18980 explicit-instantiation:
18981 template decl-specifier-seq [opt] declarator [opt] ;
18983 Things like `template int S<int>::i = 5, int S<double>::j;' are not
18984 supposed to be allowed. A defect report has been filed about this
18985 issue.
18987 GNU Extension:
18989 explicit-instantiation:
18990 storage-class-specifier template
18991 decl-specifier-seq [opt] declarator [opt] ;
18992 function-specifier template
18993 decl-specifier-seq [opt] declarator [opt] ; */
18995 static void
18997 {
18999 cp_decl_specifier_seq decl_specifiers;
19004 /* Look for an (optional) storage-class-specifier or
19005 function-specifier. */
19007 {
19008 extension_specifier
19011 extension_specifier
19014 }
19016 /* Look for the `template' keyword. */
19018 /* Let the front end know that we are processing an explicit
19019 instantiation. */
19021 /* [temp.explicit] says that we are supposed to ignore access
19022 control while processing explicit instantiation directives. */
19024 /* Parse a decl-specifier-seq. */
19026 CP_PARSER_FLAGS_OPTIONAL,
19030 cp_omp_declare_simd_data odsd;
19036 /* If there was exactly one decl-specifier, and it declared a class,
19037 and there's no declarator, then we have an explicit type
19038 instantiation. */
19040 {
19043 /* Turn access control back on for names used during
19044 template instantiation. */
19049 }
19050 else
19051 {
19053 tree decl;
19055 /* Parse the declarator. */
19056 declarator
19058 CP_PARSER_FLAGS_NONE,
19069 {
19072 "explicit instantiation shall not use"
19076 "explicit instantiation shall not use"
19080 "explicit instantiation shall not use"
19085 /* Turn access control back on for names used during
19086 template instantiation. */
19088 /* Do the explicit instantiation. */
19090 }
19091 else
19092 {
19094 /* Skip the body of the explicit instantiation. */
19096 }
19097 }
19098 /* We're done with the instantiation. */
19106 }
19108 /* Parse an explicit-specialization.
19110 explicit-specialization:
19111 template < > declaration
19113 Although the standard says `declaration', what it really means is:
19115 explicit-specialization:
19116 template <> decl-specifier [opt] init-declarator [opt] ;
19117 template <> function-definition
19118 template <> explicit-specialization
19119 template <> template-declaration */
19121 static void
19123 {
19126 /* Look for the `template' keyword. */
19128 /* Look for the `<'. */
19130 /* Look for the `>'. */
19132 /* We have processed another parameter list. */
19135 /* [temp]
19137 A template ... explicit specialization ... shall not have C
19138 linkage. */
19141 {
19145 /* Give it C++ linkage to avoid confusing other parts of the
19146 front end. */
19148 }
19150 /* Let the front end know that we are beginning a specialization. */
19152 {
19153 /* If the next keyword is `template', we need to figure out
19154 whether or not we're looking a template-declaration. */
19156 {
19161 else
19163 }
19164 else
19165 /* Parse the dependent declaration. */
19171 }
19173 /* We're done with the specialization. */
19176 /* For the erroneous case of a template with C linkage, we pushed an
19177 implicit C++ linkage scope; exit that scope now. */
19181 /* We're done with this parameter list. */
19183 }
19185 /* Preserve the attributes across a garbage collect (by making it a GC
19186 root), which can occur when parsing a member function. */
19190 /* Parse a type-specifier.
19192 type-specifier:
19193 simple-type-specifier
19194 class-specifier
19195 enum-specifier
19196 elaborated-type-specifier
19197 cv-qualifier
19199 GNU Extension:
19201 type-specifier:
19202 __complex__
19204 Returns a representation of the type-specifier. For a
19205 class-specifier, enum-specifier, or elaborated-type-specifier, a
19206 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
19208 The parser flags FLAGS is used to control type-specifier parsing.
19210 If IS_DECLARATION is TRUE, then this type-specifier is appearing
19211 in a decl-specifier-seq.
19213 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
19214 class-specifier, enum-specifier, or elaborated-type-specifier, then
19215 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
19216 if a type is declared; 2 if it is defined. Otherwise, it is set to
19217 zero.
19219 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
19220 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
19221 is set to FALSE. */
19223 static tree
19225 cp_parser_flags flags,
19230 {
19236 /* Assume this type-specifier does not declare a new type. */
19239 /* And that it does not specify a cv-qualifier. */
19242 /* Peek at the next token. */
19245 /* If we're looking at a keyword, we can use that to guide the
19246 production we choose. */
19249 {
19254 /* Look for the enum-specifier. */
19256 /* If that worked, we're done. */
19258 {
19263 type_spec,
19264 token,
19267 }
19268 else
19271 /* Any of these indicate either a class-specifier, or an
19272 elaborated-type-specifier. */
19279 /* Parse tentatively so that we can back up if we don't find a
19280 class-specifier. */
19284 /* Look for the class-specifier. */
19289 /* If that worked, we're done. */
19291 {
19296 type_spec,
19297 token,
19300 }
19302 /* Fall through. */
19303 elaborated_type_specifier:
19304 /* We're declaring (not defining) a class or enum. */
19308 /* Fall through. */
19310 /* Look for an elaborated-type-specifier. */
19311 type_spec
19312 = (cp_parser_elaborated_type_specifier
19315 is_declaration));
19318 type_spec,
19319 token,
19342 /* The `__complex__' keyword is a GNU extension. */
19348 }
19350 /* Handle simple keywords. */
19352 {
19354 {
19357 }
19359 }
19361 /* If we do not already have a type-specifier, assume we are looking
19362 at a simple-type-specifier. */
19364 decl_specs,
19365 flags);
19367 /* If we didn't find a type-specifier, and a type-specifier was not
19368 optional in this context, issue an error message. */
19370 {
19373 }
19376 }
19378 /* Parse a simple-type-specifier.
19380 simple-type-specifier:
19381 :: [opt] nested-name-specifier [opt] type-name
19382 :: [opt] nested-name-specifier template template-id
19383 char
19384 wchar_t
19385 bool
19386 short
19387 int
19388 long
19389 signed
19390 unsigned
19391 float
19392 double
19393 void
19395 C++11 Extension:
19397 simple-type-specifier:
19398 auto
19399 decltype ( expression )
19400 char16_t
19401 char32_t
19402 __underlying_type ( type-id )
19404 C++17 extension:
19406 nested-name-specifier(opt) template-name
19408 GNU Extension:
19410 simple-type-specifier:
19411 __int128
19412 __typeof__ unary-expression
19413 __typeof__ ( type-id )
19414 __typeof__ ( type-id ) { initializer-list , [opt] }
19416 Concepts Extension:
19418 simple-type-specifier:
19419 constrained-type-specifier
19421 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
19422 appropriately updated. */
19424 static tree
19427 cp_parser_flags flags)
19428 {
19433 /* Peek at the next token. */
19436 /* If we're looking at a keyword, things are easy. */
19438 {
19476 {
19479 /* Check if the alternate "__intN__" form has been used instead of
19480 "__intN". */
19484 }
19513 {
19514 /* The 'auto' might be the placeholder return type for a function decl
19515 with trailing return type. */
19524 {
19526 {
19533 }
19536 {
19539 }
19542 }
19546 {
19549 }
19552 {
19555 }
19556 else
19560 {
19563 "use of %<auto%> in lambda parameter declaration "
19564 "only available with "
19566 }
19569 "use of %<auto%> in parameter declaration "
19570 "only available with "
19574 "use of %<auto%> in parameter declaration "
19576 }
19577 else
19582 /* Since DR 743, decltype can either be a simple-type-specifier by
19583 itself or begin a nested-name-specifier. Parsing it will replace
19584 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
19585 handling below decide what to do. */
19591 /* Consume the `typeof' token. */
19593 /* Parse the operand to `typeof'. */
19595 /* If it is not already a TYPE, take its type. */
19601 token,
19610 token,
19620 token,
19625 }
19627 /* If token is an already-parsed decltype not followed by ::,
19628 it's a simple-type-specifier. */
19631 {
19634 {
19636 token,
19638 /* Remember that we are handling a decltype in order to
19639 implement the resolution of DR 1510 when the argument
19640 isn't instantiation dependent. */
19642 }
19645 }
19647 /* If the type-specifier was for a built-in type, we're done. */
19649 {
19650 /* Record the type. */
19657 type,
19658 token,
19663 /* Consume the token. */
19669 /* There is no valid C++ program where a non-template type is
19670 followed by a "<". That usually indicates that the user thought
19671 that the type was a template. */
19676 }
19678 /* The type-specifier must be a user-defined type. */
19680 {
19686 /* Don't gobble tokens or issue error messages if this is an
19687 optional type-specifier. */
19691 /* Remember current tentative parsing state -- if we know we need
19692 a type, we can give better diagnostics here. */
19697 /* Look for the optional `::' operator. */
19698 global_p
19702 /* Look for the nested-name specifier. */
19703 qualified_p
19710 /* If we have seen a nested-name-specifier, and the next token
19711 is `template', then we are using the template-id production. */
19714 {
19715 /* Look for the template-id. */
19719 none_type,
19721 /* If the template-id did not name a type, we are out of
19722 luck. */
19724 {
19725 /* ...unless we pretend we have seen 'typename'. */
19729 else
19730 {
19733 }
19734 }
19735 }
19736 /* DR 1812: A < following a qualified-id in a typename-specifier
19737 could safely be assumed to begin a template argument list, so
19738 the template keyword should be optional. */
19740 && qualified_p
19741 && typename_p
19743 {
19749 none_type,
19751 /* This is handled below, so back off. */
19762 }
19764 /* Otherwise, look for a type-name. */
19766 {
19774 }
19777 {
19778 /* Try for a type-constraint with template arguments. We check
19779 decl_specs here to avoid trying this for a functional cast. */
19786 none_type,
19789 {
19794 /* Perhaps it's a concept-check expression. */
19796 }
19797 else
19802 }
19805 {
19806 /* Try class template argument deduction or type-constraint without
19807 template arguments. */
19811 {
19812 location_t loc
19815 none_type,
19827 else
19828 {
19833 }
19834 }
19835 else
19837 }
19839 /* If it didn't work out, we don't have a TYPE. */
19844 /* Keep track of all name-lookups performed in class scopes. */
19846 && !global_p
19847 && !qualified_p
19854 token,
19856 }
19858 /* If we didn't get a type-name, issue an error message. */
19860 {
19863 }
19866 {
19867 /* See if TYPE is an Objective-C type, and if so, parse and
19868 accept any protocol references following it. Do this before
19869 the cp_parser_check_for_invalid_template_id() call, because
19870 Objective-C types can be followed by '<...>' which would
19871 enclose protocol names rather than template arguments, and so
19872 everything is fine. */
19875 {
19879 /* Clobber the "unqualified" type previously entered into
19880 DECL_SPECS with the new, improved protocol-qualified version. */
19885 }
19887 /* There is no valid C++ program where a non-template type is
19888 followed by a "<". That usually indicates that the user
19889 thought that the type was a template. */
19891 none_type,
19893 }
19896 }
19898 /* Parse the remainder of a placholder-type-specifier.
19900 placeholder-type-specifier:
19901 type-constraint_opt auto
19902 type-constraint_opt decltype(auto)
19904 The raw form of the constraint is parsed in cp_parser_simple_type_specifier
19905 and passed as TMPL. This function converts TMPL to an actual type-constraint,
19906 parses the placeholder type, and performs some contextual syntactic analysis.
19908 LOC provides the location of the template name.
19910 TENTATIVE is true if the type-specifier parsing is tentative; in that case,
19911 don't give an error if TMPL isn't a valid type-constraint, as the template-id
19912 might actually be a concept-check,
19914 Note that the Concepts TS allows the auto or decltype(auto) to be
19915 omitted in a constrained-type-specifier. */
19917 static tree
19920 {
19926 /* Get the arguments as written for subsequent analysis. */
19929 {
19932 }
19933 else
19934 /* A concept-name with no arguments can't be an expression. */
19939 /* Get the concept and prototype parameter for the constraint. */
19946 /* As per the standard, require auto or decltype(auto), except in some
19947 cases (template parameter lists, -fconcepts-ts enabled). */
19950 {
19954 {
19956 matching_parens parens;
19960 }
19961 }
19963 /* A type constraint constrains a contextually determined type or type
19964 parameter pack. However, the Concepts TS does allow concepts
19965 to introduce non-type and template template parameters. */
19967 {
19970 {
19972 {
19975 }
19977 }
19978 }
19980 /* In a template parameter list, a type-parameter can be introduced
19981 by type-constraints alone. */
19985 /* Diagnose issues placeholder issues. */
19989 {
19991 /* Perhaps it's a concept-check expression (c++/91073). */
19998 /* Fall through. This is an error of omission. */
19999 }
20001 {
20002 /* A trailing return type only allows type-constraints. */
20005 }
20007 /* In a parameter-declaration-clause, a placeholder-type-specifier
20008 results in an invented template parameter. */
20010 {
20012 {
20018 }
20021 }
20023 /* Determine if the type should be deduced using template argument
20024 deduction or decltype deduction. Note that the latter is always
20025 used for type-constraints in trailing return types. */
20030 /* Otherwise, this is the type of a variable or return type. */
20033 else
20035 }
20037 /* Parse a type-name.
20039 type-name:
20040 class-name
20041 enum-name
20042 typedef-name
20043 simple-template-id [in c++0x]
20045 enum-name:
20046 identifier
20048 typedef-name:
20049 identifier
20051 Concepts:
20053 type-name:
20054 concept-name
20055 partial-concept-id
20057 concept-name:
20058 identifier
20060 Returns a TYPE_DECL for the type. */
20062 static tree
20064 {
20065 tree type_decl;
20067 /* We can't know yet whether it is a class-name or not. */
20069 /* Try a class-name. */
20071 typename_keyword_p,
20073 none_type,
20077 /* If it's not a class-name, keep looking. */
20079 {
20081 /* It must be a typedef-name or an enum-name. */
20085 /* It is either a simple-template-id representing an
20086 instantiation of an alias template... */
20090 none_type,
20092 /* Note that this must be an instantiation of an alias template
20093 because [temp.names]/6 says:
20095 A template-id that names an alias template specialization
20096 is a type-name.
20098 Whereas [temp.names]/7 says:
20100 A simple-template-id that names a class template
20101 specialization is a class-name.
20103 With concepts, this could also be a partial-concept-id that
20104 declares a non-type template parameter. */
20109 else
20113 /* ... Or a typedef-name or an enum-name. */
20115 }
20118 }
20120 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
20121 or a concept-name.
20123 enum-name:
20124 identifier
20126 typedef-name:
20127 identifier
20129 concept-name:
20130 identifier
20132 Returns a TYPE_DECL for the type. */
20134 static tree
20136 {
20137 tree type_decl;
20138 tree identifier;
20145 /* Look up the type-name. */
20152 {
20153 /* See if this is an Objective-C type. */
20158 }
20160 /* Issue an error if we did not find a type-name. */
20162 /* In Objective-C, we have the complication that class names are
20163 normally type names and start declarations (eg, the
20164 "NSObject" in "NSObject *object;"), but can be used in an
20165 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
20166 is an expression. So, a classname followed by a dot is not a
20167 valid type-name. */
20170 {
20175 }
20176 /* Remember that the name was used in the definition of the
20177 current class so that we can check later to see if the
20178 meaning would have been different after the class was
20179 entirely defined. */
20185 }
20187 /* Parse an elaborated-type-specifier. Note that the grammar given
20188 here incorporates the resolution to DR68.
20190 elaborated-type-specifier:
20191 class-key :: [opt] nested-name-specifier [opt] identifier
20192 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
20193 enum-key :: [opt] nested-name-specifier [opt] identifier
20194 typename :: [opt] nested-name-specifier identifier
20195 typename :: [opt] nested-name-specifier template [opt]
20196 template-id
20198 GNU extension:
20200 elaborated-type-specifier:
20201 class-key attributes :: [opt] nested-name-specifier [opt] identifier
20202 class-key attributes :: [opt] nested-name-specifier [opt]
20203 template [opt] template-id
20204 enum attributes :: [opt] nested-name-specifier [opt] identifier
20206 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
20207 declared `friend'. If IS_DECLARATION is TRUE, then this
20208 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
20209 something is being declared.
20211 Returns the TYPE specified. */
20213 static tree
20217 {
20219 tree identifier;
20222 tree globalscope;
20225 /* For class and enum types the location of the class-key or enum-key. */
20227 /* For a scoped enum, the 'class' or 'struct' keyword id. */
20230 /* See if we're looking at the `enum' keyword. */
20232 {
20233 /* Consume the `enum' token. */
20235 /* Remember that it's an enumeration type. */
20237 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
20238 enums) is used here. */
20242 {
20250 /* Consume the `struct' or `class' and parse it anyway. */
20252 /* Create a combined location for the whole scoped-enum-key. */
20254 }
20255 else
20258 /* Parse the attributes. */
20260 }
20261 /* Or, it might be `typename'. */
20263 RID_TYPENAME))
20264 {
20265 /* Consume the `typename' token. */
20267 /* Remember that it's a `typename' type. */
20269 }
20270 /* Otherwise it must be a class-key. */
20271 else
20272 {
20277 /* Parse the attributes. */
20279 }
20281 /* Look for the `::' operator. */
20284 /* Look for the nested-name-specifier. */
20285 tree nested_name_specifier;
20287 {
20288 nested_name_specifier
20293 is_declaration);
20296 }
20297 else
20298 /* Even though `typename' is not present, the proposed resolution
20299 to Core Issue 180 says that in `class A<T>::B', `B' should be
20300 considered a type-name, even if `A<T>' is dependent. */
20301 nested_name_specifier
20306 is_declaration);
20307 /* For everything but enumeration types, consider a template-id.
20308 For an enumeration type, consider only a plain identifier. */
20310 {
20312 tree decl;
20314 /* Allow the `template' keyword. */
20316 /* If we didn't see `template', we don't know if there's a
20317 template-id or not. */
20320 /* The `template' keyword must follow a nested-name-specifier. */
20322 {
20326 }
20328 /* Parse the template-id. */
20332 tag_type,
20333 is_declaration);
20334 /* If we didn't find a template-id, look for an ordinary
20335 identifier. */
20337 ;
20338 /* We can get here when cp_parser_template_id, called by
20339 cp_parser_class_name with tag_type == none_type, succeeds
20340 and caches a BASELINK. Then, when called again here,
20341 instead of failing and returning an error_mark_node
20342 returns it (see template/typename17.C in C++11).
20343 ??? Could we diagnose this earlier? */
20345 {
20348 }
20349 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
20350 in effect, then we must assume that, upon instantiation, the
20351 template will correspond to a class. */
20355 typename_type,
20357 /* If the `typename' keyword is in effect and DECL is not a type
20358 decl, then type is non existent. */
20360 ;
20362 {
20366 /* If the next token is a semicolon, this must be a specialization,
20367 instantiation, or friend declaration. Check the scope while we
20368 still know whether or not we had a nested-name-specifier. */
20373 }
20376 }
20379 {
20384 {
20387 }
20389 /* For a `typename', we needn't call xref_tag. */
20395 /* Template parameter lists apply only if we are not within a
20396 function parameter list. */
20397 bool template_parm_lists_apply
20406 /* Look up a qualified name in the usual way. */
20408 {
20409 tree decl;
20410 tree ambiguous_decls;
20413 tag_type,
20420 /* If the lookup was ambiguous, an error will already have been
20421 issued. */
20425 /* If we are parsing friend declaration, DECL may be a
20426 TEMPLATE_DECL tree node here. However, we need to check
20427 whether this TEMPLATE_DECL results in valid code. Consider
20428 the following example:
20430 namespace N {
20431 template <class T> class C {};
20432 }
20433 class X {
20434 template <class T> friend class N::C; // #1, valid code
20435 };
20436 template <class T> class Y {
20437 friend class N::C; // #2, invalid code
20438 };
20440 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
20441 name lookup of `N::C'. We see that friend declaration must
20442 be template for the code to be valid. Note that
20443 processing_template_decl does not work here since it is
20444 always 1 for the above two cases. */
20446 decl = (cp_parser_maybe_treat_template_as_class
20451 {
20453 identifier,
20456 }
20459 {
20463 allow_template);
20467 }
20469 /* Forward declarations of nested types, such as
20471 class C1::C2;
20472 class C1::C2::C3;
20474 are invalid unless all components preceding the final '::'
20475 are complete. If all enclosing types are complete, these
20476 declarations become merely pointless.
20478 Invalid forward declarations of nested types are errors
20479 caught elsewhere in parsing. Those that are pointless arrive
20480 here. */
20488 }
20489 else
20490 {
20491 /* An elaborated-type-specifier sometimes introduces a new type and
20492 sometimes names an existing type. Normally, the rule is that it
20493 introduces a new type only if there is not an existing type of
20494 the same name already in scope. For example, given:
20496 struct S {};
20497 void f() { struct S s; }
20499 the `struct S' in the body of `f' is the same `struct S' as in
20500 the global scope; the existing definition is used. However, if
20501 there were no global declaration, this would introduce a new
20502 local class named `S'.
20504 An exception to this rule applies to the following code:
20506 namespace N { struct S; }
20508 Here, the elaborated-type-specifier names a new type
20509 unconditionally; even if there is already an `S' in the
20510 containing scope this declaration names a new type.
20511 This exception only applies if the elaborated-type-specifier
20512 forms the complete declaration:
20514 [class.name]
20516 A declaration consisting solely of `class-key identifier ;' is
20517 either a redeclaration of the name in the current scope or a
20518 forward declaration of the identifier as a class name. It
20519 introduces the name into the current scope.
20521 We are in this situation precisely when the next token is a `;'.
20523 An exception to the exception is that a `friend' declaration does
20524 *not* name a new type; i.e., given:
20526 struct S { friend struct T; };
20528 `T' is not a new type in the scope of `S'.
20530 Also, `new struct S' or `sizeof (struct S)' never results in the
20531 definition of a new type; a new type can only be declared in a
20532 declaration context. */
20534 TAG_how how;
20537 /* Friends have special name lookup rules. */
20541 CPP_SEMICOLON))
20542 /* This is a `class-key identifier ;' */
20544 else
20548 (template_parm_lists_apply
20551 /* An unqualified name was used to reference this type, so
20552 there were no qualifying templates. */
20562 }
20563 }
20568 /* Allow attributes on forward declarations of classes. */
20570 {
20581 {
20585 }
20588 else
20590 "attributes ignored on elaborated-type-specifier that is "
20592 }
20596 else
20597 {
20598 /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
20599 for alias definition. */
20603 decl_class);
20605 /* Indicate whether this class was declared as a `class' or as a
20606 `struct'. */
20609 }
20611 /* A "<" cannot follow an elaborated type specifier. If that
20612 happens, the user was probably trying to form a template-id. */
20617 }
20619 /* Parse an enum-specifier.
20621 enum-specifier:
20622 enum-head { enumerator-list [opt] }
20623 enum-head { enumerator-list , } [C++0x]
20625 enum-head:
20626 enum-key identifier [opt] enum-base [opt]
20627 enum-key nested-name-specifier identifier enum-base [opt]
20629 enum-key:
20630 enum
20631 enum class [C++0x]
20632 enum struct [C++0x]
20634 enum-base: [C++0x]
20635 : type-specifier-seq
20637 opaque-enum-specifier:
20638 enum-key identifier enum-base [opt] ;
20640 GNU Extensions:
20641 enum-key attributes[opt] identifier [opt] enum-base [opt]
20642 { enumerator-list [opt] }attributes[opt]
20643 enum-key attributes[opt] identifier [opt] enum-base [opt]
20644 { enumerator-list, }attributes[opt] [C++0x]
20646 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
20647 if the token stream isn't an enum-specifier after all. */
20649 static tree
20651 {
20652 tree identifier;
20654 tree prev_scope;
20656 tree attributes;
20667 /* Parse tentatively so that we can back up if we don't find a
20668 enum-specifier. */
20671 /* Caller guarantees that the current token is 'enum', an identifier
20672 possibly follows, and the token after that is an opening brace.
20673 If we don't have an identifier, fabricate an anonymous name for
20674 the enumeration being defined. */
20677 /* Parse the "class" or "struct", which indicates a scoped
20678 enumeration type in C++0x. */
20681 {
20685 /* Consume the `struct' or `class' token. */
20689 }
20693 /* Clear the qualification. */
20698 /* Figure out in what scope the declaration is being placed. */
20704 nested_name_specifier
20712 {
20713 tree name;
20717 enum_type,
20722 input_location);
20724 {
20727 {
20728 /* Are template enums allowed in ISO? */
20732 /* ignore a typename reference, for it will be solved by name
20733 in start_enum. */
20735 }
20736 }
20739 else
20740 {
20745 }
20746 }
20747 else
20748 {
20751 else
20752 {
20758 }
20759 }
20762 /* Check for the `:' that denotes a specified underlying type in C++0x.
20763 Note that a ':' could also indicate a bitfield width, however. */
20765 {
20766 cp_decl_specifier_seq type_specifiers;
20768 /* Consume the `:'. */
20771 auto tdf
20775 /* Parse the type-specifier-seq. */
20781 /* At this point this is surely not elaborated type specifier. */
20790 /* If that didn't work, stop. */
20792 {
20798 }
20799 }
20801 /* Look for the `{' but don't consume it yet. */
20803 {
20805 {
20811 }
20812 /* An opaque-enum-specifier must have a ';' here. */
20815 {
20821 }
20822 }
20828 {
20830 {
20834 }
20837 }
20839 /* Issue an error message if type-definitions are forbidden here. */
20842 else
20843 /* Create the new type. We do this before consuming the opening
20844 brace so the enum will be recorded as being on the line of its
20845 tag (or the 'enum' keyword, if there is no tag). */
20849 /* If the next token is not '{' it is an opaque-enum-specifier or an
20850 elaborated-type-specifier. */
20852 {
20856 {
20857 /* The following catches invalid code such as:
20858 enum class S<int>::E { A, B, C }; */
20866 {
20870 nested_name_specifier);
20872 }
20875 {
20877 "%qT for enum declaration does not name a class "
20880 }
20881 /* If that scope does not contain the scope in which the
20882 class was originally declared, the program is invalid. */
20884 nested_name_specifier))
20885 {
20888 "declaration of %qD in namespace %qD which does not "
20891 else
20893 "declaration of %qD in %qD which does not "
20897 }
20898 /* If that scope is the scope where the declaration is being placed
20899 the program is invalid. */
20903 {
20907 }
20908 }
20913 /* Consume the opening brace. */
20914 matching_braces braces;
20921 {
20925 }
20926 else
20927 {
20933 }
20937 /* If the next token is not '}', then there are some enumerators. */
20939 {
20943 }
20944 else
20945 {
20946 /* We've seen a '{' so we know we're in an enum-specifier.
20947 Commit to any tentative parse to get syntax errors. */
20950 }
20952 /* Consume the final '}'. */
20958 }
20959 else
20960 {
20961 /* If a ';' follows, then it is an opaque-enum-specifier
20962 and additional restrictions apply. */
20964 {
20971 }
20972 }
20974 /* Look for trailing attributes to apply to this enumeration, and
20975 apply them if appropriate. */
20977 {
20980 trailing_attr,
20982 }
20984 /* Finish up the enumeration. */
20986 {
20991 }
20994 {
20996 {
20999 }
21002 }
21004 }
21006 /* Parse an enumerator-list. The enumerators all have the indicated
21007 TYPE.
21009 enumerator-list:
21010 enumerator-definition
21011 enumerator-list , enumerator-definition */
21013 static void
21015 {
21017 {
21018 /* Parse an enumerator-definition. */
21021 /* If the next token is not a ',', we've reached the end of
21022 the list. */
21025 /* Otherwise, consume the `,' and keep going. */
21027 /* If the next token is a `}', there is a trailing comma. */
21029 {
21034 }
21035 }
21036 }
21038 /* Parse an enumerator-definition. The enumerator has the indicated
21039 TYPE.
21041 enumerator-definition:
21042 enumerator
21043 enumerator = constant-expression
21045 enumerator:
21046 identifier
21048 GNU Extensions:
21050 enumerator-definition:
21051 enumerator attributes [opt]
21052 enumerator attributes [opt] = constant-expression */
21054 static void
21056 {
21057 tree identifier;
21058 tree value;
21059 location_t loc;
21061 /* Save the input location because we are interested in the location
21062 of the identifier and not the location of the explicit value. */
21065 /* Look for the identifier. */
21070 /* Parse any specified attributes. */
21073 /* If the next token is an '=', then there is an explicit value. */
21075 {
21076 /* Consume the `=' token. */
21078 /* Parse the value. */
21080 }
21081 else
21084 /* If we are processing a template, make sure the initializer of the
21085 enumerator doesn't contain any bare template parameter pack. */
21089 /* Create the enumerator. */
21091 }
21093 /* Parse a namespace-name.
21095 namespace-name:
21096 original-namespace-name
21097 namespace-alias
21099 Returns the NAMESPACE_DECL for the namespace. */
21101 static tree
21103 {
21104 tree identifier;
21105 tree namespace_decl;
21109 /* Get the name of the namespace. */
21114 /* Look up the identifier in the currently active scope. Look only
21115 for namespaces, due to:
21117 [basic.lookup.udir]
21119 When looking up a namespace-name in a using-directive or alias
21120 definition, only namespace names are considered.
21122 And:
21124 [basic.lookup.qual]
21126 During the lookup of a name preceding the :: scope resolution
21127 operator, object, function, and enumerator names are ignored.
21129 (Note that cp_parser_qualifying_entity only calls this
21130 function if the token after the name is the scope resolution
21131 operator.) */
21133 none_type,
21139 /* If it's not a namespace, issue an error. */
21142 {
21144 {
21145 auto_diagnostic_group d;
21146 name_hint hint;
21150 identifier,
21153 {
21159 }
21160 else
21162 identifier);
21163 }
21164 else
21167 }
21170 }
21172 /* Parse a namespace-definition.
21174 namespace-definition:
21175 named-namespace-definition
21176 unnamed-namespace-definition
21178 named-namespace-definition:
21179 original-namespace-definition
21180 extension-namespace-definition
21182 original-namespace-definition:
21183 namespace identifier { namespace-body }
21185 extension-namespace-definition:
21186 namespace original-namespace-name { namespace-body }
21188 unnamed-namespace-definition:
21189 namespace { namespace-body } */
21191 static void
21193 {
21194 tree identifier;
21204 {
21207 }
21209 /* Look for the `namespace' keyword. */
21210 cp_token* token
21213 /* Parse any specified attributes before the identifier. */
21217 {
21221 RID_INLINE);
21223 {
21227 "definitions only available with %<-std=c++20%> or "
21230 }
21233 {
21238 "standard attributes on namespaces must precede "
21241 /* Parse any attributes specified after the identifier. */
21243 }
21246 {
21247 /* Don't forget that the innermost namespace might have been
21248 marked as inline. Use |= because we cannot overwrite
21249 IS_INLINE in case the outermost namespace is inline, but
21250 there are no nested inlines. */
21253 }
21257 "nested namespace definitions only available with "
21260 /* Nested namespace names can create new namespaces (unlike
21261 other qualified-ids). */
21266 else
21269 }
21281 /* Start the namespace. */
21288 /* Look for the `{' to validate starting the namespace. */
21289 matching_braces braces;
21291 {
21292 /* Parse the body of the namespace. */
21295 /* Look for the final `}'. */
21297 }
21302 /* Pop the nested namespace definitions. */
21305 }
21307 /* Parse a namespace-body.
21309 namespace-body:
21310 declaration-seq [opt] */
21312 static void
21314 {
21316 }
21318 /* Parse a namespace-alias-definition.
21320 namespace-alias-definition:
21321 namespace identifier = qualified-namespace-specifier ; */
21323 static void
21325 {
21326 tree identifier;
21327 tree namespace_specifier;
21331 /* Look for the `namespace' keyword. */
21333 /* Look for the identifier. */
21337 /* Look for the `=' token. */
21340 {
21342 /* Skip the definition. */
21347 }
21349 /* Look for the qualified-namespace-specifier. */
21350 namespace_specifier
21353 /* Look for the `;' token. */
21356 /* Register the alias in the symbol table. */
21358 }
21360 /* Parse a qualified-namespace-specifier.
21362 qualified-namespace-specifier:
21363 :: [opt] nested-name-specifier [opt] namespace-name
21365 Returns a NAMESPACE_DECL corresponding to the specified
21366 namespace. */
21368 static tree
21370 {
21371 /* Look for the optional `::'. */
21375 /* Look for the optional nested-name-specifier. */
21383 }
21385 /* Subroutine of cp_parser_using_declaration. */
21387 static tree
21389 {
21392 {
21393 /* Create the USING_DECL. */
21402 /* Add it to the list of members in this class. */
21404 }
21405 else
21408 }
21410 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
21411 access declaration.
21413 using-declaration:
21414 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
21415 using :: unqualified-id ;
21417 access-declaration:
21418 qualified-id ;
21420 */
21422 static bool
21425 {
21429 tree identifier;
21430 tree qscope;
21435 {
21438 }
21439 else
21440 {
21441 /* Look for the `using' keyword. */
21444 again:
21445 /* Peek at the next token. */
21447 /* See if it's `typename'. */
21449 {
21450 /* Remember that we've seen it. */
21452 /* Consume the `typename' token. */
21454 }
21455 }
21457 /* Look for the optional global scope qualification. */
21458 global_scope_p
21463 /* If we saw `typename', or didn't see `::', then there must be a
21464 nested-name-specifier present. */
21466 {
21472 {
21475 }
21476 }
21477 /* Otherwise, we could be in either of the two productions. In that
21478 case, treat the nested-name-specifier as optional. */
21479 else
21491 /* Something has already gone wrong; there's no need to parse
21492 further. Since an error has occurred, the return value of
21493 cp_parser_parse_definitely will be false, as required. */
21497 /* Parse the unqualified-id. */
21505 {
21510 }
21512 {
21516 "pack expansion in using-declaration only available "
21519 }
21521 /* The function we call to handle a using-declaration is different
21522 depending on what scope we are in. */
21524 ;
21527 /* [namespace.udecl]
21529 A using declaration shall not name a template-id. */
21532 else
21533 {
21537 {
21540 }
21541 }
21545 {
21549 "comma-separated list in using-declaration only available "
21552 }
21554 /* Look for the final `;'. */
21559 "access declarations are deprecated "
21560 "in favour of using-declarations; "
21564 }
21566 /* C++20 using enum declaration.
21568 using-enum-declaration :
21569 using elaborated-enum-specifier ; */
21571 static void
21573 {
21576 /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
21577 breaks one of the motivating examples in using-enum-5.C.
21578 cp_parser_simple_type_specifier seems to be closer to what we actually
21579 want, though that hasn't been properly specified yet. */
21581 /* Consume 'enum'. */
21587 tree type = (cp_parser_simple_type_specifier
21594 {
21597 }
21601 /* The elaborated-enum-specifier shall not name a dependent type and the type
21602 shall have a reachable enum-specifier. */
21616 {
21618 auto_diagnostic_group g;
21622 ;
21625 else
21627 }
21629 /* A using-enum-declaration introduces the enumerator names of the named
21630 enumeration as if by a using-declaration for each enumerator. */
21634 }
21636 /* Parse an alias-declaration.
21638 alias-declaration:
21639 using identifier attribute-specifier-seq [opt] = type-id */
21641 static tree
21643 {
21647 cp_decl_specifier_seq decl_specs;
21651 /* Look for the `using' keyword. */
21652 cp_token *using_token
21674 /* Now we are going to parse the type-id of the declaration. */
21676 /*
21677 [dcl.type]/3 says:
21679 "A type-specifier-seq shall not define a class or enumeration
21680 unless it appears in the type-id of an alias-declaration (7.1.3) that
21681 is not the declaration of a template-declaration."
21683 In other words, if we currently are in an alias template, the
21684 type-id should not define a type.
21686 So let's set parser->type_definition_forbidden_message in that
21687 case; cp_parser_check_type_definition (called by
21688 cp_parser_class_specifier) will then emit an error if a type is
21689 defined in the type-id. */
21691 {
21695 }
21700 /* Restore the error message if need be. */
21706 {
21709 }
21711 /* A typedef-name can also be introduced by an alias-declaration. The
21712 identifier following the using keyword becomes a typedef-name. It has
21713 the same semantics as if it were introduced by the typedef
21714 specifier. In particular, it does not define a new type and it shall
21715 not appear in the type-id. */
21720 {
21723 ds_attribute,
21724 attrs_token);
21725 }
21727 ds_typedef,
21728 using_token);
21730 ds_alias,
21731 using_token);
21738 id_location,
21748 else
21759 /* If decl is a template, return its TEMPLATE_DECL so that it gets
21760 added into the symbol table; otherwise, return the TYPE_DECL. */
21764 {
21768 }
21771 }
21773 /* Parse a using-directive.
21775 using-directive:
21776 attribute-specifier-seq [opt] using namespace :: [opt]
21777 nested-name-specifier [opt] namespace-name ; */
21779 static void
21781 {
21782 tree namespace_decl;
21785 {
21786 /* Error during attribute parsing that resulted in skipping
21787 to next semicolon. */
21790 }
21792 /* Look for the `using' keyword. */
21794 /* And the `namespace' keyword. */
21796 /* Look for the optional `::' operator. */
21798 /* And the optional nested-name-specifier. */
21804 /* Get the namespace being used. */
21807 /* And any specified GNU attributes. */
21811 /* Update the symbol table. */
21814 /* Look for the final `;'. */
21816 }
21818 /* Parse an asm-definition.
21820 asm-qualifier:
21821 volatile
21822 inline
21823 goto
21825 asm-qualifier-list:
21826 asm-qualifier
21827 asm-qualifier-list asm-qualifier
21829 asm-definition:
21830 asm ( string-literal ) ;
21832 GNU Extension:
21834 asm-definition:
21835 asm asm-qualifier-list [opt] ( string-literal ) ;
21836 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
21837 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
21838 : asm-operand-list [opt] ) ;
21839 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
21840 : asm-operand-list [opt]
21841 : asm-clobber-list [opt] ) ;
21842 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
21843 : asm-clobber-list [opt]
21844 : asm-goto-list ) ;
21846 The form with asm-goto-list is valid if and only if the asm-qualifier-list
21847 contains goto, and is the only allowed form in that case. No duplicates are
21848 allowed in an asm-qualifier-list. */
21850 static void
21852 {
21853 tree string;
21858 tree asm_stmt;
21865 /* Look for the `asm' keyword. */
21868 /* In C++20, unevaluated inline assembly is permitted in constexpr
21869 functions. */
21874 "function only available with %<-std=c++20%> or "
21877 /* Handle the asm-qualifier-list. */
21885 {
21889 {
21892 {
21896 }
21897 else
21898 {
21903 }
21909 {
21913 }
21914 else
21923 {
21927 }
21928 else
21943 }
21945 }
21952 {
21955 }
21957 /* Look for the opening `('. */
21960 /* Look for the string. */
21963 {
21967 }
21969 /* If we're allowing GNU extensions, check for the extended assembly
21970 syntax. Unfortunately, the `:' tokens need not be separated by
21971 a space in C, and so, for compatibility, we tolerate that here
21972 too. Doing that means that we have to treat the `::' operator as
21973 two `:' tokens. */
21978 {
21983 /* The extended syntax was used. */
21986 /* Look for outputs. */
21988 {
21989 /* Consume the `:'. */
21991 /* Parse the output-operands. */
21993 CPP_COLON)
21995 CPP_SCOPE)
21997 CPP_CLOSE_PAREN))
21998 {
22002 }
22003 }
22004 /* If the next token is `::', there are no outputs, and the
22005 next token is the beginning of the inputs. */
22007 /* The inputs are coming next. */
22010 /* Look for inputs. */
22013 {
22014 /* Consume the `:' or `::'. */
22016 /* Parse the output-operands. */
22018 CPP_COLON)
22020 CPP_SCOPE)
22022 CPP_CLOSE_PAREN))
22023 {
22027 }
22028 }
22030 /* The clobbers are coming next. */
22033 /* Look for clobbers. */
22036 {
22038 /* Consume the `:' or `::'. */
22040 /* Parse the clobbers. */
22042 CPP_COLON)
22044 CPP_CLOSE_PAREN))
22046 }
22048 /* The labels are coming next. */
22051 /* Look for labels. */
22054 {
22056 /* Consume the `:' or `::'. */
22058 /* Parse the labels. */
22060 }
22064 }
22068 /* Look for the closing `)'. */
22076 {
22077 /* Create the ASM_EXPR. */
22079 {
22082 /* If the extended syntax was not used, mark the ASM_EXPR. */
22084 {
22090 }
22091 }
22092 else
22094 }
22095 }
22097 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
22098 type that comes from the decl-specifier-seq. */
22100 static tree
22102 {
22105 {
22118 }
22121 }
22123 /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
22124 a construct looks like a variable definition but is actually a function
22125 declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
22126 is the declarator for this function declaration. */
22128 static void
22131 {
22132 /* Only warn if we are declaring a function at block scope. */
22136 /* And only if there is no storage class specified. */
22148 /* Don't warn when the whole declarator (not just the declarator-id!)
22149 was parenthesized. That is, don't warn for int(n()) but do warn
22150 for int(f)(). */
22154 tree type;
22156 {
22161 /* If the return type is void there is no ambiguity. */
22164 }
22166 /* Code like long f(); will have null ->type. If we have any
22167 type-specifiers, pretend we've seen int. */
22169 else
22172 auto_diagnostic_group d;
22177 /* The T t() case. */
22179 {
22181 "empty parentheses were disambiguated as a function "
22183 {
22184 /* () means value-initialization (C++03 and up); {} (C++11 and up)
22185 means value-initialization or aggregate-initialization, nothing
22186 means default-initialization. We can only suggest removing the
22187 parentheses/adding {} if T has a default constructor. */
22189 {
22195 {
22199 else
22202 }
22203 }
22204 }
22206 }
22208 /* If we had (...) or the parameter-list wasn't parenthesized,
22209 we're done. */
22213 /* The T t(X()) case. */
22215 {
22217 "parentheses were disambiguated as a function "
22219 {
22221 /* {}-initialization means that we can use an initializer-list
22222 constructor if no default constructor is available, so don't
22223 suggest using {} for classes that have an initializer_list
22224 constructor. */
22226 {
22231 }
22232 else
22233 {
22237 }
22238 }
22239 }
22240 /* The T t(X(), X()) case. */
22242 "parentheses were disambiguated as a function "
22244 {
22247 {
22252 }
22253 }
22254 }
22256 /* If DECLARATOR with DECL_SPECS is a function declarator that has
22257 the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
22258 has the same meaning as in cp_parser_declarator. */
22260 static void
22265 {
22271 {
22279 {
22283 }
22284 }
22285 }
22287 /* Declarators [gram.dcl.decl] */
22289 /* Parse an init-declarator.
22291 init-declarator:
22292 declarator initializer [opt]
22294 GNU Extension:
22296 init-declarator:
22297 declarator asm-specification [opt] attributes [opt] initializer [opt]
22299 function-definition:
22300 decl-specifier-seq [opt] declarator ctor-initializer [opt]
22301 function-body
22302 decl-specifier-seq [opt] declarator function-try-block
22304 GNU Extension:
22306 function-definition:
22307 __extension__ function-definition
22309 TM Extension:
22311 function-definition:
22312 decl-specifier-seq [opt] declarator function-transaction-block
22314 The parser flags FLAGS is used to control type-specifier parsing.
22316 The DECL_SPECIFIERS apply to this declarator. Returns a
22317 representation of the entity declared. If MEMBER_P is TRUE, then
22318 this declarator appears in a class scope. The new DECL created by
22319 this declarator is returned.
22321 The CHECKS are access checks that should be performed once we know
22322 what entity is being declared (and, therefore, what classes have
22323 befriended it).
22325 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
22326 for a function-definition here as well. If the declarator is a
22327 declarator for a function-definition, *FUNCTION_DEFINITION_P will
22328 be TRUE upon return. By that point, the function-definition will
22329 have been completely parsed.
22331 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
22332 is FALSE.
22334 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
22335 parsed declaration if it is an uninitialized single declarator not followed
22336 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
22337 if present, will not be consumed. If returned, this declarator will be
22338 created with SD_INITIALIZED but will not call cp_finish_decl.
22340 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
22341 and there is an initializer, the pointed location_t is set to the
22342 location of the '=' or `(', or '{' in C++11 token introducing the
22343 initializer. */
22345 static tree
22347 cp_parser_flags flags,
22357 {
22361 tree prefix_attributes;
22363 tree asm_specification;
22364 tree initializer;
22366 tree scope;
22368 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
22369 initialized with "= ..", CPP_OPEN_PAREN if initialized with
22370 "(...)". */
22385 /* Assume that this is not the declarator for a function
22386 definition. */
22390 /* Default arguments are only permitted for function parameters. */
22394 /* Defer access checks while parsing the declarator; we cannot know
22395 what names are accessible until we know what is being
22396 declared. */
22401 /* Parse the declarator. */
22402 declarator
22407 /* Gather up the deferred checks. */
22412 /* If the DECLARATOR was erroneous, there's no need to go
22413 further. */
22417 /* Check that the number of template-parameter-lists is OK. */
22427 /* Figure out what scope the entity declared by the DECLARATOR is
22428 located in. `grokdeclarator' sometimes changes the scope, so
22429 we compute it now. */
22432 /* Perform any lookups in the declared type which were thought to be
22433 dependent, but are not in the scope of the declarator. */
22434 decl_specifiers->type
22437 /* If we're allowing GNU extensions, look for an
22438 asm-specification. */
22440 {
22441 /* Look for an asm-specification. */
22444 }
22445 else
22448 /* Gather the attributes that were provided with the
22449 decl-specifiers. */
22452 /* Look for attributes. */
22456 /* Peek at the next token. */
22462 {
22463 /* Handle C++17 deduction guides. Note that class-scope
22464 non-template deduction guides are instead handled in
22465 cp_parser_member_declaration. */
22467 decl_specifiers,
22468 declarator,
22474 /* Check to see if the token indicates the start of a
22475 function-definition. */
22477 {
22479 {
22480 /* If a function-definition should not appear here, issue an
22481 error message. */
22485 }
22487 location_t func_brace_location
22490 /* Neither attributes nor an asm-specification are allowed
22491 on a function-definition. */
22494 "an %<asm%> specification is not allowed "
22498 "attributes are not allowed "
22500 /* This is a function-definition. */
22503 /* Parse the function definition. */
22506 decl_specifiers,
22507 declarator,
22508 prefix_attributes);
22509 else
22510 decl =
22511 (cp_parser_function_definition_from_specifiers_and_declarator
22515 {
22516 /* This is where the prologue starts... */
22519 }
22522 }
22523 }
22525 {
22526 /* A non-template declaration involving a function parameter list
22527 containing an implicit template parameter will be made into a
22528 template. If the resulting declaration is not going to be an
22529 actual function then finish the template scope here to prevent it.
22530 An error message will be issued once we have a decl to talk about.
22532 FIXME probably we should do type deduction rather than create an
22533 implicit template, but the standard currently doesn't allow it. */
22536 }
22538 /* [dcl.dcl]
22540 Only in function declarations for constructors, destructors, type
22541 conversions, and deduction guides can the decl-specifier-seq be omitted.
22543 We explicitly postpone this check past the point where we handle
22544 function-definitions because we tolerate function-definitions
22545 that are missing their return types in some modes. */
22547 {
22551 }
22553 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
22557 {
22569 {
22575 }
22576 }
22577 else
22578 {
22579 /* If the init-declarator isn't initialized and isn't followed by a
22580 `,' or `;', it's not a valid init-declarator. */
22583 {
22586 else
22587 {
22591 }
22592 }
22595 }
22597 /* Because start_decl has side-effects, we should only call it if we
22598 know we're going ahead. By this point, we know that we cannot
22599 possibly be looking at any other construct. */
22602 /* Enter the newly declared entry in the symbol table. If we're
22603 processing a declaration in a class-specifier, we wait until
22604 after processing the initializer. */
22606 {
22614 /* Adjust location of decl if declarator->id_loc is more appropriate:
22615 set, and decl wasn't merged with another decl, in which case its
22616 location would be different from input_location, and more accurate. */
22621 }
22623 /* Enter the SCOPE. That way unqualified names appearing in the
22624 initializer will be looked up in SCOPE. */
22627 /* Perform deferred access control checks, now that we know in which
22628 SCOPE the declared entity resides. */
22630 {
22633 /* If the entity being declared is a function, pretend that we
22634 are in its scope. If it is a `friend', it may have access to
22635 things that would not otherwise be accessible. */
22637 {
22640 }
22642 /* Perform access checks for template parameters. */
22645 /* Perform the access control checks for the declarator and the
22646 decl-specifiers. */
22649 /* Restore the saved value. */
22652 }
22654 /* Parse the initializer. */
22659 {
22661 {
22664 else
22665 {
22666 /* If the declaration was erroneous, we don't really
22667 know what the user intended, so just silently
22668 consume the initializer. */
22675 }
22676 }
22677 else
22678 {
22679 /* We want to record the extra mangling scope for in-class
22680 initializers of class members and initializers of static
22681 data member templates and namespace-scope initializers.
22682 The former involves deferring parsing of the initializer
22683 until end of class as with default arguments. So right
22684 here we only handle the latter two. */
22688 && !member_p
22701 }
22702 }
22704 /* The old parser allows attributes to appear after a parenthesized
22705 initializer. Mark Mitchell proposed removing this functionality
22706 on the GCC mailing lists on 2002-08-13. This parser accepts the
22707 attributes -- but ignores them. Made a permerror in GCC 8. */
22713 {
22716 {
22720 }
22721 }
22723 /* And now complain about a non-function implicit template. */
22728 /* For an in-class declaration, use `grokfield' to create the
22729 declaration. */
22731 {
22733 {
22736 }
22745 }
22747 /* Finish processing the declaration. But, skip member
22748 declarations. */
22750 {
22753 asm_specification,
22754 /* If the initializer is in parentheses, then this is
22755 a direct-initialization, which means that an
22756 `explicit' constructor is OK. Otherwise, an
22757 `explicit' constructor cannot be used. */
22760 }
22763 /* Core issue #226 (C++0x only): A default template-argument
22764 shall not be specified in a friend class template
22765 declaration. */
22774 {
22777 else
22779 }
22786 }
22788 /* Parse a declarator.
22790 declarator:
22791 direct-declarator
22792 ptr-operator declarator
22794 abstract-declarator:
22795 ptr-operator abstract-declarator [opt]
22796 direct-abstract-declarator
22798 GNU Extensions:
22800 declarator:
22801 attributes [opt] direct-declarator
22802 attributes [opt] ptr-operator declarator
22804 abstract-declarator:
22805 attributes [opt] ptr-operator abstract-declarator [opt]
22806 attributes [opt] direct-abstract-declarator
22808 The parser flags FLAGS is used to control type-specifier parsing.
22810 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
22811 detect constructors, destructors, deduction guides, or conversion operators.
22812 It is set to -1 if the declarator is a name, and +1 if it is a
22813 function. Otherwise it is set to zero. Usually you just want to
22814 test for >0, but internally the negative value is used.
22816 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
22817 a decl-specifier-seq unless it declares a constructor, destructor,
22818 or conversion. It might seem that we could check this condition in
22819 semantic analysis, rather than parsing, but that makes it difficult
22820 to handle something like `f()'. We want to notice that there are
22821 no decl-specifiers, and therefore realize that this is an
22822 expression, not a declaration.)
22824 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
22825 the declarator is a direct-declarator of the form "(...)".
22827 MEMBER_P is true iff this declarator is a member-declarator.
22829 FRIEND_P is true iff this declarator is a friend.
22831 STATIC_P is true iff the keyword static was seen. */
22835 cp_parser_declarator_kind dcl_kind,
22836 cp_parser_flags flags,
22840 {
22843 cp_cv_quals cv_quals;
22844 tree class_type;
22847 /* Assume this is not a constructor, destructor, or type-conversion
22848 operator. */
22855 /* Check for the ptr-operator production. */
22857 /* Parse the ptr-operator. */
22863 /* If that worked, then we have a ptr-operator. */
22865 {
22866 /* If a ptr-operator was found, then this declarator was not
22867 parenthesized. */
22870 /* The dependent declarator is optional if we are parsing an
22871 abstract-declarator. */
22875 /* Parse the dependent declarator. */
22881 /* If we are parsing an abstract-declarator, we must handle the
22882 case where the dependent declarator is absent. */
22887 declarator = cp_parser_make_indirect_declarator
22889 }
22890 /* Everything else is a direct-declarator. */
22891 else
22892 {
22895 CPP_OPEN_PAREN);
22899 }
22904 }
22906 /* Parse a direct-declarator or direct-abstract-declarator.
22908 direct-declarator:
22909 declarator-id
22910 direct-declarator ( parameter-declaration-clause )
22911 cv-qualifier-seq [opt]
22912 ref-qualifier [opt]
22913 exception-specification [opt]
22914 direct-declarator [ constant-expression [opt] ]
22915 ( declarator )
22917 direct-abstract-declarator:
22918 direct-abstract-declarator [opt]
22919 ( parameter-declaration-clause )
22920 cv-qualifier-seq [opt]
22921 ref-qualifier [opt]
22922 exception-specification [opt]
22923 direct-abstract-declarator [opt] [ constant-expression [opt] ]
22924 ( abstract-declarator )
22926 Returns a representation of the declarator. DCL_KIND is
22927 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
22928 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
22929 we are parsing a direct-declarator. It is
22930 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
22931 of ambiguity we prefer an abstract declarator, as per
22932 [dcl.ambig.res].
22933 The parser flags FLAGS is used to control type-specifier parsing.
22934 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
22935 as for cp_parser_declarator. */
22939 cp_parser_declarator_kind dcl_kind,
22940 cp_parser_flags flags,
22943 {
22954 {
22955 /* Peek at the next token. */
22958 {
22959 /* This is either a parameter-declaration-clause, or a
22960 parenthesized declarator. When we know we are parsing a
22961 named declarator, it must be a parenthesized declarator
22962 if FIRST is true. For instance, `(int)' is a
22963 parameter-declaration-clause, with an omitted
22964 direct-abstract-declarator. But `((*))', is a
22965 parenthesized abstract declarator. Finally, when T is a
22966 template parameter `(T)' is a
22967 parameter-declaration-clause, and not a parenthesized
22968 named declarator.
22970 We first try and parse a parameter-declaration-clause,
22971 and then try a nested declarator (if FIRST is true).
22973 It is not an error for it not to be a
22974 parameter-declaration-clause, even when FIRST is
22975 false. Consider,
22977 int i (int);
22978 int i (3);
22980 The first is the declaration of a function while the
22981 second is the definition of a variable, including its
22982 initializer.
22984 Having seen only the parenthesis, we cannot know which of
22985 these two alternatives should be selected. Even more
22986 complex are examples like:
22988 int i (int (a));
22989 int i (int (3));
22991 The former is a function-declaration; the latter is a
22992 variable initialization.
22994 Thus again, we try a parameter-declaration-clause, and if
22995 that fails, we back out and return. */
22998 {
22999 tree params;
23004 /* In a member-declarator, the only valid interpretation
23005 of a parenthesis is the start of a
23006 parameter-declaration-clause. (It is invalid to
23007 initialize a static data member with a parenthesized
23008 initializer; only the "=" form of initialization is
23009 permitted.) */
23013 /* Consume the `('. */
23015 matching_parens parens;
23018 {
23019 /* If this is going to be an abstract declarator, we're
23020 in a declarator and we can't have default args. */
23023 }
23027 /* Signal we are in the immediate function context. */
23031 /* Parse the parameter-declaration-clause. */
23032 params
23034 const location_t parens_end
23037 /* Consume the `)'. */
23040 /* If all went well, parse the cv-qualifier-seq,
23041 ref-qualifier and the exception-specification. */
23043 {
23044 cp_cv_quals cv_quals;
23045 cp_virt_specifiers virt_specifiers;
23046 cp_ref_qualifier ref_qual;
23047 tree exception_specification;
23048 tree late_return;
23049 tree attrs;
23052 unsigned char local_variables_forbidden_p
23054 /* 'this' is not allowed in static member functions. */
23064 /* Parse the cv-qualifier-seq. */
23066 /* Parse the ref-qualifier. */
23068 /* Parse the tx-qualifier. */
23074 /* DR 1207: 'this' is in scope after the cv-quals. */
23077 /* If it turned out that this is e.g. a pointer to a
23078 function, we don't want to delay noexcept parsing. */
23082 /* Parse the exception-specification. */
23083 exception_specification
23085 flags);
23089 cp_omp_declare_simd_data odsd;
23091 && declarator
23094 {
23098 }
23100 /* In here, we handle cases where attribute is used after
23101 the function declaration. For example:
23102 void func (int x) __attribute__((vector(..))); */
23105 late_return
23107 requires_clause);
23111 /* Parse the virt-specifier-seq. */
23115 parens_start,
23116 parens_end);
23117 /* Create the function-declarator. */
23119 params,
23120 cv_quals,
23121 virt_specifiers,
23122 ref_qual,
23123 tx_qual,
23124 exception_specification,
23125 late_return,
23126 requires_clause,
23127 parens_loc);
23130 /* Any subsequent parameter lists are to do with
23131 return type, so are not those of the declared
23132 function. */
23138 /* Restore the state of local_variables_forbidden_p. */
23139 parser->local_variables_forbidden_p
23141 }
23143 /* Remove the function parms from scope. */
23147 /* Repeat the main loop. */
23149 }
23151 /* If this is the first, we can try a parenthesized
23152 declarator. */
23154 {
23161 /* Consume the `('. */
23162 matching_parens parens;
23164 /* Parse the nested declarator. */
23167 declarator
23169 ctor_dtor_or_conv_p,
23175 /* Expect a `)'. */
23183 }
23184 /* Otherwise, we must be done. */
23185 else
23187 }
23191 {
23192 /* Parse an array-declarator. */
23202 /* Consume the `['. */
23204 /* Peek at the next token. */
23206 /* If the next token is `]', then there is no
23207 constant-expression. */
23209 {
23211 bounds
23223 {
23224 /* Normally, the array bound must be an integral constant
23225 expression. However, as an extension, we allow VLAs
23226 in function scopes as long as they aren't part of a
23227 parameter declaration. */
23231 }
23234 {
23235 /* Remember this wasn't a constant-expression. */
23238 }
23239 }
23240 else
23242 /* Look for the closing `]'. */
23244 {
23247 }
23252 }
23254 {
23255 {
23256 tree qualifying_scope;
23257 tree unqualified_name;
23258 tree attrs;
23259 special_function_kind sfk;
23264 /* Parse a declarator-id */
23267 {
23270 /* If we see an ellipsis, we should be looking at a
23271 parameter pack. */
23273 {
23274 /* Consume the `...' */
23278 }
23279 }
23282 unqualified_name
23286 {
23290 {
23291 /* Check whether an error occurred. */
23294 /* We already consumed the ellipsis to mark a
23295 parameter pack, but we have no way to report it,
23296 so abort the tentative parse. We will be exiting
23297 immediately anyway. */
23299 }
23300 else
23306 && (qualifying_scope
23308 {
23311 }
23312 }
23317 {
23322 }
23328 {
23329 /* In the declaration of a member of a template class
23330 outside of the class itself, the SCOPE will sometimes
23331 be a TYPENAME_TYPE. For example, given:
23333 template <typename T>
23334 int S<T>::R::i = 3;
23336 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
23337 this context, we must resolve S<T>::R to an ordinary
23338 type, rather than a typename type.
23340 The reason we normally avoid resolving TYPENAME_TYPEs
23341 is that a specialization of `S' might render
23342 `S<T>::R' not a type. However, if `S' is
23343 specialized, then this `i' will not be used, so there
23344 is no harm in resolving the types here. */
23345 tree type;
23347 /* Resolve the TYPENAME_TYPE. */
23350 /* If that failed, the declarator is invalid. */
23352 {
23355 "cannot define member of dependent typedef "
23357 else
23362 }
23364 }
23369 {
23370 tree class_type;
23375 else
23379 {
23383 {
23384 /* We do not attempt to print the declarator
23385 here because we do not have enough
23386 information about its original syntactic
23387 form. */
23391 }
23394 {
23398 "use %<%T::%D%> instead of %<%T::%D%> to "
23400 class_type,
23405 }
23407 }
23410 {
23417 for an unnamed type, even if the type
23418 got a name for linkage purposes. */
23420 /* Handle correctly (c++/19200):
23422 struct S {
23423 struct T{};
23424 friend void S(T);
23425 };
23427 and also:
23429 namespace N {
23430 void S();
23431 }
23433 struct S {
23434 friend void N::S();
23435 }; */
23438 class_type))
23447 }
23448 }
23450 unqualified_name,
23458 /* We're looking for this case in [temp.res]:
23459 A qualified-id is assumed to name a type if [...]
23460 - it is a decl-specifier of the decl-specifier-seq of a
23461 parameter-declaration in a declarator of a function or
23462 function template declaration, ... */
23468 {
23469 /* ...whose declarator-id is qualified. If it isn't, never
23470 assume the parameters to refer to types. */
23473 else
23474 {
23475 /* Now we have something like
23476 template <typename T> int C::x(S::p);
23477 which can be a function template declaration or a
23478 variable template definition. If name lookup for
23479 the declarator-id C::x finds one or more function
23480 templates, assume S::p to name a type. Otherwise,
23481 don't. */
23482 tree decl
23484 none_type,
23492 /* Allow
23493 template<typename T>
23494 A<T>::A(T::type) { } */
23497 qualifying_scope)))
23499 }
23500 }
23501 }
23503 handle_declarator:;
23506 {
23507 /* Any names that appear after the declarator-id for a
23508 member are looked up in the containing scope. */
23510 {
23511 /* But declarations with qualified-ids can't appear in a
23512 function. */
23516 }
23518 }
23522 /* Default args are only allowed on function
23523 declarations. */
23525 else
23529 }
23530 /* We're done. */
23531 else
23533 }
23535 /* For an abstract declarator, we might wind up with nothing at this
23536 point. That's an error; the declarator is not optional. */
23540 {
23541 /* Record overly parenthesized declarator so we can give a
23542 diagnostic about confusing decl/expr disambiguation. */
23544 {
23545 /* If the open and close parens are on different lines, this
23546 is probably a formatting thing, so ignore. */
23551 }
23556 }
23558 /* If we entered a scope, we must exit it now. */
23566 }
23568 /* Parse a ptr-operator.
23570 ptr-operator:
23571 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
23572 * cv-qualifier-seq [opt]
23573 &
23574 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
23575 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
23577 GNU Extension:
23579 ptr-operator:
23580 & cv-qualifier-seq [opt]
23582 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
23583 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
23584 an rvalue reference. In the case of a pointer-to-member, *TYPE is
23585 filled in with the TYPE containing the member. *CV_QUALS is
23586 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
23587 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
23588 Note that the tree codes returned by this function have nothing
23589 to do with the types of trees that will be eventually be created
23590 to represent the pointer or reference type being parsed. They are
23591 just constants with suggestive names. */
23592 static enum tree_code
23597 {
23602 /* Assume that it's not a pointer-to-member. */
23604 /* And that there are no cv-qualifiers. */
23607 /* Peek at the next token. */
23610 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
23620 {
23621 /* Consume the `*', `&' or `&&'. */
23624 /* A `*' can be followed by a cv-qualifier-seq, and so can a
23625 `&', if we are allowing GNU extensions. (The only qualifier
23626 that can legally appear after `&' is `restrict', but that is
23627 enforced during semantic analysis. */
23635 }
23636 else
23637 {
23638 /* Try the pointer-to-member case. */
23640 /* Look for the optional `::' operator. */
23643 /* Look for the nested-name specifier. */
23650 /* If we found it, and the next token is a `*', then we are
23651 indeed looking at a pointer-to-member operator. */
23654 {
23655 /* Indicate that the `*' operator was used. */
23663 else
23664 {
23665 /* The type of which the member is a member is given by the
23666 current SCOPE. */
23668 /* The next name will not be qualified. */
23672 /* Look for optional c++11 attributes. */
23676 /* Look for the optional cv-qualifier-seq. */
23678 }
23679 }
23680 /* If that didn't work we don't have a ptr-operator. */
23683 }
23686 }
23688 /* Parse an (optional) cv-qualifier-seq.
23690 cv-qualifier-seq:
23691 cv-qualifier cv-qualifier-seq [opt]
23693 cv-qualifier:
23694 const
23695 volatile
23697 GNU Extension:
23699 cv-qualifier:
23700 __restrict__
23702 Returns a bitmask representing the cv-qualifiers. */
23704 static cp_cv_quals
23706 {
23710 {
23712 cp_cv_quals cv_qualifier;
23714 /* Peek at the next token. */
23716 /* See if it's a cv-qualifier. */
23718 {
23734 }
23740 {
23745 }
23746 else
23747 {
23750 }
23751 }
23754 }
23756 /* Parse an (optional) ref-qualifier
23758 ref-qualifier:
23759 &
23760 &&
23762 Returns cp_ref_qualifier representing ref-qualifier. */
23764 static cp_ref_qualifier
23766 {
23769 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
23774 {
23779 {
23791 }
23796 {
23799 }
23800 else
23801 {
23804 }
23805 }
23808 }
23810 /* Parse an optional tx-qualifier.
23812 tx-qualifier:
23813 transaction_safe
23814 transaction_safe_dynamic */
23816 static tree
23818 {
23821 {
23826 {
23830 {
23833 {
23836 }
23837 else
23839 }
23840 }
23841 }
23843 }
23845 /* Parse an (optional) virt-specifier-seq.
23847 virt-specifier-seq:
23848 virt-specifier virt-specifier-seq [opt]
23850 virt-specifier:
23851 override
23852 final
23854 Returns a bitmask representing the virt-specifiers. */
23856 static cp_virt_specifiers
23858 {
23862 {
23864 cp_virt_specifiers virt_specifier;
23866 /* Peek at the next token. */
23868 /* See if it's a virt-specifier-qualifier. */
23872 {
23875 }
23877 {
23880 }
23882 {
23884 }
23885 else
23889 {
23894 }
23895 else
23896 {
23899 }
23900 }
23902 }
23904 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
23905 is in scope even though it isn't real. */
23907 void
23909 {
23910 tree this_parm;
23913 {
23914 /* We don't clear this between NSDMIs. Is it already what we want? */
23921 }
23924 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
23926 current_class_ref
23929 }
23931 /* Return true iff our current scope is a non-static data member
23932 initializer. */
23934 bool
23936 {
23937 /* We recognize NSDMI context by the context-less 'this' pointer set up
23938 by the function above. */
23944 }
23946 /* True if we're parsing a function declarator. */
23948 bool
23950 {
23951 /* this_entity is NULL for a function parameter scope while parsing the
23952 declarator; it is set when parsing the body of the function. */
23955 }
23957 /* Parse a late-specified return type, if any. This is not a separate
23958 non-terminal, but part of a function declarator, which looks like
23960 -> trailing-type-specifier-seq abstract-declarator(opt)
23962 Returns the type indicated by the type-id.
23964 In addition to this, parse any queued up #pragma omp declare simd
23965 clauses, and #pragma acc routine clauses.
23967 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
23968 function. */
23970 static tree
23973 {
23977 && declarator
23981 && declarator
23984 /* Peek at the next token. */
23986 /* A late-specified return type is indicated by an initial '->'. */
23995 {
23996 /* Consume the ->. */
24000 }
24002 /* Function declarations may be followed by a trailing
24003 requires-clause. */
24007 declarator->attributes
24011 declarator->attributes
24016 }
24018 /* Parse a declarator-id.
24020 declarator-id:
24021 id-expression
24022 :: [opt] nested-name-specifier [opt] type-name
24024 In the `id-expression' case, the value returned is as for
24025 cp_parser_id_expression if the id-expression was an unqualified-id.
24026 If the id-expression was a qualified-id, then a SCOPE_REF is
24027 returned. The first operand is the scope (either a NAMESPACE_DECL
24028 or TREE_TYPE), but the second is still just a representation of an
24029 unqualified-id. */
24031 static tree
24033 {
24034 tree id;
24035 /* The expression must be an id-expression. Assume that qualified
24036 names are the names of types so that:
24038 template <class T>
24039 int S<T>::R::i = 3;
24041 will work; we must treat `S<T>::R' as the name of a type.
24042 Similarly, assume that qualified names are templates, where
24043 required, so that:
24045 template <class T>
24046 int S<T>::R<T>::i = 3;
24048 will work, too. */
24054 optional_p);
24058 }
24060 /* Parse a type-id.
24062 type-id:
24063 type-specifier-seq abstract-declarator [opt]
24065 The parser flags FLAGS is used to control type-specifier parsing.
24067 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
24069 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24070 i.e. we've just seen "->".
24072 Returns the TYPE specified. */
24074 static tree
24078 {
24079 cp_decl_specifier_seq type_specifier_seq;
24082 /* Parse the type-specifier-seq. */
24085 is_trailing_return,
24093 /* A bare template name as a template argument is a template template
24094 argument, not a placeholder, so fail parsing it as a type argument. */
24095 {
24099 }
24103 /* There might or might not be an abstract declarator. */
24105 /* Look for the declarator. */
24106 abstract_declarator
24113 /* Check to see if there really was a declarator. */
24118 /* The concepts TS allows 'auto' as a type-id. */
24121 /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
24122 outside the template-argument-list context here only for the sake of
24123 diagnostic: grokdeclarator then can emit a better error message for
24124 e.g. using T = auto. */
24130 && !auto_typeid_ok
24131 /* None of the valid uses of 'auto' in C++14 involve the type-id
24132 nonterminal, but it is valid in a trailing-return-type. */
24135 {
24136 /* A type-id with type 'auto' is only ok if the abstract declarator
24137 is a function declarator with a late-specified return type.
24139 A type-id with 'auto' is also valid in a trailing-return-type
24140 in a compound-requirement. */
24147 else
24148 {
24151 {
24153 {
24155 auto_node);
24157 tmpl);
24158 }
24159 }
24162 auto_node);
24163 else
24166 }
24167 }
24170 is_template_arg);
24171 }
24173 /* Wrapper for cp_parser_type_id_1. */
24175 static tree
24178 {
24180 }
24182 /* Wrapper for cp_parser_type_id_1. */
24184 static tree
24186 {
24187 tree r;
24189 parser->type_definition_forbidden_message
24194 {
24197 }
24199 }
24201 /* Wrapper for cp_parser_type_id_1. */
24203 static tree
24205 {
24208 }
24210 /* Parse a type-specifier-seq.
24212 type-specifier-seq:
24213 type-specifier type-specifier-seq [opt]
24215 GNU extension:
24217 type-specifier-seq:
24218 attributes type-specifier-seq [opt]
24220 The parser flags FLAGS is used to control type-specifier parsing.
24222 If IS_DECLARATION is true, we are at the start of a "condition" or
24223 exception-declaration, so we might be followed by a declarator-id.
24225 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24226 i.e. we've just seen "->".
24228 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
24230 static void
24232 cp_parser_flags flags,
24236 {
24240 /* Clear the TYPE_SPECIFIER_SEQ. */
24244 /* In the context of a trailing return type, enum E { } is an
24245 elaborated-type-specifier followed by a function-body, not an
24246 enum-specifier. */
24250 /* Parse the type-specifiers and attributes. */
24252 {
24253 tree type_specifier;
24256 /* Check for attributes first. */
24258 {
24259 /* GNU attributes at the end of a declaration apply to the
24260 declaration as a whole, not to the trailing return type. So look
24261 ahead to see if these attributes are at the end. */
24264 {
24270 }
24271 type_specifier_seq->attributes
24275 }
24277 /* record the token of the beginning of the type specifier seq,
24278 for error reporting purposes*/
24282 /* Look for the type-specifier. */
24284 flags,
24285 type_specifier_seq,
24287 NULL,
24290 {
24291 /* If the first type-specifier could not be found, this is not a
24292 type-specifier-seq at all. */
24294 {
24295 /* Set in_declarator_p to avoid skipping to the semicolon. */
24307 }
24308 /* If subsequent type-specifiers could not be found, the
24309 type-specifier-seq is complete. */
24311 }
24314 /* The standard says that a condition can be:
24316 type-specifier-seq declarator = assignment-expression
24318 However, given:
24320 struct S {};
24321 if (int S = ...)
24323 we should treat the "S" as a declarator, not as a
24324 type-specifier. The standard doesn't say that explicitly for
24325 type-specifier-seq, but it does say that for
24326 decl-specifier-seq in an ordinary declaration. Perhaps it
24327 would be clearer just to allow a decl-specifier-seq here, and
24328 then add a semantic restriction that if any decl-specifiers
24329 that are not type-specifiers appear, the program is invalid. */
24332 }
24333 }
24335 /* Return whether the function currently being declared has an associated
24336 template parameter list. */
24338 static bool
24340 {
24353 }
24355 /* Parse a parameter-declaration-clause.
24357 parameter-declaration-clause:
24358 parameter-declaration-list [opt] ... [opt]
24359 parameter-declaration-list , ...
24361 The parser flags FLAGS is used to control type-specifier parsing.
24363 Returns a representation for the parameter declarations. A return
24364 value of NULL indicates a parameter-declaration-clause consisting
24365 only of an ellipsis. */
24367 static tree
24369 cp_parser_flags flags)
24370 {
24371 tree parameters;
24379 && !processing_template_parmlist
24380 && !processing_explicit_instantiation
24381 /* default_arg_ok_p tracks whether this is a parameter-clause for an
24382 actual function or a random abstract declarator. */
24388 /* Peek at the next token. */
24390 /* Check for trivial parameter-declaration-clauses. */
24392 {
24393 /* Consume the `...' token. */
24396 }
24398 /* There are no parameters. */
24400 /* Check for `(void)', too, which is a special case. */
24404 {
24405 /* Consume the `void' token. */
24407 /* There are no parameters. */
24409 }
24411 /* Parse the parameter-declaration-list. */
24413 /* If a parse error occurred while parsing the
24414 parameter-declaration-list, then the entire
24415 parameter-declaration-clause is erroneous. */
24419 /* Peek at the next token. */
24421 /* If it's a `,', the clause should terminate with an ellipsis. */
24423 {
24424 /* Consume the `,'. */
24426 /* Expect an ellipsis. */
24427 ellipsis_p
24429 }
24430 /* It might also be `...' if the optional trailing `,' was
24431 omitted. */
24433 {
24434 /* Consume the `...' token. */
24436 /* And remember that we saw it. */
24438 }
24439 else
24442 /* Finish the parameter list. */
24447 }
24449 /* Parse a parameter-declaration-list.
24451 parameter-declaration-list:
24452 parameter-declaration
24453 parameter-declaration-list , parameter-declaration
24455 The parser flags FLAGS is used to control type-specifier parsing.
24457 Returns a representation of the parameter-declaration-list, as for
24458 cp_parser_parameter_declaration_clause. However, the
24459 `void_list_node' is never appended to the list. */
24461 static tree
24463 {
24469 /* The special considerations that apply to a function within an
24470 unbraced linkage specifications do not apply to the parameters
24471 to the function. */
24472 saved_in_unbraced_linkage_specification_p
24476 /* Look for more parameters. */
24478 {
24483 /* Parse the parameter. */
24484 parameter
24489 /* We don't know yet if the enclosing context is unavailable or deprecated,
24490 so wait and deal with it in grokparms if appropriate. */
24494 {
24497 PARM,
24502 }
24506 /* If a parse error occurred parsing the parameter declaration,
24507 then the entire parameter-declaration-list is erroneous. */
24509 {
24512 }
24522 {
24526 }
24528 /* Add the new parameter to the list. */
24532 /* If the parameters were parenthesized, it's the case of
24533 T foo(X(x)) which looks like a variable definition but
24534 is a function declaration. */
24538 /* Peek at the next token. */
24541 /* These are for Objective-C++ */
24544 /* The parameter-declaration-list is complete. */
24547 {
24550 /* Peek at the next token. */
24552 /* If it's an ellipsis, then the list is complete. */
24555 /* Otherwise, there must be more parameters. Consume the
24556 `,'. */
24558 /* When parsing something like:
24560 int i(float f, double d)
24562 we can tell after seeing the declaration for "f" that we
24563 are not looking at an initialization of a variable "i",
24564 but rather at the declaration of a function "i".
24566 Due to the fact that the parsing of template arguments
24567 (as specified to a template-id) requires backtracking we
24568 cannot use this technique when inside a template argument
24569 list. */
24573 /* However, a parameter-declaration of the form
24574 "float(f)" (which is a valid declaration of a
24575 parameter "f") can also be interpreted as an
24576 expression (the conversion of "f" to "float"). */
24579 }
24580 else
24581 {
24589 }
24590 }
24592 parser->in_unbraced_linkage_specification_p
24595 /* Reset implicit_template_scope if we are about to leave the function
24596 parameter list that introduced it. Note that for out-of-line member
24597 definitions, there will be one or more class scopes before we get to
24598 the template parameter scope. */
24602 {
24606 {
24609 }
24610 }
24613 }
24615 /* Parse a parameter declaration.
24617 parameter-declaration:
24618 decl-specifier-seq ... [opt] declarator
24619 decl-specifier-seq declarator = assignment-expression
24620 decl-specifier-seq ... [opt] abstract-declarator [opt]
24621 decl-specifier-seq abstract-declarator [opt] = assignment-expression
24623 The parser flags FLAGS is used to control type-specifier parsing.
24625 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
24626 declares a template parameter. (In that case, a non-nested `>'
24627 token encountered during the parsing of the assignment-expression
24628 is not interpreted as a greater-than operator.)
24630 Returns a representation of the parameter, or NULL if an error
24631 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
24632 true iff the declarator is of the form "(p)". */
24636 cp_parser_flags flags,
24639 {
24641 cp_decl_specifier_seq decl_specifiers;
24643 tree default_argument;
24648 /* In a template parameter, `>' is not an operator.
24650 [temp.param]
24652 When parsing a default template-argument for a non-type
24653 template-parameter, the first non-nested `>' is taken as the end
24654 of the template parameter-list rather than a greater-than
24655 operator. */
24657 /* Type definitions may not appear in parameter types. */
24659 parser->type_definition_forbidden_message
24666 /* Parse the declaration-specifiers. */
24669 flags,
24673 /* Complain about missing 'typename' or other invalid type names. */
24678 /* If an error occurred, there's no reason to attempt to parse the
24679 rest of the declaration. */
24681 {
24684 }
24686 /* Peek at the next token. */
24689 /* If the next token is a `)', `,', `=', `>', or `...', then there
24690 is no declarator. However, when variadic templates are enabled,
24691 there may be a declarator following `...'. */
24696 {
24700 }
24701 /* Otherwise, there should be a declarator. */
24702 else
24703 {
24707 /* After seeing a decl-specifier-seq, if the next token is not a
24708 "(" or "{", there is no possibility that the code is a valid
24709 expression. Therefore, if parsing tentatively, we commit at
24710 this point. */
24712 /* In an expression context, having seen:
24714 (int((char ...
24716 we cannot be sure whether we are looking at a
24717 function-type (taking a "char" as a parameter) or a cast
24718 of some object of type "char" to "int". */
24722 {
24724 {
24727 /* This is a CTAD expression, not a parameter declaration. */
24729 }
24730 else
24732 }
24733 /* Parse the declarator. */
24736 CP_PARSER_DECLARATOR_EITHER,
24737 CP_PARSER_FLAGS_NONE,
24739 parenthesized_p,
24744 /* After the declarator, allow more attributes. */
24745 decl_specifiers.attributes
24749 /* If the declarator is a template parameter pack, remember that and
24750 clear the flag in the declarator itself so we don't get errors
24751 from grokdeclarator. */
24753 {
24756 }
24757 }
24759 /* If the next token is an ellipsis, and we have not seen a declarator
24760 name, and if either the type of the declarator contains parameter
24761 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
24762 for, eg, abbreviated integral type names), then we actually have a
24763 parameter pack expansion expression. Otherwise, leave the ellipsis
24764 for a C-style variadic function. */
24767 /* If a function parameter pack was specified and an implicit template
24768 parameter was introduced during cp_parser_parameter_declaration,
24769 change any implicit parameters introduced into packs. */
24774 {
24782 }
24785 {
24796 {
24797 /* Consume the `...'. */
24801 /* Build a pack expansion type */
24806 else
24808 }
24809 }
24811 /* The restriction on defining new types applies only to the type
24812 of the parameter, not to the default argument. */
24815 /* If the next token is `=', then process a default argument. */
24817 {
24822 /* If we are defining a class, then the tokens that make up the
24823 default argument must be saved and processed later. */
24829 /* A constrained-type-specifier may declare a type
24830 template-parameter. */
24832 default_argument
24835 /* A constrained-type-specifier may declare a
24836 template-template-parameter. */
24838 default_argument
24841 /* Outside of a class definition, we can just parse the
24842 assignment-expression. */
24843 else
24844 default_argument
24848 {
24850 "default arguments are only "
24852 }
24854 || template_parameter_pack_p
24857 {
24858 /* Find the name of the parameter pack. */
24865 template_parm_p
24871 else
24873 template_parm_p
24880 }
24881 }
24882 else
24888 /* Generate a location for the parameter, ranging from the start of the
24889 initial token to the end of the final token (using input_location for
24890 the latter, set up by cp_lexer_set_source_position_from_token when
24891 consuming tokens).
24893 If we have a identifier, then use it for the caret location, e.g.
24895 extern int callee (int one, int (*two)(int, int), float three);
24896 ~~~~~~^~~~~~~~~~~~~~
24898 otherwise, reuse the start location for the caret location e.g.:
24900 extern int callee (int one, int (*)(int, int), float three);
24901 ^~~~~~~~~~~~~~~~~
24903 */
24909 input_location);
24912 declarator,
24913 default_argument,
24914 param_loc,
24915 template_parameter_pack_p);
24916 }
24918 /* Parse a default argument and return it.
24920 TEMPLATE_PARM_P is true if this is a default argument for a
24921 non-type template parameter. */
24922 static tree
24924 {
24930 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
24931 set correctly. */
24938 /* Local variable names (and the `this' keyword) may not
24939 appear in a default argument. */
24942 /* Parse the assignment-expression. */
24947 /* The "this" pointer is not valid in a default argument. */
24949 {
24954 }
24955 default_argument
24957 /* Restore the "this" pointer. */
24959 {
24962 }
24971 }
24973 /* Parse a function-body.
24975 function-body:
24976 compound_statement */
24978 static void
24980 {
24984 }
24986 /* Parse a ctor-initializer-opt followed by a function-body. Return
24987 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
24988 is true we are parsing a function-try-block. */
24990 static void
24993 {
24995 const bool check_body_p
25003 {
25006 "function-try-block body of %<constexpr%> constructor only "
25008 else
25010 "function-try-block body of %<constexpr%> function only "
25012 }
25014 /* Begin the function body. */
25016 /* Parse the optional ctor-initializer. */
25019 /* If we're parsing a constexpr constructor definition, we need
25020 to check that the constructor body is indeed empty. However,
25021 before we get to cp_parser_function_body lot of junk has been
25022 generated, so we can't just check that we have an empty block.
25023 Rather we take a snapshot of the outermost block, and check whether
25024 cp_parser_function_body changed its state. */
25026 {
25030 }
25031 /* Parse the function-body. */
25035 /* Finish the function body. */
25037 }
25039 /* Parse an initializer.
25041 initializer:
25042 = initializer-clause
25043 ( expression-list )
25045 Returns an expression representing the initializer. If no
25046 initializer is present, NULL_TREE is returned.
25048 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
25049 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
25050 set to TRUE if there is no initializer present. If there is an
25051 initializer, and it is not a constant-expression, *NON_CONSTANT_P
25052 is set to true; otherwise it is set to false. */
25054 static tree
25057 {
25059 tree init;
25061 /* Peek at the next token. */
25064 /* Let our caller know whether or not this initializer was
25065 parenthesized. */
25067 /* Assume that the initializer is constant. */
25071 {
25072 /* Consume the `='. */
25074 /* Parse the initializer-clause. */
25076 }
25078 {
25083 non_constant_p);
25088 }
25090 {
25095 }
25096 else
25097 {
25098 /* Anything else is an error. */
25101 }
25107 }
25109 /* Parse an initializer-clause.
25111 initializer-clause:
25112 assignment-expression
25113 braced-init-list
25115 Returns an expression representing the initializer.
25117 If the `assignment-expression' production is used the value
25118 returned is simply a representation for the expression.
25120 Otherwise, calls cp_parser_braced_list. */
25122 static cp_expr
25124 {
25125 cp_expr initializer;
25127 /* Assume the expression is constant. */
25130 /* If it is not a `{', then we are looking at an
25131 assignment-expression. */
25133 {
25134 initializer
25137 non_constant_p);
25138 }
25139 else
25143 }
25145 /* Parse a brace-enclosed initializer list.
25147 braced-init-list:
25148 { initializer-list , [opt] }
25149 { designated-initializer-list , [opt] }
25150 { }
25152 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
25153 the elements of the initializer-list (or NULL, if the last
25154 production is used). The TREE_TYPE for the CONSTRUCTOR will be
25155 NULL_TREE. There is no way to detect whether or not the optional
25156 trailing `,' was provided. NON_CONSTANT_P is as for
25157 cp_parser_initializer. */
25159 static cp_expr
25161 {
25162 tree initializer;
25165 /* Consume the `{' token. */
25166 matching_braces braces;
25168 /* Create a CONSTRUCTOR to represent the braced-initializer. */
25170 /* If it's not a `}', then there is a non-trivial initializer. */
25172 {
25174 /* Parse the initializer list. */
25178 /* A trailing `,' token is allowed. */
25181 }
25182 else
25184 /* Now, there should be a trailing `}'. */
25190 /* Build a location of the form:
25191 { ... }
25192 ^~~~~~~
25193 with caret==start at the open brace, finish at the close brace. */
25197 }
25199 /* Consume tokens up to, and including, the next non-nested closing `]'.
25200 Returns true iff we found a closing `]'. */
25202 static bool
25204 {
25208 {
25212 {
25216 /* FALLTHRU */
25218 /* If we've run out of tokens, then there is no closing `]'. */
25227 {
25230 }
25235 }
25237 /* Consume the token. */
25239 }
25240 }
25242 /* Return true if we are looking at an array-designator, false otherwise. */
25244 static bool
25246 {
25247 /* Consume the `['. */
25252 /* Skip tokens until the next token is a closing square bracket.
25253 If we find the closing `]', and the next token is a `=', then
25254 we are looking at an array designator. */
25255 bool array_designator_p
25259 /* Roll back the tokens we skipped. */
25263 }
25265 /* Parse an initializer-list.
25267 initializer-list:
25268 initializer-clause ... [opt]
25269 initializer-list , initializer-clause ... [opt]
25271 C++20 Extension:
25273 designated-initializer-list:
25274 designated-initializer-clause
25275 designated-initializer-list , designated-initializer-clause
25277 designated-initializer-clause:
25278 designator brace-or-equal-initializer
25280 designator:
25281 . identifier
25283 GNU Extension:
25285 initializer-list:
25286 designation initializer-clause ...[opt]
25287 initializer-list , designation initializer-clause ...[opt]
25289 designation:
25290 . identifier =
25291 identifier :
25292 [ constant-expression ] =
25294 Returns a vec of constructor_elt. The VALUE of each elt is an expression
25295 for the initializer. If the INDEX of the elt is non-NULL, it is the
25296 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
25297 as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
25298 are any designators. */
25303 {
25308 /* Assume all of the expressions are constant. */
25314 /* Parse the rest of the list. */
25316 {
25318 tree designator;
25319 tree initializer;
25323 /* Handle the C++20 syntax, '. id ='. */
25331 {
25334 "C++ designated initializers only available with "
25336 /* Consume the `.'. */
25338 /* Consume the identifier. */
25341 /* Consume the `='. */
25343 }
25344 /* Also, if the next token is an identifier and the following one is a
25345 colon, we are looking at the GNU designated-initializer
25346 syntax. */
25351 {
25352 /* Warn the user that they are using an extension. */
25355 /* Consume the identifier. */
25357 /* Consume the `:'. */
25359 }
25360 /* Also handle C99 array designators, '[ const ] ='. */
25364 {
25365 /* In C++11, [ could start a lambda-introducer. */
25371 {
25374 }
25375 else
25376 {
25381 }
25386 && (!require_potential_rvalue_constant_expression
25390 /* Warn the user that they are using an extension. */
25393 }
25394 else
25398 {
25401 }
25405 {
25409 }
25413 /* Parse the initializer. */
25416 /* If any clause is non-constant, so is the entire initializer. */
25420 /* If we have an ellipsis, this is an initializer pack
25421 expansion. */
25423 {
25426 /* Consume the `...'. */
25433 /* Turn the initializer into an initializer expansion. */
25435 }
25437 /* Add it to the vector. */
25440 /* If the next token is not a comma, we have reached the end of
25441 the list. */
25445 /* Peek at the next token. */
25447 /* If the next token is a `}', then we're still done. An
25448 initializer-clause can have a trailing `,' after the
25449 initializer-list and before the closing `}'. */
25453 /* Suppress location wrappers in a long initializer to save memory
25454 (14179). The cutoff is chosen arbitrarily. */
25458 /* Look one level down because it's easy. Looking deeper would require
25459 passing down a nelts pointer, and I don't think multi-level massive
25460 initializers are common enough to justify this. */
25466 /* Consume the `,' token. */
25468 }
25470 /* The same identifier shall not appear in multiple designators
25471 of a designated-initializer-list. */
25473 {
25478 {
25480 {
25482 "%<.%s%> designator used multiple times in "
25486 }
25487 else
25489 }
25493 }
25499 }
25501 /* Classes [gram.class] */
25503 /* Parse a class-name.
25505 class-name:
25506 identifier
25507 template-id
25509 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
25510 to indicate that names looked up in dependent types should be
25511 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
25512 keyword has been used to indicate that the name that appears next
25513 is a template. TAG_TYPE indicates the explicit tag given before
25514 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
25515 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
25516 is the class being defined in a class-head. If ENUM_OK is TRUE,
25517 enum-names are also accepted.
25519 Returns the TYPE_DECL representing the class. */
25521 static tree
25530 {
25531 tree decl;
25534 /* All class-names start with an identifier. */
25537 {
25540 }
25542 /* PARSER->SCOPE can be cleared when parsing the template-arguments
25543 to a template-id, so we save it here. Consider object scope too,
25544 so that make_typename_type below can use it (cp_parser_template_name
25545 considers object scope also). This may happen with code like
25547 p->template A<T>::a()
25549 where we first want to look up A<T>::a in the class of the object
25550 expression, as per [basic.lookup.classref]. */
25552 /* This only checks parser->scope to avoid duplicate errors; if
25553 ->object_type is erroneous, go on to give a parse error. */
25557 /* Any name names a type if we're following the `typename' keyword
25558 in a qualified name where the enclosing scope is type-dependent. */
25563 /* Handle the common case (an identifier, but not a template-id)
25564 efficiently. */
25567 {
25571 /* Look for the identifier. */
25575 /* If the next token isn't an identifier, we are certainly not
25576 looking at a class-name. */
25579 /* If we know this is a type-name, there's no need to look it
25580 up. */
25583 else
25584 {
25585 tree ambiguous_decls;
25586 /* If we already know that this lookup is ambiguous, then
25587 we've already issued an error message; there's no reason
25588 to check again. */
25590 {
25593 }
25594 /* If the next token is a `::', then the name must be a type
25595 name.
25597 [basic.lookup.qual]
25599 During the lookup for a name preceding the :: scope
25600 resolution operator, object, function, and enumerator
25601 names are ignored. */
25604 /* Look up the name. */
25606 tag_type,
25609 check_dependency_p,
25613 {
25617 }
25618 }
25619 }
25620 else
25621 {
25622 /* Try a template-id. */
25624 check_dependency_p,
25625 tag_type,
25626 is_declaration);
25629 }
25633 /* If this is a typename, create a TYPENAME_TYPE. */
25635 {
25640 }
25644 /* Check to see that it is really the name of a class. */
25648 /* Situations like this:
25650 template <typename T> struct A {
25651 typename T::template X<int>::I i;
25652 };
25654 are problematic. Is `T::template X<int>' a class-name? The
25655 standard does not seem to be definitive, but there is no other
25656 valid interpretation of the following `::'. Therefore, those
25657 names are considered class-names. */
25658 {
25662 }
25667 /* In Objective-C 2.0, a classname followed by '.' starts a
25668 dot-syntax expression, and it's not a type-name. */
25680 }
25682 /* Make sure that any member-function parameters are in scope.
25683 For instance, a function's noexcept-specifier can use the function's
25684 parameters:
25686 struct S {
25687 void fn (int p) noexcept(noexcept(p));
25688 };
25690 so we need to make sure name lookup can find them. This is used
25691 when we delay parsing of the noexcept-specifier. */
25693 static void
25695 {
25702 {
25706 }
25707 }
25709 /* Undo the effects of inject_parm_decls. */
25711 static void
25713 {
25716 }
25718 /* Parse a class-specifier.
25720 class-specifier:
25721 class-head { member-specification [opt] }
25723 Returns the TREE_TYPE representing the class. */
25725 static tree
25727 {
25728 tree type;
25742 /* Parse the class-head. */
25745 /* If the class-head was a semantic disaster, skip the entire body
25746 of the class. */
25748 {
25752 }
25754 /* Look for the `{'. */
25755 matching_braces braces;
25757 {
25760 }
25765 /* Issue an error message if type-definitions are forbidden here. */
25767 /* Remember that we are defining one more class. */
25769 /* Inside the class, surrounding template-parameter-lists do not
25770 apply. */
25771 saved_num_template_parameter_lists
25774 /* We are not in a function body. */
25777 /* Or in a loop. */
25780 /* Or in a switch. */
25783 /* We are not immediately inside an extern "lang" block. */
25784 saved_in_unbraced_linkage_specification_p
25788 /* Start the class. */
25790 {
25792 /* SCOPE must be a scope nested inside current scope. */
25796 else
25798 }
25802 /* If the type is erroneous, skip the entire body of the class. */
25804 else
25805 /* Parse the member-specification. */
25808 /* Look for the trailing `}'. */
25810 /* Look for trailing attributes to apply to this class. */
25818 /* We've finished a type definition. Check for the common syntax
25819 error of forgetting a semicolon after the definition. We need to
25820 be careful, as we can't just check for not-a-semicolon and be done
25821 with it; the user might have typed:
25823 class X { } c = ...;
25824 class X { } *p = ...;
25826 and so forth. Instead, enumerate all the possible tokens that
25827 might follow this production; if we don't see one of them, then
25828 complain and silently insert the semicolon. */
25829 {
25834 /* Don't try to parse c++11 attributes here. As per the
25835 grammar, that should be a task for
25836 cp_parser_decl_specifier_seq. */
25840 {
25851 /* While it's legal for type qualifiers and storage class
25852 specifiers to follow type definitions in the grammar, only
25853 compiler testsuites contain code like that. Assume that if
25854 we see such code, then what we're really seeing is a case
25855 like:
25857 class X { }
25858 const <type> var = ...;
25860 or
25862 class Y { }
25863 static <type> func (...) ...
25865 i.e. the qualifier or specifier applies to the next
25866 declaration. To do so, however, we need to look ahead one
25867 more token to see if *that* token is a type specifier.
25869 This code could be improved to handle:
25871 class Z { }
25872 static const <type> var = ...; */
25875 {
25878 /* Handling user-defined types here would be nice, but very
25879 tricky. */
25880 want_semicolon
25883 }
25887 }
25889 /* If we don't have a type, then something is very wrong and we
25890 shouldn't try to do anything clever. Likewise for not seeing the
25891 closing brace. */
25893 {
25894 /* Locate the closing brace. */
25895 cp_token_position prev
25900 /* We want to suggest insertion of a ';' immediately *after* the
25901 closing brace, so, if we can, offset the location by 1 column. */
25908 /* If we successfully offset the location, suggest the fix-it. */
25921 else
25924 /* Unget one token and smash it to look as though we encountered
25925 a semicolon in the input stream. */
25930 }
25931 }
25933 /* If this class is not itself within the scope of another class,
25934 then we need to parse the bodies of all of the queued function
25935 definitions. Note that the queued functions defined in a class
25936 are not always processed immediately following the
25937 class-specifier for that class. Consider:
25939 struct A {
25940 struct B { void f() { sizeof (A); } };
25941 };
25943 If `f' were processed before the processing of `A' were
25944 completed, there would be no way to compute the size of `A'.
25945 Note that the nesting we are interested in here is lexical --
25946 not the semantic nesting given by TYPE_CONTEXT. In particular,
25947 for:
25949 struct A { struct B; };
25950 struct A::B { void f() { } };
25952 there is no need to delay the parsing of `A::B::f'. */
25954 {
25955 tree decl;
25962 {
25963 /* Skip default arguments, NSDMIs, etc, in order to improve
25964 error recovery (c++/71169, c++/71832). */
25968 }
25970 /* In a first pass, parse default arguments to the functions.
25971 Then, in a second pass, parse the bodies of the functions.
25972 This two-phased approach handles cases like:
25974 struct S {
25975 void f() { g(); }
25976 void g(int i = 3);
25977 };
25979 */
25981 {
25983 /* If there are default arguments that have not yet been processed,
25984 take care of them now. */
25986 {
25991 }
25992 /* Make sure that any template parameters are in scope. */
25994 /* Parse the default argument expressions. */
25996 /* Remove any template parameters from the symbol table. */
25998 }
26001 /* If there are noexcept-specifiers that have not yet been processed,
26002 take care of them now. Do this before processing NSDMIs as they
26003 may depend on noexcept-specifiers already having been processed. */
26007 {
26010 {
26015 }
26020 /* Make sure that any template parameters are in scope. */
26023 /* Make sure that any member-function parameters are in scope.
26024 This function doesn't expect ccp to be set. */
26028 /* 'this' is not allowed in static member functions. */
26029 unsigned char local_variables_forbidden_p
26034 /* Now we can parse the noexcept-specifier. */
26040 /* Update the fn's type directly -- it might have escaped
26041 beyond this decl :( */
26043 /* Update any instantiations we've already created. We must
26044 keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
26045 so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
26046 in the pattern. */
26051 /* Restore the state of local_variables_forbidden_p. */
26054 /* The finish_struct call above performed various override checking,
26055 but it skipped unparsed noexcept-specifier operands. Now that we
26056 have resolved them, check again. */
26059 /* Remove any member-function parameters from the symbol table. */
26062 /* Remove any template parameters from the symbol table. */
26064 }
26067 /* Now parse any NSDMIs. */
26069 {
26071 {
26076 }
26079 }
26086 /* Now parse the body of the functions. */
26088 {
26089 /* OpenMP UDRs need to be parsed before all other functions. */
26096 }
26097 else
26101 }
26103 /* Put back any saved access checks. */
26106 /* Restore saved state. */
26110 parser->num_template_parameter_lists
26112 parser->in_unbraced_linkage_specification_p
26116 }
26118 static tree
26120 {
26121 tree ret;
26126 }
26128 /* Parse a class-head.
26130 class-head:
26131 class-key identifier [opt] base-clause [opt]
26132 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
26133 class-key nested-name-specifier [opt] template-id
26134 base-clause [opt]
26136 class-virt-specifier:
26137 final
26139 GNU Extensions:
26140 class-key attributes identifier [opt] base-clause [opt]
26141 class-key attributes nested-name-specifier identifier base-clause [opt]
26142 class-key attributes nested-name-specifier [opt] template-id
26143 base-clause [opt]
26145 Upon return BASES is initialized to the list of base classes (or
26146 NULL, if there are none) in the same form returned by
26147 cp_parser_base_clause.
26149 Returns the TYPE of the indicated class. Sets
26150 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
26151 involving a nested-name-specifier was used, and FALSE otherwise.
26153 Returns error_mark_node if this is not a class-head.
26155 Returns NULL_TREE if the class-head is syntactically valid, but
26156 semantically invalid in a way that means we should skip the entire
26157 body of the class. */
26159 static tree
26162 {
26163 tree nested_name_specifier;
26167 tree attributes;
26168 tree bases;
26178 /* Assume no nested-name-specifier will be present. */
26180 /* Assume no template parameter lists will be used in defining the
26181 type. */
26185 /* Look for the class-key. */
26192 /* Parse the attributes. */
26195 /* If the next token is `::', that is invalid -- but sometimes
26196 people do try to write:
26198 struct ::S {};
26200 Handle this gracefully by accepting the extra qualifier, and then
26201 issuing an error about it later if this really is a
26202 class-head. If it turns out just to be an elaborated type
26203 specifier, remain silent. */
26209 /* Determine the name of the class. Begin by looking for an
26210 optional nested-name-specifier. */
26212 nested_name_specifier
26218 /* If there was a nested-name-specifier, then there *must* be an
26219 identifier. */
26224 {
26226 /* Although the grammar says `identifier', it really means
26227 `class-name' or `template-name'. You are only allowed to
26228 define a class that has already been declared with this
26229 syntax.
26231 The proposed resolution for Core Issue 180 says that wherever
26232 you see `class T::X' you should treat `X' as a type-name.
26234 It is OK to define an inaccessible class; for example:
26236 class A { class B; };
26237 class A::B {};
26239 We do not know if we will see a class-name, or a
26240 template-name. We look for a class-name first, in case the
26241 class-name is a template-id; if we looked for the
26242 template-name first we would stop after the template-name. */
26249 class_type,
26253 /* If that didn't work, ignore the nested-name-specifier. */
26255 {
26261 }
26262 /* If we could not find a corresponding TYPE, treat this
26263 declaration like an unqualified declaration. */
26266 /* Otherwise, count the number of templates used in TYPE and its
26267 containing scopes. */
26268 else
26270 }
26271 /* Otherwise, the identifier is optional. */
26272 else
26273 {
26274 /* We don't know whether what comes next is a template-id,
26275 an identifier, or nothing at all. */
26277 /* Check for a template-id. */
26282 class_key,
26284 /* If that didn't work, it could still be an identifier. */
26286 {
26288 {
26291 }
26292 else
26294 }
26295 else
26296 {
26299 }
26300 }
26305 {
26307 class_key,
26309 }
26312 /* If it's not a `:' or a `{' then we can't really be looking at a
26313 class-head, since a class-head only appears as part of a
26314 class-specifier. We have to detect this situation before calling
26315 xref_tag, since that has irreversible side-effects. */
26317 {
26321 }
26323 /* At this point, we're going ahead with the class-specifier, even
26324 if some other problem occurs. */
26327 {
26332 }
26333 /* Issue the error about the overly-qualified name now. */
26335 {
26340 }
26342 {
26347 }
26349 {
26350 tree scope;
26353 /* [temp.names]: in a qualified-id formed by a class-head-name, the
26354 keyword template shall not appear at the top level. */
26358 /* Reject typedef-names in class heads. */
26360 {
26363 type);
26366 }
26368 /* Figure out in what scope the declaration is being placed. */
26370 /* If that scope does not contain the scope in which the
26371 class was originally declared, the program is invalid. */
26373 {
26376 "declaration of %qD in namespace %qD which does not "
26379 else
26385 }
26386 /* [dcl.meaning]
26388 A declarator-id shall not be qualified except for the
26389 definition of a ... nested class outside of its class
26390 ... [or] the definition or explicit instantiation of a
26391 class member of a namespace outside of its namespace. */
26395 }
26396 /* An explicit-specialization must be preceded by "template <>". If
26397 it is not, try to recover gracefully. */
26400 && !processing_template_parmlist
26402 {
26403 /* Build a location of this form:
26404 struct typename <ARGS>
26405 ^~~~~~~~~~~~~~~~~~~~~~
26406 with caret==start at the start token, and
26407 finishing at the end of the type. */
26408 location_t reported_loc
26410 class_head_start_location,
26416 "an explicit specialization must be preceded by"
26419 /* Take the same action that would have been taken by
26420 cp_parser_explicit_specialization. */
26423 }
26424 /* There must be no "return" statements between this point and the
26425 end of this function; set "type "to the correct return value and
26426 use "goto done;" to return. */
26427 /* Make sure that the right number of template parameters were
26428 present. */
26430 template_id_p,
26433 {
26434 /* If something went wrong, there is no point in even trying to
26435 process the class-definition. */
26438 }
26440 /* Look up the type. */
26442 {
26446 {
26450 }
26451 else
26452 {
26456 /* Check the scope while we still know whether or not we had a
26457 nested-name-specifier. */
26460 }
26463 }
26465 {
26466 tree class_type;
26468 /* Given:
26470 template <typename T> struct S { struct T };
26471 template <typename T> struct S<T>::T { };
26473 we will get a TYPENAME_TYPE when processing the definition of
26474 `S::T'. We need to resolve it to the actual type before we
26475 try to define it. */
26477 {
26482 else
26483 {
26486 }
26487 }
26491 {
26494 }
26497 /* Enter the scope indicated by the nested-name-specifier. */
26499 /* Get the canonical version of this type. */
26501 /* Call push_template_decl if it seems like we should be defining a
26502 template either from the template headers or the type we're
26503 defining, so that we diagnose both extra and missing headers. */
26507 {
26510 {
26513 }
26514 }
26518 }
26520 {
26521 /* If the class was unnamed, create a dummy name. */
26529 }
26531 /* Diagnose class/struct/union mismatches. */
26535 /* Indicate whether this class was declared as a `class' or as a
26536 `struct'. */
26540 /* If this type was already complete, and we see another definition,
26541 that's an error. Likewise if the type is already being defined:
26542 this can happen, eg, when it's defined from within an expression
26543 (c++/84605). */
26546 {
26548 type);
26550 type);
26553 }
26558 {
26559 /* Apply attributes now, before any use of the class as a template
26560 argument in its base list. */
26563 }
26565 /* Associate constraints with the type. */
26569 /* We will have entered the scope containing the class; the names of
26570 base classes should be looked up in that context. For example:
26572 struct A { struct B {}; struct C; };
26573 struct A::C : B {};
26575 is valid. */
26577 /* Get the list of base-classes, if there is one. Defer access checking
26578 until the entire list has been seen, as per [class.access.general]. */
26581 {
26587 }
26588 else
26591 /* If we're really defining a class, process the base classes.
26592 If they're invalid, fail. */
26596 /* Now that all bases have been seen and attached to the class, check
26597 accessibility of the types named in the base-clause. This must be
26598 done relative to the class scope, so that we accept e.g.
26600 struct A { protected: struct B {}; };
26601 struct C : A::B, A {}; // OK: A::B is accessible via base A
26603 as per [class.access.general]. */
26610 done:
26611 /* Leave the scope given by the nested-name-specifier. We will
26612 enter the class scope itself while processing the members. */
26617 {
26620 }
26626 out:
26629 }
26631 /* Parse a class-key.
26633 class-key:
26634 class
26635 struct
26636 union
26638 Returns the kind of class-key specified, or none_type to indicate
26639 error. */
26641 static enum tag_types
26643 {
26647 /* Look for the class-key. */
26652 /* Check to see if the TOKEN is a class-key. */
26657 }
26659 /* Parse a type-parameter-key.
26661 type-parameter-key:
26662 class
26663 typename
26664 */
26666 static void
26668 {
26669 /* Look for the type-parameter-key. */
26673 {
26677 /* typename is not allowed in a template template parameter
26678 by the standard until C++17. */
26680 "ISO C++ forbids typename key in template template parameter;"
26682 }
26683 else
26687 }
26689 /* Parse an (optional) member-specification.
26691 member-specification:
26692 member-declaration member-specification [opt]
26693 access-specifier : member-specification [opt] */
26695 static void
26697 {
26699 {
26703 /* Peek at the next token. */
26705 /* If it's a `}', or EOF then we've seen all the members. */
26711 /* See if this token is a keyword. */
26714 {
26718 /* Consume the access-specifier. */
26720 /* Remember which access-specifier is active. */
26722 /* Look for the `:'. */
26727 /* Accept #pragmas at class scope. */
26729 {
26732 }
26734 /* Otherwise, the next construction must be a
26735 member-declaration. */
26737 }
26738 }
26739 }
26741 /* Parse a member-declaration.
26743 member-declaration:
26744 decl-specifier-seq [opt] member-declarator-list [opt] ;
26745 function-definition ; [opt]
26746 :: [opt] nested-name-specifier template [opt] unqualified-id ;
26747 using-declaration
26748 template-declaration
26749 alias-declaration
26751 member-declarator-list:
26752 member-declarator
26753 member-declarator-list , member-declarator
26755 member-declarator:
26756 declarator pure-specifier [opt]
26757 declarator constant-initializer [opt]
26758 identifier [opt] : constant-expression
26760 GNU Extensions:
26762 member-declaration:
26763 __extension__ member-declaration
26765 member-declarator:
26766 declarator attributes [opt] pure-specifier [opt]
26767 declarator attributes [opt] constant-initializer [opt]
26768 identifier [opt] attributes [opt] : constant-expression
26770 C++0x Extensions:
26772 member-declaration:
26773 static_assert-declaration */
26775 static void
26777 {
26778 cp_decl_specifier_seq decl_specifiers;
26779 tree prefix_attributes;
26780 tree decl;
26789 /* Check for the `__extension__' keyword. */
26791 {
26792 /* Recurse. */
26794 /* Restore the old value of the PEDANTIC flag. */
26798 }
26800 /* Check for a template-declaration. */
26802 {
26803 /* An explicit specialization here is an error condition, and we
26804 expect the specialization handler to detect and report this. */
26808 else
26812 }
26813 /* Check for a template introduction. */
26817 /* Check for a using-declaration. */
26819 {
26821 /* Parse the using-declaration. */
26825 else
26826 {
26827 tree decl;
26831 /* Note that if we actually see the '=' token after the
26832 identifier, cp_parser_alias_declaration commits the
26833 tentative parse. In that case, we really expect an
26834 alias-declaration. Otherwise, we expect a using
26835 declaration. */
26836 alias_decl_expected =
26842 else
26845 }
26847 }
26849 /* Check for @defs. */
26851 {
26856 {
26861 }
26863 }
26865 /* If the next token is `static_assert' we have a static assertion. */
26867 {
26870 }
26874 cp_omp_declare_simd_data odsd;
26878 /* Parse the decl-specifier-seq. */
26881 (CP_PARSER_FLAGS_OPTIONAL
26891 /* Check for an invalid type-name. */
26895 /* If there is no declarator, then the decl-specifier-seq should
26896 specify a type. */
26898 {
26899 /* If there was no decl-specifier-seq, and the next token is a
26900 `;', then we have something like:
26902 struct S { ; };
26904 [class.mem]
26906 Each member-declaration shall declare at least one member
26907 name of the class. */
26909 {
26912 {
26916 }
26917 }
26918 else
26919 {
26920 /* See if this declaration is a friend. */
26922 /* If there were decl-specifiers, check to see if there was
26923 a class-declaration. */
26926 /* Nested classes have already been added to the class, but
26927 a `friend' needs to be explicitly registered. */
26929 {
26930 /* If the `friend' keyword was present, the friend must
26931 be introduced with a class-key. */
26934 "in C++03 a class-key must be used "
26936 /* In this case:
26938 template <typename T> struct A {
26939 friend struct A<T>::B;
26940 };
26942 A<T>::B will be represented by a TYPENAME_TYPE, and
26943 therefore not recognized by check_tag_decl. */
26945 {
26949 }
26950 /* Warn if an attribute cannot appear here, as per
26951 [dcl.attr.grammar]/5. But not when declares_class_or_enum:
26952 we ignore attributes in elaborated-type-specifiers. */
26955 {
26960 "that appertains to a friend declaration that "
26962 }
26965 "friend declaration does not name a class or "
26967 else
26970 }
26971 /* If there is no TYPE, an error message will already have
26972 been issued. */
26974 ;
26975 /* An anonymous aggregate has to be handled specially; such
26976 a declaration really declares a data member (with a
26977 particular type), as opposed to a nested class. */
26979 {
26980 /* C++11 9.5/6. */
26983 "a storage class on an anonymous aggregate "
26986 /* Remove constructors and such from TYPE, now that we
26987 know it is an anonymous aggregate. */
26989 /* And make the corresponding data member. */
26992 /* Add it to the class. */
26994 }
26995 else
26996 cp_parser_check_access_in_redeclaration
26999 }
27000 }
27001 else
27002 {
27005 /* Clear attributes from the decl_specifiers but keep them
27006 around as prefix attributes that apply them to the entity
27007 being declared. */
27015 /* See if these declarations will be friends. */
27018 /* Keep going until we hit the `;' at the end of the
27019 declaration. */
27021 {
27023 tree first_attribute;
27024 tree initializer;
27027 /* Peek at the next token. */
27030 /* The following code wants to know early if it is a bit-field
27031 or some other declaration. Attributes can appear before
27032 the `:' token. Skip over them without consuming any tokens
27033 to peek if they are followed by `:'. */
27038 {
27039 size_t n
27042 }
27044 /* Check for a bitfield declaration. */
27050 {
27051 tree identifier;
27052 tree width;
27054 location_t id_location
27059 else
27062 /* Look for attributes that apply to the bitfield. */
27065 /* Consume the `:' token. */
27068 /* Get the width of the bitfield. */
27072 /* In C++20 and as extension for C++11 and above we allow
27073 default member initializers for bit-fields. */
27078 CPP_OPEN_BRACE)))
27079 {
27080 location_t loc
27085 "default member initializers for bit-fields "
27086 "only available with %<-std=c++20%> or "
27091 {
27095 }
27096 }
27097 else
27098 {
27099 /* Look for attributes that apply to the bitfield after
27100 the `:' token and width. This is where GCC used to
27101 parse attributes in the past, pedwarn if there is
27102 a std attribute. */
27105 "ISO C++ allows bit-field attributes only "
27109 }
27113 /* Remember which attributes are prefix attributes and
27114 which are not. */
27116 /* Combine the attributes. */
27119 /* Create the bitfield declaration. */
27122 identifier,
27123 sfk_none,
27124 id_location)
27128 attributes);
27129 }
27130 else
27131 {
27133 tree asm_specification;
27137 /* We can't delay parsing for friends,
27138 alias-declarations, and typedefs, even though the
27139 standard seems to require it. */
27144 /* Parse the declarator. */
27145 declarator
27147 flags,
27153 /* If something went wrong parsing the declarator, make sure
27154 that we at least consume some tokens. */
27156 {
27157 /* Skip to the end of the statement. */
27159 /* If the next token is not a semicolon, that is
27160 probably because we just skipped over the body of
27161 a function. So, we consume a semicolon if
27162 present, but do not issue an error message if it
27163 is not present. */
27165 CPP_SEMICOLON))
27168 }
27170 /* Handle class-scope non-template C++17 deduction guides. */
27173 declarator,
27177 cp_parser_check_for_definition_in_return_type
27181 /* Look for an asm-specification. */
27183 /* Look for attributes that apply to the declaration. */
27185 /* Remember which attributes are prefix attributes and
27186 which are not. */
27188 /* Combine the attributes. */
27191 /* If it's an `=', then we have a constant-initializer or a
27192 pure-specifier. It is not correct to parse the
27193 initializer before registering the member declaration
27194 since the member declaration should be in scope while
27195 its initializer is processed. However, the rest of the
27196 front end does not yet provide an interface that allows
27197 us to handle this correctly. */
27199 {
27200 /* In [class.mem]:
27202 A pure-specifier shall be used only in the declaration of
27203 a virtual function.
27205 A member-declarator can contain a constant-initializer
27206 only if it declares a static member of integral or
27207 enumeration type.
27209 Therefore, if the DECLARATOR is for a function, we look
27210 for a pure-specifier; otherwise, we look for a
27211 constant-initializer. When we call `grokfield', it will
27212 perform more stringent semantics checks. */
27225 {
27227 /* Don't require a constant rvalue in C++11, since we
27228 might want a reference constant. We'll enforce
27229 constancy later. */
27231 /* Parse the initializer. */
27234 }
27235 else
27236 /* Parse the initializer. */
27238 }
27241 {
27243 declarator->init_loc
27247 else
27249 }
27250 /* Detect invalid bit-field cases such as
27252 int *p : 4;
27253 int &&r : 3;
27255 and similar. */
27257 /* If there were no type specifiers, it was a
27258 constructor. */
27260 {
27261 /* This is called for a decent diagnostic only. */
27270 /* Avoid "extra ;" pedwarns. */
27272 CPP_SEMICOLON))
27275 }
27276 /* Otherwise, there is no initializer. */
27277 else
27280 /* See if we are probably looking at a function
27281 definition. We are certainly not looking at a
27282 member-declarator. Calling `grokfield' has
27283 side-effects, so we must not do it unless we are sure
27284 that we are looking at a member-declarator. */
27287 {
27288 /* The grammar does not allow a pure-specifier to be
27289 used when a member function is defined. (It is
27290 possible that this fact is an oversight in the
27291 standard, since a pure function may be defined
27292 outside of the class-specifier. */
27298 declarator,
27299 attributes);
27302 /* If the member was not a friend, declare it here. */
27305 /* Peek at the next token. */
27307 /* If the next token is a semicolon, consume it. */
27309 {
27310 location_t semicolon_loc
27315 "extra %<;%> after in-class "
27317 }
27319 }
27320 else
27323 /* Create the declaration. */
27328 {
27331 else
27333 }
27334 }
27339 /* Reset PREFIX_ATTRIBUTES. */
27341 {
27346 }
27348 /* If there is any qualification still in effect, clear it
27349 now; we will be starting fresh with the next declarator. */
27353 /* If it's a `,', then there are more declarators. */
27355 {
27358 {
27364 }
27365 }
27366 /* If the next token isn't a `;', then we have a parse error. */
27368 CPP_SEMICOLON))
27369 {
27370 /* The next token might be a ways away from where the
27371 actual semicolon is missing. Find the previous token
27372 and use that for our error position. */
27379 /* Assume that the user meant to provide a semicolon. If
27380 we were to cp_parser_skip_to_end_of_statement, we might
27381 skip to a semicolon inside a member function definition
27382 and issue nonsensical error messages. */
27384 }
27387 {
27388 /* Add DECL to the list of members. */
27390 /* Explicitly include, eg, NSDMIs, for better error
27391 recovery (c++/58650). */
27399 /* Add DECL to the queue of NSDMI to be parsed later. */
27401 }
27405 }
27406 }
27409 out:
27412 }
27414 /* Parse a pure-specifier.
27416 pure-specifier:
27417 = 0
27419 Returns INTEGER_ZERO_NODE if a pure specifier is found.
27420 Otherwise, ERROR_MARK_NODE is returned. */
27422 static tree
27424 {
27427 /* Look for the `=' token. */
27430 /* Look for the `0' token. */
27439 /* Accept = default or = delete in c++0x mode. */
27442 {
27445 }
27447 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
27449 {
27454 }
27456 {
27459 }
27462 }
27464 /* Parse a constant-initializer.
27466 constant-initializer:
27467 = constant-expression
27469 Returns a representation of the constant-expression. */
27471 static tree
27473 {
27474 /* Look for the `=' token. */
27478 /* It is invalid to write:
27480 struct S { static const int i = { 7 }; };
27482 */
27484 {
27487 /* Consume the opening brace. */
27488 matching_braces braces;
27490 /* Skip the initializer. */
27492 /* Look for the trailing `}'. */
27496 }
27499 }
27501 /* Derived classes [gram.class.derived] */
27503 /* Parse a base-clause.
27505 base-clause:
27506 : base-specifier-list
27508 base-specifier-list:
27509 base-specifier ... [opt]
27510 base-specifier-list , base-specifier ... [opt]
27512 Returns a TREE_LIST representing the base-classes, in the order in
27513 which they were declared. The representation of each node is as
27514 described by cp_parser_base_specifier.
27516 In the case that no bases are specified, this function will return
27517 NULL_TREE, not ERROR_MARK_NODE. */
27519 static tree
27521 {
27524 /* Look for the `:' that begins the list. */
27527 /* Scan the base-specifier-list. */
27529 {
27531 tree base;
27534 /* Look for the base-specifier. */
27536 /* Look for the (optional) ellipsis. */
27538 {
27539 /* Consume the `...'. */
27543 }
27545 /* Add BASE to the front of the list. */
27547 {
27549 /* Make this a pack expansion type. */
27553 {
27556 }
27557 }
27558 /* Peek at the next token. */
27560 /* If it's not a comma, then the list is complete. */
27563 /* Consume the `,'. */
27565 }
27567 /* PARSER->SCOPE may still be non-NULL at this point, if the last
27568 base class had a qualified name. However, the next name that
27569 appears is certainly not qualified. */
27575 }
27577 /* Parse a base-specifier.
27579 base-specifier:
27580 :: [opt] nested-name-specifier [opt] class-name
27581 virtual access-specifier [opt] :: [opt] nested-name-specifier
27582 [opt] class-name
27583 access-specifier virtual [opt] :: [opt] nested-name-specifier
27584 [opt] class-name
27586 Returns a TREE_LIST. The TREE_PURPOSE will be one of
27587 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
27588 indicate the specifiers provided. The TREE_VALUE will be a TYPE
27589 (or the ERROR_MARK_NODE) indicating the type that was specified. */
27591 static tree
27593 {
27601 tree type;
27603 /* Process the optional `virtual' and `access-specifier'. */
27605 {
27606 /* Peek at the next token. */
27608 /* Process `virtual'. */
27610 {
27612 /* If `virtual' appears more than once, issue an error. */
27614 {
27618 }
27622 /* Consume the `virtual' token. */
27630 /* If more than one access specifier appears, issue an
27631 error. */
27634 {
27638 }
27642 /* Consume the access-specifier. */
27650 }
27651 }
27652 /* It is not uncommon to see programs mechanically, erroneously, use
27653 the 'typename' keyword to denote (dependent) qualified types
27654 as base classes. */
27656 {
27661 else
27663 "keyword %<typename%> not allowed in this context "
27666 }
27668 /* Look for the optional `::' operator. */
27670 /* Look for the nested-name-specifier. The simplest way to
27671 implement:
27673 [temp.res]
27675 The keyword `typename' is not permitted in a base-specifier or
27676 mem-initializer; in these contexts a qualified name that
27677 depends on a template-parameter is implicitly assumed to be a
27678 type name.
27680 is to pretend that we have seen the `typename' keyword at this
27681 point. */
27687 /* If the base class is given by a qualified name, assume that names
27688 we see are type names or templates, as appropriate. */
27694 /* DR 950 allows decltype as a base-specifier. */
27696 else
27697 {
27698 /* Otherwise, look for the class-name. */
27700 class_scope_p,
27701 template_p,
27702 typename_type,
27707 }
27713 }
27715 /* Exception handling [gram.exception] */
27717 /* Save the tokens that make up the noexcept-specifier for a member-function.
27718 Returns a DEFERRED_PARSE. */
27720 static tree
27722 {
27724 /* We want everything up to, including, the final ')'. */
27728 /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
27729 to carry the information we will need. */
27731 /* Save away the noexcept-specifier; we will process it when the
27732 class is complete. */
27737 }
27739 /* Used for late processing of noexcept-specifiers of member-functions.
27740 DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
27741 we saved for later; parse it now. DECL is the declaration of the
27742 member function. */
27744 static tree
27746 {
27747 /* Make sure we've gotten something that hasn't been parsed yet. */
27752 /* Push the saved tokens for the noexcept-specifier onto the parser's
27753 lexer stack. */
27757 /* Parse the cached noexcept-specifier. */
27758 tree parsed_arg
27760 CP_PARSER_FLAGS_NONE,
27765 /* Revert to the main lexer. */
27768 /* Restore the queue. */
27771 /* And we're done. */
27773 }
27775 /* Perform late checking of overriding function with respect to their
27776 noexcept-specifiers. TYPE is the class and FNDECL is the function
27777 that potentially overrides some virtual function with the same
27778 signature. */
27780 static void
27782 {
27784 tree base_binfo;
27790 {
27799 }
27800 }
27802 /* Parse an (optional) noexcept-specification.
27804 noexcept-specification:
27805 noexcept ( constant-expression ) [opt]
27807 If no noexcept-specification is present, returns NULL_TREE.
27808 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
27809 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
27810 there are no parentheses. CONSUMED_EXPR will be set accordingly.
27811 Otherwise, returns a noexcept specification unless RETURN_COND is true,
27812 in which case a boolean condition is returned instead. The parser flags
27813 FLAGS is used to control parsing. QUALS are qualifiers indicating whether
27814 the (member) function is `const'. */
27816 static tree
27818 cp_parser_flags flags,
27822 {
27826 /* Peek at the next token. */
27829 /* Is it a noexcept-specification? */
27831 {
27832 tree expr;
27834 /* [class.mem]/6 says that a noexcept-specifer (within the
27835 member-specification of the class) is a complete-class context of
27836 a class. So, if the noexcept-specifier has the optional expression,
27837 just save the tokens, and reparse this after we're done with the
27838 class. */
27842 /* No need to delay parsing for a number literal or true/false. */
27854 {
27855 matching_parens parens;
27859 {
27860 /* Types may not be defined in an exception-specification. */
27862 parser->type_definition_forbidden_message
27866 expr
27872 {
27875 }
27877 /* Restore the saved message. */
27879 }
27880 else
27881 {
27884 }
27887 }
27888 else
27889 {
27893 }
27895 /* We cannot build a noexcept-spec right away because this will check
27896 that expr is a constexpr. */
27899 else
27901 }
27902 else
27904 }
27906 /* Parse an (optional) exception-specification.
27908 exception-specification:
27909 throw ( type-id-list [opt] )
27911 Returns a TREE_LIST representing the exception-specification. The
27912 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
27913 control parsing. QUALS are qualifiers indicating whether the (member)
27914 function is `const'. */
27916 static tree
27918 cp_parser_flags flags)
27919 {
27921 tree type_id_list;
27924 /* Peek at the next token. */
27927 /* Is it a noexcept-specification? */
27928 type_id_list
27936 /* If it's not `throw', then there's no exception-specification. */
27942 /* Consume the `throw'. */
27945 /* Look for the `('. */
27946 matching_parens parens;
27949 /* Peek at the next token. */
27951 /* If it's not a `)', then there is a type-id-list. */
27953 {
27954 /* Types may not be defined in an exception-specification. */
27956 parser->type_definition_forbidden_message
27958 /* Parse the type-id-list. */
27960 /* Restore the saved message. */
27964 {
27968 }
27971 "dynamic exception specifications are deprecated in "
27973 }
27974 /* In C++17, throw() is equivalent to noexcept (true). throw()
27975 is deprecated in C++11 and above as well, but is still widely used,
27976 so don't warn about it yet. */
27979 else
27982 /* Look for the `)'. */
27986 }
27988 /* Parse an (optional) type-id-list.
27990 type-id-list:
27991 type-id ... [opt]
27992 type-id-list , type-id ... [opt]
27994 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
27995 in the order that the types were presented. */
27997 static tree
27999 {
28003 {
28005 tree type;
28009 /* Get the next type-id. */
28011 /* Check for invalid 'auto'. */
28013 {
28017 }
28018 /* Parse the optional ellipsis. */
28020 {
28021 /* Consume the `...'. */
28024 /* Turn the type into a pack expansion expression. */
28026 }
28027 /* Add it to the list. */
28029 /* Peek at the next token. */
28031 /* If it is not a `,', we are done. */
28034 /* Consume the `,'. */
28036 }
28039 }
28041 /* Parse a try-block.
28043 try-block:
28044 try compound-statement handler-seq */
28046 static tree
28048 {
28049 tree try_block;
28056 "%<try%> in %<constexpr%> function only "
28066 }
28068 /* Parse a function-try-block.
28070 function-try-block:
28071 try ctor-initializer [opt] function-body handler-seq */
28073 static void
28075 {
28076 tree compound_stmt;
28077 tree try_block;
28079 /* Look for the `try' keyword. */
28082 /* Let the rest of the front end know where we are. */
28084 /* Parse the function-body. */
28085 cp_parser_ctor_initializer_opt_and_function_body
28087 /* We're done with the `try' part. */
28089 /* Parse the handlers. */
28091 /* We're done with the handlers. */
28093 }
28095 /* Parse a handler-seq.
28097 handler-seq:
28098 handler handler-seq [opt] */
28100 static void
28102 {
28104 {
28107 /* Parse the handler. */
28109 /* Peek at the next token. */
28111 /* If it's not `catch' then there are no more handlers. */
28114 }
28115 }
28117 /* Parse a handler.
28119 handler:
28120 catch ( exception-declaration ) compound-statement */
28122 static void
28124 {
28125 tree handler;
28126 tree declaration;
28130 matching_parens parens;
28137 }
28139 /* Parse an exception-declaration.
28141 exception-declaration:
28142 type-specifier-seq declarator
28143 type-specifier-seq abstract-declarator
28144 type-specifier-seq
28145 ...
28147 Returns a VAR_DECL for the declaration, or NULL_TREE if the
28148 ellipsis variant is used. */
28150 static tree
28152 {
28153 cp_decl_specifier_seq type_specifiers;
28157 /* If it's an ellipsis, it's easy to handle. */
28159 {
28160 /* Consume the `...' token. */
28163 }
28165 /* Types may not be defined in exception-declarations. */
28167 parser->type_definition_forbidden_message
28170 /* Parse the type-specifier-seq. */
28175 /* If it's a `)', then there is no declarator. */
28178 else
28180 CP_PARSER_FLAGS_NONE,
28187 /* Restore the saved message. */
28194 }
28196 /* Parse a throw-expression.
28198 throw-expression:
28199 throw assignment-expression [opt]
28201 Returns a THROW_EXPR representing the throw-expression. */
28203 static tree
28205 {
28206 tree expression;
28212 /* Figure out whether or not there is an assignment-expression
28213 following the "throw" keyword. */
28221 else
28224 /* Construct a location e.g.:
28225 throw x
28226 ^~~~~~~
28227 with caret == start at the start of the "throw" token, and
28228 the end at the end of the final token we consumed. */
28234 }
28236 /* Parse a yield-expression.
28238 yield-expression:
28239 co_yield assignment-expression
28240 co_yield braced-init-list
28242 Returns a CO_YIELD_EXPR representing the yield-expression. */
28244 static tree
28246 {
28247 tree expr;
28255 {
28258 /* ??? : probably a moot point? */
28261 }
28262 else
28269 }
28271 /* GNU Extensions */
28273 /* Parse an (optional) asm-specification.
28275 asm-specification:
28276 asm ( string-literal )
28278 If the asm-specification is present, returns a STRING_CST
28279 corresponding to the string-literal. Otherwise, returns
28280 NULL_TREE. */
28282 static tree
28284 {
28286 tree asm_specification;
28288 /* Peek at the next token. */
28290 /* If the next token isn't the `asm' keyword, then there's no
28291 asm-specification. */
28295 /* Consume the `asm' token. */
28297 /* Look for the `('. */
28298 matching_parens parens;
28301 /* Look for the string-literal. */
28304 /* Look for the `)'. */
28308 }
28310 /* Parse an asm-operand-list.
28312 asm-operand-list:
28313 asm-operand
28314 asm-operand-list , asm-operand
28316 asm-operand:
28317 string-literal ( expression )
28318 [ string-literal ] string-literal ( expression )
28320 Returns a TREE_LIST representing the operands. The TREE_VALUE of
28321 each node is the expression. The TREE_PURPOSE is itself a
28322 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
28323 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
28324 is a STRING_CST for the string literal before the parenthesis. Returns
28325 ERROR_MARK_NODE if any of the operands are invalid. */
28327 static tree
28329 {
28334 {
28335 tree string_literal;
28336 tree expression;
28337 tree name;
28340 {
28341 /* Consume the `[' token. */
28343 /* Read the operand name. */
28348 /* Look for the closing `]'. */
28350 }
28351 else
28353 /* Look for the string-literal. */
28356 /* Look for the `('. */
28357 matching_parens parens;
28359 /* Parse the expression. */
28361 /* Look for the `)'. */
28369 /* Add this operand to the list. */
28371 expression,
28372 asm_operands);
28373 /* If the next token is not a `,', there are no more
28374 operands. */
28377 /* Consume the `,'. */
28379 }
28382 }
28384 /* Parse an asm-clobber-list.
28386 asm-clobber-list:
28387 string-literal
28388 asm-clobber-list , string-literal
28390 Returns a TREE_LIST, indicating the clobbers in the order that they
28391 appeared. The TREE_VALUE of each node is a STRING_CST. */
28393 static tree
28395 {
28399 {
28400 tree string_literal;
28402 /* Look for the string literal. */
28404 /* Add it to the list. */
28406 /* If the next token is not a `,', then the list is
28407 complete. */
28410 /* Consume the `,' token. */
28412 }
28415 }
28417 /* Parse an asm-label-list.
28419 asm-label-list:
28420 identifier
28421 asm-label-list , identifier
28423 Returns a TREE_LIST, indicating the labels in the order that they
28424 appeared. The TREE_VALUE of each node is a label. */
28426 static tree
28428 {
28432 {
28435 /* Look for the identifier. */
28438 {
28441 {
28447 }
28448 }
28449 /* If the next token is not a `,', then the list is
28450 complete. */
28453 /* Consume the `,' token. */
28455 }
28458 }
28460 /* Return TRUE iff the next tokens in the stream are possibly the
28461 beginning of a GNU extension attribute. */
28463 static bool
28465 {
28467 }
28469 /* Return TRUE iff the next tokens in the stream are possibly the
28470 beginning of a standard C++-11 attribute specifier. */
28472 static bool
28474 {
28476 }
28478 /* Return TRUE iff the next Nth tokens in the stream are possibly the
28479 beginning of a standard C++-11 attribute specifier. */
28481 static bool
28483 {
28491 }
28493 /* Return TRUE iff the next Nth tokens in the stream are possibly the
28494 beginning of a GNU extension attribute. */
28496 static bool
28498 {
28502 }
28504 /* Return true iff the next tokens can be the beginning of either a
28505 GNU attribute list, or a standard C++11 attribute sequence. */
28507 static bool
28509 {
28512 }
28514 /* Return true iff the next Nth tokens can be the beginning of either
28515 a GNU attribute list, or a standard C++11 attribute sequence. */
28517 static bool
28519 {
28522 }
28524 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
28525 of GNU attributes, or return NULL. */
28527 static tree
28529 {
28533 }
28535 /* Parse an (optional) series of attributes.
28537 attributes:
28538 attributes attribute
28540 attribute:
28541 __attribute__ (( attribute-list [opt] ))
28543 The return value is as for cp_parser_gnu_attribute_list. */
28545 static tree
28547 {
28554 {
28556 tree attribute_list;
28559 /* Peek at the next token. */
28561 /* If it's not `__attribute__', then we're done. */
28565 /* Consume the `__attribute__' keyword. */
28567 /* Look for the two `(' tokens. */
28568 matching_parens outer_parens;
28571 matching_parens inner_parens;
28575 /* Peek at the next token. */
28578 /* Parse the attribute-list. */
28580 else
28581 /* If the next token is a `)', then there is no attribute
28582 list. */
28585 /* Look for the two `)' tokens. */
28593 /* Add these new attributes to the list. */
28595 }
28598 }
28600 /* Parse a GNU attribute-list.
28602 attribute-list:
28603 attribute
28604 attribute-list , attribute
28606 attribute:
28607 identifier
28608 identifier ( identifier )
28609 identifier ( identifier , expression-list )
28610 identifier ( expression-list )
28612 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
28613 to an attribute. The TREE_PURPOSE of each node is the identifier
28614 indicating which attribute is in use. The TREE_VALUE represents
28615 the arguments, if any. */
28617 static tree
28619 {
28623 /* Don't create wrapper nodes within attributes: the
28624 handlers don't know how to handle them. */
28625 auto_suppress_location_wrappers sentinel;
28629 {
28631 tree identifier;
28632 tree attribute;
28634 /* Look for the identifier. We also allow keywords here; for
28635 example `__attribute__ ((const))' is legal. */
28639 {
28642 /* Consume the token, but save it since we need it for the
28643 SIMD enabled function parsing. */
28646 /* Save away the identifier that indicates which attribute
28647 this is. */
28649 /* For keywords, use the canonical spelling, not the
28650 parsed identifier. */
28657 /* Peek at the next token. */
28659 /* If it's an `(', then parse the attribute arguments. */
28661 {
28665 vec = cp_parser_parenthesized_expression_list
28671 else
28672 {
28675 }
28676 /* Save the arguments away. */
28678 }
28681 {
28682 /* Add this attribute to the list. */
28685 }
28688 }
28689 /* Unless EXACTLY_ONE is set look for more attributes.
28690 If the next token isn't a `,', we're done. */
28694 /* Consume the comma and keep going. */
28696 }
28699 /* We built up the list in reverse order. */
28701 }
28703 /* Parse arguments of omp::directive attribute.
28705 ( directive-name ,[opt] clause-list[opt] )
28707 For directive just remember the first/last tokens for subsequent
28708 parsing. */
28710 static void
28712 {
28715 {
28721 }
28724 {
28730 }
28739 }
28741 /* Parse arguments of omp::sequence attribute.
28743 ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
28745 static void
28747 {
28748 matching_parens parens;
28750 do
28751 {
28756 {
28760 }
28765 else
28770 {
28779 }
28783 UNKNOWN_LOCATION);
28786 else
28791 }
28796 }
28798 /* Parse a standard C++11 attribute.
28800 The returned representation is a TREE_LIST which TREE_PURPOSE is
28801 the scoped name of the attribute, and the TREE_VALUE is its
28802 arguments list.
28804 Note that the scoped name of the attribute is itself a TREE_LIST
28805 which TREE_PURPOSE is the namespace of the attribute, and
28806 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
28807 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
28808 and which TREE_PURPOSE is directly the attribute name.
28810 Clients of the attribute code should use get_attribute_namespace
28811 and get_attribute_name to get the actual namespace and name of
28812 attributes, regardless of their being GNU or C++11 attributes.
28814 attribute:
28815 attribute-token attribute-argument-clause [opt]
28817 attribute-token:
28818 identifier
28819 attribute-scoped-token
28821 attribute-scoped-token:
28822 attribute-namespace :: identifier
28824 attribute-namespace:
28825 identifier
28827 attribute-argument-clause:
28828 ( balanced-token-seq )
28830 balanced-token-seq:
28831 balanced-token [opt]
28832 balanced-token-seq balanced-token
28834 balanced-token:
28835 ( balanced-token-seq )
28836 [ balanced-token-seq ]
28837 { balanced-token-seq }. */
28839 static tree
28841 {
28848 /* First, parse name of the attribute, a.k.a attribute-token. */
28865 {
28866 /* We are seeing a scoped attribute token. */
28881 else
28882 {
28886 }
28892 NULL_TREE);
28894 }
28896 {
28900 NULL_TREE);
28901 }
28902 else
28903 {
28906 NULL_TREE);
28907 /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
28908 but no longer: we have to be able to tell [[noreturn]] and
28909 __attribute__((noreturn)) apart. */
28910 /* C++14 deprecated attribute is equivalent to GNU's. */
28913 /* C++17 fallthrough attribute is equivalent to GNU's. */
28916 /* Transactional Memory TS optimize_for_synchronized attribute is
28917 equivalent to GNU transaction_callable. */
28921 /* Transactional Memory attributes are GNU attributes. */
28924 }
28926 /* Now parse the optional argument clause of the attribute. */
28929 {
28934 {
28936 attr_id);
28938 }
28940 }
28942 {
28946 /* Maybe we don't expect to see any arguments for this attribute. */
28950 {
28952 attr_id);
28958 }
28962 /* A GNU attribute that takes an identifier in parameter. */
28966 {
28968 {
28970 {
28973 }
28975 {
28981 }
28982 }
28984 /* For unknown attributes, just skip balanced tokens instead of
28985 trying to parse the arguments. */
28989 }
28991 vec = cp_parser_parenthesized_expression_list
28997 else
28998 {
29000 /* e.g. [[attr()]]. */
29003 attr_id);
29006 }
29010 else
29012 }
29015 }
29017 /* Warn if the attribute ATTRIBUTE appears more than once in the
29018 attribute-list ATTRIBUTES. This used to be enforced for certain
29019 attributes, but the restriction was removed in P2156. Note that
29020 carries_dependency ([dcl.attr.depend]) isn't implemented yet in GCC.
29021 LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
29022 found in ATTRIBUTES. */
29024 static bool
29026 {
29034 {
29039 }
29041 }
29043 /* Parse a list of standard C++-11 attributes.
29045 attribute-list:
29046 attribute [opt]
29047 attribute-list , attribute[opt]
29048 attribute ...
29049 attribute-list , attribute ...
29050 */
29052 static tree
29054 {
29059 {
29065 {
29067 {
29070 }
29071 }
29074 {
29079 else
29080 {
29085 }
29087 }
29091 }
29094 }
29096 /* Parse a standard C++-11 attribute specifier.
29098 attribute-specifier:
29099 [ [ attribute-using-prefix [opt] attribute-list ] ]
29100 alignment-specifier
29102 attribute-using-prefix:
29103 using attribute-namespace :
29105 alignment-specifier:
29106 alignas ( type-id ... [opt] )
29107 alignas ( alignment-expression ... [opt] ). */
29109 static tree
29111 {
29117 {
29124 {
29135 {
29138 "attribute using prefix only available "
29144 }
29145 else
29147 }
29154 else
29155 /* Warn about parsing c++11 attribute in non-c++11 mode, only
29156 when we are sure that we have actually parsed them. */
29158 }
29159 else
29160 {
29161 tree alignas_expr;
29163 /* Look for an alignment-specifier. */
29174 matching_parens parens;
29182 {
29189 }
29194 /* Handle alignas (pack...). */
29196 {
29199 }
29201 /* Something went wrong, so don't build the attribute. */
29205 /* Missing ')' means the code cannot possibly be valid; go ahead
29206 and commit to make sure we issue a hard error. */
29214 /* Build the C++-11 representation of an 'aligned'
29215 attribute. */
29216 attributes
29219 }
29222 }
29224 /* Parse a standard C++-11 attribute-specifier-seq.
29226 attribute-specifier-seq:
29227 attribute-specifier-seq [opt] attribute-specifier
29228 */
29230 static tree
29232 {
29236 /* Don't create wrapper nodes within attributes: the
29237 handlers don't know how to handle them. */
29238 auto_suppress_location_wrappers sentinel;
29241 {
29250 else
29253 }
29256 }
29258 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
29259 return index of the first token after balanced-token, or N on failure. */
29261 static size_t
29263 {
29266 do
29268 {
29272 /* FALLTHRU */
29274 /* Ran out of tokens. */
29296 }
29299 }
29301 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
29302 return index of the first token after the GNU attribute tokens, or N on
29303 failure. */
29305 static size_t
29307 {
29309 {
29321 }
29323 }
29325 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
29326 next token), return index of the first token after the standard C++11
29327 attribute tokens, or N on failure. */
29329 static size_t
29331 {
29333 {
29336 {
29343 }
29346 {
29351 }
29352 else
29354 }
29356 }
29358 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
29359 as the next token), return index of the first token after the attribute
29360 tokens, or N on failure. */
29362 static size_t
29364 {
29368 }
29370 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
29371 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
29372 current value of the PEDANTIC flag, regardless of whether or not
29373 the `__extension__' keyword is present. The caller is responsible
29374 for restoring the value of the PEDANTIC flag. */
29376 static bool
29378 {
29379 /* Save the old value of the PEDANTIC flag. */
29383 {
29384 /* Consume the `__extension__' token. */
29386 /* We're not being pedantic while the `__extension__' keyword is
29387 in effect. */
29391 }
29394 }
29396 /* Parse a label declaration.
29398 label-declaration:
29399 __label__ label-declarator-seq ;
29401 label-declarator-seq:
29402 identifier , label-declarator-seq
29403 identifier */
29405 static void
29407 {
29408 /* Look for the `__label__' keyword. */
29412 {
29413 tree identifier;
29415 /* Look for an identifier. */
29417 /* If we failed, stop. */
29420 /* Declare it as a label. */
29422 /* If the next token is a `;', stop. */
29425 /* Look for the `,' separating the label declarations. */
29427 }
29429 /* Look for the final `;'. */
29431 }
29433 // -------------------------------------------------------------------------- //
29434 // Concept definitions
29436 static tree
29438 {
29439 /* A concept definition is an unevaluated context. */
29440 cp_unevaluated u;
29447 {
29451 }
29454 {
29458 }
29460 processing_constraint_expression_sentinel parsing_constraint;
29465 /* Consume the trailing ';'. Diagnose the problem if it isn't there,
29466 but continue as if it were. */
29470 }
29472 // -------------------------------------------------------------------------- //
29473 // Requires Clause
29475 /* Diagnose an expression that should appear in ()'s within a requires-clause
29476 and suggest where to place those parentheses. */
29478 static void
29480 {
29482 }
29484 static void
29486 {
29491 }
29493 /* Characterizes the likely kind of expression intended by a mis-written
29494 primary constraint. */
29495 enum primary_constraint_error
29496 {
29497 pce_ok,
29498 pce_maybe_operator,
29499 pce_maybe_postfix
29500 };
29502 /* Returns true if the token(s) following a primary-expression in a
29503 constraint-logical-* expression would require parentheses. */
29505 static primary_constraint_error
29507 {
29510 {
29515 {
29516 /* An equal sign may be part of the definition of a function,
29517 and not an assignment operator, when parsing the expression
29518 for a trailing requires-clause. For example:
29520 template<typename T>
29521 struct S {
29522 S() requires C<T> = default;
29523 };
29525 Don't try to reparse this a binary operator. */
29531 }
29533 /* Arithmetic operators. */
29539 /* Bitwise operators. */
29545 /* Relational operators. */
29553 /* Pointer-to-member. */
29556 /* Assignment operators. */
29567 /* Conditional operator */
29569 /* Unenclosed binary or conditional operator. */
29573 {
29574 /* A primary constraint that precedes the parameter-list of a
29575 lambda expression is followed by an open paren.
29577 []<typename T> requires C (T a, T b) { ... }
29579 Don't try to re-parse this as a postfix expression. */
29584 }
29586 {
29587 /* A primary-constraint-expression followed by a '[[' is not a
29588 postfix expression. */
29593 }
29597 /* Unenclosed postfix operator. */
29601 /* A primary constraint that precedes the lambda-declarator of a
29602 lambda expression is followed by trailing return type.
29604 []<typename T> requires C -> void {}
29606 Don't try to re-parse this as a postfix expression in
29607 C++23 and later. In C++20 ( needs to come in between but we
29608 allow it to be omitted with pedwarn. */
29611 /* Unenclosed postfix operator. */
29613 }
29614 }
29616 /* Returns true if the next token begins a unary expression, preceded by
29617 an operator or keyword. */
29619 static bool
29621 {
29624 {
29635 {
29637 {
29653 }
29654 }
29658 }
29661 }
29663 /* Parse a primary expression within a constraint. */
29665 static cp_expr
29667 {
29668 /* If this looks like a unary expression, parse it as such, but diagnose
29669 it as ill-formed; it requires parens. */
29671 {
29675 }
29678 cp_id_kind idk;
29689 {
29690 /* The primary-expression could be part of an unenclosed non-logical
29691 compound expression. */
29693 }
29695 {
29698 }
29700 /* Retry the parse at a lower precedence. If that succeeds, diagnose the
29701 error, but return the expression as if it were valid. */
29706 else
29709 {
29712 }
29714 /* Otherwise, something has gone very wrong, and we can't generate a more
29715 meaningful diagnostic or recover. */
29718 }
29720 /* Parse a constraint-logical-and-expression.
29722 constraint-logical-and-expression:
29723 primary-expression
29724 constraint-logical-and-expression '&&' primary-expression */
29726 static cp_expr
29728 {
29731 {
29735 }
29737 }
29739 /* Parse a constraint-logical-or-expression.
29741 constraint-logical-or-expression:
29742 constraint-logical-and-expression
29743 constraint-logical-or-expression '||' constraint-logical-and-expression */
29745 static cp_expr
29747 {
29750 {
29754 }
29756 }
29758 /* Parse the expression after a requires-clause. This has a different grammar
29759 than that in the concepts TS. */
29761 static tree
29763 {
29764 processing_constraint_expression_sentinel parsing_constraint;
29767 /* Adjust processing_template_decl so that we always obtain template
29768 trees here. We don't do the usual ++processing_template_decl
29769 because that would skew the template parameter depth of a lambda
29770 within if we're already inside a template. */
29776 }
29778 /* Parse a expression after a requires clause.
29780 constraint-expression:
29781 logical-or-expression
29783 The required logical-or-expression must be a constant expression. Note
29784 that we don't check that the expression is constepxr here. We defer until
29785 we analyze constraints and then, we only check atomic constraints. */
29787 static tree
29789 {
29790 processing_constraint_expression_sentinel parsing_constraint;
29793 /* As in cp_parser_requires_clause_expression. */
29801 }
29803 /* Optionally parse a requires clause:
29805 requires-clause:
29806 `requires` constraint-logical-or-expression.
29807 [ConceptsTS]
29808 `requires constraint-expression.
29810 LAMBDA_P is true when the requires-clause is parsed before the
29811 parameter-list of a lambda-declarator. */
29813 static tree
29815 {
29816 /* A requires clause is an unevaluated context. */
29817 cp_unevaluated u;
29821 {
29824 {
29826 "%<requires%> only available with "
29828 /* Parse and discard the requires-clause. */
29831 }
29833 }
29837 {
29838 /* An opening brace following the start of a requires-clause is
29839 ill-formed; the user likely forgot the second `requires' that
29840 would start a requires-expression. */
29845 /* Don't consume the `requires', so that it's reused as the start of a
29846 requires-expression. */
29847 }
29848 else
29853 else
29855 }
29857 /*---------------------------------------------------------------------------
29858 Requires expressions
29859 ---------------------------------------------------------------------------*/
29861 /* Parse a requires expression
29863 requirement-expression:
29864 'requires' requirement-parameter-list [opt] requirement-body */
29866 static tree
29868 {
29872 /* Avoid committing to outer tentative parse. */
29875 /* This is definitely a requires-expression. */
29879 {
29880 /* Local parameters are delared as variables within the scope
29881 of the expression. They are not visible past the end of
29882 the expression. Expressions within the requires-expression
29883 are unevaluated. */
29884 struct scope_sentinel
29885 {
29887 {
29890 }
29893 {
29896 }
29899 /* Parse the optional parameter list. */
29901 {
29905 }
29906 else
29909 /* Parse the requirement body. */
29912 /* As in cp_parser_requires_clause_expression. */
29917 }
29919 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
29920 the parm chain. */
29925 {
29926 /* Perform semantic processing now to diagnose any invalid types and
29927 expressions. */
29932 }
29934 }
29936 /* Parse a parameterized requirement.
29938 requirement-parameter-list:
29939 '(' parameter-declaration-clause ')' */
29941 static tree
29943 {
29944 matching_parens parens;
29948 tree parms = (cp_parser_parameter_declaration_clause
29954 /* Modify the declared parameters by removing their context
29955 so they don't refer to the enclosing scope and explicitly
29956 indicating that they are constraint variables. */
29958 {
29963 {
29966 }
29967 }
29970 }
29972 /* Parse the body of a requirement.
29974 requirement-body:
29975 '{' requirement-list '}' */
29976 static tree
29978 {
29979 matching_braces braces;
29989 }
29991 /* Parse a sequence of requirements.
29993 requirement-seq:
29994 requirement
29995 requirement-seq requirement */
29997 static tree
29999 {
30001 do
30002 {
30006 }
30010 /* If there are no valid requirements, this is not a valid expression. */
30014 /* Reverse the order of requirements so they are analyzed in order. */
30016 }
30018 /* Parse a syntactic requirement or type requirement.
30020 requirement:
30021 simple-requirement
30022 compound-requirement
30023 type-requirement
30024 nested-requirement */
30026 static tree
30028 {
30035 else
30037 }
30039 /* Parse a simple requirement.
30041 simple-requirement:
30042 expression ';' */
30044 static tree
30046 {
30057 /* Sometimes we don't get locations, so use the cached token location
30058 as a reasonable approximation. */
30063 {
30066 {
30069 }
30071 {
30075 "if a concept-id is a valid expression; add "
30077 }
30079 }
30082 }
30084 /* Parse a type requirement
30086 type-requirement
30087 nested-name-specifier [opt] required-type-name ';'
30089 required-type-name:
30090 type-name
30091 'template' [opt] simple-template-id */
30093 static tree
30095 {
30099 // Save the scope before parsing name specifiers.
30110 tree type;
30112 {
30121 }
30122 else
30142 }
30144 /* Parse a compound requirement
30146 compound-requirement:
30147 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
30149 static tree
30151 {
30152 /* Parse an expression enclosed in '{ }'s. */
30153 matching_braces braces;
30164 {
30168 }
30170 /* If the expression was invalid, skip the remainder of the requirement. */
30172 {
30176 }
30178 /* Parse the optional noexcept. */
30181 {
30184 }
30186 /* Parse the optional trailing return type. */
30189 {
30195 /* C++20 allows either a type-id or a type-constraint. Parsing
30196 a type-id will subsume the parsing for a type-constraint but
30197 allow for more syntactic forms (e.g., const C<T>*). */
30206 /* Check that we haven't written something like 'const C<T>*'. */
30208 {
30210 {
30215 }
30216 }
30218 /* P1452R2 removed the trailing-return-type option. */
30221 }
30233 }
30235 /* Parse a nested requirement. This is the same as a requires clause.
30237 nested-requirement:
30238 requires-clause */
30240 static tree
30242 {
30254 }
30256 /* Support Functions */
30258 /* Return the appropriate prefer_type argument for lookup_name based on
30259 tag_type. */
30263 {
30265 {
30269 }
30270 }
30272 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
30273 NAME should have one of the representations used for an
30274 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
30275 is returned. If PARSER->SCOPE is a dependent type, then a
30276 SCOPE_REF is returned.
30278 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
30279 returned; the name was already resolved when the TEMPLATE_ID_EXPR
30280 was formed. Abstractly, such entities should not be passed to this
30281 function, because they do not need to be looked up, but it is
30282 simpler to check for this special case here, rather than at the
30283 call-sites.
30285 In cases not explicitly covered above, this function returns a
30286 DECL, OVERLOAD, or baselink representing the result of the lookup.
30287 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
30288 is returned.
30290 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
30291 (e.g., "struct") that was used. In that case bindings that do not
30292 refer to types are ignored.
30294 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
30295 ignored.
30297 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
30298 are ignored.
30300 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
30301 types.
30303 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
30304 TREE_LIST of candidates if name-lookup results in an ambiguity, and
30305 NULL_TREE otherwise. */
30307 static cp_expr
30314 location_t name_location)
30315 {
30316 tree decl;
30319 /* Assume that the lookup will be unambiguous. */
30323 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
30324 no longer valid. Note that if we are parsing tentatively, and
30325 the parse fails, OBJECT_TYPE will be automatically restored. */
30331 /* A template-id has already been resolved; there is no lookup to
30332 do. */
30336 {
30340 }
30342 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
30343 it should already have been checked to make sure that the name
30344 used matches the type being destroyed. */
30346 {
30347 tree type;
30349 /* Figure out to which type this destructor applies. */
30354 else
30356 /* If that's not a class type, there is no destructor. */
30360 /* In a non-static member function, check implicit this->. */
30363 tf_warning_or_error);
30372 }
30374 /* By this point, the NAME should be an ordinary identifier. If
30375 the id-expression was a qualified name, the qualifying scope is
30376 stored in PARSER->SCOPE at this point. */
30379 /* Perform the lookup. */
30381 {
30387 /* If the SCOPE is dependent, the lookup must be deferred until
30388 the template is instantiated -- unless we are explicitly
30389 looking up names in uninstantiated templates. Even then, we
30390 cannot look up the name if the scope is not a class type; it
30391 might, for example, be a template type parameter. */
30396 /* Defer lookup. */
30398 else
30399 {
30402 /* If PARSER->SCOPE is a dependent type, then it must be a
30403 class type, and we must not be checking dependencies;
30404 otherwise, we would have processed this lookup above. So
30405 that PARSER->SCOPE is not considered a dependent base by
30406 lookup_member, we must enter the scope here. */
30410 /* If the PARSER->SCOPE is a template specialization, it
30411 may be instantiated during name lookup. In that case,
30412 errors may be issued. Even if we rollback the current
30413 tentative parse, those errors are valid. */
30418 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
30419 lookup result and the nested-name-specifier nominates a class C:
30420 * if the name specified after the nested-name-specifier, when
30421 looked up in C, is the injected-class-name of C (Clause 9), or
30422 * if the name specified after the nested-name-specifier is the
30423 same as the identifier or the simple-template-id's template-
30424 name in the last component of the nested-name-specifier,
30425 the name is instead considered to name the constructor of
30426 class C. [ Note: for example, the constructor is not an
30427 acceptable lookup result in an elaborated-type-specifier so
30428 the constructor would not be used in place of the
30429 injected-class-name. --end note ] Such a constructor name
30430 shall be used only in the declarator-id of a declaration that
30431 names a constructor or in a using-declaration. */
30441 }
30443 /* If the scope is a dependent type and either we deferred lookup or
30444 we did lookup but didn't find the name, rememeber the name. */
30447 {
30449 {
30450 tree type;
30452 /* The resolution to Core Issue 180 says that `struct
30453 A::B' should be considered a type-name, even if `A'
30454 is dependent. */
30459 }
30463 CPP_CLOSE_PAREN)))
30467 else
30470 is_template);
30471 }
30474 }
30476 {
30477 /* Look up the name in the scope of the OBJECT_TYPE, unless the
30478 OBJECT_TYPE is not a class. */
30480 /* If the OBJECT_TYPE is a template specialization, it may
30481 be instantiated during name lookup. In that case, errors
30482 may be issued. Even if we rollback the current tentative
30483 parse, those errors are valid. */
30485 name,
30488 tf_warning_or_error);
30489 else
30493 /* Look it up in the enclosing context. DR 141: When looking for a
30494 template-name after -> or ., only consider class templates. */
30496 /* DR 141: When looking in the
30497 current enclosing context for a
30498 template-name after -> or ., only
30499 consider class templates. */
30503 /* If we know we're looking for a type (e.g. A in p->A::x),
30504 mock up a typename. */
30507 {
30509 typename_type);
30511 }
30515 }
30516 else
30517 {
30522 }
30524 /* If the lookup failed, let our caller know. */
30528 /* If we have resolved the name of a member declaration, check to
30529 see if the declaration is accessible. When the name resolves to
30530 set of overloaded functions, accessibility is checked when
30531 overload resolution is done. If we have a TREE_LIST, then the lookup
30532 is either ambiguous or it found multiple injected-class-names, the
30533 accessibility of which is trivially satisfied.
30535 During an explicit instantiation, access is not checked at all,
30536 as per [temp.explicit]. */
30539 tf_warning_or_error);
30541 /* Pull out the template from an injected-class-name (or multiple). */
30545 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
30547 {
30550 /* The error message we have to print is too complicated for
30551 cp_parser_error, so we incorporate its actions directly. */
30553 {
30555 name);
30557 }
30559 }
30570 }
30572 /* Like cp_parser_lookup_name, but for use in the typical case where
30573 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
30574 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
30576 static tree
30578 {
30580 none_type,
30585 location);
30586 }
30588 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
30589 the current context, return the TYPE_DECL. If TAG_NAME_P is
30590 true, the DECL indicates the class being defined in a class-head,
30591 or declared in an elaborated-type-specifier.
30593 Otherwise, return DECL. */
30595 static tree
30597 {
30598 /* If the TEMPLATE_DECL is being declared as part of a class-head,
30599 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
30601 struct A {
30602 template <typename T> struct B;
30603 };
30605 template <typename T> struct A::B {};
30607 Similarly, in an elaborated-type-specifier:
30609 namespace N { struct X{}; }
30611 struct A {
30612 template <typename T> friend struct N::X;
30613 };
30615 However, if the DECL refers to a class type, and we are in
30616 the scope of the class, then the name lookup automatically
30617 finds the TYPE_DECL created by build_self_reference rather
30618 than a TEMPLATE_DECL. For example, in:
30620 template <class T> struct S {
30621 S s;
30622 };
30624 there is no need to handle such case. */
30630 }
30632 /* If too many, or too few, template-parameter lists apply to the
30633 declarator, issue an error message. Returns TRUE if all went well,
30634 and FALSE otherwise. */
30636 static bool
30639 location_t declarator_location)
30640 {
30642 {
30644 {
30653 {
30654 /* If the DECLARATOR has the form `X<y>' then it uses one
30655 additional level of template parameters. */
30658 }
30660 return cp_parser_check_template_parameters
30662 declarator);
30663 }
30679 }
30681 }
30683 /* NUM_TEMPLATES were used in the current declaration. If that is
30684 invalid, return FALSE and issue an error messages. Otherwise,
30685 return TRUE. If DECLARATOR is non-NULL, then we are checking a
30686 declarator and we can print more accurate diagnostics. */
30688 static bool
30692 location_t location,
30694 {
30695 /* If there are the same number of template classes and parameter
30696 lists, that's OK. */
30699 /* If there are more, but only one more, and the name ends in an identifier,
30700 then we are declaring a primary template. That's OK too. */
30708 /* If there are more template classes than parameter lists, we have
30709 something like:
30711 template <class T> void S<T>::R<T>::f (); */
30713 {
30723 else
30726 }
30727 /* Otherwise, there are too many template parameter lists. We have
30728 something like:
30730 template <class T> template <class U> void S::f(); */
30733 }
30735 /* Parse an optional `::' token indicating that the following name is
30736 from the global namespace. If so, PARSER->SCOPE is set to the
30737 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
30738 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
30739 Returns the new value of PARSER->SCOPE, if the `::' token is
30740 present, and NULL_TREE otherwise. */
30742 static tree
30744 {
30747 /* Peek at the next token. */
30749 /* If we're looking at a `::' token then we're starting from the
30750 global namespace, not our current location. */
30752 {
30753 /* Consume the `::' token. */
30755 /* Set the SCOPE so that we know where to start the lookup. */
30761 }
30763 {
30767 }
30770 }
30772 /* Returns TRUE if the upcoming token sequence is the start of a
30773 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
30774 declarator is preceded by the `friend' specifier. The parser flags FLAGS
30775 is used to control type-specifier parsing. */
30777 static bool
30780 {
30783 tree nested_name_specifier;
30786 /* The common case is that this is not a constructor declarator, so
30787 try to avoid doing lots of work if at all possible. It's not
30788 valid declare a constructor at function scope. */
30791 /* And only certain tokens can begin a constructor declarator. */
30796 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
30797 declarator-id of a constructor or destructor. */
30801 /* Parse tentatively; we are going to roll back all of the tokens
30802 consumed here. */
30804 /* Assume that we are looking at a constructor declarator. */
30807 /* Look for the optional `::' operator. */
30810 /* Look for the nested-name-specifier. */
30811 nested_name_specifier
30818 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
30821 {
30826 }
30832 /* Outside of a class-specifier, there must be a
30833 nested-name-specifier. Except in C++17 mode, where we
30834 might be declaring a guiding declaration. */
30841 /* If we have a class scope, this is easy; DR 147 says that S::S always
30842 names the constructor, and no other qualified name could. */
30845 {
30855 }
30856 /* If we still think that this might be a constructor-declarator,
30857 look for a class-name. */
30859 {
30860 /* If we have:
30862 template <typename T> struct S {
30863 S();
30864 };
30866 we must recognize that the nested `S' names a class. */
30870 tree type_decl;
30874 none_type,
30881 {
30887 none_type,
30892 else
30894 }
30896 /* If there was no class-name, then this is not a constructor.
30897 Otherwise, if we are in a class-specifier and we aren't
30898 handling a friend declaration, check that its type matches
30899 current_class_type (c++/38313). Note: error_mark_node
30900 is left alone for error recovery purposes. */
30902 && (outside_class_specifier_p
30908 /* If we're still considering a constructor, we have to see a `(',
30909 to begin the parameter-declaration-clause, followed by either a
30910 `)', an `...', or a decl-specifier. We need to check for a
30911 type-specifier to avoid being fooled into thinking that:
30913 S (f) (int);
30915 is a constructor. (It is actually a function named `f' that
30916 takes one parameter (of type `int') and returns a value of type
30917 `S'. */
30925 /* A parameter declaration begins with a decl-specifier,
30926 which is either the "attribute" keyword, a storage class
30927 specifier, or (usually) a type-specifier. */
30929 /* GNU attributes can actually appear both at the start of
30930 a parameter and parenthesized declarator.
30931 S (__attribute__((unused)) int);
30932 is a constructor, but
30933 S (__attribute__((unused)) foo) (int);
30934 is a function declaration. [[attribute]] can appear in the
30935 first form too, but not in the second form. */
30937 {
30938 tree type;
30944 {
30948 }
30950 /* Names appearing in the type-specifier should be looked up
30951 in the scope of the class. */
30955 {
30958 {
30962 {
30965 }
30966 }
30968 }
30970 /* Inside the constructor parameter list, surrounding
30971 template-parameter-lists do not apply. */
30972 saved_num_template_parameter_lists
30976 /* Look for the type-specifier. It's not optional, but its typename
30977 might be. Unless this is a friend declaration; we don't want to
30978 treat
30980 friend S (T::fn)(int);
30982 as a constructor, but with P0634, we might assume a type when
30983 looking for the type-specifier. It is actually a function named
30984 `T::fn' that takes one parameter (of type `int') and returns a
30985 value of type `S'. Constructors can be friends, but they must
30986 use a qualified name.
30988 Parse with an empty set of declaration specifiers since we're
30989 trying to match a decl-specifier-seq of the first parameter.
30990 This must be non-null so that cp_parser_simple_type_specifier
30991 will recognize a constrained placeholder type such as:
30992 'C<int> auto' where C is a type concept. */
30993 cp_decl_specifier_seq ctor_specs;
31003 parser->num_template_parameter_lists
31006 /* Leave the scope of the class. */
31011 }
31012 }
31014 /* We did not really want to consume any tokens. */
31018 }
31020 /* Parse the definition of the function given by the DECL_SPECIFIERS,
31021 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
31022 they must be performed once we are in the scope of the function.
31024 Returns the function defined. */
31026 static tree
31027 cp_parser_function_definition_from_specifiers_and_declarator
31030 tree attributes,
31032 {
31033 tree fn;
31036 /* Begin the function-definition. */
31039 /* The things we're about to see are not directly qualified by any
31040 template headers we've seen thus far. */
31043 /* If there were names looked up in the decl-specifier-seq that we
31044 did not check, check them now. We must wait until we are in the
31045 scope of the function to perform the checks, since the function
31046 might be a friend. */
31050 {
31055 }
31058 {
31059 /* Skip the entire function. */
31062 }
31064 {
31065 /* Seen already, skip it. An error message has already been output. */
31069 /* If this is a function from a class, pop the nested class. */
31072 }
31073 else
31074 {
31075 timevar_id_t tv;
31078 else
31084 }
31087 }
31089 /* Parse the part of a function-definition that follows the
31090 declarator. INLINE_P is TRUE iff this function is an inline
31091 function defined within a class-specifier.
31093 Returns the function defined. */
31095 static tree
31098 {
31099 tree fn;
31104 bool fully_implicit_function_template_p
31107 tree implicit_template_parms
31110 cp_binding_level* implicit_template_scope
31116 /* If the next token is `return', then the code may be trying to
31117 make use of the "named return value" extension that G++ used to
31118 support. */
31121 {
31122 /* Consume the `return' keyword. */
31124 /* Look for the identifier that indicates what value is to be
31125 returned. */
31127 /* Issue an error message. */
31130 /* Skip tokens until we reach the start of the function body. */
31132 {
31139 }
31140 }
31141 /* The `extern' in `extern "C" void f () { ... }' does not apply to
31142 anything declared inside `f'. */
31143 saved_in_unbraced_linkage_specification_p
31146 /* Inside the function, surrounding template-parameter-lists do not
31147 apply. */
31148 saved_num_template_parameter_lists
31152 /* If the next token is `try', `__transaction_atomic', or
31153 `__transaction_relaxed`, then we are looking at either function-try-block
31154 or function-transaction-block. Note that all of these include the
31155 function-body. */
31159 RID_TRANSACTION_RELAXED))
31163 else
31164 cp_parser_ctor_initializer_opt_and_function_body
31167 /* Finish the function. */
31171 && !inline_p
31177 /* Generate code for it, if necessary. */
31179 /* Restore the saved values. */
31180 parser->in_unbraced_linkage_specification_p
31182 parser->num_template_parameter_lists
31186 parser->fully_implicit_function_template_p
31188 parser->implicit_template_parms
31190 parser->implicit_template_scope
31197 }
31199 /* Parse a template-declaration body (following argument list). */
31201 static void
31203 tree parameter_list,
31205 {
31209 /* We just processed one more parameter list. */
31212 /* Get the deferred access checks from the parameter list. These
31213 will be checked once we know what is being declared, as for a
31214 member template the checks must be performed in the scope of the
31215 class containing the member. */
31218 /* Tentatively parse for a new template parameter list, which can either be
31219 the template keyword or a template introduction. */
31228 /* Allow 'concept bool' to be handled as per the TS. */
31230 else
31231 {
31234 checks,
31235 member_p,
31239 /* If this is a member template declaration, let the front
31240 end know. */
31242 {
31247 }
31252 }
31253 /* We are done with the current parameter list. */
31258 /* Finish up. */
31261 /* Check the template arguments for a literal operator template. */
31265 {
31269 else
31270 {
31273 {
31280 /* OK, C++20 string literal operator template. We don't need
31281 to warn in lower dialects here because we will have already
31286 }
31288 {
31297 else
31298 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
31300 "ISO C++ did not adopt string literal operator templa"
31302 }
31303 else
31305 }
31307 {
31310 "template %qD has invalid parameter list; expected "
31311 "non-type template parameter pack %<<char...>%> or "
31313 decl);
31314 else
31316 "template %qD has invalid parameter list; expected "
31318 decl);
31319 }
31320 }
31322 /* Register member declarations. */
31325 /* If DECL is a function template, we must return to parse it later.
31326 (Even though there is no definition, there might be default
31327 arguments that need handling.) */
31331 }
31333 /* Parse a template introduction header for a template-declaration. Returns
31334 false if tentative parse fails. */
31336 static bool
31338 {
31347 /* Look for the optional `::' operator. */
31350 /* Look for the nested-name-specifier. */
31360 /* Look up the concept for which we will be matching
31361 template parameters. */
31372 /* Look for opening brace for introduction. */
31373 matching_braces braces;
31382 /* Build vector of placeholder parameters and grab
31383 matching identifiers. */
31386 /* Look for closing brace for introduction. */
31390 /* The introduction-list shall not be empty. */
31393 {
31394 /* In cp_parser_introduction_list we have already issued an error. */
31396 }
31399 {
31403 }
31405 /* Build and associate the constraint. */
31410 introduction_list,
31411 introduction_loc);
31413 {
31420 member_p);
31422 }
31428 }
31430 /* Parse a normal template-declaration following the template keyword. */
31432 static void
31434 {
31435 tree parameter_list;
31439 /* Look for the `<' token. */
31443 {
31444 /* 14.5.2.2 [temp.mem]
31446 A local class shall not have member templates. */
31451 }
31452 /* [temp]
31454 A template ... shall not have C linkage. */
31456 {
31459 /* Give it C++ linkage to avoid confusing other parts of the
31460 front end. */
31463 }
31464 else
31467 /* We cannot perform access checks on the template parameter
31468 declarations until we know what is being declared, just as we
31469 cannot check the decl-specifier list. */
31472 /* If the next token is `>', then we have an invalid
31473 specialization. Rather than complain about an invalid template
31474 parameter, issue an error message here. */
31476 {
31480 }
31481 else
31482 {
31483 /* Parse the template parameters. */
31485 }
31487 /* Look for the `>'. */
31490 /* Manage template requirements */
31492 {
31497 }
31500 member_p);
31502 /* For the erroneous case of a template with C linkage, we pushed an
31503 implicit C++ linkage scope; exit that scope now. */
31506 }
31508 /* Parse a template-declaration, assuming that the `export' (and
31509 `extern') keywords, if present, has already been scanned. MEMBER_P
31510 is as for cp_parser_template_declaration. */
31512 static bool
31514 {
31516 {
31520 }
31525 }
31527 /* Perform the deferred access checks from a template-parameter-list.
31528 CHECKS is a TREE_LIST of access checks, as returned by
31529 get_deferred_access_checks. */
31531 static void
31532 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
31533 {
31537 }
31539 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
31540 `function-definition' sequence that follows a template header.
31541 If MEMBER_P is true, this declaration appears in a class scope.
31543 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
31544 *FRIEND_P is set to TRUE iff the declaration is a friend. */
31546 static tree
31552 {
31555 cp_decl_specifier_seq decl_specifiers;
31559 /* This function is only used when processing a template
31560 declaration. */
31564 /* Defer access checks until we know what is being declared. */
31567 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
31568 alternative. */
31571 (CP_PARSER_FLAGS_OPTIONAL
31576 cp_omp_declare_simd_data odsd;
31585 /* There are no template typedefs. */
31587 {
31591 }
31593 /* Gather up the access checks that occurred the
31594 decl-specifier-seq. */
31597 /* Check for the declaration of a template class. */
31599 {
31602 {
31603 /* If this is a declaration, but not a definition, associate
31604 any constraints with the type declaration. Constraints
31605 are associated with definitions in cp_parser_class_specifier. */
31611 /* In this case:
31613 struct C {
31614 friend template <typename T> struct A<T>::B;
31615 };
31617 A<T>::B will be represented by a TYPENAME_TYPE, and
31618 therefore not recognized by shadow_tag. */
31620 && !decl
31627 else
31630 /* Perform access checks for template parameters. */
31633 /* Give a helpful diagnostic for
31634 template <class T> struct A { } a;
31635 if we aren't already recovering from an error. */
31638 {
31640 "a class template declaration must not declare "
31644 }
31645 }
31646 }
31648 /* Complain about missing 'typename' or other invalid type names. */
31651 {
31652 /* cp_parser_parse_and_diagnose_invalid_type_name calls
31653 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
31654 the rest of this declaration. */
31657 }
31659 /* If it's not a template class, try for a template function. If
31660 the next token is a `;', then this declaration does not declare
31661 anything. But, if there were errors in the decl-specifiers, then
31662 the error might well have come from an attempted class-specifier.
31663 In that case, there's no need to warn about a missing declarator. */
31667 {
31669 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
31671 checks,
31673 member_p,
31674 declares_class_or_enum,
31678 /* 7.1.1-1 [dcl.stc]
31680 A storage-class-specifier shall not be specified in an explicit
31681 specialization... */
31683 && explicit_specialization_p
31685 {
31689 }
31693 }
31695 /* Look for a trailing `;' after the declaration. */
31701 out:
31704 /* Clear any current qualification; whatever comes next is the start
31705 of something new. */
31713 }
31715 /* Parse a cast-expression that is not the operand of a unary "&". */
31717 static cp_expr
31719 {
31722 }
31724 /* Parse a functional cast to TYPE. Returns an expression
31725 representing the cast. */
31727 static cp_expr
31729 {
31731 tree expression_list;
31732 cp_expr cast;
31741 {
31751 /* Create a location of the form:
31752 type_name{i, f}
31753 ^~~~~~~~~~~~~~~
31754 with caret == start at the start of the type name,
31755 finishing at the closing brace. */
31760 }
31769 else
31770 {
31773 }
31775 /* Create a location of the form:
31776 float(i)
31777 ^~~~~~~~
31778 with caret == start at the start of the type name,
31779 finishing at the closing paren. */
31783 tf_warning_or_error);
31785 /* [expr.const]/1: In an integral constant expression "only type
31786 conversions to integral or enumeration type can be used". */
31792 NIC_CONSTRUCTOR))
31796 }
31798 /* Save the tokens that make up the body of a member function defined
31799 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
31800 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
31801 specifiers applied to the declaration. Returns the FUNCTION_DECL
31802 for the member function. */
31804 static tree
31808 tree attributes)
31809 {
31812 tree fn;
31815 /* Create the FUNCTION_DECL. */
31819 /* If something went badly wrong, bail out now. */
31821 {
31822 /* If there's a function-body, skip it. */
31827 }
31829 /* Remember it, if there are default args to post process. */
31832 /* Save away the tokens that make up the body of the
31833 function. */
31839 RID_TRANSACTION_ATOMIC))
31840 {
31842 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
31849 {
31855 }
31856 else
31859 {
31863 }
31864 }
31866 /* Handle function try blocks. */
31868 {
31871 }
31872 /* We can have braced-init-list mem-initializers before the fn body. */
31874 {
31877 {
31878 /* cache_group will stop after an un-nested { } pair, too. */
31882 /* variadic mem-inits have ... after the ')'. */
31885 }
31886 }
31888 /* Handle function try blocks. */
31894 /* Save away the inline definition; we will process it when the
31895 class is complete. */
31899 /* We need to know that this was defined in the class, so that
31900 friend templates are handled correctly. */
31903 /* Add FN to the queue of functions to be parsed later. */
31907 }
31909 /* Save the tokens that make up the in-class initializer for a non-static
31910 data member. Returns a DEFERRED_PARSE. */
31912 static tree
31914 {
31916 }
31918 /* Parse a template-argument-list, as well as the trailing ">" (but
31919 not the opening "<"). See cp_parser_template_argument_list for the
31920 return value. */
31922 static tree
31924 {
31925 tree arguments;
31926 tree saved_scope;
31927 tree saved_qualifying_scope;
31928 tree saved_object_scope;
31931 /* [temp.names]
31933 When parsing a template-id, the first non-nested `>' is taken as
31934 the end of the template-argument-list rather than a greater-than
31935 operator. */
31936 saved_greater_than_is_operator_p
31939 /* Parsing the argument list may modify SCOPE, so we save it
31940 here. */
31944 /* We need to evaluate the template arguments, even though this
31945 template-id may be nested within a "sizeof". */
31946 cp_evaluated ev;
31947 /* Parse the template-argument-list itself. */
31951 else
31953 /* Look for the `>' that ends the template-argument-list. If we find
31954 a '>>' instead, it's probably just a typo. */
31956 {
31958 {
31959 /* In C++0x, a `>>' in a template argument list or cast
31960 expression is considered to be two separate `>'
31961 tokens. So, change the current token to a `>', but don't
31962 consume it: it will be consumed later when the outer
31963 template argument list (or cast expression) is parsed.
31964 Note that this replacement of `>' for `>>' is necessary
31965 even if we are parsing tentatively: in the tentative
31966 case, after calling
31967 cp_parser_enclosed_template_argument_list we will always
31968 throw away all of the template arguments and the first
31969 closing `>', either because the template argument list
31970 was erroneous or because we are replacing those tokens
31971 with a CPP_TEMPLATE_ID token. The second `>' (which will
31972 not have been thrown away) is needed either to close an
31973 outer template argument list or to complete a new-style
31974 cast. */
31977 }
31979 {
31980 /* If we're in a nested template argument list, the '>>' has
31981 to be a typo for '> >'. We emit the error message, but we
31982 continue parsing and we push a '>' as next token, so that
31983 the argument list will be parsed correctly. Note that the
31984 global source location is still on the token before the
31985 '>>', so we need to say explicitly where we want it. */
31993 }
31994 else
31995 {
31996 /* If this is not a nested template argument list, the '>>'
31997 is a typo for '>'. Emit an error message and continue.
31998 Same deal about the token location, but here we can get it
31999 right by consuming the '>>' before issuing the diagnostic. */
32002 "spurious %<>>%>, use %<>%> to terminate "
32004 }
32005 }
32006 else
32008 /* The `>' token might be a greater-than operator again now. */
32009 parser->greater_than_is_operator_p
32011 /* Restore the SAVED_SCOPE. */
32017 }
32019 /* MEMBER_FUNCTION is a member function, or a friend. If default
32020 arguments, or the body of the function have not yet been parsed,
32021 parse them now. */
32023 static void
32025 {
32027 /* If this member is a template, get the underlying
32028 FUNCTION_DECL. */
32032 /* There should not be any class definitions in progress at this
32033 point; the bodies of members are only parsed outside of all class
32034 definitions. */
32036 /* While we're parsing the member functions we might encounter more
32037 classes. We want to handle them right away, but we don't want
32038 them getting mixed up with functions that are currently in the
32039 queue. */
32042 /* Make sure that any template parameters are in scope. */
32045 /* If the body of the function has not yet been parsed, parse it
32046 now. */
32048 {
32049 tree function_scope;
32052 /* The function is no longer pending; we are processing it. */
32057 /* If this is a local class, enter the scope of the containing
32058 function. */
32063 /* Push the body of the function onto the lexer stack. */
32066 /* Let the front end know that we going to be defining this
32067 function. */
32071 /* #pragma omp declare reduction needs special parsing. */
32073 {
32078 }
32079 else
32080 /* Now, parse the body of the function. */
32084 /* Leave the scope of the containing function. */
32088 }
32090 /* Remove any template parameters from the symbol table. */
32093 /* Restore the queue. */
32096 }
32098 /* If DECL contains any default args, remember it on the unparsed
32099 functions queue. */
32101 static void
32103 {
32104 tree probe;
32107 probe;
32110 {
32114 }
32116 /* Remember if there is a noexcept-specifier to post process. */
32120 }
32122 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
32123 which is either a FIELD_DECL or PARM_DECL. Parse it and return
32124 the result. For a PARM_DECL, PARMTYPE is the corresponding type
32125 from the parameter-type-list. */
32127 static tree
32130 {
32132 tree parsed_arg;
32138 /* Push the saved tokens for the default argument onto the parser's
32139 lexer stack. */
32145 /* Parse the default argument. */
32156 {
32157 /* In a non-template class, check conversions now. In a template,
32158 we'll wait and instantiate these as needed. */
32161 tf_warning_or_error);
32164 else
32166 }
32168 /* If the token stream has not been completely used up, then
32169 there was extra junk after the end of the default
32170 argument. */
32172 {
32175 else
32177 }
32179 /* Revert to the main lexer. */
32183 }
32185 /* FIELD is a non-static data member with an initializer which we saved for
32186 later; parse it now. */
32188 static void
32190 {
32191 tree def;
32198 NULL_TREE);
32204 }
32206 /* FN is a FUNCTION_DECL which may contains a parameter with an
32207 unparsed DEFERRED_PARSE. Parse the default args now. This function
32208 assumes that the current scope is the scope in which the default
32209 argument should be processed. */
32211 static void
32213 {
32216 /* While we're parsing the default args, we might (due to the
32217 statement expression extension) encounter more classes. We want
32218 to handle them right away, but we don't want them getting mixed
32219 up with default args that are currently in the queue. */
32222 /* Local variable names (and the `this' keyword) may not appear
32223 in a default argument. */
32231 /* Gather the PARM_DECLs into a vec so we can keep track of them when
32232 pushdecl clears DECL_CHAIN. */
32233 releasing_vec parms;
32243 {
32245 tree parsed_arg;
32254 /* This can happen for a friend declaration for a function
32255 already declared with default arguments. */
32258 parsed_arg
32260 default_arg,
32264 /* Update any instantiations we've already created. */
32267 }
32271 /* Restore DECL_CHAINs after clobbering by pushdecl. */
32274 {
32277 }
32281 /* Make sure no default arg is missing. */
32284 /* Restore the state of local_variables_forbidden_p. */
32287 /* Restore the queue. */
32289 }
32291 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
32293 sizeof ... ( identifier )
32295 where the 'sizeof' token has already been consumed. */
32297 static tree
32299 {
32300 /* Consume the `...'. */
32304 matching_parens parens;
32308 else
32316 /* The name is not qualified. */
32335 }
32337 /* Parse the operand of `sizeof' (or a similar operator). Returns
32338 either a TYPE or an expression, depending on the form of the
32339 input. The KEYWORD indicates which kind of expression we have
32340 encountered. */
32342 static tree
32344 {
32351 /* If it's a `...', then we are computing the length of a parameter
32352 pack. */
32357 /* Types cannot be defined in a `sizeof' expression. Save away the
32358 old message. */
32361 parser->type_definition_forbidden_message
32363 parser->type_definition_forbidden_message_arg
32366 /* The restrictions on constant-expressions do not apply inside
32367 sizeof expressions. */
32368 saved_integral_constant_expression_p
32370 saved_non_integral_constant_expression_p
32374 /* Do not actually evaluate the expression. */
32377 /* If it's a `(', then we might be looking at the type-id
32378 construction. */
32380 {
32385 /* We can't be sure yet whether we're looking at a type-id or an
32386 expression. */
32389 matching_parens parens;
32392 /* Note: as a GNU Extension, compound literals are considered
32393 postfix-expressions as they are in C99, so they are valid
32394 arguments to sizeof. See comment in cp_parser_cast_expression
32395 for details. */
32398 else
32399 {
32402 /* Look for the type-id. */
32404 /* Look for the closing `)'. */
32407 }
32409 /* If all went well, then we're done. */
32412 else
32413 {
32414 /* Commit to the tentative_firewall so we get syntax errors. */
32418 }
32419 }
32420 else
32423 /* Go back to evaluating expressions. */
32427 /* And restore the old one. */
32430 parser->integral_constant_expression_p
32432 parser->non_integral_constant_expression_p
32436 }
32438 /* If the current declaration has no declarator, return true. */
32440 static bool
32442 {
32443 /* If the next token is a `;' or a `,' then there is no
32444 declarator. */
32447 }
32449 /* Update the DECL_SPECS to reflect the storage class indicated by
32450 KEYWORD. */
32452 static void
32457 {
32458 cp_storage_class storage_class;
32461 {
32465 }
32467 {
32470 }
32475 {
32478 }
32481 {
32499 }
32503 /* A storage class specifier cannot be applied alongside a typedef
32504 specifier. If there is a typedef specifier present then set
32505 conflicting_specifiers_p which will trigger an error later
32506 on in grokdeclarator. */
32509 }
32511 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
32512 is true, the type is a class or enum definition. */
32514 static void
32516 tree type_spec,
32519 {
32522 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
32523 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
32524 this is what happened. In system headers, we ignore these
32525 declarations so that G++ can work with system headers that are not
32526 C++-safe. */
32528 && !type_definition_p
32539 {
32542 ds_redefined_builtin_type_spec,
32543 token);
32545 {
32549 }
32550 }
32553 else
32554 {
32559 }
32560 }
32562 /* True iff TOKEN is the GNU keyword __thread. */
32564 static bool
32566 {
32569 }
32571 /* Set the location for a declarator specifier and check if it is
32572 duplicated.
32574 DECL_SPECS is the sequence of declarator specifiers onto which to
32575 set the location.
32577 DS is the single declarator specifier to set which location is to
32578 be set onto the existing sequence of declarators.
32580 LOCATION is the location for the declarator specifier to
32581 consider. */
32583 static void
32586 {
32595 {
32599 }
32600 else
32601 {
32603 {
32607 else
32608 {
32611 OPT_Wlong_long,
32613 }
32614 }
32616 {
32620 {
32624 }
32625 else
32626 {
32629 }
32630 }
32631 else
32632 {
32650 "consteval"
32651 };
32655 }
32656 }
32657 }
32659 /* Return true iff the declarator specifier DS is present in the
32660 sequence of declarator specifiers DECL_SPECS. */
32662 bool
32664 cp_decl_spec ds)
32665 {
32672 }
32674 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
32675 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
32677 static bool
32679 {
32681 }
32683 /* Issue an error message indicating that TOKEN_DESC was expected.
32684 If KEYWORD is true, it indicated this function is called by
32685 cp_parser_require_keword and the required token can only be
32686 a indicated keyword.
32688 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
32689 within any error as the location of an "opening" token matching
32690 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
32691 RT_CLOSE_PAREN). */
32693 static void
32695 required_token token_desc,
32697 location_t matching_location)
32698 {
32704 {
32779 }
32782 {
32784 {
32862 }
32863 }
32867 }
32870 /* If the next token is of the indicated TYPE, consume it. Otherwise,
32871 issue an error message indicating that TOKEN_DESC was expected.
32873 Returns the token consumed, if the token had the appropriate type.
32874 Otherwise, returns NULL.
32876 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
32877 within any error as the location of an "opening" token matching
32878 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
32879 RT_CLOSE_PAREN). */
32884 required_token token_desc,
32885 location_t matching_location)
32886 {
32889 else
32890 {
32891 /* Output the MESSAGE -- unless we're parsing tentatively. */
32894 matching_location);
32896 }
32897 }
32899 /* An error message is produced if the next token is not '>'.
32900 All further tokens are skipped until the desired token is
32901 found or '{', '}', ';' or an unbalanced ')' or ']'. */
32903 static void
32905 {
32906 /* Current level of '< ... >'. */
32908 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
32911 /* Are we ready, yet? If not, issue error message. */
32915 /* Skip tokens until the desired token is found. */
32917 {
32918 /* Peek at the next token. */
32920 {
32928 /* C++0x views the `>>' operator as two `>' tokens, but
32929 C++98 does not. */
32932 {
32933 /* We've hit a `>>' where the first `>' closes the
32934 template argument list, and the second `>' is
32935 spurious. Just consume the `>>' and stop; we've
32936 already produced at least one error. */
32939 }
32940 /* Fall through for C++0x, so we handle the second `>' in
32941 the `>>'. */
32946 {
32947 /* We've reached the token we want, consume it and stop. */
32950 }
32969 /* The '>' was probably forgotten, don't look further. */
32974 }
32976 /* Consume this token. */
32978 }
32979 }
32981 /* If the next token is the indicated keyword, consume it. Otherwise,
32982 issue an error message indicating that TOKEN_DESC was expected.
32984 Returns the token consumed, if the token had the appropriate type.
32985 Otherwise, returns NULL. */
32990 required_token token_desc)
32991 {
32995 {
32997 UNKNOWN_LOCATION);
32999 }
33002 }
33004 /* Returns TRUE iff TOKEN is a token that can begin the body of a
33005 function-definition. */
33007 static bool
33009 {
33012 /* A ctor-initializer begins with a `:'. */
33014 /* A function-try-block begins with `try'. */
33016 /* A function-transaction-block begins with `__transaction_atomic'
33017 or `__transaction_relaxed'. */
33020 /* The named return value extension begins with `return'. */
33022 }
33024 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
33025 definition. */
33027 static bool
33029 {
33036 }
33038 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
33039 C++0x) ending a template-argument. */
33041 static bool
33043 {
33051 }
33053 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
33054 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
33056 static bool
33059 {
33065 /* Check for the sequence `<::' in the original code. It would be lexed as
33066 `[:', where `[' is a digraph, and there is no whitespace before
33067 `:'. */
33069 {
33074 }
33076 }
33078 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
33079 or none_type otherwise. */
33081 static enum tag_types
33083 {
33085 {
33095 }
33096 }
33098 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
33099 or none_type otherwise or if the token is null. */
33101 static enum tag_types
33103 {
33108 {
33116 }
33117 }
33119 /* Diagnose redundant enum-keys. */
33121 static void
33124 {
33130 /* Look up the NAME to see if it unambiguously refers to the TYPE. */
33135 /* The enum-key is redundant for uses of the TYPE that are not
33136 declarations and for which name lookup returns just the type
33137 itself. */
33145 {
33146 /* Avoid issuing the diagnostic for apparently redundant (unscoped)
33147 enum tag in shared C/C++ code in files (such as headers) included
33148 in the main source file. */
33151 LRK_MACRO_DEFINITION_LOCATION,
33155 }
33163 }
33165 /* Describes the set of declarations of a struct, class, or class template
33166 or its specializations. Used for -Wmismatched-tags. */
33168 class class_decl_loc_t
33169 {
33174 {
33176 }
33178 /* Constructs an object for a single declaration of a class with
33179 CLASS_KEY at the current location in the current function (or
33180 at another scope). KEY_REDUNDANT is true if the class-key may
33181 be omitted in the current context without an ambiguity with
33182 another symbol with the same name.
33183 DEF_P is true for a class declaration that is a definition.
33184 CURLOC is the associated location. */
33188 {
33191 key_redundant);
33193 }
33195 /* Copy, assign, and destroy the object. Necessary because LOCVEC
33196 isn't safely copyable and assignable and doesn't release storage
33197 on its own. */
33201 { }
33204 {
33212 }
33215 {
33217 }
33219 /* Issues -Wmismatched-tags for a single class. */
33222 /* Issues -Wmismatched-tags for all classes. */
33225 /* Adds TYPE_DECL to the collection of class decls and diagnoses
33226 redundant tags (if -Wredundant-tags is enabled). */
33229 /* Either adds this decl to the collection of class decls
33230 or diagnoses it, whichever is appropriate. */
33236 {
33238 }
33241 {
33243 }
33246 {
33248 }
33251 {
33253 }
33255 /* True if a definition for the class has been seen. */
33257 {
33259 }
33261 /* The location of a single mention of a class type with the given
33262 class-key. */
33263 struct class_key_loc_t
33264 {
33267 { }
33269 /* The function the type is mentioned in. */
33270 tree func;
33271 /* The exact location. */
33272 location_t loc;
33273 /* The class-key used in the mention of the type. */
33274 tag_types class_key;
33275 /* True when the class-key could be omitted at this location
33276 without an ambiguity with another symbol of the same name. */
33278 };
33279 /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
33281 /* LOCVEC index of the definition or UINT_MAX if none exists. */
33283 /* The class-key the class was last declared with or none_type when
33284 it has been declared with a mismatched key. */
33285 tag_types def_class_key;
33287 /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
33288 description above. */
33291 };
33295 /* Issue an error message if the CLASS_KEY does not match the TYPE.
33296 DEF_P is expected to be set for a definition of class TYPE. DECL_P
33297 is set for a declaration of class TYPE and clear for a reference to
33298 it that is not a declaration of it. */
33300 static void
33304 {
33310 {
33314 type))
33318 }
33323 /* Only consider the true class-keys below and ignore typename_type,
33324 etc. that are not C++ class-keys. */
33331 }
33333 /* Returns the template or specialization of one to which the RECORD_TYPE
33334 TYPE corresponds. */
33336 static tree
33338 {
33341 /* Determine the template or its partial specialization to which TYPE
33342 corresponds. */
33351 }
33354 /* Adds the class TYPE to the collection of class decls and diagnoses
33355 redundant tags (if -Wredundant-tags is enabled).
33356 DEF_P is expected to be set for a definition of class TYPE. DECL_P
33357 is set for a (likely, based on syntactic context) declaration of class
33358 TYPE and clear for a reference to it that is not a declaration of it. */
33360 void
33363 {
33366 /* Look up the NAME to see if it unambiguously refers to the TYPE
33367 and set KEY_REDUNDANT if so. */
33372 /* The class-key is redundant for uses of the CLASS_TYPE that are
33373 neither definitions of it nor declarations, and for which name
33374 lookup returns just the type itself. */
33384 {
33385 /* Avoid issuing the diagnostic for apparently redundant struct
33386 and union class-keys in shared C/C++ code in files (such as
33387 headers) included in the main source file. */
33390 LRK_MACRO_DEFINITION_LOCATION,
33394 }
33396 /* Set if a declaration of TYPE has previously been seen or if it must
33397 exist in a precompiled header. */
33401 {
33404 {
33405 /* TYPE_DECL is the first declaration or definition of the type
33406 (outside precompiled headers -- see below). Just create
33407 a new entry for it and return unless it's a declaration
33408 involving a template that may need to be diagnosed by
33409 -Wredundant-tags. */
33413 }
33414 else
33415 {
33416 /* TYPE was previously defined in some unknown precompiled hdeader.
33417 Simply add a record of its definition at an unknown location and
33418 proceed below to add a reference to it at the current location.
33419 (Declarations in precompiled headers that are not definitions
33420 are ignored.) */
33421 tag_types def_key
33426 }
33427 }
33429 /* A prior declaration of TYPE_DECL has been seen. */
33432 {
33439 type);
33440 }
33443 /* Do nothing if this is the first declaration of the type. */
33447 /* Do nothing if the class-key in this declaration matches
33448 the definition. */
33452 def_p);
33453 }
33455 /* Either adds this DECL corresponding to the TYPE_DECL to the collection
33456 of class decls or diagnoses it, whichever is appropriate. */
33458 void
33460 tag_types class_key,
33463 {
33464 /* Reset the CLASS_KEY associated with this type on mismatch.
33465 This is an optimization that lets the diagnostic code skip
33466 over classes that use the same class-key in all declarations. */
33470 /* Set IDXDEF to the index of the vector corresponding to
33471 the definition. */
33475 /* Append a record of this declaration to the vector. */
33477 redundant);
33483 /* As a space optimization diagnose declarations of a class
33484 whose definition has been seen and purge the LOCVEC of
33485 all entries except the definition. */
33488 {
33494 }
33495 else
33496 /* Pop the entry pushed above for this declaration. */
33498 }
33500 /* Issues -Wmismatched-tags for a single class. */
33502 void
33504 {
33508 /* Number of uses of the class. */
33511 /* The class (or template) declaration guiding the decisions about
33512 the diagnostic. For ordinary classes it's the same as THIS. For
33513 uses of instantiations of templates other than their declarations
33514 it points to the record for the declaration of the corresponding
33515 primary template or partial specialization. */
33520 {
33521 /* For implicit instantiations of a primary template look up
33522 the primary or partial specialization and use it as
33523 the expected class-key rather than using the class-key of
33524 the first reference to the instantiation. The primary must
33525 be (and inevitably is) at index zero. */
33529 }
33530 else
33531 {
33532 /* Skip declarations that consistently use the same class-key. */
33535 }
33537 /* Set if a definition for the class has been seen. */
33540 /* The index of the declaration whose class-key this declaration
33541 is expected to match. It's either the class-key of the class
33542 definition if one exists or the first declaration otherwise. */
33545 /* The class-key the class is expected to be declared with: it's
33546 either the key used in its definition or the first declaration
33547 if no definition has been provided.
33548 For implicit instantiations of a primary template it's
33549 the class-key used to declare the primary with. The primary
33550 must be at index zero. */
33554 /* Advance IDX to the first declaration that either is not
33555 a definition or that doesn't match the first declaration
33556 if no definition is provided. */
33561 /* Save the current function before changing it below. */
33563 /* Set the function declaration to print in diagnostic context. */
33571 auto_diagnostic_group d;
33572 /* Issue a warning for the first mismatched declaration.
33573 Avoid using "%#qT" since the class-key for the same type will
33574 be the same regardless of which one was used in the declaraion. */
33578 {
33579 /* Suggest how to avoid the warning for each instance since
33580 the guidance may be different depending on context. */
33582 (key_redundant_p
33585 xpectkstr);
33587 /* Also point to the first declaration or definition that guided
33588 the decision to issue the warning above. */
33590 (def_p
33594 }
33596 /* Issue warnings for the remaining inconsistent declarations. */
33598 {
33600 /* Skip over the declarations that match either the definition
33601 if one was provided or the first declaration. */
33607 /* Set the function declaration to print in diagnostic context. */
33612 /* Suggest how to avoid the warning for each instance since
33613 the guidance may be different depending on context. */
33615 (key_redundant_p
33618 xpectkstr);
33619 }
33621 /* Restore the current function in case it was replaced above. */
33623 }
33625 /* Issues -Wmismatched-tags for all classes. Called at the end
33626 of processing a translation unit, after declarations of all class
33627 types and their uses have been recorded. */
33629 void
33631 {
33632 /* CLASS2LOC should be empty if both -Wmismatched-tags and
33633 -Wredundant-tags are disabled. */
33635 || warn_redundant_tags
33638 /* Save the current function before changing on return. It should
33639 be null at this point. */
33643 {
33644 /* Iterate over the collected class/struct/template declarations. */
33647 {
33651 }
33652 }
33655 }
33657 /* Issue an error message if DECL is redeclared with different
33658 access than its original declaration [class.access.spec/3].
33659 This applies to nested classes, nested class templates and
33660 enumerations [class.mem/1]. */
33662 static void
33664 {
33675 }
33677 /* Look for the `template' keyword, as a syntactic disambiguator.
33678 Return TRUE iff it is present, in which case it will be
33679 consumed. */
33681 static bool
33683 {
33685 {
33686 /* In C++98 the `template' keyword can only be used within templates;
33687 outside templates the parser can always figure out what is a
33688 template and what is not. In C++11, per the resolution of DR 468,
33689 `template' is allowed in cases where it is not strictly necessary. */
33692 {
33695 "in C++98 %<template%> (as a disambiguator) is only "
33697 /* If this part of the token stream is rescanned, the same
33698 error message would be generated. So, we purge the token
33699 from the stream. */
33702 }
33703 else
33704 {
33705 /* Consume the `template' keyword. */
33708 }
33709 }
33711 }
33713 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
33714 set PARSER->SCOPE, and perform other related actions. */
33716 static void
33718 {
33721 /* Get the stored value. */
33723 /* Set the scope from the stored value. */
33728 }
33730 /* Consume tokens up through a non-nested END token. Returns TRUE if we
33731 encounter the end of a block before what we were looking for. */
33733 static bool
33737 {
33739 {
33742 /* Abort a parenthesized expression if we encounter a semicolon. */
33746 /* If we've reached the end of the file, stop. */
33752 /* We've hit the end of an enclosing block, so there's been some
33753 kind of syntax error. */
33756 /* Consume the token. */
33758 /* See if it starts a new group. */
33760 {
33762 /* In theory this should probably check end == '}', but
33763 cp_parser_save_member_function_body needs it to exit
33764 after either '}' or ')' when called with ')'. */
33767 }
33769 {
33773 }
33778 }
33779 }
33781 /* Like above, for caching a default argument or NSDMI. Both of these are
33782 terminated by a non-nested comma, but it can be unclear whether or not a
33783 comma is nested in a template argument list unless we do more parsing.
33784 In order to handle this ambiguity, when we encounter a ',' after a '<'
33785 we try to parse what follows as a parameter-declaration-list (in the
33786 case of a default argument) or a member-declarator (in the case of an
33787 NSDMI). If that succeeds, then we stop caching. */
33789 static tree
33791 {
33796 tree default_argument;
33798 /* Add tokens until we have processed the entire default
33799 argument. We add the range [first_token, token). */
33802 {
33803 /* For list-initialization, this is straightforward. */
33806 }
33808 {
33811 /* Peek at the next token. */
33813 /* What we do depends on what token we have. */
33815 {
33816 /* In valid code, a default argument must be
33817 immediately followed by a `,' `)', or `...'. */
33820 {
33821 /* If we've seen a '<', we might be in a
33822 template-argument-list. Until Core issue 325 is
33823 resolved, we don't know how this situation ought
33824 to be handled, so try to DTRT. We check whether
33825 what comes after the comma is a valid parameter
33826 declaration list. If it is, then the comma ends
33827 the default argument; otherwise the default
33828 argument continues. */
33832 /* Set ITALP so cp_parser_parameter_declaration_list
33833 doesn't decide to commit to this parse. */
33840 {
33841 /* Parse declarators until we reach a non-comma or
33842 somthing that cannot be an initializer.
33843 Just checking whether we're looking at a single
33844 declarator is insufficient. Consider:
33845 int var = tuple<T,U>::x;
33846 The template parameter 'U' looks exactly like a
33847 declarator. */
33848 do
33849 {
33853 CP_PARSER_FLAGS_NONE,
33862 }
33864 /* If we met an '=' or ';' then the original comma
33865 was the end of the NSDMI. Otherwise assume
33866 we're still in the NSDMI. */
33869 }
33870 else
33871 {
33874 tree t = cp_parser_parameter_declaration_list
33879 }
33886 }
33887 /* FALLTHRU */
33890 /* If we run into a non-nested `;', `}', or `]',
33891 then the code is invalid -- but the default
33892 argument is certainly over. */
33897 /* Handle correctly int n = sizeof ... ( p ); */
33900 /* Update DEPTH, if necessary. */
33915 /* This might be the comparison operator, or it might
33916 start a template argument list. */
33923 /* Fall through for C++0x, which treats the `>>'
33924 operator like two `>' tokens in certain
33925 cases. */
33930 {
33931 /* This might be an operator, or it might close a
33932 template argument list. But if a previous '<'
33933 started a template argument list, this will have
33934 closed it, so we can't be in one anymore. */
33938 }
33941 /* If we run out of tokens, issue an error message. */
33949 /* In these cases, we should look for template-ids.
33950 For example, if the default argument is
33951 `X<int, double>()', we need to do name lookup to
33952 figure out whether or not `X' is a template; if
33953 so, the `,' does not end the default argument.
33955 That is not yet done. */
33960 }
33962 /* If we've reached the end, stop. */
33966 /* Add the token to the token block. */
33968 }
33970 /* Create a DEFERRED_PARSE to represent the unparsed default
33971 argument. */
33978 }
33980 /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
33982 location_t
33984 {
33989 }
33991 /* Begin parsing tentatively. We always save tokens while parsing
33992 tentatively so that if the tentative parsing fails we can restore the
33993 tokens. */
33995 static void
33997 {
33998 /* Enter a new parsing context. */
34000 /* Begin saving tokens. */
34002 /* In order to avoid repetitive access control error messages,
34003 access checks are queued up until we are no longer parsing
34004 tentatively. */
34006 }
34008 /* Commit to the currently active tentative parse. */
34010 static void
34012 {
34016 /* Mark all of the levels as committed. */
34019 {
34026 }
34027 }
34029 /* Commit to the topmost currently active tentative parse.
34031 Note that this function shouldn't be called when there are
34032 irreversible side-effects while in a tentative state. For
34033 example, we shouldn't create a permanent entry in the symbol
34034 table, or issue an error message that might not apply if the
34035 tentative parse is aborted. */
34037 static void
34039 {
34044 {
34052 }
34053 }
34055 /* Abort the currently active tentative parse. All consumed tokens
34056 will be rolled back, and no diagnostics will be issued. */
34058 static void
34060 {
34064 /* Now, pretend that we want to see if the construct was
34065 successfully parsed. */
34067 }
34069 /* Stop parsing tentatively. If a parse error has occurred, restore the
34070 token stream. Otherwise, commit to the tokens we have consumed.
34071 Returns true if no error occurred; false otherwise. */
34073 static bool
34075 {
34079 /* Remember whether or not an error occurred, since we are about to
34080 destroy that information. */
34082 /* Remove the topmost context from the stack. */
34085 /* If no parse errors occurred, commit to the tentative parse. */
34087 {
34088 /* Commit to the tokens read tentatively, unless that was
34089 already done. */
34094 }
34095 /* Otherwise, if errors occurred, roll back our state so that things
34096 are just as they were before we began the tentative parse. */
34097 else
34098 {
34101 }
34102 /* Add the context to the front of the free list. */
34107 }
34109 /* Returns true if we are parsing tentatively and are not committed to
34110 this tentative parse. */
34112 static bool
34114 {
34117 }
34119 /* Returns nonzero iff an error has occurred during the most recent
34120 tentative parse. */
34122 static bool
34124 {
34127 }
34129 /* Returns nonzero if GNU extensions are allowed. */
34131 static bool
34133 {
34135 }
34136 \f
34137 /* Objective-C++ Productions */
34140 /* Parse an Objective-C expression, which feeds into a primary-expression
34141 above.
34143 objc-expression:
34144 objc-message-expression
34145 objc-string-literal
34146 objc-encode-expression
34147 objc-protocol-expression
34148 objc-selector-expression
34150 Returns a tree representation of the expression. */
34152 static cp_expr
34154 {
34155 /* Try to figure out what kind of declaration is present. */
34159 {
34169 {
34181 }
34182 /* FALLTHRU */
34188 }
34191 }
34193 /* Parse an Objective-C message expression.
34195 objc-message-expression:
34196 [ objc-message-receiver objc-message-args ]
34198 Returns a representation of an Objective-C message. */
34200 static tree
34202 {
34215 /* Construct a location e.g.
34216 [self func1:5]
34217 ^~~~~~~~~~~~~~
34218 ranging from the '[' to the ']', with the caret at the start. */
34224 }
34226 /* Parse an objc-message-receiver.
34228 objc-message-receiver:
34229 expression
34230 simple-type-specifier
34232 Returns a representation of the type or expression. */
34234 static tree
34236 {
34237 tree rcv;
34239 /* An Objective-C message receiver may be either (1) a type
34240 or (2) an expression. */
34244 /* If that worked out, fine. */
34251 CP_PARSER_FLAGS_NONE);
34258 }
34260 /* Parse the arguments and selectors comprising an Objective-C message.
34262 objc-message-args:
34263 objc-selector
34264 objc-selector-args
34265 objc-selector-args , objc-comma-args
34267 objc-selector-args:
34268 objc-selector [opt] : assignment-expression
34269 objc-selector-args objc-selector [opt] : assignment-expression
34271 objc-comma-args:
34272 assignment-expression
34273 objc-comma-args , assignment-expression
34275 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
34276 selector arguments and TREE_VALUE containing a list of comma
34277 arguments. */
34279 static tree
34281 {
34287 {
34293 /* Detect if we have a unary selector. */
34302 sel_args
34307 }
34309 /* Handle non-selector arguments, if any. */
34311 {
34312 tree arg;
34317 addl_args
34322 }
34325 {
34328 }
34331 }
34333 /* Parse an Objective-C encode expression.
34335 objc-encode-expression:
34336 @encode objc-typename
34338 Returns an encoded representation of the type argument. */
34340 static cp_expr
34342 {
34343 tree type;
34348 matching_parens parens;
34355 {
34359 }
34361 /* This happens if we find @encode(T) (where T is a template
34362 typename or something dependent on a template typename) when
34363 parsing a template. In that case, we can't compile it
34364 immediately, but we rather create an AT_ENCODE_EXPR which will
34365 need to be instantiated when the template is used.
34366 */
34368 {
34372 }
34375 /* Build a location of the form:
34376 @encode(int)
34377 ^~~~~~~~~~~~
34378 with caret==start at the @ token, finishing at the close paren. */
34382 }
34384 /* Parse an Objective-C @defs expression. */
34386 static tree
34388 {
34389 tree name;
34392 matching_parens parens;
34398 }
34400 /* Parse an Objective-C protocol expression.
34402 objc-protocol-expression:
34403 @protocol ( identifier )
34405 Returns a representation of the protocol expression. */
34407 static tree
34409 {
34410 tree proto;
34414 matching_parens parens;
34419 /* Build a location of the form:
34420 @protocol(prot)
34421 ^~~~~~~~~~~~~~~
34422 with caret==start at the @ token, finishing at the close paren. */
34427 }
34429 /* Parse an Objective-C selector expression.
34431 objc-selector-expression:
34432 @selector ( objc-method-signature )
34434 objc-method-signature:
34435 objc-selector
34436 objc-selector-seq
34438 objc-selector-seq:
34439 objc-selector :
34440 objc-selector-seq objc-selector :
34442 Returns a representation of the method selector. */
34444 static tree
34446 {
34453 matching_parens parens;
34459 {
34468 {
34469 /* Detect if we have a unary selector. */
34471 {
34474 }
34475 else
34476 {
34478 }
34479 }
34484 {
34485 sel_seq
34488 sel_seq
34491 }
34492 else
34493 sel_seq
34498 }
34500 finish_selector:
34504 /* Build a location of the form:
34505 @selector(func)
34506 ^~~~~~~~~~~~~~~
34507 with caret==start at the @ token, finishing at the close paren. */
34510 /* TODO: objc_build_selector_expr doesn't always honor the location. */
34513 }
34515 /* Parse a list of identifiers.
34517 objc-identifier-list:
34518 identifier
34519 objc-identifier-list , identifier
34521 Returns a TREE_LIST of identifier nodes. */
34523 static tree
34525 {
34526 tree identifier;
34527 tree list;
34538 {
34545 identifier));
34547 }
34550 }
34552 /* Parse an Objective-C alias declaration.
34554 objc-alias-declaration:
34555 @compatibility_alias identifier identifier ;
34557 This function registers the alias mapping with the Objective-C front end.
34558 It returns nothing. */
34560 static void
34562 {
34570 }
34572 /* Parse an Objective-C class forward-declaration.
34574 objc-class-declaration:
34575 @class objc-identifier-list ;
34577 The function registers the forward declarations with the Objective-C
34578 front end. It returns nothing. */
34580 static void
34582 {
34585 {
34586 tree id;
34596 else
34598 }
34600 }
34602 /* Parse a list of Objective-C protocol references.
34604 objc-protocol-refs-opt:
34605 objc-protocol-refs [opt]
34607 objc-protocol-refs:
34608 < objc-identifier-list >
34610 Returns a TREE_LIST of identifiers, if any. */
34612 static tree
34614 {
34618 {
34622 }
34625 }
34627 /* Parse a Objective-C visibility specification. */
34629 static void
34631 {
34635 {
34650 }
34652 /* Eat '@private'/'@protected'/'@public'. */
34654 }
34656 /* Parse an Objective-C method type. Return 'true' if it is a class
34657 (+) method, and 'false' if it is an instance (-) method. */
34661 {
34664 else
34666 }
34668 /* Parse an Objective-C protocol qualifier. */
34670 static tree
34672 {
34685 {
34690 }
34693 }
34695 /* Parse an Objective-C typename. */
34697 static tree
34699 {
34703 {
34706 matching_parens parens;
34710 /* An ObjC type name may consist of just protocol qualifiers, in which
34711 case the type shall default to 'id'. */
34713 {
34716 /* If the type could not be parsed, an error has already
34717 been produced. For error recovery, behave as if it had
34718 not been specified, which will use the default type
34719 'id'. */
34721 {
34723 /* We need to skip to the closing parenthesis as
34724 cp_parser_type_id() does not seem to do it for
34725 us. */
34730 }
34731 }
34735 }
34738 }
34740 /* Check to see if TYPE refers to an Objective-C selector name. */
34742 static bool
34744 {
34750 }
34752 /* Parse an Objective-C selector. */
34754 static tree
34756 {
34760 {
34763 }
34765 /* C++ operator names are allowed to appear in ObjC selectors. */
34767 {
34780 }
34781 }
34783 /* Parse an Objective-C params list. */
34785 static tree
34787 {
34793 {
34803 /* Detect if we have a unary selector. */
34806 {
34809 }
34813 {
34814 /* Something went quite wrong. There should be a colon
34815 here, but there is not. Stop parsing parameters. */
34817 }
34819 /* New ObjC allows attributes on parameters too. */
34824 params
34827 type_name,
34828 identifier,
34829 parm_attr));
34832 }
34835 {
34838 }
34840 /* We allow tail attributes for the method. */
34842 {
34850 }
34853 {
34856 }
34858 }
34860 /* Parse the non-keyword Objective-C params. */
34862 static tree
34865 {
34871 {
34873 tree parm;
34879 {
34884 }
34886 /* TODO: parse attributes for tail parameters. */
34896 }
34898 /* We allow tail attributes for the method. */
34900 {
34902 {
34907 }
34908 else
34909 /* We have an error, but parse the attributes, so that we can
34910 carry on. */
34916 }
34919 }
34921 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
34923 static void
34925 {
34928 /* If the next token is `extern' and the following token is a string
34929 literal, then we have a linkage specification. */
34931 && cp_parser_is_pure_string_literal
34934 /* Handle #pragma, if any. */
34937 /* Allow stray semicolons. */
34940 /* Mark methods as optional or required, when building protocols. */
34942 {
34945 }
34947 {
34950 }
34953 /* Other stray characters must generate errors. */
34955 {
34959 }
34960 /* Finally, try to parse a block-declaration, or a function-definition. */
34961 else
34963 }
34965 /* Parse a method signature. */
34967 static tree
34969 {
34985 }
34987 static bool
34989 {
34990 tree tattr;
34995 /* If the attributes are followed by a method introducer, this is not allowed.
34996 Dump the attributes and flag the situation. */
35001 /* Otherwise, the attributes introduce some interstitial code, possibly so
35002 rewind to allow that check. */
35005 }
35007 /* Parse an Objective-C method prototype list. */
35009 static void
35011 {
35015 {
35017 {
35022 else
35026 {
35030 }
35033 }
35039 OPT_Wattributes,
35041 else
35042 /* Allow for interspersed non-ObjC++ code. */
35046 }
35050 else
35054 }
35056 /* Parse an Objective-C method definition list. */
35058 static void
35060 {
35062 {
35066 {
35069 }
35071 {
35074 }
35076 {
35080 tree attribute;
35084 else
35085 {
35089 /* For historical reasons, we accept an optional semicolon. */
35095 tree meth
35099 }
35100 }
35101 /* The following case will be removed once @synthesize is
35102 completely implemented. */
35113 else
35114 /* Allow for interspersed non-ObjC++ code. */
35116 }
35119 }
35121 /* Parse Objective-C ivars. */
35123 static void
35125 {
35136 {
35137 cp_decl_specifier_seq declspecs;
35139 tree prefix_attributes;
35147 CP_PARSER_FLAGS_OPTIONAL,
35151 /* auto, register, static, extern, mutable. */
35153 {
35156 }
35158 /* thread_local. */
35160 {
35163 }
35165 /* typedef. */
35167 {
35170 }
35175 /* Keep going until we hit the `;' at the end of the
35176 declaration. */
35178 {
35183 /* Check for a (possibly unnamed) bitfield declaration. */
35191 {
35192 /* Get the name of the bitfield. */
35197 eat_colon:
35199 /* Get the width of the bitfield. */
35200 width
35202 }
35203 else
35204 {
35205 /* Parse the declarator. */
35206 declarator
35208 CP_PARSER_FLAGS_NONE,
35214 }
35216 /* Look for attributes that apply to the ivar. */
35218 /* Remember which attributes are prefix attributes and
35219 which are not. */
35221 /* Combine the attributes. */
35225 /* Create the bitfield declaration. */
35228 else
35233 /* Add the instance variable. */
35237 /* Reset PREFIX_ATTRIBUTES. */
35239 {
35244 }
35249 {
35252 }
35254 }
35258 }
35263 /* Do not consume the RID_AT_END, so it will be read again as terminating
35264 the @interface of @implementation. */
35268 /* For historical reasons, we accept an optional semicolon. */
35271 }
35273 /* Parse an Objective-C protocol declaration. */
35275 static void
35277 {
35283 {
35288 }
35290 /* See if we have a forward declaration or a definition. */
35293 /* Try a forward declaration first. */
35295 {
35297 {
35298 tree id;
35308 else
35310 }
35312 }
35314 /* Ok, we got a full-fledged definition (or at least should). */
35315 else
35316 {
35321 }
35322 }
35324 /* Parse an Objective-C superclass or category. */
35326 static void
35331 {
35337 {
35340 }
35342 {
35343 matching_parens parens;
35346 /* If there is no category name, and this is an @interface, we
35347 have a class extension. */
35349 {
35352 }
35353 else
35357 }
35358 }
35360 /* Parse an Objective-C class interface. */
35362 static void
35364 {
35372 {
35373 /* It's hard to recover because even if valid @interface stuff
35374 is to follow, we can't compile it (or validate it) if we
35375 don't even know which class it refers to. Let's assume this
35376 was a stray '@interface' token in the stream and skip it.
35377 */
35379 }
35384 /* We have either a class or a category on our hands. */
35387 else
35388 {
35390 /* Handle instance variable declarations, if any. */
35393 }
35396 }
35398 /* Parse an Objective-C class implementation. */
35400 static void
35402 {
35409 {
35410 /* It's hard to recover because even if valid @implementation
35411 stuff is to follow, we can't compile it (or validate it) if
35412 we don't even know which class it refers to. Let's assume
35413 this was a stray '@implementation' token in the stream and
35414 skip it.
35415 */
35417 }
35421 /* We have either a class or a category on our hands. */
35424 else
35425 {
35427 /* Handle instance variable declarations, if any. */
35430 }
35433 }
35435 /* Consume the @end token and finish off the implementation. */
35437 static void
35439 {
35442 }
35444 /* Parse an Objective-C declaration. */
35446 static void
35448 {
35449 /* Try to figure out what kind of declaration is present. */
35454 {
35470 }
35473 {
35496 }
35497 }
35499 /* Parse an Objective-C try-catch-finally statement.
35501 objc-try-catch-finally-stmt:
35502 @try compound-statement objc-catch-clause-seq [opt]
35503 objc-finally-clause [opt]
35505 objc-catch-clause-seq:
35506 objc-catch-clause objc-catch-clause-seq [opt]
35508 objc-catch-clause:
35509 @catch ( objc-exception-declaration ) compound-statement
35511 objc-finally-clause:
35512 @finally compound-statement
35514 objc-exception-declaration:
35515 parameter-declaration
35516 '...'
35518 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
35520 Returns NULL_TREE.
35522 PS: This function is identical to c_parser_objc_try_catch_finally_statement
35523 for C. Keep them in sync. */
35525 static tree
35527 {
35528 location_t location;
35529 tree stmt;
35534 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
35535 node, lest it get absorbed into the surrounding block. */
35541 {
35545 matching_parens parens;
35551 {
35552 /* We have "@catch (...)" (where the '...' are literally
35553 what is in the code). Skip the '...'.
35554 parameter_declaration is set to NULL_TREE, and
35555 objc_being_catch_clauses() knows that that means
35556 '...'. */
35559 }
35560 else
35561 {
35562 /* We have "@catch (NSException *exception)" or something
35563 like that. Parse the parameter declaration. */
35568 else
35573 }
35576 else
35577 {
35578 /* If there was no open parenthesis, we are recovering from
35579 an error, and we are trying to figure out what mistake
35580 the user has made. */
35582 /* If there is an immediate closing parenthesis, the user
35583 probably forgot the opening one (ie, they typed "@catch
35584 NSException *e)". Parse the closing parenthesis and keep
35585 going. */
35589 /* If these is no immediate closing parenthesis, the user
35590 probably doesn't know that parenthesis are required at
35591 all (ie, they typed "@catch NSException *e"). So, just
35592 forget about the closing parenthesis and keep going. */
35593 }
35597 }
35599 {
35602 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
35603 node, lest it get absorbed into the surrounding block. */
35607 }
35610 }
35612 /* Parse an Objective-C synchronized statement.
35614 objc-synchronized-stmt:
35615 @synchronized ( expression ) compound-statement
35617 Returns NULL_TREE. */
35619 static tree
35621 {
35622 location_t location;
35629 matching_parens parens;
35634 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
35635 node, lest it get absorbed into the surrounding block. */
35640 }
35642 /* Parse an Objective-C throw statement.
35644 objc-throw-stmt:
35645 @throw assignment-expression [opt] ;
35647 Returns a constructed '@throw' statement. */
35649 static tree
35651 {
35663 }
35665 /* Parse an Objective-C statement. */
35667 static tree
35669 {
35670 /* Try to figure out what kind of declaration is present. */
35674 {
35685 }
35688 }
35690 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
35691 look ahead to see if an objc keyword follows the attributes. This
35692 is to detect the use of prefix attributes on ObjC @interface and
35693 @protocol. */
35695 static bool
35697 {
35702 {
35706 else
35709 }
35712 }
35714 /* This routine is a minimal replacement for
35715 c_parser_struct_declaration () used when parsing the list of
35716 types/names or ObjC++ properties. For example, when parsing the
35717 code
35719 @property (readonly) int a, b, c;
35721 this function is responsible for parsing "int a, int b, int c" and
35722 returning the declarations as CHAIN of DECLs.
35724 TODO: Share this code with cp_parser_objc_class_ivars. It's very
35725 similar parsing. */
35726 static tree
35728 {
35730 cp_decl_specifier_seq declspecs;
35732 tree prefix_attributes;
35735 CP_PARSER_FLAGS_NONE,
35742 /* auto, register, static, extern, mutable. */
35744 {
35747 }
35749 /* thread_local. */
35751 {
35754 }
35756 /* typedef. */
35758 {
35761 }
35766 /* Keep going until we hit the `;' at the end of the declaration. */
35768 {
35773 /* Parse the declarator. */
35775 CP_PARSER_FLAGS_NONE,
35778 /* Look for attributes that apply to the ivar. */
35780 /* Remember which attributes are prefix attributes and
35781 which are not. */
35783 /* Combine the attributes. */
35793 /* Reset PREFIX_ATTRIBUTES. */
35795 {
35800 }
35807 {
35810 }
35811 else
35813 }
35815 }
35817 /* Parse an Objective-C @property declaration. The syntax is:
35819 objc-property-declaration:
35820 '@property' objc-property-attributes[opt] struct-declaration ;
35822 objc-property-attributes:
35823 '(' objc-property-attribute-list ')'
35825 objc-property-attribute-list:
35826 objc-property-attribute
35827 objc-property-attribute-list, objc-property-attribute
35829 objc-property-attribute
35830 'getter' = identifier
35831 'setter' = identifier
35832 'readonly'
35833 'readwrite'
35834 'assign'
35835 'retain'
35836 'copy'
35837 'nonatomic'
35839 For example:
35840 @property NSString *name;
35841 @property (readonly) id object;
35842 @property (retain, nonatomic, getter=getTheName) id name;
35843 @property int a, b, c;
35845 PS: This function is identical to
35846 c_parser_objc_at_property_declaration for C. Keep them in sync. */
35847 static void
35849 {
35850 /* Parse the optional attribute list.
35852 A list of parsed, but not verified, attributes. */
35858 /* Parse the optional attribute list... */
35860 {
35861 /* Eat the '('. */
35862 matching_parens parens;
35867 /* Allow empty @property attribute lists, but with a warning. */
35869 location_t attr_comb;
35871 {
35875 }
35876 else
35878 {
35885 {
35892 }
35903 /* Account for accepting the 'class' keyword in this context. */
35905 else
35909 enum objc_property_attribute_kind prop_kind
35911 property_attribute_info *prop
35915 tree meth_name;
35917 {
35922 attr_name);
35923 else
35931 {
35934 attr_name);
35937 }
35945 {
35948 attr_name);
35951 }
35953 /* Get the end of the method name, and consume the name. */
35956 /* Because method names may contain C++ keywords, we have a
35957 routine to fetch them (this also consumes the token). */
35961 {
35963 {
35965 attr_end);
35969 }
35970 else
35971 {
35975 }
35977 attr_end);
35978 }
35979 else
35981 attr_end);
35983 /* Updated location including all that was successfully
35984 parsed. */
35987 }
35989 /* If we see a comma here, then keep going - even if we already
35990 saw a syntax error. For simple mistakes e.g. (asign, getter=x)
35991 this makes a more useful output and avoid spurious warnings
35992 about missing attributes that are, in fact, specified after the
35993 one with the syntax error. */
35996 else
35998 }
36004 }
36006 /* 'properties' is the list of properties that we read. Usually a
36007 single one, but maybe more (eg, in "@property int a, b, c;" there
36008 are three).
36009 TODO: Update this parsing so that it accepts (erroneous) bitfields so
36010 that we can issue a meaningful and consistent (between C/C++) error
36011 message from objc_add_property_declaration (). */
36018 else
36019 {
36020 /* Comma-separated properties are chained together in reverse order;
36021 add them one by one. */
36025 prop_attr_list);
36026 }
36029 }
36031 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
36033 objc-synthesize-declaration:
36034 @synthesize objc-synthesize-identifier-list ;
36036 objc-synthesize-identifier-list:
36037 objc-synthesize-identifier
36038 objc-synthesize-identifier-list, objc-synthesize-identifier
36040 objc-synthesize-identifier
36041 identifier
36042 identifier = identifier
36044 For example:
36045 @synthesize MyProperty;
36046 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
36048 PS: This function is identical to c_parser_objc_at_synthesize_declaration
36049 for C. Keep them in sync.
36050 */
36051 static void
36053 {
36055 location_t loc;
36060 {
36064 {
36067 }
36069 {
36073 {
36076 }
36077 }
36078 else
36083 else
36085 }
36088 }
36090 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
36092 objc-dynamic-declaration:
36093 @dynamic identifier-list ;
36095 For example:
36096 @dynamic MyProperty;
36097 @dynamic MyProperty, AnotherProperty;
36099 PS: This function is identical to c_parser_objc_at_dynamic_declaration
36100 for C. Keep them in sync.
36101 */
36102 static void
36104 {
36106 location_t loc;
36111 {
36112 tree property;
36115 {
36118 }
36122 else
36124 }
36127 }
36129 \f
36130 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
36132 /* Returns name of the next clause.
36133 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
36134 the token is not consumed. Otherwise appropriate pragma_omp_clause is
36135 returned and the token is consumed. */
36137 static pragma_omp_clause
36139 {
36155 {
36160 {
36371 }
36372 }
36378 }
36380 /* Validate that a clause of the given type does not already exist. */
36382 static void
36385 {
36388 }
36390 /* OpenMP 2.5:
36391 variable-list:
36392 identifier
36393 variable-list , identifier
36395 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
36396 colon). An opening parenthesis will have been consumed by the caller.
36398 If KIND is nonzero, create the appropriate node and install the decl
36399 in OMP_CLAUSE_DECL and add the node to the head of the list.
36401 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
36402 return the list created.
36404 COLON can be NULL if only closing parenthesis should end the list,
36405 or pointer to bool which will receive false if the list is terminated
36406 by closing parenthesis or true if the list is terminated by colon.
36408 The optional ALLOW_DEREF argument is true if list items can use the deref
36409 (->) operator. */
36411 static tree
36415 {
36419 {
36422 }
36424 {
36432 {
36438 }
36442 {
36443 cp_id_kind idk;
36446 }
36447 else
36448 {
36455 {
36460 }
36464 else
36467 {
36473 }
36474 }
36478 ;
36480 {
36482 {
36484 /* The OpenACC cache directive explicitly only allows "array
36485 elements or subarrays". */
36487 {
36491 }
36492 /* FALLTHROUGH. */
36497 || (allow_deref
36499 {
36500 cpp_ttype ttype
36503 location_t loc
36508 decl
36512 }
36513 /* FALLTHROUGH. */
36520 {
36526 {
36528 /* Later handling is not prepared to see through these. */
36530 }
36532 parser->colon_corrects_to_scope_p
36536 else
36537 {
36538 /* Look for `:'. */
36540 {
36545 }
36549 CPP_CLOSE_SQUARE))
36550 {
36552 /* Later handling is not prepared to see through these. */
36554 }
36555 }
36556 /* Look for the closing `]'. */
36558 RT_CLOSE_SQUARE))
36559 {
36564 }
36567 }
36571 }
36574 {
36578 {
36579 depend_lvalue:
36583 }
36584 else
36586 }
36592 }
36593 else
36596 get_comma:
36600 }
36606 {
36610 }
36613 {
36616 /* Try to resync to an unnested comma. Copied from
36617 cp_parser_parenthesized_expression_list. */
36618 skip_comma:
36627 }
36630 }
36632 /* Similarly, but expect leading and trailing parenthesis. This is a very
36633 common case for omp clauses. */
36635 static tree
36638 {
36641 allow_deref);
36643 }
36645 /* OpenACC 2.0:
36646 copy ( variable-list )
36647 copyin ( variable-list )
36648 copyout ( variable-list )
36649 create ( variable-list )
36650 delete ( variable-list )
36651 present ( variable-list )
36653 OpenACC 2.6:
36654 no_create ( variable-list )
36655 attach ( variable-list )
36656 detach ( variable-list ) */
36658 static tree
36660 tree list)
36661 {
36664 {
36706 }
36714 }
36716 /* OpenACC 2.0:
36717 deviceptr ( variable-list ) */
36719 static tree
36721 {
36725 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
36726 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
36727 variable-list must only allow for pointer variables. */
36730 {
36737 }
36740 }
36742 /* OpenACC 2.5:
36743 auto
36744 finalize
36745 independent
36746 nohost
36747 seq */
36749 static tree
36751 tree list)
36752 {
36759 }
36761 /* OpenACC:
36762 num_gangs ( expression )
36763 num_workers ( expression )
36764 vector_length ( expression ) */
36766 static tree
36769 {
36772 matching_parens parens;
36780 {
36785 }
36793 }
36795 /* OpenACC:
36797 gang [( gang-arg-list )]
36798 worker [( [num:] int-expr )]
36799 vector [( [length:] int-expr )]
36801 where gang-arg is one of:
36803 [num:] int-expr
36804 static: size-expr
36806 and size-expr may be:
36808 *
36809 int-expr
36810 */
36812 static tree
36814 omp_clause_code kind,
36816 {
36825 {
36826 matching_parens parens;
36829 do
36830 {
36834 /* Gang static argument. */
36837 {
36845 {
36848 }
36850 /* Check for the '*' argument. */
36854 CPP_CLOSE_PAREN)))
36855 {
36860 {
36863 }
36865 }
36866 }
36867 /* Worker num: argument and vector length: arguments. */
36871 {
36874 }
36876 /* Now collect the actual argument. */
36878 {
36881 }
36893 {
36896 }
36898 }
36903 }
36917 cleanup_error:
36920 }
36922 /* OpenACC 2.0:
36923 tile ( size-expr-list ) */
36925 static tree
36927 {
36931 /* Collapse and tile are mutually exclusive. (The spec doesn't say
36932 so, but the spec authors never considered such a case and have
36933 differing opinions on what it might mean, including 'not
36934 allowed'.) */
36937 clause_loc);
36942 do
36943 {
36950 {
36953 }
36954 else
36958 }
36961 /* Consume the trailing ')'. */
36969 }
36971 /* OpenACC 2.0
36972 Parse wait clause or directive parameters. */
36974 static tree
36976 {
36986 {
36988 {
36991 }
36993 }
37000 {
37004 {
37007 else
37008 {
37015 }
37016 }
37017 }
37020 }
37022 /* OpenACC:
37023 wait [( int-expr-list )] */
37025 static tree
37027 {
37032 else
37033 {
37039 }
37042 }
37044 /* OpenMP 3.0:
37045 collapse ( constant-expression ) */
37047 static tree
37049 {
37051 location_t loc;
37052 HOST_WIDE_INT n;
37055 matching_parens parens;
37073 {
37076 }
37085 }
37087 /* OpenMP 2.5:
37088 default ( none | shared )
37090 OpenMP 5.1:
37091 default ( private | firstprivate )
37093 OpenACC:
37094 default ( none | present ) */
37096 static tree
37099 {
37101 tree c;
37103 matching_parens parens;
37107 {
37110 }
37112 {
37117 {
37144 }
37147 }
37148 else
37149 {
37150 invalid_kind:
37153 else
37156 }
37173 }
37175 /* OpenMP 3.1:
37176 final ( expression ) */
37178 static tree
37180 {
37183 matching_parens parens;
37202 }
37204 /* OpenMP 2.5:
37205 if ( expression )
37207 OpenMP 4.5:
37208 if ( directive-name-modifier : expression )
37210 directive-name-modifier:
37211 parallel | task | taskloop | target data | target | target update
37212 | target enter data | target exit data
37214 OpenMP 5.0:
37215 directive-name-modifier:
37216 ... | simd | cancel */
37218 static tree
37221 {
37225 matching_parens parens;
37230 {
37246 {
37249 {
37262 else
37263 {
37264 location_t loc
37269 }
37272 {
37274 {
37279 }
37281 {
37282 location_t loc
37286 }
37287 }
37288 }
37289 }
37291 {
37293 {
37296 }
37297 else
37298 {
37300 {
37301 location_t loc
37304 }
37306 }
37307 }
37308 }
37320 {
37323 {
37326 {
37338 }
37340 p);
37342 }
37344 {
37347 else
37350 }
37353 {
37357 }
37358 }
37366 }
37368 /* OpenMP 3.1:
37369 mergeable */
37371 static tree
37374 {
37375 tree c;
37378 location);
37383 }
37385 /* OpenMP 2.5:
37386 nowait */
37388 static tree
37391 {
37392 tree c;
37399 }
37401 /* OpenMP 2.5:
37402 num_threads ( expression ) */
37404 static tree
37406 location_t location)
37407 {
37410 matching_parens parens;
37430 }
37432 /* OpenMP 4.5:
37433 num_tasks ( expression )
37435 OpenMP 5.1:
37436 num_tasks ( strict : expression ) */
37438 static tree
37440 location_t location)
37441 {
37444 matching_parens parens;
37451 {
37454 {
37458 }
37459 }
37478 }
37480 /* OpenMP 4.5:
37481 grainsize ( expression )
37483 OpenMP 5.1:
37484 grainsize ( strict : expression ) */
37486 static tree
37488 location_t location)
37489 {
37492 matching_parens parens;
37499 {
37502 {
37506 }
37507 }
37526 }
37528 /* OpenMP 4.5:
37529 priority ( expression ) */
37531 static tree
37533 location_t location)
37534 {
37537 matching_parens parens;
37557 }
37559 /* OpenMP 4.5:
37560 hint ( expression ) */
37562 static tree
37564 {
37567 matching_parens parens;
37574 {
37582 }
37595 }
37597 /* OpenMP 5.1:
37598 filter ( integer-expression ) */
37600 static tree
37602 {
37605 matching_parens parens;
37623 }
37625 /* OpenMP 4.5:
37626 defaultmap ( tofrom : scalar )
37628 OpenMP 5.0:
37629 defaultmap ( implicit-behavior [ : variable-category ] ) */
37631 static tree
37633 location_t location)
37634 {
37638 enum omp_clause_defaultmap_kind category
37641 matching_parens parens;
37648 {
37649 invalid_behavior:
37651 "%<tofrom%>, %<firstprivate%>, %<none%> "
37654 }
37655 else
37656 {
37659 }
37662 {
37666 else
37673 else
37682 else
37689 else
37698 else
37704 }
37708 {
37713 {
37714 invalid_category:
37718 }
37723 {
37727 else
37734 else
37741 else
37747 }
37750 }
37760 {
37767 {
37782 }
37785 p);
37786 else
37790 }
37797 out_err:
37802 }
37804 /* OpenMP 5.0:
37805 order ( concurrent )
37807 OpenMP 5.1:
37808 order ( order-modifier : concurrent )
37810 order-modifier:
37811 reproducible
37812 unconstrained */
37814 static tree
37816 {
37822 matching_parens parens;
37828 {
37835 else
37836 {
37840 }
37843 }
37845 {
37848 }
37849 else
37850 {
37853 }
37855 {
37858 }
37870 out_err:
37875 }
37877 /* OpenMP 5.0:
37878 bind ( teams | parallel | thread ) */
37880 static tree
37882 location_t location)
37883 {
37884 tree c;
37888 matching_parens parens;
37893 {
37894 invalid:
37898 }
37899 else
37900 {
37903 }
37914 /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
37920 out_err:
37925 }
37927 /* OpenMP 2.5:
37928 ordered
37930 OpenMP 4.5:
37931 ordered ( constant-expression ) */
37933 static tree
37936 {
37938 HOST_WIDE_INT n;
37944 {
37945 matching_parens parens;
37962 {
37964 "ordered argument needs positive constant integer "
37967 }
37968 }
37974 }
37976 /* OpenMP 2.5:
37977 reduction ( reduction-operator : variable-list )
37979 reduction-operator:
37980 One of: + * - & ^ | && ||
37982 OpenMP 3.1:
37984 reduction-operator:
37985 One of: + * - & ^ | && || min max
37987 OpenMP 4.0:
37989 reduction-operator:
37990 One of: + * - & ^ | && ||
37991 id-expression
37993 OpenMP 5.0:
37994 reduction ( reduction-modifier, reduction-operator : variable-list )
37995 in_reduction ( reduction-operator : variable-list )
37996 task_reduction ( reduction-operator : variable-list ) */
37998 static tree
38001 {
38011 {
38014 {
38017 }
38020 {
38028 {
38031 }
38032 }
38033 }
38036 {
38046 }
38050 else
38051 {
38062 {
38092 }
38093 else
38094 {
38096 resync_fail:
38101 }
38102 }
38108 NULL);
38110 {
38117 }
38120 }
38122 /* OpenMP 2.5:
38123 schedule ( schedule-kind )
38124 schedule ( schedule-kind , expression )
38126 schedule-kind:
38127 static | dynamic | guided | runtime | auto
38129 OpenMP 4.5:
38130 schedule ( schedule-modifier : schedule-kind )
38131 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
38133 schedule-modifier:
38134 simd
38135 monotonic
38136 nonmonotonic */
38138 static tree
38140 {
38144 matching_parens parens;
38152 {
38161 else
38167 {
38170 }
38171 else
38172 {
38175 }
38176 }
38181 {
38186 {
38207 }
38208 }
38213 else
38219 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
38221 {
38225 }
38228 {
38243 else
38248 }
38260 invalid_kind:
38262 resync_fail:
38267 }
38269 /* OpenMP 3.0:
38270 untied */
38272 static tree
38275 {
38276 tree c;
38283 }
38285 /* OpenMP 4.0:
38286 inbranch
38287 notinbranch */
38289 static tree
38292 {
38297 }
38299 /* OpenMP 4.0:
38300 parallel
38301 for
38302 sections
38303 taskgroup */
38305 static tree
38309 {
38313 }
38315 /* OpenMP 4.5:
38316 nogroup */
38318 static tree
38321 {
38326 }
38328 /* OpenMP 4.5:
38329 simd
38330 threads */
38332 static tree
38336 {
38341 }
38343 /* OpenMP 4.0:
38344 num_teams ( expression )
38346 OpenMP 5.1:
38347 num_teams ( expression : expression ) */
38349 static tree
38351 location_t location)
38352 {
38355 matching_parens parens;
38366 {
38370 }
38387 }
38389 /* OpenMP 4.0:
38390 thread_limit ( expression ) */
38392 static tree
38394 location_t location)
38395 {
38398 matching_parens parens;
38418 }
38420 /* OpenMP 4.0:
38421 aligned ( variable-list )
38422 aligned ( variable-list : constant-expression ) */
38424 static tree
38426 {
38430 matching_parens parens;
38438 {
38448 }
38454 }
38456 /* OpenMP 5.0:
38457 allocate ( variable-list )
38458 allocate ( expression : variable-list )
38460 OpenMP 5.1:
38461 allocate ( allocator-modifier : variable-list )
38462 allocate ( allocator-modifier , allocator-modifier : variable-list )
38464 allocator-modifier:
38465 allocator ( expression )
38466 align ( expression ) */
38468 static tree
38470 {
38474 matching_parens parens;
38484 {
38490 matching_parens parens2;
38494 {
38498 }
38499 else
38500 {
38504 }
38508 {
38511 }
38515 }
38516 else
38519 {
38525 }
38528 {
38535 }
38536 else
38537 {
38541 }
38548 {
38551 }
38554 }
38556 /* OpenMP 2.5:
38557 lastprivate ( variable-list )
38559 OpenMP 5.0:
38560 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
38562 static tree
38564 {
38572 {
38577 {
38581 }
38582 }
38591 }
38593 /* OpenMP 4.0:
38594 linear ( variable-list )
38595 linear ( variable-list : expression )
38597 OpenMP 4.5:
38598 linear ( modifier ( variable-list ) )
38599 linear ( modifier ( variable-list ) : expression ) */
38601 static tree
38604 {
38609 matching_parens parens;
38614 {
38626 else
38628 }
38633 else
38634 {
38643 }
38646 {
38651 {
38662 {
38665 }
38668 }
38679 }
38682 {
38685 }
38688 }
38690 /* OpenMP 4.0:
38691 safelen ( constant-expression ) */
38693 static tree
38695 location_t location)
38696 {
38699 matching_parens parens;
38718 }
38720 /* OpenMP 4.0:
38721 simdlen ( constant-expression ) */
38723 static tree
38725 location_t location)
38726 {
38729 matching_parens parens;
38748 }
38750 /* OpenMP 4.5:
38751 vec:
38752 identifier [+/- integer]
38753 vec , identifier [+/- integer]
38754 */
38756 static tree
38758 tree list)
38759 {
38763 {
38766 }
38769 {
38776 else
38777 {
38778 t = cp_parser_lookup_name_simple
38783 id_loc);
38784 }
38790 {
38793 }
38797 {
38800 }
38804 {
38807 }
38810 add_to_vector:
38812 {
38816 }
38823 }
38826 {
38832 }
38834 }
38836 /* OpenMP 5.0:
38837 detach ( event-handle ) */
38839 static tree
38841 {
38842 matching_parens parens;
38858 else
38859 {
38862 else
38867 }
38880 }
38882 /* OpenMP 5.0:
38883 iterators ( iterators-definition )
38885 iterators-definition:
38886 iterator-specifier
38887 iterator-specifier , iterators-definition
38889 iterator-specifier:
38890 identifier = range-specification
38891 iterator-type identifier = range-specification
38893 range-specification:
38894 begin : end
38895 begin : end : step */
38897 static tree
38899 {
38903 matching_parens parens;
38907 bool saved_colon_corrects_to_scope_p
38909 bool saved_colon_doesnt_start_class_def_p
38912 do
38913 {
38914 tree iter_type;
38918 else
38919 {
38922 parser->type_definition_forbidden_message
38928 }
38932 {
38935 }
38955 {
38958 }
38973 {
38976 }
38978 }
38982 parser->colon_doesnt_start_class_def_p
38992 }
38994 /* OpenMP 5.0:
38995 affinity ( [aff-modifier :] variable-list )
38996 aff-modifier:
38997 iterator ( iterators-definition ) */
38999 static tree
39001 {
39004 matching_parens parens;
39009 {
39014 CPP_OPEN_PAREN)));
39016 {
39019 }
39021 {
39025 {
39033 }
39034 }
39035 }
39039 {
39042 {
39047 }
39048 }
39050 }
39052 /* OpenMP 4.0:
39053 depend ( depend-kind : variable-list )
39055 depend-kind:
39056 in | out | inout
39058 OpenMP 4.5:
39059 depend ( source )
39061 depend ( sink : vec )
39063 OpenMP 5.0:
39064 depend ( depend-modifier , depend-kind: variable-list )
39066 depend-kind:
39067 in | out | inout | mutexinoutset | depobj
39069 depend-modifier:
39070 iterator ( iterators-definition ) */
39072 static tree
39074 {
39078 matching_parens parens;
39082 do
39083 {
39091 {
39096 }
39111 else
39114 }
39121 {
39126 }
39129 {
39139 }
39145 {
39151 }
39152 else
39153 {
39158 {
39162 else
39164 }
39167 {
39172 }
39173 }
39176 invalid_kind:
39178 resync_fail:
39185 }
39187 /* OpenMP 4.0:
39188 map ( map-kind : variable-list )
39189 map ( variable-list )
39191 map-kind:
39192 alloc | to | from | tofrom
39194 OpenMP 4.5:
39195 map-kind:
39196 alloc | to | from | tofrom | release | delete
39198 map ( always [,] map-kind: variable-list )
39200 OpenMP 5.0:
39201 map ( [map-type-modifier[,] ...] map-kind: variable-list )
39203 map-type-modifier:
39204 always | close */
39206 static tree
39208 {
39219 {
39221 {
39224 }
39227 pos++;
39228 pos++;
39229 }
39234 {
39237 {
39240 }
39244 {
39246 {
39253 }
39255 }
39257 {
39259 {
39266 }
39268 }
39269 else
39270 {
39272 "modifier other than %<always%> or %<close%>"
39279 }
39282 }
39286 {
39300 else
39301 {
39307 }
39310 }
39313 {
39317 }
39320 NULL);
39326 }
39328 /* OpenMP 4.0:
39329 device ( expression )
39331 OpenMP 5.0:
39332 device ( [device-modifier :] integer-expression )
39334 device-modifier:
39335 ancestor | device_num */
39337 static tree
39339 location_t location)
39340 {
39344 matching_parens parens;
39350 {
39354 {
39357 /* A requires directive with the reverse_offload clause must be
39358 specified. */
39360 {
39362 "preceded by %<requires%> directive "
39366 }
39367 }
39369 ;
39370 else
39371 {
39375 }
39378 }
39397 }
39399 /* OpenMP 4.0:
39400 dist_schedule ( static )
39401 dist_schedule ( static , expression ) */
39403 static tree
39405 location_t location)
39406 {
39409 matching_parens parens;
39420 {
39431 }
39435 /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
39436 "dist_schedule", location); */
39442 invalid_kind:
39444 resync_fail:
39449 }
39451 /* OpenMP 4.0:
39452 proc_bind ( proc-bind-kind )
39454 proc-bind-kind:
39455 primary | master | close | spread
39456 where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
39458 static tree
39460 location_t location)
39461 {
39462 tree c;
39469 {
39481 else
39483 }
39484 else
39493 location);
39498 invalid_kind:
39500 resync_fail:
39505 }
39507 /* OpenMP 5.0:
39508 device_type ( host | nohost | any ) */
39510 static tree
39512 location_t location)
39513 {
39514 tree c;
39521 {
39531 else
39533 }
39534 else
39542 /* check_no_duplicate_clause (list, OMP_CLAUSE_DEVICE_TYPE, "device_type",
39543 location); */
39548 invalid_kind:
39550 resync_fail:
39555 }
39557 /* OpenACC:
39558 async [( int-expr )] */
39560 static tree
39562 {
39569 {
39570 matching_parens parens;
39579 }
39589 }
39591 /* Parse all OpenACC clauses. The set clauses allowed by the directive
39592 is a bitmask in MASK. Return the list of clauses found. */
39594 static tree
39598 {
39602 /* Don't create location wrapper nodes within OpenACC clauses. */
39603 auto_suppress_location_wrappers sentinel;
39606 {
39607 location_t here;
39608 pragma_omp_clause c_kind;
39609 omp_clause_code code;
39620 {
39627 clauses);
39680 clauses);
39685 clauses);
39703 clauses);
39708 clauses);
39721 clauses);
39728 clauses);
39734 clauses);
39742 clauses);
39746 clauses
39753 clauses);
39762 clauses);
39768 OMP_CLAUSE_VECTOR,
39775 clauses);
39784 OMP_CLAUSE_WORKER,
39790 }
39795 {
39796 /* Remove the invalid clause(s) from the list to avoid
39797 confusing the rest of the compiler. */
39800 }
39801 }
39803 saw_error:
39810 }
39812 /* Parse all OpenMP clauses. The set clauses allowed by the directive
39813 is a bitmask in MASK. Return the list of clauses found.
39814 FINISH_P set if finish_omp_clauses should be called.
39815 NESTED non-zero if clauses should be terminated by closing paren instead
39816 of end of pragma. If it is 2, additionally commas are required in between
39817 the clauses. */
39819 static tree
39823 {
39828 /* Don't create location wrapper nodes within OpenMP clauses. */
39829 auto_suppress_location_wrappers sentinel;
39832 {
39833 pragma_omp_clause c_kind;
39841 /* OpenMP 5.1 allows optional comma in between directive-name and
39842 clauses everywhere, but as we aren't done with OpenMP 5.0
39843 implementation yet, let's allow it for now only in C++11
39844 attributes. */
39846 {
39851 "clauses in %<simd%> trait should be separated "
39853 }
39859 {
39876 clauses);
39895 clauses);
39915 clauses);
39920 clauses);
39925 clauses);
39934 clauses
39980 clauses);
39984 clauses
39996 clauses);
40000 clauses
40002 OMP_CLAUSE_TASK_REDUCTION,
40018 clauses);
40023 OMP_CLAUSE_NOTINBRANCH,
40032 {
40033 clause_not_first:
40037 }
40067 clauses);
40068 else
40078 clauses);
40100 {
40105 }
40161 clauses
40167 clauses
40175 }
40180 {
40181 /* Remove the invalid clause(s) from the list to avoid
40182 confusing the rest of the compiler. */
40185 }
40186 }
40187 saw_error:
40191 {
40194 else
40196 }
40198 }
40200 /* OpenMP 2.5:
40201 structured-block:
40202 statement
40204 In practice, we're also interested in adding the statement to an
40205 outer node. So it is convenient if we work around the fact that
40206 cp_parser_statement calls add_stmt. */
40208 static unsigned
40210 {
40213 /* Only move the values to IN_OMP_BLOCK if they weren't false.
40214 This preserves the "not within loop or switch" style error messages
40215 for nonsense cases like
40216 void foo() {
40217 #pragma omp single
40218 break;
40219 }
40220 */
40225 }
40227 static void
40229 {
40231 }
40233 static tree
40235 {
40244 }
40246 /* OpenMP 5.0:
40247 # pragma omp allocate (list) [allocator(allocator)] */
40249 static void
40251 {
40256 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
40263 {
40264 matching_parens parens;
40272 {
40277 }
40278 }
40286 }
40288 /* OpenMP 2.5:
40289 # pragma omp atomic new-line
40290 expression-stmt
40292 expression-stmt:
40293 x binop= expr | x++ | ++x | x-- | --x
40294 binop:
40295 +, *, -, /, &, ^, |, <<, >>
40297 where x is an lvalue expression with scalar type.
40299 OpenMP 3.1:
40300 # pragma omp atomic new-line
40301 update-stmt
40303 # pragma omp atomic read new-line
40304 read-stmt
40306 # pragma omp atomic write new-line
40307 write-stmt
40309 # pragma omp atomic update new-line
40310 update-stmt
40312 # pragma omp atomic capture new-line
40313 capture-stmt
40315 # pragma omp atomic capture new-line
40316 capture-block
40318 read-stmt:
40319 v = x
40320 write-stmt:
40321 x = expr
40322 update-stmt:
40323 expression-stmt | x = x binop expr
40324 capture-stmt:
40325 v = expression-stmt
40326 capture-block:
40327 { v = x; update-stmt; } | { update-stmt; v = x; }
40329 OpenMP 4.0:
40330 update-stmt:
40331 expression-stmt | x = x binop expr | x = expr binop x
40332 capture-stmt:
40333 v = update-stmt
40334 capture-block:
40335 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
40337 OpenMP 5.1:
40338 # pragma omp atomic compare new-line
40339 conditional-update-atomic
40341 # pragma omp atomic compare capture new-line
40342 conditional-update-capture-atomic
40344 conditional-update-atomic:
40345 cond-expr-stmt | cond-update-stmt
40346 cond-expr-stmt:
40347 x = expr ordop x ? expr : x;
40348 x = x ordop expr ? expr : x;
40349 x = x == e ? d : x;
40350 cond-update-stmt:
40351 if (expr ordop x) { x = expr; }
40352 if (x ordop expr) { x = expr; }
40353 if (x == e) { x = d; }
40354 ordop:
40355 <, >
40356 conditional-update-capture-atomic:
40357 v = cond-expr-stmt
40358 { v = x; cond-expr-stmt }
40359 { cond-expr-stmt v = x; }
40360 { v = x; cond-update-stmt }
40361 { cond-update-stmt v = x; }
40362 if (x == e) { x = d; } else { v = x; }
40363 { r = x == e; if (r) { x = d; } }
40364 { r = x == e; if (r) { x = d; } else { v = x; } }
40366 where x, r and v are lvalue expressions with scalar type,
40367 expr, e and d are expressions with scalar type and e might be
40368 the same as v. */
40370 static void
40372 {
40389 {
40390 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
40399 {
40404 enum omp_memory_order new_memory_order
40420 {
40424 }
40432 {
40433 matching_parens parens;
40440 {
40450 }
40453 {
40457 else
40459 }
40460 else
40470 }
40482 {
40486 }
40487 else
40488 {
40491 "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
40492 "%<seq_cst%>, %<acq_rel%>, %<release%>, "
40494 }
40496 {
40498 {
40499 /* OpenACC permits 'update capture'. */
40506 else
40508 }
40510 {
40513 else
40515 }
40517 {
40520 else
40522 }
40524 {
40527 else
40529 }
40531 {
40534 else
40536 }
40539 }
40540 }
40542 }
40548 {
40552 else
40554 }
40556 {
40560 }
40562 {
40565 }
40567 {
40570 }
40574 {
40575 omp_requires_mask
40580 {
40590 {
40600 }
40604 }
40605 }
40606 else
40608 {
40611 {
40615 }
40621 {
40625 }
40631 }
40633 memory_order
40638 {
40648 else
40653 {
40654 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
40655 opcode. */
40660 }
40664 {
40667 }
40671 else
40672 {
40680 {
40684 }
40685 }
40688 }
40690 restart:
40692 {
40695 matching_parens parens;
40699 tree cmp_expr;
40702 else
40710 {
40716 }
40718 ;
40720 {
40724 }
40727 {
40729 "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
40732 }
40743 {
40746 }
40751 else
40764 {
40766 {
40769 }
40771 {
40776 }
40777 else
40779 }
40784 {
40789 }
40790 else
40791 {
40792 bad_if:
40796 }
40799 {
40803 {
40807 }
40835 /* Signal to c_finish_omp_atomic that in
40836 if (x == e) { x = d; } else { v = x; }
40837 case the store to v should be conditional. */
40839 }
40841 {
40844 }
40850 }
40854 {
40861 /* FALLTHROUGH */
40873 /* FALLTHROUGH */
40890 /* Undo effects of boolean_increment for post {in,de}crement. */
40892 /* FALLTHRU */
40896 {
40897 /* Undo effects of boolean_increment. */
40899 {
40900 /* This is pre or post increment. */
40905 && !structured_block
40911 }
40912 }
40913 /* FALLTHRU */
40916 {
40919 }
40921 {
40956 {
40960 }
40963 {
40969 {
40974 }
40976 {
40990 {
40992 {
40997 }
40998 else
41000 }
41005 || !structured_block
41006 || v
41012 {
41014 {
41020 }
41021 }
41029 {
41033 cond_expr:
41035 bool saved_colon_corrects_to_scope_p
41039 parser->colon_corrects_to_scope_p
41044 {
41046 {
41048 {
41052 }
41054 {
41055 opcode
41059 }
41060 }
41061 else
41062 {
41065 {
41066 opcode
41071 }
41072 }
41073 }
41075 "invalid form of "
41078 }
41082 }
41087 {
41094 }
41098 }
41102 {
41105 {
41113 }
41115 {
41120 }
41164 }
41167 {
41169 "invalid form of "
41172 }
41183 {
41185 {
41187 "invalid form of "
41190 }
41192 }
41198 }
41205 }
41206 stmt_done:
41208 {
41221 }
41223 {
41227 }
41228 done:
41230 {
41233 }
41241 invalid_compare:
41243 /* FALLTHRU */
41244 saw_error:
41249 {
41253 {
41257 }
41258 }
41259 }
41262 /* OpenMP 2.5:
41263 # pragma omp barrier new-line */
41265 static void
41267 {
41270 }
41272 /* OpenMP 2.5:
41273 # pragma omp critical [(name)] new-line
41274 structured-block
41276 OpenMP 4.5:
41277 # pragma omp critical [(name) [hint(expression)]] new-line
41278 structured-block */
41280 #define OMP_CRITICAL_CLAUSE_MASK \
41281 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
41283 static tree
41285 {
41289 {
41290 matching_parens parens;
41306 }
41313 }
41315 /* OpenMP 5.0:
41316 # pragma omp depobj ( depobj ) depobj-clause new-line
41318 depobj-clause:
41319 depend (dependence-type : locator)
41320 destroy
41321 update (dependence-type)
41323 dependence-type:
41324 in
41325 out
41326 inout
41327 mutexinout */
41329 static void
41331 {
41333 matching_parens parens;
41335 {
41338 }
41350 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
41355 {
41361 {
41362 /* Don't create location wrapper nodes within the depend clause. */
41363 auto_suppress_location_wrappers sentinel;
41369 }
41373 {
41374 matching_parens c_parens;
41376 {
41377 location_t c2_loc
41380 {
41393 }
41395 {
41399 }
41405 }
41406 else
41408 }
41409 }
41411 {
41414 }
41418 }
41421 /* OpenMP 2.5:
41422 # pragma omp flush flush-vars[opt] new-line
41424 flush-vars:
41425 ( variable-list )
41427 OpenMP 5.0:
41428 # pragma omp flush memory-order-clause new-line */
41430 static void
41432 {
41434 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
41440 {
41451 else
41453 "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
41456 }
41458 {
41461 "%<flush%> list specified together with memory order "
41464 }
41468 }
41470 /* Helper function, to parse omp for increment expression. */
41472 static tree
41474 {
41479 {
41482 }
41485 {
41497 }
41499 /* If decl is an iterator, preserve LHS and RHS of the relational
41500 expr until finish_omp_for. */
41511 }
41513 /* Helper function, to parse omp for increment expression. */
41515 static tree
41517 {
41521 cp_id_kind idk;
41525 {
41534 }
41543 {
41548 }
41555 {
41559 }
41572 do
41573 {
41580 {
41582 {
41585 else
41587 tf_warning_or_error);
41588 }
41589 else
41592 }
41593 }
41597 {
41603 }
41604 else
41608 }
41610 /* Parse the initialization statement of an OpenMP for loop.
41612 Return true if the resulting construct should have an
41613 OMP_CLAUSE_PRIVATE added to it. */
41615 static tree
41623 {
41629 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
41631 init-expr:
41632 var = lb
41633 integer-type var = lb
41634 random-access-iterator-type var = lb
41635 pointer-type var = lb
41636 */
41637 cp_decl_specifier_seq type_specifiers;
41639 /* First, try to parse as an initialized declaration. See
41640 cp_parser_condition, from whence the bulk of this is copied. */
41648 {
41649 /* If parsing a type specifier seq succeeded, then this
41650 MUST be a initialized declaration. */
41655 CP_PARSER_DECLARATOR_NAMED,
41656 CP_PARSER_FLAGS_NONE,
41668 else
41669 {
41679 {
41681 CPP_OPEN_PAREN))
41684 else
41685 /* Trigger an error. */
41690 }
41694 {
41702 {
41705 auto_node);
41710 }
41713 asm_specification,
41714 LOOKUP_ONLYCONVERTING);
41717 {
41720 }
41721 else
41722 {
41725 {
41727 /* Move lambda DECL_EXPRs to FOR_BLOCK. */
41729 {
41733 {
41737 }
41739 }
41741 {
41746 }
41747 }
41748 }
41750 }
41751 else
41752 {
41753 /* Consume '='. */
41757 non_class:
41760 else
41763 asm_specification,
41764 LOOKUP_ONLYCONVERTING);
41765 }
41769 }
41770 }
41771 else
41772 {
41773 cp_id_kind idk;
41774 /* If parsing a type specifier sequence failed, then
41775 this MUST be a simple expression. */
41781 && decl
41784 {
41795 {
41800 }
41805 }
41807 && decl
41810 {
41811 tree rhs;
41819 rhs,
41820 tf_warning_or_error));
41823 }
41824 else
41825 {
41830 {
41834 }
41835 }
41836 }
41838 }
41840 /* Helper for cp_parser_omp_for_loop, handle one range-for loop. */
41842 void
41846 {
41851 {
41855 /* do_auto_deduction doesn't mess with template init-lists. */
41857 {
41860 {
41866 }
41868 }
41875 }
41880 /* If an error happened previously do nothing or else a lot of
41881 unhelpful errors would be issued. */
41883 else
41884 {
41885 tree range_temp;
41889 /* Can't bind a reference to an array of runtime bound. */
41891 else
41892 {
41898 LOOKUP_ONLYCONVERTING);
41901 }
41904 }
41915 LOOKUP_ONLYCONVERTING);
41917 /* The new for initialization statement. */
41925 else
41926 {
41929 }
41932 LOOKUP_ONLYCONVERTING);
41934 /* The new for condition. */
41937 else
41943 /* The new increment expression. */
41946 else
41949 tf_warning_or_error);
41954 {
41957 }
41962 {
41967 {
41972 }
41973 }
41977 {
41979 tf_none);
41983 }
41990 {
41993 }
41995 }
41997 /* Helper for cp_parser_omp_for_loop, finalize part of range for
41998 inside of the collapsed body. */
42000 void
42002 {
42010 {
42014 }
42016 /* The declaration is initialized with *__begin inside the loop body. */
42019 tf_warning_or_error),
42021 LOOKUP_ONLYCONVERTING);
42024 }
42026 /* Return true if next tokens contain a standard attribute that contains
42027 omp::directive (DIRECTIVE). */
42029 static bool
42032 {
42040 {
42047 }
42052 location_t last_loc
42061 {
42063 {
42067 cnt++;
42071 {
42075 }
42076 }
42077 }
42079 {
42082 }
42084 {
42086 "%<[[omp::directive(%s)]]%> must be the only specified "
42090 }
42095 }
42097 /* Parse an OpenMP structured block sequence. KIND is the corresponding
42098 separating directive. */
42100 static tree
42103 {
42109 {
42122 kind == PRAGMA_OMP_SCAN
42127 }
42131 }
42134 /* OpenMP 5.0:
42136 scan-loop-body:
42137 { structured-block scan-directive structured-block } */
42139 static void
42141 {
42144 matching_braces braces;
42154 {
42164 {
42171 }
42173 {
42176 }
42177 else
42182 }
42183 else
42189 clauses);
42193 }
42195 /* Parse the restricted form of the for statement allowed by OpenMP. */
42197 static tree
42200 {
42202 tree orig_decl;
42205 location_t loc_first;
42208 releasing_vec for_block;
42217 {
42220 }
42223 {
42226 }
42233 {
42239 }
42241 {
42244 {
42246 "%<linear%> clause may not be specified together "
42249 }
42250 else
42252 }
42266 {
42269 location_t loc;
42272 {
42276 }
42279 /* Don't create location wrapper nodes within an OpenMP "for"
42280 statement. */
42281 auto_suppress_location_wrappers sentinel;
42283 matching_parens parens;
42291 {
42292 /* Save tokens so that we can put them back. */
42295 /* Look for ':' that is not nested in () or {}. */
42296 bool is_range_for
42299 CPP_COLON,
42300 /*consume_paren=*/
42303 /* Roll back the tokens we skipped. */
42307 {
42308 bool saved_colon_corrects_to_scope_p
42311 /* A colon is used in range-based for. */
42314 /* Parse the declaration. */
42316 /*function_definition_allowed_p=*/
42318 parser->colon_corrects_to_scope_p
42330 {
42332 {
42338 }
42339 else
42341 }
42345 "%<ordered%> clause with parameter on "
42349 }
42350 }
42352 add_private_clause
42358 {
42361 {
42367 }
42368 else
42370 }
42378 {
42383 {
42387 }
42390 {
42391 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
42395 {
42398 }
42399 else
42400 {
42403 }
42405 }
42406 else
42407 {
42412 }
42413 }
42416 {
42417 tree c;
42419 {
42428 decl);
42433 decl);
42434 }
42436 {
42441 else
42446 {
42449 /* For linear, signal that we need to fill up
42450 the so far unknown linear step. */
42453 }
42454 }
42455 }
42464 {
42465 /* If decl is an iterator, preserve the operator on decl
42466 until finish_omp_for. */
42468 && ((processing_template_decl
42473 else
42476 }
42478 parse_close_paren:
42489 {
42492 }
42494 {
42498 }
42505 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
42506 in between the collapsed for loops to be still considered perfectly
42507 nested. Hopefully the final version clarifies this.
42508 For now handle (multiple) {'s and empty statements. */
42511 {
42515 {
42517 bracecount++;
42518 }
42522 else
42523 {
42530 }
42531 }
42534 {
42537 }
42538 }
42543 /* Note that we saved the original contents of this flag when we entered
42544 the structured block, and so we don't need to re-save it here. */
42547 /* Note that the grammar doesn't call for a structured block here,
42548 though the loop as a whole is a structured block. */
42550 {
42556 }
42557 else
42561 else
42565 else
42570 else
42575 {
42577 {
42579 nbraces--;
42580 }
42583 else
42584 {
42586 {
42589 }
42594 }
42595 }
42598 {
42602 else
42604 }
42607 }
42609 /* Helper function for OpenMP parsing, split clauses and call
42610 finish_omp_clauses on each of the set of clauses afterwards. */
42612 static void
42615 {
42621 i == C_OMP_CLAUSE_SPLIT_TARGET
42623 }
42625 /* OpenMP 5.0:
42626 #pragma omp loop loop-clause[optseq] new-line
42627 for-loop */
42629 #define OMP_LOOP_CLAUSE_MASK \
42630 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
42631 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
42632 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
42633 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
42634 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
42635 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
42637 static tree
42641 {
42652 {
42655 }
42667 }
42669 /* OpenMP 4.0:
42670 #pragma omp simd simd-clause[optseq] new-line
42671 for-loop */
42673 #define OMP_SIMD_CLAUSE_MASK \
42674 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
42675 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
42676 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
42677 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
42678 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
42679 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
42680 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
42681 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
42682 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
42683 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
42684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
42686 static tree
42690 {
42701 {
42705 OMP_CLAUSE_ORDERED);
42707 {
42709 "%<ordered%> clause with parameter may not be specified "
42712 }
42713 }
42725 }
42727 /* OpenMP 2.5:
42728 #pragma omp for for-clause[optseq] new-line
42729 for-loop
42731 OpenMP 4.0:
42732 #pragma omp for simd for-simd-clause[optseq] new-line
42733 for-loop */
42735 #define OMP_FOR_CLAUSE_MASK \
42736 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
42737 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
42738 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
42739 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
42740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
42741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
42742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
42743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
42744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
42745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
42746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
42748 static tree
42752 {
42759 /* parallel for{, simd} disallows nowait clause, but for
42760 target {teams distribute ,}parallel for{, simd} it should be accepted. */
42763 /* Composite distribute parallel for{, simd} disallows ordered clause. */
42768 {
42773 {
42797 }
42798 }
42800 {
42803 }
42805 /* Composite distribute parallel for disallows linear clause. */
42812 {
42815 }
42827 }
42832 /* OpenMP 2.5:
42833 # pragma omp master new-line
42834 structured-block */
42836 static tree
42840 {
42848 {
42853 {
42873 }
42874 }
42876 {
42879 }
42882 {
42886 }
42887 else
42892 }
42894 /* OpenMP 5.1:
42895 # pragma omp masked masked-clauses new-line
42896 structured-block */
42898 #define OMP_MASKED_CLAUSE_MASK \
42899 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
42901 static tree
42905 {
42914 {
42919 {
42940 }
42941 }
42943 {
42946 }
42951 {
42954 }
42958 clauses);
42959 }
42961 /* OpenMP 2.5:
42962 # pragma omp ordered new-line
42963 structured-block
42965 OpenMP 4.5:
42966 # pragma omp ordered ordered-clauses new-line
42967 structured-block */
42969 #define OMP_ORDERED_CLAUSE_MASK \
42970 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
42971 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
42973 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
42974 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
42976 static bool
42979 {
42983 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
42989 {
42994 {
42996 {
42999 }
43001 {
43003 "%<depend%> clause may only be used in compound "
43007 }
43008 tree clauses
43010 OMP_ORDERED_DEPEND_CLAUSE_MASK,
43014 }
43015 }
43017 tree clauses
43028 }
43030 /* OpenMP 2.5:
43032 section-scope:
43033 { section-sequence }
43035 section-sequence:
43036 section-directive[opt] structured-block
43037 section-sequence section-directive structured-block */
43039 static tree
43041 {
43046 matching_braces braces;
43053 != PRAGMA_OMP_SECTION
43055 {
43057 PRAGMA_OMP_SECTION);
43060 }
43063 {
43073 {
43077 }
43079 {
43082 }
43085 PRAGMA_OMP_SECTION);
43088 }
43099 }
43101 /* OpenMP 2.5:
43102 # pragma omp sections sections-clause[optseq] newline
43103 sections-scope */
43105 #define OMP_SECTIONS_CLAUSE_MASK \
43106 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43107 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43108 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43109 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43110 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43111 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43113 static tree
43116 {
43128 {
43131 }
43138 }
43140 /* OpenMP 2.5:
43141 # pragma omp parallel parallel-clause[optseq] new-line
43142 structured-block
43143 # pragma omp parallel for parallel-for-clause[optseq] new-line
43144 structured-block
43145 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
43146 structured-block
43148 OpenMP 4.0:
43149 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
43150 structured-block */
43152 #define OMP_PARALLEL_CLAUSE_MASK \
43153 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43154 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43155 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43156 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
43157 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43158 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
43159 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43160 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
43161 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43162 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
43164 static tree
43168 {
43175 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
43181 {
43189 if_p);
43193 if_p);
43196 block);
43201 }
43202 /* When combined with distribute, parallel has to be followed by for.
43203 #pragma omp target parallel is allowed though. */
43207 {
43211 }
43213 {
43217 {
43231 block);
43234 /* masked does have just filter clause, but during gimplification
43235 isn't represented by a gimplification omp context, so for
43236 #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
43237 so that
43238 #pragma omp parallel masked
43239 #pragma omp taskloop simd lastprivate (x)
43240 isn't confused with
43241 #pragma omp parallel masked taskloop simd lastprivate (x) */
43245 }
43247 {
43261 block);
43264 /* master doesn't have any clauses and during gimplification
43265 isn't represented by a gimplification omp context, so for
43266 #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
43267 so that
43268 #pragma omp parallel master
43269 #pragma omp taskloop simd lastprivate (x)
43270 isn't confused with
43271 #pragma omp parallel master taskloop simd lastprivate (x) */
43275 }
43277 {
43292 block);
43297 }
43299 {
43302 }
43304 {
43314 block);
43317 }
43318 }
43320 {
43323 }
43328 {
43331 }
43340 }
43342 /* OpenMP 2.5:
43343 # pragma omp single single-clause[optseq] new-line
43344 structured-block */
43346 #define OMP_SINGLE_CLAUSE_MASK \
43347 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43348 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43349 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
43350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43353 static tree
43355 {
43366 }
43368 /* OpenMP 5.1:
43369 # pragma omp scope scope-clause[optseq] new-line
43370 structured-block */
43372 #define OMP_SCOPE_CLAUSE_MASK \
43373 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43374 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43375 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43377 static tree
43379 {
43390 }
43392 /* OpenMP 3.0:
43393 # pragma omp task task-clause[optseq] new-line
43394 structured-block */
43396 #define OMP_TASK_CLAUSE_MASK \
43397 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43398 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
43399 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
43400 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43401 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43402 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43403 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
43404 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
43405 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
43406 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
43407 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43408 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
43409 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
43410 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
43412 static tree
43414 {
43426 }
43428 /* OpenMP 3.0:
43429 # pragma omp taskwait new-line
43431 OpenMP 5.0:
43432 # pragma omp taskwait taskwait-clause[opt] new-line */
43434 #define OMP_TASKWAIT_CLAUSE_MASK \
43435 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
43437 static void
43439 {
43440 tree clauses
43445 {
43452 }
43453 else
43455 }
43457 /* OpenMP 3.1:
43458 # pragma omp taskyield new-line */
43460 static void
43462 {
43465 }
43467 /* OpenMP 4.0:
43468 # pragma omp taskgroup new-line
43469 structured-block
43471 OpenMP 5.0:
43472 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
43474 #define OMP_TASKGROUP_CLAUSE_MASK \
43475 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43476 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
43478 static tree
43480 {
43481 tree clauses
43486 if_p),
43487 clauses);
43488 }
43491 /* OpenMP 2.5:
43492 # pragma omp threadprivate (variable-list) */
43494 static void
43496 {
43497 tree vars;
43503 }
43505 /* OpenMP 4.0:
43506 # pragma omp cancel cancel-clause[optseq] new-line */
43508 #define OMP_CANCEL_CLAUSE_MASK \
43509 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
43510 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
43511 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
43512 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
43513 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
43515 static void
43517 {
43521 }
43523 /* OpenMP 4.0:
43524 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
43526 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
43527 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
43528 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
43529 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
43530 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
43532 static bool
43535 {
43536 tree clauses;
43540 {
43545 {
43548 }
43549 }
43551 {
43555 }
43558 {
43563 else
43567 }
43570 OMP_CANCELLATION_POINT_CLAUSE_MASK,
43572 pragma_tok);
43575 }
43577 /* OpenMP 4.0:
43578 #pragma omp distribute distribute-clause[optseq] new-line
43579 for-loop */
43581 #define OMP_DISTRIBUTE_CLAUSE_MASK \
43582 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43583 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43584 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43585 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
43586 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43587 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
43588 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
43590 static tree
43594 {
43603 {
43611 else
43614 {
43620 {
43624 else
43627 }
43633 else
43647 }
43648 }
43650 {
43653 }
43658 {
43661 }
43673 }
43675 /* OpenMP 4.0:
43676 # pragma omp teams teams-clause[optseq] new-line
43677 structured-block */
43679 #define OMP_TEAMS_CLAUSE_MASK \
43680 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43681 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43682 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43683 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
43685 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
43686 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43687 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
43689 static tree
43693 {
43702 {
43706 {
43732 }
43734 {
43760 }
43761 }
43763 {
43766 }
43771 {
43774 }
43784 }
43786 /* OpenMP 4.0:
43787 # pragma omp target data target-data-clause[optseq] new-line
43788 structured-block */
43790 #define OMP_TARGET_DATA_CLAUSE_MASK \
43791 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
43792 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
43793 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43794 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
43795 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
43797 static tree
43799 {
43800 tree clauses
43806 {
43809 {
43827 "%<#pragma omp target data%> with map-type other "
43828 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
43832 }
43837 }
43840 {
43843 "%<#pragma omp target data%> must contain at least "
43844 "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
43847 }
43858 }
43860 /* OpenMP 4.5:
43861 # pragma omp target enter data target-enter-data-clause[optseq] new-line
43862 structured-block */
43864 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
43865 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
43866 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
43867 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43868 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
43869 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43871 static bool
43874 {
43877 {
43882 {
43885 }
43886 }
43888 {
43892 }
43895 {
43901 }
43903 tree clauses
43909 {
43912 {
43926 "%<#pragma omp target enter data%> with map-type other "
43930 }
43932 }
43935 {
43938 "%<#pragma omp target enter data%> must contain at least "
43941 }
43949 }
43951 /* OpenMP 4.5:
43952 # pragma omp target exit data target-enter-data-clause[optseq] new-line
43953 structured-block */
43955 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
43956 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
43957 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
43958 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43959 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
43960 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43962 static bool
43965 {
43968 {
43973 {
43976 }
43977 }
43979 {
43983 }
43986 {
43992 }
43994 tree clauses
44000 {
44003 {
44018 "%<#pragma omp target exit data%> with map-type other "
44019 "than %<from%>, %<release%> or %<delete%> on %<map%>"
44023 }
44025 }
44028 {
44031 "%<#pragma omp target exit data%> must contain at least "
44034 }
44042 }
44044 /* OpenMP 4.0:
44045 # pragma omp target update target-update-clause[optseq] new-line */
44047 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
44048 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
44049 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
44050 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44051 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44052 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44053 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44055 static bool
44058 {
44060 {
44066 }
44068 tree clauses
44073 {
44075 "%<#pragma omp target update%> must contain at least one "
44078 }
44086 }
44088 /* OpenMP 4.0:
44089 # pragma omp target target-clause[optseq] new-line
44090 structured-block */
44092 #define OMP_TARGET_CLAUSE_MASK \
44093 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44094 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44095 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44096 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44097 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
44098 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
44099 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
44100 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
44101 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44102 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
44103 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
44104 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR))
44106 static bool
44109 {
44113 omp_requires_mask
44117 {
44129 {
44137 {
44138 tree stmt;
44140 {
44143 OMP_TARGET_CLAUSE_MASK,
44148 OMP_TARGET_CLAUSE_MASK,
44153 OMP_TARGET_CLAUSE_MASK,
44158 }
44160 }
44165 {
44169 if_p);
44174 if_p);
44179 if_p);
44183 }
44189 /* For combined target teams, ensure the num_teams and
44190 thread_limit clause expressions are evaluated on the host,
44191 before entering the target construct. */
44200 {
44203 tf_none);
44210 OMP_CLAUSE_FIRSTPRIVATE);
44215 }
44226 }
44228 {
44231 }
44233 {
44237 }
44239 {
44242 }
44244 {
44247 }
44249 {
44252 }
44253 }
44255 {
44258 }
44268 {
44274 }
44286 check_clauses:
44288 {
44291 {
44306 "%<#pragma omp target%> with map-type other "
44307 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
44311 }
44313 }
44315 }
44317 /* OpenACC 2.0:
44318 # pragma acc cache (variable-list) new-line
44319 */
44321 static tree
44323 {
44324 /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
44325 clauses. */
44326 auto_suppress_location_wrappers sentinel;
44342 }
44344 /* OpenACC 2.0:
44345 # pragma acc data oacc-data-clause[optseq] new-line
44346 structured-block */
44348 #define OACC_DATA_CLAUSE_MASK \
44349 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44353 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44354 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
44355 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44356 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44357 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44358 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
44360 static tree
44362 {
44375 }
44377 /* OpenACC 2.0:
44378 # pragma acc host_data <clauses> new-line
44379 structured-block */
44381 #define OACC_HOST_DATA_CLAUSE_MASK \
44382 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
44383 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44384 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
44386 static tree
44388 {
44401 }
44403 /* OpenACC 2.0:
44404 # pragma acc declare oacc-data-clause[optseq] new-line
44405 */
44407 #define OACC_DECLARE_CLAUSE_MASK \
44408 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44409 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44410 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44411 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44412 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44413 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
44414 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
44415 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
44417 static tree
44419 {
44429 {
44433 }
44436 {
44440 {
44444 }
44447 {
44459 {
44461 "%qD must be a global variable in "
44463 decl);
44466 }
44471 {
44475 }
44477 {
44479 "invalid use of %<extern%> variable %qD "
44483 }
44485 {
44487 "invalid use of %<global%> variable %qD "
44491 }
44493 }
44496 /* This seems to ignore the existence of cleanup scopes?
44497 What is the meaning for local extern decls? The local
44498 extern is in this scope, but it is referring to a decl that
44499 is namespace scope. */
44502 {
44505 }
44507 {
44509 "%qD must be a variable declared in the same scope as "
44513 }
44518 {
44523 }
44526 {
44527 tree id;
44530 /* We need to mark the aliased decl, as that is the entity
44531 that is being referred to. This won't work for
44532 dependent variables, but it didn't work for them before
44533 DECL_LOCAL_DECL_P was a thing either. But then
44534 dependent local extern variable decls are as rare as
44535 hen's teeth. */
44542 else
44548 {
44551 {
44554 {
44558 }
44559 }
44560 }
44561 }
44562 }
44575 }
44577 /* OpenACC 2.0:
44578 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
44580 or
44582 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
44584 LOC is the location of the #pragma token.
44585 */
44587 #define OACC_ENTER_DATA_CLAUSE_MASK \
44588 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44589 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44590 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44591 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44592 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44593 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44595 #define OACC_EXIT_DATA_CLAUSE_MASK \
44596 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44597 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44598 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44599 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
44600 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
44601 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
44602 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44604 static tree
44607 {
44616 {
44621 }
44628 else
44633 {
44637 }
44645 }
44647 /* OpenACC 2.0:
44648 # pragma acc loop oacc-loop-clause[optseq] new-line
44649 structured-block */
44651 #define OACC_LOOP_CLAUSE_MASK \
44652 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
44653 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
44654 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
44655 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
44656 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
44657 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
44658 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
44659 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
44660 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
44661 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
44663 static tree
44666 {
44675 {
44681 }
44690 }
44692 /* OpenACC 2.0:
44693 # pragma acc kernels oacc-kernels-clause[optseq] new-line
44694 structured-block
44696 or
44698 # pragma acc parallel oacc-parallel-clause[optseq] new-line
44699 structured-block
44701 OpenACC 2.6:
44703 # pragma acc serial oacc-serial-clause[optseq] new-line
44704 */
44706 #define OACC_KERNELS_CLAUSE_MASK \
44707 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44708 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44709 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44710 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44711 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44712 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44713 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
44714 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44715 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44716 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44717 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
44718 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
44719 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
44720 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
44721 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44723 #define OACC_PARALLEL_CLAUSE_MASK \
44724 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44725 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44726 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44727 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44728 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44729 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44730 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
44731 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44732 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
44733 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44734 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44735 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
44736 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
44737 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
44738 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
44739 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
44740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
44741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44743 #define OACC_SERIAL_CLAUSE_MASK \
44744 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
44751 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44752 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44753 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44754 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
44755 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
44756 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
44757 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
44758 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
44760 static tree
44763 {
44764 omp_clause_mask mask;
44767 {
44785 }
44788 {
44792 {
44795 tree clauses;
44800 }
44801 }
44810 }
44812 /* OpenACC 2.0:
44813 # pragma acc update oacc-update-clause[optseq] new-line
44814 */
44816 #define OACC_UPDATE_CLAUSE_MASK \
44817 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
44818 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
44819 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
44820 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44821 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
44822 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
44824 static tree
44826 {
44833 {
44835 "%<#pragma acc update%> must contain at least one "
44838 }
44846 }
44848 /* OpenACC 2.0:
44849 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
44851 LOC is the location of the #pragma token.
44852 */
44854 #define OACC_WAIT_CLAUSE_MASK \
44855 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
44857 static tree
44859 {
44873 }
44875 /* OpenMP 4.0:
44876 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
44878 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
44879 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
44880 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
44881 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
44882 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
44883 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
44884 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
44886 static void
44890 {
44892 cp_omp_declare_simd_data data;
44894 {
44902 /* It is safe to take the address of a local variable; it will only be
44903 used while this scope is live. */
44905 }
44907 {
44909 "%<#pragma omp declare %s%> followed by "
44914 }
44916 /* Store away all pragma tokens. */
44925 {
44929 {
44942 }
44947 "%<#pragma omp declare %s%> not immediately followed by "
44952 }
44953 }
44965 /* OpenMP 5.0:
44967 trait-selector:
44968 trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
44970 trait-score:
44971 score(score-expression) */
44973 static tree
44975 {
44977 do
44978 {
44979 tree selector;
44983 else
44984 {
44987 }
44998 {
45025 }
45027 {
45029 {
45031 {
45034 }
45035 else
45036 {
45042 }
45043 }
45048 }
45058 {
45060 {
45064 }
45066 matching_parens parens;
45074 {
45081 {
45085 matching_parens parens2;
45093 {
45105 else
45108 }
45109 }
45110 else
45114 }
45117 {
45118 tree t;
45120 do
45121 {
45124 {
45132 "constant integer expression or string "
45134 else
45136 }
45137 else
45142 else
45144 }
45150 {
45154 }
45155 else
45156 {
45159 }
45162 do
45163 {
45167 {
45170 }
45173 else
45174 {
45178 }
45184 else
45186 }
45192 {
45199 else
45201 }
45202 else
45207 {
45209 "selector may not be specified in "
45212 }
45213 properties
45215 OMP_DECLARE_SIMD_CLAUSE_MASK,
45220 }
45226 }
45230 {
45233 }
45239 else
45241 }
45245 }
45247 /* OpenMP 5.0:
45249 trait-set-selector[,trait-set-selector[,...]]
45251 trait-set-selector:
45252 trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
45254 trait-set-selector-name:
45255 constructor
45256 device
45257 implementation
45258 user */
45260 static tree
45263 {
45265 do
45266 {
45269 setp
45272 {
45291 }
45293 {
45297 }
45305 matching_braces braces;
45309 tree selectors
45312 {
45315 }
45323 else
45325 }
45331 }
45333 /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
45334 that into "omp declare variant base" attribute. */
45336 static tree
45338 tree attrs)
45339 {
45340 matching_parens parens;
45342 {
45343 fail:
45346 }
45351 cp_expr varid
45359 tree variant;
45366 else
45367 {
45368 tree ambiguous_decls;
45376 }
45380 {
45382 variant
45390 }
45396 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45407 {
45410 }
45422 {
45424 match_loc);
45433 }
45438 }
45441 /* Finalize #pragma omp declare simd clauses after direct declarator has
45442 been parsed, and put that into "omp declare simd" attribute. */
45444 static tree
45446 {
45452 {
45457 }
45462 {
45473 {
45474 /* For now only in C++ attributes, do it always for OpenMP 5.1.
45475 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
45476 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
45477 cp_lexer_consume_token (parser->lexer); */
45481 pragma_tok);
45489 }
45490 else
45491 {
45493 attrs
45495 }
45497 }
45501 {
45507 {
45509 {
45516 {
45524 else
45527 }
45533 {
45535 "unknown OpenMP directive name in "
45538 }
45542 {
45544 "OpenMP directive other than %<declare simd%> "
45545 "or %<declare variant%> appertains to a "
45548 }
45551 {
45553 "mixing OpenMP directives with attribute and "
45556 }
45561 {
45564 }
45566 cp_token tok = {};
45574 tok = {};
45579 tok = {};
45591 /* Move the current source position to that of the first token
45592 in the new lexer. */
45602 {
45610 pragma_tok);
45614 cl);
45619 }
45620 else
45621 {
45623 attrs
45625 attrs);
45626 }
45629 }
45631 }
45632 else
45634 }
45640 }
45642 /* Helper for cp_parser_omp_declare_target, handle one to or link clause
45643 on #pragma omp declare target. Return false if errors were reported. */
45645 static bool
45647 {
45650 tree id;
45652 {
45655 }
45656 else
45659 {
45661 "%qD specified both in declare target %<link%> and %<to%>"
45664 }
45666 {
45673 {
45676 {
45680 }
45681 }
45682 }
45686 {
45690 {
45693 }
45694 }
45696 {
45700 {
45703 }
45704 }
45706 }
45708 /* OpenMP 4.0:
45709 # pragma omp declare target new-line
45710 declarations and definitions
45711 # pragma omp end declare target new-line
45713 OpenMP 4.5:
45714 # pragma omp declare target ( extended-list ) new-line
45716 # pragma omp declare target declare-target-clauses[seq] new-line */
45718 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
45719 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
45720 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
45721 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE))
45723 static void
45725 {
45730 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45734 clauses
45738 {
45740 clauses);
45743 }
45744 else
45745 {
45746 struct omp_declare_target_attr a
45751 }
45756 {
45769 device_type);
45770 }
45774 }
45776 static void
45778 {
45782 {
45785 }
45787 {
45791 {
45794 }
45797 else
45798 {
45802 }
45803 }
45804 else
45805 {
45809 }
45813 "%<#pragma omp end declare target%> without corresponding "
45815 else
45816 {
45817 omp_declare_target_attr
45820 {
45823 "%<declare target%> in attribute syntax terminated "
45825 else
45827 "%<declare target%> in pragma syntax terminated "
45829 }
45830 }
45831 }
45833 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
45834 expression and optional initializer clause of
45835 #pragma omp declare reduction. We store the expression(s) as
45836 either 3, 6 or 7 special statements inside of the artificial function's
45837 body. The first two statements are DECL_EXPRs for the artificial
45838 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
45839 expression that uses those variables.
45840 If there was any INITIALIZER clause, this is followed by further statements,
45841 the fourth and fifth statements are DECL_EXPRs for the artificial
45842 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
45843 constructor variant (first token after open paren is not omp_priv),
45844 then the sixth statement is a statement with the function call expression
45845 that uses the OMP_PRIV and optionally OMP_ORIG variable.
45846 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
45847 to initialize the OMP_PRIV artificial variable and there is seventh
45848 statement, a DECL_EXPR of the OMP_PRIV statement again. */
45850 static bool
45852 {
45864 tree combiner;
45879 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45887 {
45890 }
45893 {
45895 matching_parens parens;
45901 {
45904 }
45920 {
45924 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
45928 == CPP_CLOSE_PAREN
45931 {
45935 }
45940 }
45941 else
45942 {
45944 /* Don't create location wrapper nodes here. */
45945 auto_suppress_location_wrappers sentinel;
45960 {
45965 }
45967 tree arg;
45980 }
45993 }
45997 UNKNOWN_LOCATION);
46000 }
46002 /* OpenMP 4.0
46003 #pragma omp declare reduction (reduction-id : typename-list : expression) \
46004 initializer-clause[opt] new-line
46006 initializer-clause:
46007 initializer (omp_priv initializer)
46008 initializer (function-name (argument-list)) */
46010 static void
46013 {
46023 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
46030 {
46062 }
46074 /* Types may not be defined in declare reduction type list. */
46077 parser->type_definition_forbidden_message
46083 saved_colon_doesnt_start_class_def_p
46088 {
46092 ;
46110 else
46115 else
46117 }
46119 /* Restore the saved message. */
46122 parser->colon_doesnt_start_class_def_p
46127 {
46128 fail:
46131 }
46137 {
46138 tree fntype
46141 NULL_TREE);
46158 {
46162 }
46168 {
46171 }
46173 {
46175 {
46181 }
46188 }
46189 else
46190 {
46193 /* We should never meet a matched duplicate decl. */
46195 }
46200 else
46203 {
46206 }
46214 else
46215 {
46219 }
46224 {
46232 }
46240 }
46244 done:
46245 /* Free any declarators allocated. */
46247 }
46249 /* OpenMP 4.0
46250 #pragma omp declare simd declare-simd-clauses[optseq] new-line
46251 #pragma omp declare reduction (reduction-id : typename-list : expression) \
46252 initializer-clause[opt] new-line
46253 #pragma omp declare target new-line
46255 OpenMP 5.0
46256 #pragma omp declare variant (identifier) match (context-selector) */
46258 static bool
46261 {
46263 {
46268 {
46273 }
46275 {
46280 }
46283 {
46286 context);
46288 }
46290 {
46293 }
46295 {
46299 }
46300 }
46305 }
46307 /* OpenMP 5.0
46308 #pragma omp requires clauses[optseq] new-line */
46310 static bool
46312 {
46318 {
46319 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46328 {
46343 {
46346 matching_parens parens;
46348 {
46350 {
46355 this_req
46358 this_req
46361 this_req
46363 }
46365 {
46367 "expected %<seq_cst%>, %<relaxed%> or "
46370 {
46377 CPP_CLOSE_PAREN))
46380 }
46381 }
46382 else
46389 /*consume_paren=*/
46393 {
46396 }
46397 }
46399 }
46400 else
46401 {
46403 "%<unified_shared_memory%>, "
46404 "%<dynamic_allocators%>, "
46405 "%<reverse_offload%> "
46409 }
46416 {
46418 {
46425 }
46427 {
46431 }
46434 {
46437 this_req
46439 (omp_requires_mask
46441 }
46445 "lexically after first %<atomic%> construct "
46448 omp_requires_mask
46451 }
46452 }
46454 }
46460 }
46463 /* OpenMP 5.1:
46464 #pragma omp nothing new-line */
46466 static void
46468 {
46470 }
46473 /* OpenMP 5.1
46474 #pragma omp error clauses[optseq] new-line */
46476 static bool
46479 {
46488 {
46489 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46505 };
46513 {
46516 }
46518 {
46523 }
46527 matching_parens parens;
46529 {
46531 {
46535 else
46537 tf_warning_or_error,
46538 LOOKUP_NORMAL);
46539 }
46540 else
46541 {
46543 {
46551 }
46553 {
46558 {
46565 CPP_CLOSE_PAREN))
46568 }
46569 }
46570 else
46572 }
46578 /*consume_paren=*/
46582 {
46584 {
46587 }
46588 else
46590 }
46592 {
46594 {
46597 }
46598 else
46600 }
46601 }
46602 else
46604 }
46614 {
46616 {
46620 }
46621 tree fndecl
46630 }
46637 {
46641 }
46645 else
46649 }
46651 /* OpenMP 4.5:
46652 #pragma omp taskloop taskloop-clause[optseq] new-line
46653 for-loop
46655 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
46656 for-loop */
46658 #define OMP_TASKLOOP_CLAUSE_MASK \
46659 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46660 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46661 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46662 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46663 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
46664 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
46665 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
46666 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46667 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
46668 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46669 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
46670 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
46671 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
46672 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
46673 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46674 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46675 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
46677 static tree
46681 {
46688 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
46689 clause. */
46694 {
46699 {
46723 }
46724 }
46726 {
46729 }
46734 {
46737 }
46744 if_p);
46750 }
46753 /* OpenACC 2.0:
46754 # pragma acc routine oacc-routine-clause[optseq] new-line
46755 function-definition
46757 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
46758 */
46760 #define OACC_ROUTINE_CLAUSE_MASK \
46761 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
46762 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
46763 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
46764 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
46765 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
46767 /* Parse the OpenACC routine pragma. This has an optional '( name )'
46768 component, which must resolve to a declared namespace-scope
46769 function. The clauses are either processed directly (for a named
46770 function), or defered until the immediatley following declaration
46771 is parsed. */
46773 static void
46776 {
46778 /* The checking for "another pragma following this one" in the "no optional
46779 '( name )'" case makes sure that we dont re-enter. */
46782 cp_oacc_routine_data data;
46788 /* It is safe to take the address of a local variable; it will only be
46789 used while this scope is live. */
46792 /* Look for optional '( name )'. */
46794 {
46795 matching_parens parens;
46798 /* We parse the name as an id-expression. If it resolves to
46799 anything other than a non-overloaded function at namespace
46800 scope, it's an error. */
46816 {
46820 }
46822 data.clauses
46826 /* The clauses are in reverse order; fix that to make later diagnostic
46827 emission easier. */
46833 {
46838 }
46840 /* Perhaps we should use the same rule as declarations in different
46841 namespaces? */
46843 {
46848 }
46851 {
46855 }
46859 }
46861 {
46862 /* Store away all pragma tokens. */
46870 /* Emit a helpful diagnostic if there's another pragma following this
46871 one. */
46873 {
46876 /* ..., and then just keep going. */
46878 }
46880 /* We only have to consider the pragma_external case here. */
46885 else
46888 }
46889 }
46891 /* Finalize #pragma acc routine clauses after direct declarator has
46892 been parsed. */
46894 static tree
46896 {
46901 {
46903 "%<#pragma acc routine%> not immediately followed by "
46906 }
46922 /* The clauses are in reverse order; fix that to make later diagnostic
46923 emission easier. */
46926 /* Later, cp_finalize_oacc_routine will process the clauses. */
46930 }
46932 /* Apply any saved OpenACC routine clauses to a just-parsed
46933 declaration. */
46935 static void
46937 {
46939 {
46940 /* Keep going if we're in error reporting mode. */
46946 {
46948 {
46950 "%<#pragma acc routine%> not immediately followed by"
46954 }
46958 }
46960 int compatible
46965 {
46968 }
46970 {
46971 }
46972 else
46973 {
46975 {
46984 }
46986 /* Set the routine's level of parallelism. */
46990 /* Add an "omp declare target" attribute. */
46995 }
46996 }
46997 }
46999 /* Main entry point to OpenMP statement pragmas. */
47001 static void
47003 {
47004 tree stmt;
47009 {
47037 if_p);
47057 if_p);
47062 if_p);
47067 if_p);
47072 if_p);
47077 if_p);
47082 if_p);
47094 if_p);
47108 if_p);
47113 if_p);
47117 }
47120 }
47121 \f
47122 /* Transactional Memory parsing routines. */
47124 /* Parse a transaction attribute.
47126 txn-attribute:
47127 attribute
47128 [ [ identifier ] ]
47130 We use this instead of cp_parser_attributes_opt for transactions to avoid
47131 the pedwarn in C++98 mode. */
47133 static tree
47135 {
47150 {
47154 /* For keywords, use the canonical spelling,
47155 not the parsed identifier. */
47159 }
47160 else
47164 error1:
47167 }
47169 /* Parse a __transaction_atomic or __transaction_relaxed statement.
47171 transaction-statement:
47172 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
47173 compound-statement
47174 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
47175 */
47177 static tree
47179 {
47190 else
47191 {
47195 }
47197 /* Parse a noexcept specification. */
47201 {
47202 /* cancel-and-throw is unimplemented. */
47205 }
47206 else
47208 CP_PARSER_FLAGS_NONE,
47213 /* Keep track if we're in the lexical scope of an outer transaction. */
47225 }
47227 /* Parse a __transaction_atomic or __transaction_relaxed expression.
47229 transaction-expression:
47230 __transaction_atomic txn-noexcept-spec[opt] ( expression )
47231 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
47232 */
47234 static tree
47236 {
47249 keyword == RID_TRANSACTION_RELAXED
47263 /* Set this early. This might mean that we allow transaction_cancel in
47264 an expression that we find out later actually has to be a constexpr.
47265 However, we expect that cxx_constant_value will be able to deal with
47266 this; also, if the noexcept has no constexpr, then what we parse next
47267 really is a transaction's body. */
47270 /* Parse a noexcept specification. */
47272 CP_PARSER_FLAGS_NONE,
47279 {
47280 matching_parens parens;
47287 }
47288 else
47289 {
47290 /* The only expression that is available got parsed for the noexcept
47291 already. noexcept is true then. */
47294 }
47303 }
47305 /* Parse a function-transaction-block.
47307 function-transaction-block:
47308 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
47309 function-body
47310 __transaction_atomic txn-attribute[opt] function-try-block
47311 __transaction_relaxed ctor-initializer[opt] function-body
47312 __transaction_relaxed function-try-block
47313 */
47315 static void
47317 {
47332 else
47333 {
47337 }
47345 else
47346 cp_parser_ctor_initializer_opt_and_function_body
47352 }
47354 /* Parse a __transaction_cancel statement.
47356 cancel-statement:
47357 __transaction_cancel txn-attribute[opt] ;
47358 __transaction_cancel txn-attribute[opt] throw-expression ;
47360 ??? Cancel and throw is not yet implemented. */
47362 static tree
47364 {
47370 RT_TRANSACTION_CANCEL);
47377 /* ??? Parse cancel-and-throw here. */
47382 {
47386 }
47388 {
47392 }
47394 {
47397 {
47403 }
47404 }
47406 {
47410 }
47416 }
47417 \f
47418 /* The parser. */
47422 \f
47423 /* Special handling for the first token or line in the file. The first
47424 thing in the file might be #pragma GCC pch_preprocess, which loads a
47425 PCH file, which is a GC collection point. So we need to handle this
47426 first pragma without benefit of an existing lexer structure.
47428 Always returns one token to the caller in *FIRST_TOKEN. This is
47429 either the true first token of the file, or the first token after
47430 the initial pragma. */
47432 static void
47434 {
47442 {
47446 }
47448 /* Skip to the end of the pragma. */
47450 {
47453 do
47456 }
47458 /* Now actually load the PCH file. */
47462 /* Read one more token to return to our caller. We have to do this
47463 after reading the PCH file in, since its pointers have to be
47464 live. */
47466 }
47468 /* Parse a pragma GCC ivdep. */
47470 static bool
47472 {
47475 }
47477 /* Parse a pragma GCC unroll. */
47479 static unsigned short
47481 {
47491 {
47493 " assignment-expression that evaluates to a non-negative"
47496 }
47497 else
47498 {
47502 }
47505 }
47507 /* Normal parsing of a pragma token. Here we can (and must) use the
47508 regular lexer. */
47510 static bool
47512 {
47515 tree stmt;
47526 {
47534 {
47545 }
47550 {
47561 }
47566 {
47577 }
47582 {
47594 }
47599 {
47611 }
47616 {
47628 }
47647 {
47653 }
47661 {
47667 }
47675 {
47680 }
47686 {
47692 }
47700 {
47706 }
47747 {
47749 "%<#pragma omp requires%> may only be used at file or "
47753 }
47785 "%<#pragma omp scan%> may only be used in "
47791 "%<#pragma omp section%> may only be used in "
47796 {
47798 {
47802 }
47808 {
47812 }
47813 else
47819 {
47822 }
47825 }
47828 {
47830 {
47834 }
47835 const unsigned short unroll
47841 {
47845 }
47846 else
47852 {
47855 }
47858 }
47865 bad_stmt:
47868 }
47872 }
47874 /* The interface the pragma parsers have to the lexer. */
47876 enum cpp_ttype
47878 {
47890 else
47891 {
47895 }
47898 }
47900 \f
47901 /* External interface. */
47903 /* Parse one entire translation unit. */
47905 void
47907 {
47915 /* cp_lexer_new_main is called before doing any GC allocation
47916 because tokenization might load a PCH file. */
47927 }
47929 /* Create an identifier for a generic parameter type (a synthesized
47930 template parameter implied by `auto' or a concept identifier). */
47933 static tree
47935 {
47939 }
47941 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
47942 (creating a new template parameter list if necessary). Returns the newly
47943 created template type parm. */
47945 static tree
47947 {
47948 /* A requires-clause is not a function and cannot have placeholders. */
47950 {
47953 }
47957 /* We are either continuing a function template that already contains implicit
47958 template parameters, creating a new fully-implicit function template, or
47959 extending an existing explicit function template with implicit template
47960 parameters. */
47968 {
47972 }
47973 else
47974 {
47975 /* Roll back to the existing template parameter scope (in the case of
47976 extending an explicit function template) or introduce a new template
47977 parameter scope ahead of the function parameter scope (or class scope
47978 in the case of out-of-line member definitions). The function scope is
47979 added back after template parameter synthesis below. */
47984 {
47987 }
47989 {
47990 /* If not defining a class, then any class scope is a scope level in
47991 an out-of-line member definition. In this case simply wind back
47992 beyond the first such scope to inject the template parameter list.
47993 Otherwise wind back to the class being defined. The latter can
47994 occur in class member friend declarations such as:
47996 class A {
47997 void foo (auto);
47998 };
47999 class B {
48000 friend void A::foo (auto);
48001 };
48003 The template parameter list synthesized for the friend declaration
48004 must be injected in the scope of 'B'. This can also occur in
48005 erroneous cases such as:
48007 struct A {
48008 struct B {
48009 void foo (auto);
48010 };
48011 void B::foo (auto) {}
48012 };
48014 Here the attempted definition of 'B::foo' within 'A' is ill-formed
48015 but, nevertheless, the template parameter list synthesized for the
48016 declarator should be injected into the scope of 'A' as if the
48017 ill-formed template was specified explicitly. */
48020 {
48023 }
48024 }
48030 {
48031 /* Introduce a new template parameter list for implicit template
48032 parameters. */
48036 parser->implicit_template_scope
48043 }
48044 else
48045 {
48046 /* Synthesize implicit template parameters at the end of the explicit
48047 template parameter list. */
48054 parser->implicit_template_parms
48056 }
48057 }
48059 /* Synthesize a new template parameter and track the current template
48060 parameter chain with implicit_template_parms. */
48064 tree synth_tmpl_parm;
48067 /* Synthesize the type template parameter. */
48071 /* Attach the constraint to the parm before processing. */
48074 tree new_parm
48076 input_location,
48077 node,
48081 /* Mark the synthetic declaration "virtual". This is used when
48082 comparing template-heads to determine if whether an abbreviated
48083 function template is equivalent to an explicit template.
48085 Note that DECL_ARTIFICIAL is used elsewhere for template parameters. */
48088 // Chain the new parameter to the list of implicit parameters.
48090 parser->implicit_template_parms
48092 else
48097 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
48100 /* If creating a fully implicit function template, start the new implicit
48101 template parameter list with this synthesized type, otherwise grow the
48102 current template parameter list. */
48105 {
48112 }
48113 else
48114 {
48119 }
48121 /* If the new parameter was constrained, we need to add that to the
48122 constraints in the template parameter list. */
48124 {
48128 }
48133 }
48135 /* Finish the declaration of a fully implicit function template. Such a
48136 template has no explicit template parameter list so has not been through the
48137 normal template head and tail processing. synthesize_implicit_template_parm
48138 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
48139 provided if the declaration is a class member such that its template
48140 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
48141 form is returned. Otherwise NULL_TREE is returned. */
48143 static tree
48145 {
48150 {
48154 }
48166 }
48168 /* Like finish_fully_implicit_template, but to be used in error
48169 recovery, rearranging scopes so that we restore the state we had
48170 before synthesize_implicit_template_parm inserted the implement
48171 template parms scope. */
48173 static void
48175 {
48180 {
48189 }
48190 else
48196 }
48198 /* Helper function for diagnostics that have complained about things
48199 being used with 'extern "C"' linkage.
48201 Attempt to issue a note showing where the 'extern "C"' linkage began. */
48203 void
48205 {
48209 }