| blob | b2ed2baa3a5701598f1c3cdb315591982751da2d |
1 /* -*- C++ -*- Parser.
2 Copyright (C) 2000-2024 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 #define INCLUDE_MEMORY
53 \f
54 /* The lexer. */
56 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
57 and c-lex.cc) and the C++ parser. */
59 /* The various kinds of non integral constant we encounter. */
61 NIC_NONE,
62 /* floating-point literal */
63 NIC_FLOAT,
64 /* %<this%> */
65 NIC_THIS,
66 /* %<__FUNCTION__%> */
67 NIC_FUNC_NAME,
68 /* %<__PRETTY_FUNCTION__%> */
69 NIC_PRETTY_FUNC,
70 /* %<__func__%> */
71 NIC_C99_FUNC,
72 /* "%<va_arg%> */
73 NIC_VA_ARG,
74 /* a cast */
75 NIC_CAST,
76 /* %<typeid%> operator */
77 NIC_TYPEID,
78 /* non-constant compound literals */
79 NIC_NCC,
80 /* a function call */
81 NIC_FUNC_CALL,
82 /* an increment */
83 NIC_INC,
84 /* an decrement */
85 NIC_DEC,
86 /* an array reference */
87 NIC_ARRAY_REF,
88 /* %<->%> */
89 NIC_ARROW,
90 /* %<.%> */
91 NIC_POINT,
92 /* the address of a label */
93 NIC_ADDR_LABEL,
94 /* %<*%> */
95 NIC_STAR,
96 /* %<&%> */
97 NIC_ADDR,
98 /* %<++%> */
99 NIC_PREINCREMENT,
100 /* %<--%> */
101 NIC_PREDECREMENT,
102 /* %<new%> */
103 NIC_NEW,
104 /* %<delete%> */
105 NIC_DEL,
106 /* calls to overloaded operators */
107 NIC_OVERLOADED,
108 /* an assignment */
109 NIC_ASSIGNMENT,
110 /* a comma operator */
111 NIC_COMMA,
112 /* a call to a constructor */
113 NIC_CONSTRUCTOR,
114 /* a transaction expression */
115 NIC_TRANSACTION
116 };
118 /* The various kinds of errors about name-lookup failing. */
120 /* NULL */
121 NLE_NULL,
122 /* is not a type */
123 NLE_TYPE,
124 /* is not a class or namespace */
125 NLE_CXX98,
126 /* is not a class, namespace, or enumeration */
127 NLE_NOT_CXX98
128 };
130 /* The various kinds of required token */
132 RT_NONE,
154 /* The type is CPP_KEYWORD */
186 RT_CO_YIELD /* co_yield */
187 };
189 /* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
190 reverting it on destruction. */
192 class type_id_in_expr_sentinel
193 {
203 };
205 /* Prototypes. */
211 static void cp_lexer_destroy
213 static int cp_lexer_saving_tokens
217 static void cp_lexer_get_preprocessor_token
225 static bool cp_lexer_next_token_is_not
227 static bool cp_lexer_next_token_is_keyword
231 static void cp_lexer_purge_token
233 static void cp_lexer_purge_tokens_after
235 static void cp_lexer_save_tokens
237 static void cp_lexer_commit_tokens
239 static void cp_lexer_rollback_tokens
241 static void cp_lexer_print_token
245 static void cp_lexer_start_debugging
247 static void cp_lexer_stop_debugging
258 static tree cp_parser_late_noexcept_specifier
260 static void noexcept_override_late_checks
263 static void cp_parser_initial_pragma
266 static bool cp_parser_omp_declare_reduction_exprs
268 static void cp_finalize_oacc_routine
271 static void check_omp_intervening_code
275 /* Manifest constants. */
276 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
277 #define CP_SAVED_TOKEN_STACK 5
279 /* Variables. */
281 /* The stream to which debugging output should be written. */
284 /* Nonzero if we are parsing an unevaluated operand: an operand to
285 sizeof, typeof, or alignof. */
288 /* Dump up to NUM tokens in BUFFER to FILE starting with token
289 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
290 first token in BUFFER. If NUM is 0, dump all the tokens. If
291 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
292 highlighted by surrounding it in [[ ]]. */
294 static void
298 {
315 {
318 }
323 {
330 nprinted++;
340 {
350 }
351 }
354 {
357 }
360 }
363 /* Dump all tokens in BUFFER to stderr. */
365 void
367 {
369 }
371 DEBUG_FUNCTION void
373 {
375 }
377 DEBUG_FUNCTION void
379 {
382 else
384 }
387 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
388 description for T. */
390 static void
392 {
394 {
397 }
398 }
401 /* Dump parser context C to FILE. */
403 static void
405 {
410 }
413 /* Print the stack of parsing contexts to FILE starting with FIRST. */
415 static void
417 {
423 {
426 }
427 }
430 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
432 static void
434 {
437 }
440 /* Print an unparsed function entry UF to FILE. */
442 static void
444 {
447 tree fn;
452 i++)
453 {
459 }
464 {
467 }
473 {
476 }
478 }
481 /* Print the stack of unparsed member functions S to FILE. */
483 static void
486 {
492 {
495 }
496 }
499 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
500 the given PARSER. If FILE is NULL, the output is printed on stderr. */
502 static void
504 {
516 next_token);
517 }
520 /* Dump debugging information for the given PARSER. If FILE is NULL,
521 the output is printed on stderr. */
523 void
525 {
528 expanded_location eloc;
593 parser->type_definition_forbidden_message_arg
609 }
611 DEBUG_FUNCTION void
613 {
615 }
617 DEBUG_FUNCTION void
619 {
622 else
624 }
626 /* Allocate memory for a new lexer object and return it. */
630 {
631 /* Allocate the memory. */
634 /* Initially we are not debugging. */
639 /* Create the buffer. */
643 }
645 /* Return TRUE if token is the start of a module declaration that will be
646 terminated by a CPP_PRAGMA_EOL token. */
649 {
653 }
655 /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
656 PRAGMA_NONE. */
658 static enum pragma_kind
660 {
663 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
665 }
667 /* Handle early pragmas such as #pragma GCC diagnostic, which needs to be done
668 during preprocessing for the case of preprocessing-related diagnostics. This
669 is called immediately after pushing the CPP_PRAGMA_EOL token onto
670 lexer->buffer. */
672 static void
674 {
678 /* Back up to the start of the pragma so pragma_lex () can parse it when
679 c-pragma lib asks it to. */
683 {
688 }
694 /* Dispatch it. */
695 const unsigned int id
700 /* Reset to normal state. */
702 }
704 /* The parser. */
708 /* Create a new main C++ lexer, the lexer that gets tokens from the
709 preprocessor, and also create the main parser. */
713 {
714 cp_token token;
716 /* It's possible that parsing the first pragma will load a PCH file,
717 which is a GC collection point. So we have to do that before
718 allocating any memory. */
724 /* Put the first token in the buffer. */
731 /* Create the parser now, so we can use it to handle early pragmas. */
735 /* Get the remaining tokens from the preprocessor. */
737 {
739 /* Process the previous token. */
743 /* Check for early pragmas that need to be handled now. */
749 }
757 {
758 /* Set the EOF token's location to be the just after the previous
759 token's range. That way 'at-eof' diagnostics point at something
760 meaninful. */
764 }
769 /* Subsequent preprocessor diagnostics should use compiler
770 diagnostic functions to get the compiler source location. */
775 /* If we processed any #pragma GCC target directives, we handled them early so
776 any macros they defined would be effective during preprocessing. Now, we
777 need to reset to the default state to begin compilation, and we will
778 process them again at the correct time as needed. */
783 }
785 /* Create a lexer and parser to be used during preprocess-only mode.
786 This will be filled with tokens to parse when needed by pragma_lex (). */
787 void
789 {
792 }
794 /* Create a new lexer whose token stream is primed with the tokens in
795 CACHE. When these tokens are exhausted, no new tokens will be read. */
799 {
804 /* We do not own the buffer. */
807 /* Insert an EOF token. */
818 /* Initially we are not debugging. */
824 }
826 /* Frees all resources associated with LEXER. */
828 static void
830 {
833 else
834 {
835 /* Restore the token we overwrite with EOF. */
838 }
841 }
843 /* This needs to be set to TRUE before the lexer-debugging infrastructure can
844 be used. The point of this flag is to help the compiler to fold away calls
845 to cp_lexer_debugging_p within this source file at compile time, when the
846 lexer is not being debugged. */
848 #define LEXER_DEBUGGING_ENABLED_P false
850 /* Returns nonzero if debugging information should be output. */
854 {
859 }
864 {
866 }
870 {
872 }
876 {
878 }
882 {
884 }
888 {
891 /* Skip past purged tokens. */
893 {
895 tp--;
896 }
899 }
901 /* Same as above, but return NULL when the lexer doesn't own the token
902 buffer or if the next_token is at the start of the token
903 vector or if all previous tokens are purged. */
907 {
910 {
913 /* Skip past purged tokens. */
915 {
918 tp--;
919 }
921 }
924 }
926 /* Overload for make_location, taking the lexer to mean the location of the
927 previous token. */
931 {
934 }
936 /* Overload for make_location taking tokens instead of locations. */
940 {
942 }
944 /* nonzero if we are presently saving tokens. */
948 {
950 }
952 /* Store the next token from the preprocessor in *TOKEN. Return true
953 if we reach EOF. If LEXER is NULL, assume we are handling an
954 initial #pragma pch_preprocess, and thus want the lexer to return
955 processed strings.
957 Diagnostics issued from this function must have their controlling option (if
958 any) in c.opt annotated as a libcpp option via the CppReason property. */
960 static void
962 {
965 /* Get a new token from the preprocessor. */
966 token->type
968 flags);
973 /* Usually never see a zero, but just in case ... */
976 /* On some systems, some header files are surrounded by an
977 implicit extern "C" block. Set a flag in the token if it
978 comes from such a header. */
983 /* Check to see if this token is a keyword. */
985 {
987 {
988 /* Mark this token as a keyword. */
990 /* Record which keyword. */
992 }
993 else
994 {
998 /* These are outside the CXX11 range. */
1002 {
1003 /* Warn about the C++11 keyword (but still treat it as
1004 an identifier). */
1009 /* Clear out the C_RID_CODE so we don't warn about this
1010 particular identifier-turned-keyword again. */
1012 }
1016 {
1017 /* Warn about the C++20 keyword (but still treat it as
1018 an identifier). */
1023 /* Clear out the C_RID_CODE so we don't warn about this
1024 particular identifier-turned-keyword again. */
1026 }
1029 }
1030 }
1032 {
1033 /* This only happens in Objective-C++; it must be a keyword. */
1036 {
1037 /* Replace 'class' with '@class', 'private' with '@private',
1038 etc. This prevents confusion with the C++ keyword
1039 'class', and makes the tokens consistent with other
1040 Objective-C 'AT' keywords. For example '@class' is
1041 reported as RID_AT_CLASS which is consistent with
1042 '@synchronized', which is reported as
1043 RID_AT_SYNCHRONIZED.
1044 */
1054 }
1055 }
1056 }
1058 /* Update the globals input_location and the input file stack from TOKEN. */
1061 {
1063 }
1065 /* Update the globals input_location and the input file stack from LEXER. */
1068 {
1071 }
1073 /* Return a pointer to the next token in the token stream, but do not
1074 consume it. */
1078 {
1080 {
1084 }
1086 }
1088 /* Return true if the next token has the indicated TYPE. */
1092 {
1094 }
1096 /* Return true if the next token does not have the indicated TYPE. */
1100 {
1102 }
1104 /* Return true if the next token is the indicated KEYWORD. */
1108 {
1110 }
1114 {
1116 }
1120 {
1122 }
1124 /* Return true if KEYWORD can start a decl-specifier. */
1126 bool
1128 {
1130 {
1131 /* auto specifier: storage-class-specifier in C++,
1132 simple-type-specifier in C++0x. */
1134 /* Storage classes. */
1140 /* Elaborated type specifiers. */
1146 /* Simple type specifiers. */
1160 CASE_RID_FLOATN_NX:
1162 /* CV qualifiers. */
1165 /* Function specifiers. */
1168 /* friend/typdef/inline specifiers. */
1172 /* GNU extensions. */
1174 /* C++11 extensions. */
1177 /* C++20 extensions. */
1188 }
1189 }
1191 /* Peeks the corresponding built-in trait if the first token is
1192 a built-in trait and the second token is either `(' or `<' depending
1193 on the trait. Otherwise, returns nullptr. */
1197 {
1200 {
1204 /* Check if the subsequent token is a `<' token to
1205 __type_pack_element or is a `(' token to everything else. */
1213 }
1215 }
1217 /* Similarly, but only if the token is an expression-yielding
1218 built-in trait. */
1222 {
1228 }
1230 /* Similarly, but only if the token is a type-yielding
1231 built-in trait. */
1235 {
1241 }
1243 /* Return true if the next token is a keyword for a decl-specifier. */
1245 static bool
1247 {
1255 }
1257 /* Returns TRUE iff the token T begins a decltype type. */
1259 static bool
1261 {
1264 }
1266 /* Returns TRUE iff the next token begins a decltype type. */
1268 static bool
1270 {
1273 }
1275 /* Called when processing a token with tree_check_value; perform or defer the
1276 associated checks and return the value. */
1278 static tree
1280 {
1281 /* Perform any access checks that were deferred. */
1286 {
1292 }
1293 /* Return the stored value. */
1295 }
1297 /* Return a pointer to the Nth token in the token stream. If N is 1,
1298 then this is precisely equivalent to cp_lexer_peek_token (except
1299 that it is not inline). One would like to disallow that case, but
1300 there is one case (cp_parser_nth_token_starts_template_id) where
1301 the caller passes a variable for N and it might be 1. */
1305 {
1308 /* N is 1-based, not zero-based. */
1319 {
1323 }
1326 {
1329 }
1332 }
1334 /* Return the next token, and advance the lexer's next_token pointer
1335 to point to the next non-purged token. */
1339 {
1342 do
1343 {
1346 }
1351 /* Provide debugging output. */
1353 {
1357 }
1360 }
1362 /* Permanently remove the next token from the token stream, and
1363 advance the next_token pointer to refer to the next non-purged
1364 token. */
1366 static void
1368 {
1377 do
1378 tok++;
1381 }
1383 /* Permanently remove all tokens after TOK, up to, but not
1384 including, the token that will be returned next by
1385 cp_lexer_peek_token. */
1387 static void
1389 {
1395 {
1400 }
1401 }
1403 /* Begin saving tokens. All tokens consumed after this point will be
1404 preserved. */
1406 static void
1408 {
1409 /* Provide debugging output. */
1414 }
1416 /* Commit to the portion of the token stream most recently saved. */
1418 static void
1420 {
1421 /* Provide debugging output. */
1426 }
1428 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1429 to the token stream. Stop saving tokens. */
1431 static void
1433 {
1434 /* Provide debugging output. */
1439 }
1441 /* Determines what saved_token_sentinel does when going out of scope. */
1444 STS_COMMIT,
1445 STS_ROLLBACK,
1446 STS_DONOTHING
1447 };
1449 /* RAII wrapper around the above functions, with sanity checking (the token
1450 stream should be the same at the point of instantiation as it is at the
1451 point of destruction).
1453 Creating a variable saves tokens. MODE determines what happens when the
1454 object is destroyed. STS_COMMIT commits tokens (default),
1455 STS_ROLLBACK rolls-back and STS_DONOTHING does nothing. Calling
1456 rollback() will immediately roll-back tokens and set MODE to
1457 STS_DONOTHING. */
1459 struct saved_token_sentinel
1460 {
1463 saved_token_sentinel_mode mode;
1467 {
1470 }
1472 {
1474 cp_lexer_set_source_position_from_token
1477 }
1479 {
1486 }
1487 };
1489 /* Print a representation of the TOKEN on the STREAM. */
1491 static void
1493 {
1494 /* We don't use cpp_type2name here because the parser defines
1495 a few tokens of its own. */
1497 /* cpplib-defined token types */
1498 #define OP(e, s) #e,
1499 #define TK(e, s) #e,
1500 TTYPE_TABLE
1501 #undef OP
1502 #undef TK
1503 /* C++ parser token types - see "Manifest constants", above. */
1507 };
1509 /* For some tokens, print the associated data. */
1511 {
1513 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1514 For example, `struct' is mapped to an INTEGER_CST. */
1517 /* fall through */
1535 /* If we have a name for the token, print it out. Otherwise, we
1536 simply give the numeric code. */
1539 else
1542 }
1543 }
1545 DEBUG_FUNCTION void
1547 {
1550 }
1552 DEBUG_FUNCTION void
1554 {
1557 else
1559 }
1562 /* Start emitting debugging information. */
1564 static void
1566 {
1573 }
1575 /* Stop emitting debugging information. */
1577 static void
1579 {
1586 }
1588 /* Create a new cp_token_cache, representing a range of tokens. */
1592 {
1597 }
1599 /* Diagnose if #pragma omp declare simd isn't followed immediately
1600 by function declaration or definition. */
1604 {
1606 {
1611 }
1612 }
1614 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1615 and put that into "omp declare simd" attribute. */
1619 {
1621 {
1623 {
1626 }
1628 {
1631 }
1632 }
1633 }
1635 /* Similarly, but for use in declaration parsing functions
1636 which call cp_parser_handle_directive_omp_attributes. */
1640 {
1647 "%<declare %s%> directive not immediately followed by "
1651 }
1653 /* Diagnose if #pragma acc routine isn't followed immediately by function
1654 declaration or definition. */
1658 {
1660 {
1662 "%<#pragma acc routine%> not immediately followed by "
1665 }
1666 }
1667 \f
1668 /* Decl-specifiers. */
1670 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1672 static void
1674 {
1676 }
1678 /* Declarators. */
1680 /* Nothing other than the parser should be creating declarators;
1681 declarators are a semi-syntactic representation of C++ entities.
1682 Other parts of the front end that need to create entities (like
1683 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1697 /* An erroneous declarator. */
1700 /* The obstack on which declarators and related data structures are
1701 allocated. */
1704 /* Alloc BYTES from the declarator memory pool. */
1708 {
1710 }
1712 /* Allocate a declarator of the indicated KIND. Clear fields that are
1713 common to all declarators. */
1717 {
1731 }
1733 /* Make a declarator for a generalized identifier. If
1734 QUALIFYING_SCOPE is non-NULL, the identifier is
1735 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1736 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1737 is, if any. */
1742 {
1745 /* It is valid to write:
1747 class C { void f(); };
1748 typedef C D;
1749 void D::f();
1751 The standard is not clear about whether `typedef const C D' is
1752 legal; as of 2002-09-15 the committee is considering that
1753 question. EDG 3.0 allows that syntax. Therefore, we do as
1754 well. */
1769 }
1771 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1772 of modifiers such as const or volatile to apply to the pointer
1773 type, represented as identifiers. ATTRIBUTES represent the attributes that
1774 appertain to the pointer or reference. */
1776 cp_declarator *
1778 tree attributes)
1779 {
1787 {
1791 }
1792 else
1798 }
1800 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1801 represent the attributes that appertain to the pointer or
1802 reference. */
1804 cp_declarator *
1807 {
1815 {
1819 }
1820 else
1826 }
1828 /* Like make_pointer_declarator -- but for a pointer to a non-static
1829 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1830 appertain to the pointer or reference. */
1832 cp_declarator *
1835 tree attributes)
1836 {
1845 {
1848 }
1849 else
1855 }
1857 /* Make a declarator for the function given by TARGET, with the
1858 indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1859 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1860 indicates what exceptions can be thrown. STD_ATTRS contains
1861 attributes that appertain to the function type. */
1863 cp_declarator *
1865 tree parms,
1866 cp_cv_quals cv_qualifiers,
1867 cp_virt_specifiers virt_specifiers,
1868 cp_ref_qualifier ref_qualifier,
1869 tree tx_qualifier,
1870 tree exception_specification,
1871 tree late_return_type,
1872 tree requires_clause,
1873 tree std_attrs,
1874 location_t parens_loc)
1875 {
1890 {
1894 }
1895 else
1901 }
1903 /* Make a declarator for an array of BOUNDS elements, each of which is
1904 defined by ELEMENT. */
1906 cp_declarator *
1908 {
1915 {
1919 }
1920 else
1924 }
1926 /* Determine whether the declarator we've seen so far can be a
1927 parameter pack, when followed by an ellipsis. */
1928 static bool
1930 {
1932 /* We already saw an ellipsis. */
1935 /* Search for a declarator name, or any other declarator that goes
1936 after the point where the ellipsis could appear in a parameter
1937 pack. If we find any of these, then this declarator cannot be
1938 made into a parameter pack. */
1941 {
1943 {
1956 }
1957 }
1960 }
1964 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1965 DECLARATOR and DEFAULT_ARGUMENT. */
1967 cp_parameter_declarator *
1970 tree default_argument,
1971 location_t loc,
1973 {
1981 else
1989 }
1991 /* Returns true iff DECLARATOR is a declaration for a function. */
1993 static bool
1995 {
1997 {
2006 }
2008 }
2010 /* The parser. */
2012 /* Overview
2013 --------
2015 A cp_parser parses the token stream as specified by the C++
2016 grammar. Its job is purely parsing, not semantic analysis. For
2017 example, the parser breaks the token stream into declarators,
2018 expressions, statements, and other similar syntactic constructs.
2019 It does not check that the types of the expressions on either side
2020 of an assignment-statement are compatible, or that a function is
2021 not declared with a parameter of type `void'.
2023 The parser invokes routines elsewhere in the compiler to perform
2024 semantic analysis and to build up the abstract syntax tree for the
2025 code processed.
2027 The parser (and the template instantiation code, which is, in a
2028 way, a close relative of parsing) are the only parts of the
2029 compiler that should be calling push_scope and pop_scope, or
2030 related functions. The parser (and template instantiation code)
2031 keeps track of what scope is presently active; everything else
2032 should simply honor that. (The code that generates static
2033 initializers may also need to set the scope, in order to check
2034 access control correctly when emitting the initializers.)
2036 Methodology
2037 -----------
2039 The parser is of the standard recursive-descent variety. Upcoming
2040 tokens in the token stream are examined in order to determine which
2041 production to use when parsing a non-terminal. Some C++ constructs
2042 require arbitrary look ahead to disambiguate. For example, it is
2043 impossible, in the general case, to tell whether a statement is an
2044 expression or declaration without scanning the entire statement.
2045 Therefore, the parser is capable of "parsing tentatively." When the
2046 parser is not sure what construct comes next, it enters this mode.
2047 Then, while we attempt to parse the construct, the parser queues up
2048 error messages, rather than issuing them immediately, and saves the
2049 tokens it consumes. If the construct is parsed successfully, the
2050 parser "commits", i.e., it issues any queued error messages and
2051 the tokens that were being preserved are permanently discarded.
2052 If, however, the construct is not parsed successfully, the parser
2053 rolls back its state completely so that it can resume parsing using
2054 a different alternative.
2056 Future Improvements
2057 -------------------
2059 The performance of the parser could probably be improved substantially.
2060 We could often eliminate the need to parse tentatively by looking ahead
2061 a little bit. In some places, this approach might not entirely eliminate
2062 the need to parse tentatively, but it might still speed up the average
2063 case. */
2065 /* Flags that are passed to some parsing functions. These values can
2066 be bitwise-ored together. */
2068 enum
2069 {
2070 /* No flags. */
2072 /* The construct is optional. If it is not present, then no error
2073 should be issued. */
2075 /* When parsing a type-specifier, treat user-defined type-names
2076 as non-type identifiers. */
2078 /* When parsing a type-specifier, do not try to parse a class-specifier
2079 or enum-specifier. */
2081 /* When parsing a decl-specifier-seq, only allow type-specifier or
2082 constexpr. */
2084 /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
2085 for C++20 consteval or for C++23 static. */
2087 /* When parsing a decl-specifier-seq, allow missing typename. */
2089 /* When parsing of the noexcept-specifier should be delayed. */
2091 /* When parsing a consteval declarator. */
2093 /* When parsing a parameter declaration. */
2095 };
2097 /* This type is used for parameters and variables which hold
2098 combinations of the above flags. */
2101 /* The different kinds of declarators we want to parse. */
2103 enum cp_parser_declarator_kind
2104 {
2105 /* We want an abstract declarator. */
2106 CP_PARSER_DECLARATOR_ABSTRACT,
2107 /* We want a named declarator. */
2108 CP_PARSER_DECLARATOR_NAMED,
2109 /* We don't mind, but the name must be an unqualified-id. */
2110 CP_PARSER_DECLARATOR_EITHER
2111 };
2113 /* The precedence values used to parse binary expressions. The minimum value
2114 of PREC must be 1, because zero is reserved to quickly discriminate
2115 binary operators from other tokens. */
2117 enum cp_parser_prec
2118 {
2119 PREC_NOT_OPERATOR,
2120 PREC_LOGICAL_OR_EXPRESSION,
2121 PREC_LOGICAL_AND_EXPRESSION,
2122 PREC_INCLUSIVE_OR_EXPRESSION,
2123 PREC_EXCLUSIVE_OR_EXPRESSION,
2124 PREC_AND_EXPRESSION,
2125 PREC_EQUALITY_EXPRESSION,
2126 PREC_RELATIONAL_EXPRESSION,
2127 PREC_SPACESHIP_EXPRESSION,
2128 PREC_SHIFT_EXPRESSION,
2129 PREC_ADDITIVE_EXPRESSION,
2130 PREC_MULTIPLICATIVE_EXPRESSION,
2131 PREC_PM_EXPRESSION,
2132 NUM_PREC_VALUES = PREC_PM_EXPRESSION
2133 };
2135 /* A mapping from a token type to a corresponding tree node type, with a
2136 precedence value. */
2138 struct cp_parser_binary_operations_map_node
2139 {
2140 /* The token type. */
2142 /* The corresponding tree code. */
2144 /* The precedence of this operator. */
2146 };
2148 struct cp_parser_expression_stack_entry
2149 {
2150 /* Left hand side of the binary operation we are currently
2151 parsing. */
2152 cp_expr lhs;
2153 /* Original tree code for left hand side, if it was a binary
2154 expression itself (used for -Wparentheses). */
2156 /* Tree code for the binary operation we are parsing. */
2158 /* Precedence of the binary operation we are parsing. */
2160 /* Location of the binary operation we are parsing. */
2161 location_t loc;
2162 /* Flags from the operator token. */
2164 };
2166 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
2167 entries because precedence levels on the stack are monotonically
2168 increasing. */
2172 /* Used for parsing OMP for loops.
2174 Some notes on flags used for context:
2175 parser->omp_for_parse_state is non-null anywhere inside the OMP FOR
2176 construct, except for the final-loop-body.
2177 The want_nested_loop flag is true if inside a {} sequence where
2178 a loop-nest (or another {} sequence containing a loop-nest) is expected,
2179 but has not yet been seen. It's false when parsing intervening code
2180 statements or their substatements that cannot contain a loop-nest.
2181 The in_intervening_code flag is true when parsing any intervening code,
2182 including substatements, and whether or not want_nested_loop is true.
2184 And, about error handling:
2185 The saw_intervening_code flag is set if the loop is not perfectly
2186 nested, even in the usual case where this is not an error.
2187 perfect_nesting_fail is set if an error has been diagnosed because an
2188 imperfectly-nested loop was found where a perfectly-nested one is
2189 required (we diagnose this only once).
2190 fail is set if any kind of structural error in the loop nest
2191 has been found and diagnosed.
2192 */
2196 tree pre_body;
2197 tree orig_declv;
2201 location_t for_loc;
2202 releasing_vec init_blockv;
2203 releasing_vec body_blockv;
2204 releasing_vec init_placeholderv;
2205 releasing_vec body_placeholderv;
2213 tree clauses;
2215 tree ordered_cl;
2216 };
2218 /* Prototypes. */
2220 /* Constructors and destructors. */
2225 /* Class variables. */
2229 /* The operator-precedence table used by cp_parser_binary_expression.
2230 Transformed into an associative array (binops_by_token) by
2231 cp_parser_new. */
2266 };
2268 /* The same as binops, but initialized by cp_parser_new so that
2269 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2270 for speed. */
2273 /* Constructors and destructors. */
2275 /* Construct a new context. The context below this one on the stack
2276 is given by NEXT. */
2280 {
2283 /* Allocate the storage. */
2285 {
2286 /* Pull the first entry from the free list. */
2290 }
2291 else
2294 /* No errors have occurred yet in this context. */
2296 /* If this is not the bottommost context, copy information that we
2297 need from the previous context. */
2299 {
2300 /* If, in the NEXT context, we are parsing an `x->' or `x.'
2301 expression, then we are parsing one in this context, too. */
2303 /* Thread the stack. */
2305 }
2308 }
2310 /* Managing the unparsed function queues. */
2312 #define unparsed_funs_with_default_args \
2313 parser->unparsed_queues->last ().funs_with_default_args
2314 #define unparsed_funs_with_definitions \
2315 parser->unparsed_queues->last ().funs_with_definitions
2316 #define unparsed_nsdmis \
2317 parser->unparsed_queues->last ().nsdmis
2318 #define unparsed_noexcepts \
2319 parser->unparsed_queues->last ().noexcepts
2320 #define unparsed_contracts \
2321 parser->unparsed_queues->last ().contracts
2323 static void
2325 {
2326 cp_unparsed_functions_entry e
2329 }
2331 static void
2333 {
2336 }
2338 /* Prototypes. */
2340 /* Routines to parse various constructs.
2342 Those that return `tree' will return the error_mark_node (rather
2343 than NULL_TREE) if a parse error occurs, unless otherwise noted.
2344 Sometimes, they will return an ordinary node if error-recovery was
2345 attempted, even though a parse error occurred. So, to check
2346 whether or not a parse error occurred, you should always use
2347 cp_parser_error_occurred. If the construct is optional (indicated
2348 either by an `_opt' in the name of the function that does the
2349 parsing or via a FLAGS parameter), then NULL_TREE is returned if
2350 the construct is not present. */
2352 /* Lexical conventions [gram.lex] */
2354 static tree finish_userdef_string_literal
2357 /* Basic concepts [gram.basic] */
2361 /* Expressions [gram.expr] */
2363 static cp_expr cp_parser_primary_expression
2365 static cp_expr cp_parser_id_expression
2367 static cp_expr cp_parser_unqualified_id
2369 static tree cp_parser_nested_name_specifier_opt
2371 static tree cp_parser_nested_name_specifier
2373 static tree cp_parser_qualifying_entity
2375 static cp_expr cp_parser_postfix_expression
2377 static tree cp_parser_postfix_open_square_expression
2379 static tree cp_parser_postfix_dot_deref_expression
2384 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2387 static void cp_parser_pseudo_destructor_name
2389 static cp_expr cp_parser_unary_expression
2391 static enum tree_code cp_parser_unary_operator
2393 static tree cp_parser_has_attribute_expression
2395 static tree cp_parser_new_expression
2399 static tree cp_parser_new_type_id
2407 static tree cp_parser_delete_expression
2409 static cp_expr cp_parser_cast_expression
2411 static cp_expr cp_parser_binary_expression
2413 static tree cp_parser_question_colon_clause
2416 static cp_expr cp_parser_assignment_expression
2418 static enum tree_code cp_parser_assignment_operator_opt
2420 static cp_expr cp_parser_expression
2422 static cp_expr cp_parser_constant_expression
2424 static cp_expr cp_parser_builtin_offsetof
2426 static cp_expr cp_parser_lambda_expression
2428 static void cp_parser_lambda_introducer
2430 static bool cp_parser_lambda_declarator_opt
2432 static void cp_parser_lambda_body
2435 /* Statements [gram.stmt.stmt] */
2437 static void cp_parser_statement
2439 static void cp_parser_label_for_labeled_statement
2441 static tree cp_parser_expression_statement
2443 static tree cp_parser_compound_statement
2445 static void cp_parser_statement_seq_opt
2447 static tree cp_parser_selection_statement
2449 static tree cp_parser_condition
2451 static tree cp_parser_iteration_statement
2453 static bool cp_parser_init_statement
2455 static tree cp_parser_for
2457 static tree cp_parser_c_for
2459 static tree cp_parser_range_for
2461 static void do_range_for_auto_deduction
2463 static tree cp_parser_perform_range_for_lookup
2465 static tree cp_parser_range_for_member_function
2467 static tree cp_parser_jump_statement
2469 static void cp_parser_declaration_statement
2472 static tree cp_parser_implicitly_scoped_statement
2474 static void cp_parser_already_scoped_statement
2477 /* State of module-declaration parsing. */
2478 enum module_parse
2479 {
2482 _MP_UNUSED,
2492 };
2494 static module_parse cp_parser_module_declaration
2496 static void cp_parser_import_declaration
2499 /* Declarations [gram.dcl.dcl] */
2501 static void cp_parser_declaration_seq_opt
2503 static void cp_parser_declaration
2505 static void cp_parser_toplevel_declaration
2507 static void cp_parser_block_declaration
2509 static void cp_parser_simple_declaration
2511 static void cp_parser_decl_specifier_seq
2513 static tree cp_parser_storage_class_specifier_opt
2515 static tree cp_parser_function_specifier_opt
2517 static tree cp_parser_type_specifier
2520 static tree cp_parser_simple_type_specifier
2522 static tree cp_parser_placeholder_type_specifier
2524 static tree cp_parser_type_name
2526 static tree cp_parser_nonclass_name
2528 static tree cp_parser_elaborated_type_specifier
2530 static tree cp_parser_enum_specifier
2532 static void cp_parser_enumerator_list
2534 static void cp_parser_enumerator_definition
2536 static tree cp_parser_namespace_name
2538 static void cp_parser_namespace_definition
2540 static void cp_parser_namespace_body
2542 static tree cp_parser_qualified_namespace_specifier
2544 static void cp_parser_namespace_alias_definition
2546 static bool cp_parser_using_declaration
2548 static void cp_parser_using_directive
2550 static void cp_parser_using_enum
2552 static tree cp_parser_alias_declaration
2554 static void cp_parser_asm_definition
2556 static void cp_parser_linkage_specification
2558 static void cp_parser_static_assert
2560 static tree cp_parser_decltype
2562 static tree cp_parser_decomposition_declaration
2565 /* Declarators [gram.dcl.decl] */
2567 static tree cp_parser_init_declarator
2577 static enum tree_code cp_parser_ptr_operator
2579 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2581 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2583 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2585 static tree cp_parser_tx_qualifier_opt
2587 static tree cp_parser_late_return_type_opt
2589 static tree cp_parser_declarator_id
2591 static tree cp_parser_type_id
2593 static tree cp_parser_template_type_arg
2596 static tree cp_parser_type_id_1
2598 static void cp_parser_type_specifier_seq
2600 static tree cp_parser_parameter_declaration_clause
2602 static tree cp_parser_parameter_declaration_list
2606 static tree cp_parser_default_argument
2608 static void cp_parser_function_body
2610 static tree cp_parser_initializer
2612 static cp_expr cp_parser_initializer_clause
2614 static cp_expr cp_parser_braced_list
2619 static void cp_parser_ctor_initializer_opt_and_function_body
2622 static tree cp_parser_late_parsing_omp_declare_simd
2625 static tree cp_parser_late_parsing_oacc_routine
2628 static tree synthesize_implicit_template_parm
2630 static tree finish_fully_implicit_template
2632 static void abort_fully_implicit_template
2635 /* Classes [gram.class] */
2637 static tree cp_parser_class_name
2639 static tree cp_parser_class_specifier
2641 static tree cp_parser_class_head
2643 static enum tag_types cp_parser_class_key
2645 static void cp_parser_type_parameter_key
2647 static void cp_parser_member_specification_opt
2649 static void cp_parser_member_declaration
2651 static tree cp_parser_pure_specifier
2653 static tree cp_parser_constant_initializer
2656 /* Derived classes [gram.class.derived] */
2658 static tree cp_parser_base_clause
2660 static tree cp_parser_base_specifier
2663 /* Special member functions [gram.special] */
2665 static tree cp_parser_conversion_function_id
2667 static tree cp_parser_conversion_type_id
2671 static void cp_parser_ctor_initializer_opt
2673 static void cp_parser_mem_initializer_list
2675 static tree cp_parser_mem_initializer
2677 static tree cp_parser_mem_initializer_id
2680 /* Overloading [gram.over] */
2682 static cp_expr cp_parser_operator_function_id
2684 static cp_expr cp_parser_operator
2687 /* Templates [gram.temp] */
2689 static void cp_parser_template_declaration
2691 static tree cp_parser_template_parameter_list
2693 static tree cp_parser_template_parameter
2695 static tree cp_parser_type_parameter
2697 static tree cp_parser_template_id
2699 static tree cp_parser_template_id_expr
2701 static tree cp_parser_template_name
2703 static tree cp_parser_template_argument_list
2705 static tree cp_parser_template_argument
2707 static void cp_parser_explicit_instantiation
2709 static void cp_parser_explicit_specialization
2712 /* Exception handling [gram.except] */
2714 static tree cp_parser_try_block
2716 static void cp_parser_function_try_block
2718 static void cp_parser_handler_seq
2720 static void cp_parser_handler
2722 static tree cp_parser_exception_declaration
2724 static tree cp_parser_throw_expression
2726 static tree cp_parser_exception_specification_opt
2728 static tree cp_parser_type_id_list
2730 static tree cp_parser_noexcept_specification_opt
2733 /* GNU Extensions */
2735 static tree cp_parser_asm_specification_opt
2737 static tree cp_parser_asm_operand_list
2739 static tree cp_parser_asm_clobber_list
2741 static tree cp_parser_asm_label_list
2743 static bool cp_next_tokens_can_be_attribute_p
2745 static bool cp_next_tokens_can_be_gnu_attribute_p
2747 static bool cp_next_tokens_can_be_std_attribute_p
2749 static bool cp_nth_tokens_can_be_std_attribute_p
2751 static bool cp_nth_tokens_can_be_gnu_attribute_p
2753 static bool cp_nth_tokens_can_be_attribute_p
2755 static tree cp_parser_attributes_opt
2757 static tree cp_parser_gnu_attributes_opt
2759 static tree cp_parser_gnu_attribute_list
2761 static tree cp_parser_std_attribute
2763 static tree cp_parser_std_attribute_spec
2765 static tree cp_parser_std_attribute_spec_seq
2767 static size_t cp_parser_skip_std_attribute_spec_seq
2769 static size_t cp_parser_skip_attributes_opt
2771 static bool cp_parser_extension_opt
2773 static void cp_parser_label_declaration
2776 /* Concept Extensions */
2778 static tree cp_parser_concept_definition
2780 static tree cp_parser_constraint_expression
2782 static tree cp_parser_requires_clause_opt
2784 static tree cp_parser_requires_expression
2786 static tree cp_parser_requirement_parameter_list
2788 static tree cp_parser_requirement_body
2790 static tree cp_parser_requirement_seq
2792 static tree cp_parser_requirement
2794 static tree cp_parser_simple_requirement
2796 static tree cp_parser_compound_requirement
2798 static tree cp_parser_type_requirement
2800 static tree cp_parser_nested_requirement
2803 /* Transactional Memory Extensions */
2805 static tree cp_parser_transaction
2807 static tree cp_parser_transaction_expression
2809 static void cp_parser_function_transaction
2811 static tree cp_parser_transaction_cancel
2814 /* Coroutine extensions. */
2816 static tree cp_parser_yield_expression
2819 /* Contracts */
2821 static void cp_parser_late_contract_condition
2825 pragma_external,
2826 pragma_member,
2827 pragma_objc_icode,
2828 pragma_stmt,
2829 pragma_compound
2830 };
2831 static bool cp_parser_pragma
2834 /* Objective-C++ Productions */
2836 static tree cp_parser_objc_message_receiver
2838 static tree cp_parser_objc_message_args
2840 static tree cp_parser_objc_message_expression
2842 static cp_expr cp_parser_objc_encode_expression
2844 static tree cp_parser_objc_defs_expression
2846 static tree cp_parser_objc_protocol_expression
2848 static tree cp_parser_objc_selector_expression
2850 static cp_expr cp_parser_objc_expression
2852 static bool cp_parser_objc_selector_p
2854 static tree cp_parser_objc_selector
2856 static tree cp_parser_objc_protocol_refs_opt
2858 static void cp_parser_objc_declaration
2860 static tree cp_parser_objc_statement
2862 static bool cp_parser_objc_valid_prefix_attributes
2864 static void cp_parser_objc_at_property_declaration
2866 static void cp_parser_objc_at_synthesize_declaration
2868 static void cp_parser_objc_at_dynamic_declaration
2870 static tree cp_parser_objc_struct_declaration
2873 /* Utility Routines */
2875 static cp_expr cp_parser_lookup_name
2877 static tree cp_parser_lookup_name_simple
2879 static tree cp_parser_maybe_treat_template_as_class
2881 static bool cp_parser_check_declarator_template_parameters
2883 static bool cp_parser_check_template_parameters
2885 static cp_expr cp_parser_simple_cast_expression
2887 static tree cp_parser_global_scope_opt
2889 static bool cp_parser_constructor_declarator_p
2891 static tree cp_parser_function_definition_from_specifiers_and_declarator
2893 static tree cp_parser_function_definition_after_declarator
2895 static bool cp_parser_template_declaration_after_export
2897 static void cp_parser_perform_template_parameter_access_checks
2899 static tree cp_parser_single_declaration
2901 static cp_expr cp_parser_functional_cast
2903 static tree cp_parser_save_member_function_body
2905 static tree cp_parser_save_nsdmi
2907 static tree cp_parser_enclosed_template_argument_list
2909 static void cp_parser_save_default_args
2911 static void cp_parser_late_parsing_for_member
2913 static tree cp_parser_late_parse_one_default_arg
2915 static void cp_parser_late_parsing_nsdmi
2917 static void cp_parser_late_parsing_default_args
2919 static tree cp_parser_sizeof_operand
2921 static cp_expr cp_parser_trait
2923 static bool cp_parser_declares_only_class_p
2925 static void cp_parser_set_storage_class
2927 static void cp_parser_set_decl_spec_type
2929 static void set_and_check_decl_spec_loc
2932 static bool cp_parser_friend_p
2934 static void cp_parser_required_error
2940 static bool cp_parser_token_starts_function_definition_p
2942 static bool cp_parser_next_token_starts_class_definition_p
2944 static bool cp_parser_next_token_ends_template_argument_p
2946 static bool cp_parser_nth_token_starts_template_argument_list_p
2948 static enum tag_types cp_parser_token_is_class_key
2950 static enum tag_types cp_parser_token_is_type_parameter_key
2953 static void cp_parser_check_class_key
2955 static void cp_parser_check_access_in_redeclaration
2957 static bool cp_parser_optional_template_keyword
2959 static void cp_parser_pre_parsed_nested_name_specifier
2961 static bool cp_parser_cache_group
2963 static tree cp_parser_cache_defarg
2965 static void cp_parser_parse_tentatively
2967 static void cp_parser_commit_to_tentative_parse
2969 static void cp_parser_commit_to_topmost_tentative_parse
2971 static void cp_parser_abort_tentative_parse
2973 static bool cp_parser_parse_definitely
2977 static bool cp_parser_uncommitted_to_tentative_parse_p
2979 static void cp_parser_error
2981 static void cp_parser_name_lookup_error
2983 static bool cp_parser_simulate_error
2985 static bool cp_parser_check_type_definition
2987 static void cp_parser_check_for_definition_in_return_type
2989 static void cp_parser_check_for_invalid_template_id
2991 static bool cp_parser_non_integral_constant_expression
2993 static void cp_parser_diagnose_invalid_type_name
2995 static bool cp_parser_parse_and_diagnose_invalid_type_name
2997 static int cp_parser_skip_to_closing_parenthesis
2999 static void cp_parser_skip_to_end_of_statement
3001 static void cp_parser_consume_semicolon_at_end_of_statement
3003 static void cp_parser_skip_to_end_of_block_or_statement
3005 static bool cp_parser_skip_to_closing_brace
3007 static bool cp_parser_skip_entire_template_parameter_list
3009 static void cp_parser_require_end_of_template_parameter_list
3011 static bool cp_parser_skip_to_end_of_template_parameter_list
3013 static void cp_parser_skip_to_pragma_eol
3015 static bool cp_parser_error_occurred
3017 static bool cp_parser_allow_gnu_extensions_p
3019 static bool cp_parser_is_pure_string_literal
3021 static bool cp_parser_is_string_literal
3023 static bool cp_parser_is_keyword
3025 static tree cp_parser_make_typename_type
3029 static bool cp_parser_compound_literal_p
3031 static bool cp_parser_array_designator_p
3033 static bool cp_parser_init_statement_p
3035 static bool cp_parser_skip_up_to_closing_square_bracket
3037 static bool cp_parser_skip_to_closing_square_bracket
3042 // -------------------------------------------------------------------------- //
3043 // Unevaluated Operand Guard
3044 //
3045 // Implementation of an RAII helper for unevaluated operand parsing.
3047 {
3050 }
3053 {
3056 }
3058 // -------------------------------------------------------------------------- //
3059 // Tentative Parsing
3061 /* Returns nonzero if we are parsing tentatively. */
3065 {
3067 }
3069 /* Returns nonzero if TOKEN is a string literal. */
3071 static bool
3073 {
3079 }
3081 /* Returns nonzero if TOKEN is a string literal
3082 of a user-defined string literal. */
3084 static bool
3086 {
3093 }
3095 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
3097 static bool
3099 {
3101 }
3103 /* Helper function for cp_parser_error.
3104 Having peeked a token of kind TOK1_KIND that might signify
3105 a conflict marker, peek successor tokens to determine
3106 if we actually do have a conflict marker.
3107 Specifically, we consider a run of 7 '<', '=' or '>' characters
3108 at the start of a line as a conflict marker.
3109 These come through the lexer as three pairs and a single,
3110 e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
3111 If it returns true, *OUT_LOC is written to with the location/range
3112 of the marker. */
3114 static bool
3117 {
3128 /* It must be at the start of the line. */
3133 /* We have a conflict marker. Construct a location of the form:
3134 <<<<<<<
3135 ^~~~~~~
3136 with start == caret, finishing at the end of the marker. */
3141 }
3143 /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
3144 RT_CLOSE_PAREN. */
3148 {
3150 {
3158 }
3159 }
3161 /* Attempt to convert TOKEN_DESC from a required_token to an
3162 enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
3164 static enum cpp_ttype
3166 {
3168 {
3189 /* Use CPP_EOF as a "no completions possible" code. */
3191 }
3192 }
3195 /* Subroutine of cp_parser_error and cp_parser_required_error.
3197 Issue a diagnostic of the form
3198 FILE:LINE: MESSAGE before TOKEN
3199 where TOKEN is the next token in the input stream. MESSAGE
3200 (specified by the caller) is usually of the form "expected
3201 OTHER-TOKEN".
3203 This bypasses the check for tentative passing, and potentially
3204 adds material needed by cp_parser_required_error.
3206 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
3207 suggesting insertion of the missing token.
3209 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
3210 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
3211 location. */
3213 static void
3215 required_token missing_token_desc,
3216 location_t matching_location)
3217 {
3219 /* This diagnostic makes more sense if it is tagged to the line
3220 of the token we just peeked at. */
3224 {
3229 }
3231 /* If this is actually a conflict marker, report it as such. */
3235 {
3236 location_t loc;
3238 {
3241 /* Consume tokens until the end of the source line. */
3243 {
3257 }
3259 }
3260 }
3262 auto_diagnostic_group d;
3269 {
3270 /* Potentially supply a fix-it hint, suggesting to add the
3271 missing token immediately after the *previous* token.
3272 This may move the primary location within richloc. */
3276 prev_token_loc);
3278 /* If matching_location != UNKNOWN_LOCATION, highlight it.
3279 Attempt to consolidate diagnostics by printing it as a
3280 secondary range within the main diagnostic. */
3282 added_matching_location
3284 }
3286 /* If we were parsing a string-literal and there is an unknown name
3287 token right after, then check to see if that could also have been
3288 a literal string by checking the name against a list of known
3289 standard string literal constants defined in header files. If
3290 there is one, then add that as an hint to the error message. */
3291 name_hint h;
3295 {
3302 token_name,
3303 header_hint));
3304 }
3306 /* Actually emit the error. */
3308 /* Because c_parser_error does not understand
3309 CPP_KEYWORD, keywords are treated like
3310 identifiers. */
3315 {
3316 /* If we weren't able to consolidate matching_location, then
3317 print it as a secondary diagnostic. */
3322 }
3323 }
3325 /* If not parsing tentatively, issue a diagnostic of the form
3326 FILE:LINE: MESSAGE before TOKEN
3327 where TOKEN is the next token in the input stream. MESSAGE
3328 (specified by the caller) is usually of the form "expected
3329 OTHER-TOKEN". */
3331 static void
3333 {
3336 }
3338 /* Issue an error about name-lookup failing. NAME is the
3339 IDENTIFIER_NODE DECL is the result of
3340 the lookup (as returned from cp_parser_lookup_name). DESIRED is
3341 the thing that we hoped to find. */
3343 static void
3345 tree name,
3346 tree decl,
3347 name_lookup_error desired,
3348 location_t location)
3349 {
3350 /* If name lookup completely failed, tell the user that NAME was not
3351 declared. */
3353 {
3366 else
3368 }
3370 {
3372 {
3389 }
3390 }
3392 {
3394 {
3404 name);
3408 }
3409 }
3410 else
3411 {
3413 {
3426 }
3427 }
3428 }
3430 /* If we are parsing tentatively, remember that an error has occurred
3431 during this tentative parse. Returns true if the error was
3432 simulated; false if a message should be issued by the caller. */
3434 static bool
3436 {
3438 {
3441 }
3443 }
3445 /* This function is called when a type is defined. If type
3446 definitions are forbidden at this point, an error message is
3447 issued. */
3449 static bool
3451 {
3452 /* If types are forbidden here, issue a message. */
3454 {
3455 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3456 or %qs in the message need to be interpreted. */
3460 }
3462 }
3464 /* This function is called when the DECLARATOR is processed. The TYPE
3465 was a type defined in the decl-specifiers. If it is invalid to
3466 define a type in the decl-specifiers for DECLARATOR, an error is
3467 issued. TYPE_LOCATION is the location of TYPE and is used
3468 for error reporting. */
3470 static void
3473 {
3474 /* [dcl.fct] forbids type definitions in return types.
3475 Unfortunately, it's not easy to know whether or not we are
3476 processing a return type until after the fact. */
3484 {
3489 type);
3490 }
3491 }
3493 /* A type-specifier (TYPE) has been parsed which cannot be followed by
3494 "<" in any valid C++ program. If the next token is indeed "<",
3495 issue a message warning the user about what appears to be an
3496 invalid attempt to form a template-id. LOCATION is the location
3497 of the type-specifier (TYPE) */
3499 static void
3501 tree type,
3503 location_t location)
3504 {
3508 {
3514 {
3517 else
3519 }
3520 else
3522 /* Remember the location of the invalid "<". */
3525 /* Consume the "<". */
3527 /* Parse the template arguments. */
3529 /* Permanently remove the invalid template arguments so that
3530 this error message is not issued again. */
3533 }
3534 }
3536 /* If parsing an integral constant-expression, issue an error message
3537 about the fact that THING appeared and return true. Otherwise,
3538 return false. In either case, set
3539 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3541 static bool
3543 non_integral_constant thing)
3544 {
3547 {
3549 {
3552 {
3555 "ISO C++ forbids using a floating-point literal "
3560 "enumeration type cannot appear in a "
3651 }
3655 }
3656 }
3658 }
3660 /* Emit a diagnostic for an invalid type name. This function commits
3661 to the current active tentative parse, if any. (Otherwise, the
3662 problematic construct might be encountered again later, resulting
3663 in duplicate error messages.) LOCATION is the location of ID. */
3665 static void
3667 location_t location)
3668 {
3671 /* Try to lookup the identifier. */
3678 /* If the lookup was ambiguous, an error will already have
3679 been issued. */
3681 /* If the lookup found a template-name, it means that the user forgot
3682 to specify an argument list. Emit a useful error message. */
3684 {
3685 auto_diagnostic_group d;
3688 decl);
3693 }
3697 /* Something like 'unsigned A a;' */
3700 {
3701 /* Issue an error message. */
3702 auto_diagnostic_group d;
3703 name_hint hint;
3707 {
3713 }
3714 else
3716 /* If we're in a template class, it's possible that the user was
3717 referring to a type from a base class. For example:
3719 template <typename T> struct A { typedef T X; };
3720 template <typename T> struct B : public A<T> { X x; };
3722 The user should have said "typename A<T>::X". */
3731 {
3734 id);
3737 id);
3738 else
3741 }
3758 {
3761 {
3765 {
3766 /* Go from a particular instantiation of the
3767 template (which will have an empty TYPE_FIELDs),
3768 to the main version. */
3774 {
3779 }
3780 }
3781 }
3782 found:;
3783 }
3784 }
3785 /* Here we diagnose qualified-ids where the scope is actually correct,
3786 but the identifier does not resolve to a valid type name. */
3788 {
3790 {
3791 auto_diagnostic_group d;
3792 name_hint hint;
3801 {
3804 "%qE in namespace %qE does not name a template"
3807 else
3811 }
3813 {
3816 "%qE in namespace %qE does not name a template"
3819 else
3821 "%qE in namespace %qE does not name a template"
3824 }
3825 else
3826 {
3829 "%qE in namespace %qE does not name a type"
3832 else
3836 }
3839 }
3842 {
3843 /* A<T>::A<T>() */
3844 auto_diagnostic_group d;
3850 }
3853 {
3858 "need %<typename%> before %<%T::%D::%E%> because "
3862 id,
3865 else
3869 }
3871 {
3872 auto_diagnostic_group d;
3884 else
3890 }
3891 else
3893 }
3894 }
3896 /* Check for a common situation where a type-name should be present,
3897 but is not, and issue a sensible error message. Returns true if an
3898 invalid type-name was detected.
3900 The situation handled by this function are variable declarations of the
3901 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3902 Usually, `ID' should name a type, but if we got here it means that it
3903 does not. We try to emit the best possible error message depending on
3904 how exactly the id-expression looks like. */
3906 static bool
3908 {
3909 tree id;
3912 /* Avoid duplicate error about ambiguous lookup. */
3914 {
3918 }
3927 /* If the next token is a (, this is a function with no explicit return
3928 type, i.e. constructor, destructor or conversion op. */
3931 {
3934 }
3938 /* Emit a diagnostic for the invalid type. */
3940 out:
3941 /* If we aren't in the middle of a declarator (i.e. in a
3942 parameter-declaration-clause), skip to the end of the declaration;
3943 there's no point in trying to process it. */
3947 }
3949 /* Consume tokens up to, and including, the next non-nested closing `)'.
3950 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3951 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3952 found an unnested token of that type. */
3954 static int
3957 cpp_ttype or_ttype,
3959 {
3970 {
3973 /* Have we found what we're looking for before the closing paren? */
3979 {
3983 /* FALLTHRU */
3985 /* If we've run out of tokens, then there is no closing `)'. */
3988 /* This is good for lambda expression capture-lists. */
3998 /* This matches the processing in skip_to_end_of_statement. */
4018 {
4022 }
4032 condop_depth--;
4038 /* FALLTHROUGH */
4041 /* We fell into a pragma. Skip it, and continue. */
4047 }
4049 /* Consume the token. */
4051 }
4052 }
4054 /* Consume tokens up to, and including, the next non-nested closing `)'.
4055 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
4056 are doing error recovery. Returns -1 if OR_COMMA is true and we
4057 found an unnested token of that type. */
4059 static int
4064 {
4068 }
4070 /* Consume tokens until we reach the end of the current statement.
4071 Normally, that will be just before consuming a `;'. However, if a
4072 non-nested `}' comes first, then we stop before consuming that. */
4074 static void
4076 {
4079 /* Unwind generic function template scope if necessary. */
4084 {
4088 {
4092 /* FALLTHRU */
4094 /* If we've run out of tokens, stop. */
4098 /* If the next token is a `;', we have reached the end of the
4099 statement. */
4105 /* If this is a non-nested '}', stop before consuming it.
4106 That way, when confronted with something like:
4108 { 3 + }
4110 we stop before consuming the closing '}', even though we
4111 have not yet reached a `;'. */
4115 /* If it is the closing '}' for a block that we have
4116 scanned, stop -- but only after consuming the token.
4117 That way given:
4119 void f g () { ... }
4120 typedef int I;
4122 we will stop after the body of the erroneously declared
4123 function, but before consuming the following `typedef'
4124 declaration. */
4126 {
4129 }
4139 /* FALLTHROUGH */
4142 /* We fell into a pragma. Skip it, and continue or return. */
4150 }
4152 /* Consume the token. */
4154 }
4155 }
4157 /* This function is called at the end of a statement or declaration.
4158 If the next token is a semicolon, it is consumed; otherwise, error
4159 recovery is attempted. */
4161 static void
4163 {
4164 /* Look for the trailing `;'. */
4166 {
4167 /* If there is additional (erroneous) input, skip to the end of
4168 the statement. */
4170 /* If the next token is now a `;', consume it. */
4173 }
4174 }
4176 /* Skip tokens until we have consumed an entire block, or until we
4177 have consumed a non-nested `;'. */
4179 static void
4181 {
4184 /* Unwind generic function template scope if necessary. */
4189 {
4193 {
4197 /* FALLTHRU */
4199 /* If we've run out of tokens, stop. */
4203 /* Stop if this is an unnested ';'. */
4209 /* Stop if this is an unnested '}', or closes the outermost
4210 nesting level. */
4211 nesting_depth--;
4219 /* Nest. */
4220 nesting_depth++;
4226 /* FALLTHROUGH */
4229 /* Skip it, and continue or return. */
4237 }
4239 /* Consume the token. */
4241 }
4242 }
4244 /* Skip tokens until a non-nested closing curly brace is the next
4245 token, or there are no more tokens. Return true in the first case,
4246 false otherwise. */
4248 static bool
4250 {
4254 {
4258 {
4262 /* FALLTHRU */
4264 /* If we've run out of tokens, stop. */
4268 /* If the next token is a non-nested `}', then we have reached
4269 the end of the current block. */
4275 /* If it the next token is a `{', then we are entering a new
4276 block. Consume the entire block. */
4282 }
4284 /* Consume the token. */
4286 }
4287 }
4289 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4290 parameter is the PRAGMA token, allowing us to purge the entire pragma
4291 sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4292 forwards (not error recovery). */
4294 static void
4296 {
4299 do
4300 {
4301 /* The preprocessor makes sure that a PRAGMA_EOL token appears
4302 before an EOF token, even when the EOF is on the pragma line.
4303 We should never get here without being inside a deferred
4304 pragma. */
4307 }
4311 {
4315 {
4317 /* Put the current source position back where it was before this
4318 lexer was pushed. */
4320 }
4321 }
4322 }
4324 /* Require pragma end of line, resyncing with it as necessary. The
4325 arguments are as for cp_parser_skip_to_pragma_eol. */
4327 static void
4329 {
4335 {
4337 /* Put the current source position back where it was before this
4338 lexer was pushed. */
4340 }
4341 }
4343 /* This is a simple wrapper around make_typename_type. When the id is
4344 an unresolved identifier node, we can provide a superior diagnostic
4345 using cp_parser_diagnose_invalid_type_name. */
4347 static tree
4349 location_t id_location)
4350 {
4351 tree result;
4353 {
4359 }
4361 }
4363 /* This is a wrapper around the
4364 make_{pointer,ptrmem,reference}_declarator functions that decides
4365 which one to call based on the CODE and CLASS_TYPE arguments. The
4366 CODE argument should be one of the values returned by
4367 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4368 appertain to the pointer or reference. */
4372 cp_cv_quals cv_qualifiers,
4374 tree attributes)
4375 {
4382 else
4392 }
4394 /* Create a new C++ parser. */
4398 {
4399 /* Initialize the binops_by_token so that we can get the tree
4400 directly from the token. */
4408 /* For now, we always accept GNU extensions. */
4411 /* The `>' token is a greater-than operator, not the end of a
4412 template-id. */
4417 /* We are not parsing a constant-expression. */
4422 /* Local variable names are not forbidden. */
4425 /* We are not processing an `extern "C"' declaration. */
4428 /* We are not processing a declarator. */
4431 /* We are not processing a template-argument-list. */
4434 /* We are not in an iteration statement. */
4437 /* We are not in a switch statement. */
4440 /* We are not parsing a type-id inside an expression. */
4443 /* String literals should be translated to the execution character set. */
4446 /* We are not parsing a function body. */
4449 /* We can correct until told otherwise. */
4452 /* The unparsed function queue is empty. */
4455 /* There are no classes being defined. */
4458 /* No template parameters apply. */
4461 /* Special parsing data structures. */
4465 /* Disallow OpenMP array sections in expressions. */
4468 /* Not declaring an implicit function template. */
4474 /* Allow constrained-type-specifiers. */
4477 /* We haven't yet seen an 'extern "C"'. */
4481 }
4483 /* Create a cp_lexer structure which will emit the tokens in CACHE
4484 and push it onto the parser's lexer stack. This is used for delayed
4485 parsing of in-class method bodies and default arguments, and should
4486 not be confused with tentative parsing. */
4487 static void
4489 {
4494 /* Move the current source position to that of the first token in the
4495 new lexer. */
4497 }
4499 /* Pop the top lexer off the parser stack. This is never used for the
4500 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4501 static void
4503 {
4508 /* Put the current source position back where it was before this
4509 lexer was pushed. */
4511 }
4513 /* Lexical conventions [gram.lex] */
4515 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4516 identifier. */
4518 static cp_expr
4520 {
4523 /* Look for the identifier. */
4525 /* Return the value. */
4528 else
4530 }
4532 /* Worker for cp_parser_string_literal, cp_parser_userdef_string_literal
4533 and cp_parser_unevaluated_string_literal.
4534 Do not call this directly; use either of the above.
4536 Parse a sequence of adjacent string constants. Return a
4537 TREE_STRING representing the combined, nul-terminated string
4538 constant. If TRANSLATE is true, translate the string to the
4539 execution character set. If WIDE_OK is true, a wide string is
4540 valid here. If UDL_OK is true, a string literal with user-defined
4541 suffix can be used in this context. If UNEVAL is true, diagnose
4542 numeric and conditional escape sequences in it if pedantic.
4544 C++98 [lex.string] says that if a narrow string literal token is
4545 adjacent to a wide string literal token, the behavior is undefined.
4546 However, C99 6.4.5p4 says that this results in a wide string literal.
4547 We follow C99 here, for consistency with the C front end.
4549 This code is largely lifted from lex_string() in c-lex.cc.
4551 FUTURE: ObjC++ will need to handle @-strings here. */
4553 static cp_expr
4557 {
4558 tree value;
4566 tree string_tree;
4572 {
4575 }
4580 {
4582 {
4586 }
4590 }
4591 else
4592 {
4595 }
4598 /* Try to avoid the overhead of creating and destroying an obstack
4599 for the common case of just one string. */
4602 {
4610 {
4614 }
4615 else
4619 }
4620 else
4621 {
4627 do
4628 {
4630 count++;
4635 {
4638 {
4641 }
4644 {
4649 }
4651 }
4652 else
4656 {
4660 {
4664 "concatenation of string literals with "
4666 }
4667 }
4676 {
4678 {
4682 }
4686 }
4687 else
4688 {
4692 }
4693 }
4696 /* A string literal built by concatenation has its caret=start at
4697 the start of the initial string, and its finish at the finish of
4698 the final string literal. */
4702 }
4705 {
4708 }
4714 {
4718 {
4722 }
4725 {
4733 else
4745 }
4750 {
4755 else
4757 }
4758 }
4759 else
4760 /* cpp_interpret_string has issued an error. */
4764 {
4767 }
4770 }
4772 /* Parse a sequence of adjacent string constants. Return a TREE_STRING
4773 representing the combined, nul-terminated string constant. If
4774 TRANSLATE is true, translate the string to the execution character set.
4775 If WIDE_OK is true, a wide string is valid here.
4777 This function issues an error if a user defined string literal is
4778 encountered; use cp_parser_userdef_string_literal if UDLs are allowed. */
4782 {
4787 }
4789 /* Parse a string literal or user defined string literal.
4791 user-defined-string-literal :
4792 string-literal ud-suffix
4794 If LOOKUP_UDLIT, perform a lookup for a suitable template function. */
4798 {
4802 }
4804 /* Parse an unevaluated string literal.
4806 unevaluated-string:
4807 string-literal */
4811 {
4816 }
4818 /* Look up a literal operator with the name and the exact arguments. */
4820 static tree
4822 {
4828 {
4832 {
4839 {
4849 }
4853 /* May be this should be sufficient_parms_p instead,
4854 depending on how exactly should user-defined literals
4855 work in presence of default arguments on the literal
4856 operator parameters. */
4859 }
4860 }
4863 }
4865 /* Parse a user-defined char constant. Returns a call to a user-defined
4866 literal operator taking the character as an argument. */
4868 static cp_expr
4870 {
4878 /* Build up a call to the user-defined operator */
4879 /* Lookup the name we got back from the id-expression. */
4880 releasing_vec args;
4884 {
4888 }
4891 }
4893 /* A subroutine of cp_parser_userdef_numeric_literal to
4894 create a char... template parameter pack from a string node. */
4896 static tree
4898 {
4899 tree charvec;
4906 /* Fill in CHARVEC with all of the parameters. */
4909 {
4918 }
4920 /* Build the argument packs. */
4926 }
4928 /* A subroutine of cp_parser_userdef_numeric_literal to
4929 create a char... template parameter pack from a string node. */
4931 static tree
4933 {
4934 tree charvec;
4945 /* First template parm is character type. */
4948 /* Fill in CHARVEC with all of the parameters. */
4955 /* Build the argument packs. */
4961 }
4963 /* Parse a user-defined numeric constant. returns a call to a user-defined
4964 literal operator. */
4966 static cp_expr
4968 {
4978 /* Look for a literal operator taking the exact type of numeric argument
4979 as the literal value. */
4980 releasing_vec args;
4984 {
4986 tf_warning_or_error);
4989 {
4992 long_long_unsigned_type_node);
4993 }
4994 else
4995 {
4999 long_double_type_node);
5003 }
5006 }
5008 /* If the numeric argument didn't work, look for a raw literal
5009 operator taking a const char* argument consisting of the number
5010 in string format. */
5015 {
5017 tf_warning_or_error);
5019 }
5021 /* If the raw literal didn't work, look for a non-type template
5022 function with parameter pack char.... Call the function with
5023 template parameter characters representing the number. */
5027 {
5030 {
5032 num_string);
5034 }
5037 tf_warning_or_error);
5039 }
5041 /* In C++14 the standard library defines complex number suffixes that
5042 conflict with GNU extensions. Prefer them if <complex> is #included. */
5052 {
5056 {
5057 /* No <complex>, so pedwarn and use GNU semantics. */
5060 }
5061 }
5063 bool complained
5070 {
5072 "(from %<<complex>%>) to enable the C++14 user-defined literal "
5077 }
5084 else
5085 {
5086 /* Use the built-in semantics. */
5087 tree type;
5089 {
5092 else
5094 }
5102 }
5105 /* Avoid repeated diagnostics. */
5108 }
5110 /* Parse a user-defined string constant. Returns a call to a user-defined
5111 literal operator taking a character pointer and the length of the string
5112 as arguments. */
5114 static tree
5116 {
5122 tree decl;
5124 /* Build up a call to the user-defined operator. */
5125 /* Lookup the name we got back from the id-expression. */
5126 releasing_vec args;
5133 tf_warning_or_error);
5135 /* Look for a suitable template function, either (C++20) with a single
5136 parameter of class type, or (N3599) with typename parameter CharT and
5137 parameter pack CharT... */
5141 {
5142 /* Use resolve_nondeduced_context to try to choose one form of template
5143 or the other. */
5150 else
5151 {
5156 }
5160 tf_warning_or_error);
5161 }
5166 }
5169 /* Basic concepts [gram.basic] */
5171 /* Parse a translation-unit.
5173 translation-unit:
5174 declaration-seq [opt] */
5176 static void
5178 {
5181 /* Create the declarator obstack. */
5183 /* Create the error declarator. */
5185 /* Create the empty parameter list. */
5187 UNKNOWN_LOCATION);
5188 /* Remember where the base of the declarator obstack lies. */
5200 /* Parse until EOF. */
5202 {
5205 /* If we're entering or exiting a region that's implicitly
5206 extern "C", modify the lang context appropriately. This is
5207 so horrible. Please die. */
5210 {
5214 else
5216 }
5222 {
5223 /* Top-level module declarations are ok, and change the
5224 portion of file we're in. Top-level import declarations
5225 are significant for the import portions. */
5230 {
5233 }
5235 {
5236 mp_state
5239 }
5241 {
5246 }
5247 else
5251 {
5254 {
5257 "global module fragment contents must be"
5259 }
5260 }
5261 }
5263 /* This relies on the ordering of module_parse values. */
5265 /* We're no longer in the import portion of a named module. */
5271 {
5274 /* If the next token is now a `;', consume it. */
5277 }
5278 else
5280 }
5282 /* Get rid of the token array; we don't need it any more. */
5286 /* The EOF should have reset this. */
5289 /* Make sure the declarator obstack was fully cleaned up. */
5292 }
5294 /* Return the appropriate tsubst flags for parsing, possibly in N3276
5295 decltype context. */
5299 {
5304 }
5306 /* We're about to parse a collection of statements. If we're currently
5307 parsing tentatively, set up a firewall so that any nested
5308 cp_parser_commit_to_tentative_parse won't affect the current context. */
5310 static cp_token_position
5312 {
5319 }
5321 /* We've finished parsing the collection of statements. Wrap up the
5322 firewall and replace the relevant tokens with the parsed form. */
5324 static void
5326 tree expr)
5327 {
5331 /* Finish the firewall level. */
5333 /* And remember the result of the parse for when we try again. */
5339 }
5341 /* Like the above functions, but let the user modify the tokens. Used by
5342 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5343 later parses, so it makes sense to localize the effects of
5344 cp_parser_commit_to_tentative_parse. */
5346 struct tentative_firewall
5347 {
5352 {
5353 /* If we're currently parsing tentatively, start a committed level as a
5354 firewall and then an inner tentative parse. */
5356 {
5360 }
5361 }
5364 {
5366 {
5367 /* Finish the inner tentative parse and the firewall, propagating any
5368 uncommitted error state to the outer tentative parse. */
5374 }
5375 }
5376 };
5378 /* Some tokens naturally come in pairs e.g.'(' and ')'.
5379 This class is for tracking such a matching pair of symbols.
5380 In particular, it tracks the location of the first token,
5381 so that if the second token is missing, we can highlight the
5382 location of the first token when notifying the user about the
5383 problem. */
5386 class token_pair
5387 {
5389 /* token_pair's ctor. */
5392 /* If the next token is the opening symbol for this pair, consume it and
5393 return true.
5394 Otherwise, issue an error and return false.
5395 In either case, record the location of the opening token. */
5398 {
5402 }
5404 /* Consume the next token from PARSER, recording its location as
5405 that of the opening token within the pair. */
5408 {
5413 }
5415 /* If the next token is the closing symbol for this pair, consume it
5416 and return it.
5417 Otherwise, issue an error, highlighting the location of the
5418 corresponding opening token, and return NULL. */
5421 {
5424 m_open_loc);
5425 }
5430 location_t m_open_loc;
5431 };
5433 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5435 struct matching_paren_traits
5436 {
5441 };
5443 /* "matching_parens" is a token_pair<T> class for tracking matching
5444 pairs of parentheses. */
5448 /* Traits for token_pair<T> for tracking matching pairs of braces. */
5450 struct matching_brace_traits
5451 {
5456 };
5458 /* "matching_braces" is a token_pair<T> class for tracking matching
5459 pairs of braces. */
5464 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5465 enclosing parentheses. */
5467 static cp_expr
5469 {
5473 /* Consume the '('. */
5475 matching_parens parens;
5477 /* Start the statement-expression. */
5479 /* Parse the compound-statement. */
5481 /* Finish up. */
5483 /* Consume the ')'. */
5491 }
5493 /* Expressions [gram.expr] */
5495 /* Parse a fold-operator.
5497 fold-operator:
5498 - * / % ^ & | = < > << >>
5499 = -= *= /= %= ^= &= |= <<= >>=
5500 == != <= >= && || , .* ->*
5502 This returns the tree code corresponding to the matched operator
5503 as an int. When the current token matches a compound assignment
5504 operator, the resulting tree code is the negative value of the
5505 non-assignment operator. */
5507 static int
5509 {
5511 {
5551 }
5552 }
5554 /* Returns true if CODE indicates a binary expression, which is not allowed in
5555 the LHS of a fold-expression. More codes will need to be added to use this
5556 function in other contexts. */
5558 static bool
5560 {
5562 {
5595 }
5596 }
5598 /* If the next token is a suitable fold operator, consume it and return as
5599 the function above. */
5601 static int
5603 {
5609 }
5611 /* Parse a fold-expression.
5613 fold-expression:
5614 ( ... folding-operator cast-expression)
5615 ( cast-expression folding-operator ... )
5616 ( cast-expression folding operator ... folding-operator cast-expression)
5618 Note that the '(' and ')' are matched in primary expression. */
5620 static cp_expr
5622 {
5623 cp_id_kind pidk;
5627 // Left fold.
5629 {
5636 {
5639 }
5647 }
5652 {
5655 }
5658 {
5661 }
5664 /* The operands of a fold-expression are cast-expressions, so binary or
5665 conditional expressions are not allowed. We check this here to avoid
5666 tentative parsing. */
5678 // Right fold.
5680 {
5683 }
5686 {
5689 }
5692 // Binary left or right fold.
5698 }
5700 /* Parse a primary-expression.
5702 primary-expression:
5703 literal
5704 this
5705 ( expression )
5706 id-expression
5707 lambda-expression (C++11)
5709 GNU Extensions:
5711 primary-expression:
5712 ( compound-statement )
5713 __builtin_va_arg ( assignment-expression , type-id )
5714 __builtin_offsetof ( type-id , offsetof-expression )
5716 C++ Extensions:
5717 __has_nothrow_assign ( type-id )
5718 __has_nothrow_constructor ( type-id )
5719 __has_nothrow_copy ( type-id )
5720 __has_trivial_assign ( type-id )
5721 __has_trivial_constructor ( type-id )
5722 __has_trivial_copy ( type-id )
5723 __has_trivial_destructor ( type-id )
5724 __has_virtual_destructor ( type-id )
5725 __is_abstract ( type-id )
5726 __is_base_of ( type-id , type-id )
5727 __is_class ( type-id )
5728 __is_empty ( type-id )
5729 __is_enum ( type-id )
5730 __is_final ( type-id )
5731 __is_literal_type ( type-id )
5732 __is_pod ( type-id )
5733 __is_polymorphic ( type-id )
5734 __is_std_layout ( type-id )
5735 __is_trivial ( type-id )
5736 __is_union ( type-id )
5738 Objective-C++ Extension:
5740 primary-expression:
5741 objc-expression
5743 literal:
5744 __null
5746 ADDRESS_P is true iff this expression was immediately preceded by
5747 "&" and therefore might denote a pointer-to-member. CAST_P is true
5748 iff this expression is the target of a cast. TEMPLATE_ARG_P is
5749 true iff this expression is a template argument.
5751 Returns a representation of the expression. Upon return, *IDK
5752 indicates what kind of id-expression (if any) was present. */
5754 static cp_expr
5761 {
5764 /* Assume the primary expression is not an id-expression. */
5767 /* Peek at the next token. */
5770 {
5771 /* literal:
5772 integer-literal
5773 character-literal
5774 floating-literal
5775 string-literal
5776 boolean-literal
5777 pointer-literal
5778 user-defined-literal */
5790 {
5794 }
5795 /* Floating-point literals are only allowed in an integral
5796 constant expression if they are cast to an integral or
5797 enumeration type. */
5803 {
5804 /* CAST_P will be set even in invalid code like "int(2.7 +
5805 ...)". Therefore, we have to check that the next token
5806 is sure to end the cast. */
5808 {
5813 enumerator-definition. */
5815 /* The curly brace at the end of an enum-specifier. */
5817 /* The end of a statement. */
5819 /* The end of the cast-expression. */
5821 /* The end of an array bound. */
5823 /* The closing ">" in a template-argument-list. */
5826 /* C++0x only: A ">>" treated like two ">" tokens,
5827 in a template-argument-list. */
5832 }
5834 /* If we are within a cast, then the constraint that the
5835 cast is to an integral or enumeration type will be
5836 checked at that point. If we are not within a cast, then
5837 this code is invalid. */
5840 }
5861 /* ??? Should wide strings be allowed when parser->translate_strings_p
5862 is false (i.e. in attributes)? If not, we can kill the third
5863 argument to cp_parser_string_literal. */
5868 else
5875 /* If we see `( { ' then we are looking at the beginning of
5876 a GNU statement-expression. */
5879 {
5880 /* Statement-expressions are not allowed by the standard. */
5884 /* And they're not allowed outside of a function-body; you
5885 cannot, for example, write:
5887 int i = ({ int j = 3; j + 1; });
5889 at class or namespace scope. */
5892 {
5894 "statement-expressions are not allowed outside "
5900 }
5901 else
5903 }
5904 /* Otherwise it's a normal parenthesized expression. */
5905 {
5906 cp_expr expr;
5911 /* Consume the `('. */
5912 matching_parens parens;
5914 /* Within a parenthesized expression, a `>' token is always
5915 the greater-than operator. */
5916 saved_greater_than_is_operator_p
5921 /* Left fold expression. */
5923 else
5924 /* Parse the parenthesized expression. */
5929 {
5934 "fold-expressions only available with %<-std=c++17%> "
5936 }
5937 else
5938 /* Let the front end know that this expression was
5939 enclosed in parentheses. This matters in case, for
5940 example, the expression is of the form `A::B', since
5941 `&A::B' might be a pointer-to-member, but `&(A::B)' is
5942 not. */
5945 /* DR 705: Wrapping an unqualified name in parentheses
5946 suppresses arg-dependent lookup. We want to pass back
5947 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5948 (c++/37862), but none of the others. */
5952 /* The `>' token might be the end of a template-id or
5953 template-parameter-list now. */
5954 parser->greater_than_is_operator_p
5957 /* Consume the `)'. */
5969 }
5972 {
5974 {
5975 /* We might have an Objective-C++ message. */
5978 /* If that works out, we're done ... */
5981 /* ... else, fall though to see if it's a lambda. */
5982 }
5984 /* Don't warn about a failed tentative parse. */
5989 }
5993 /* We have an Objective-C++ string literal. */
6000 {
6001 /* These two are the boolean literals. */
6009 /* The `__null' literal. */
6014 /* The `nullptr' literal. */
6019 /* Recognize the `this' keyword. */
6023 {
6027 }
6028 /* Pointers cannot appear in constant-expressions. */
6033 /* The `operator' keyword can be the beginning of an
6034 id-expression. */
6041 {
6042 non_integral_constant name;
6044 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
6045 __func__ are the names of variables -- but they are
6046 treated specially. Therefore, they are handled here,
6047 rather than relying on the generic id-expression logic
6048 below. Grammatically, these names are id-expressions.
6050 Consume the token. */
6054 {
6066 }
6071 /* Look up the name. */
6073 }
6076 {
6077 tree expression;
6078 tree type;
6079 location_t type_location;
6080 location_t start_loc
6082 /* The `__builtin_va_arg' construct is used to handle
6083 `va_arg'. Consume the `__builtin_va_arg' token. */
6085 /* Look for the opening `('. */
6086 matching_parens parens;
6088 /* Now, parse the assignment-expression. */
6090 /* Look for the `,'. */
6093 /* Parse the type-id. */
6094 {
6097 }
6098 /* Look for the closing `)'. */
6099 location_t finish_loc
6102 /* Using `va_arg' in a constant-expression is not
6103 allowed. */
6105 NIC_VA_ARG))
6107 /* Construct a location of the form:
6108 __builtin_va_arg (v, int)
6109 ~~~~~~~~~~~~~~~~~~~~~^~~~
6110 with the caret at the type, ranging from the start of the
6111 "__builtin_va_arg" token to the close paren. */
6112 location_t combined_loc
6115 }
6120 // C++ concepts
6124 /* Objective-C++ expressions. */
6134 "%<omp_all_memory%> may only be used in OpenMP "
6142 {
6147 }
6148 /* FALLTHRU */
6152 }
6154 /* An id-expression can start with either an identifier, a
6155 `::' as the beginning of a qualified-id, or the "operator"
6156 keyword. */
6160 /* FALLTHRU */
6164 {
6165 id_expression:
6166 cp_expr id_expression;
6167 cp_expr decl;
6173 /* Parse the id-expression. */
6174 id_expression
6191 /* If we have a template-id, then no further lookup is
6192 required. If the template-id was for a template-class, we
6193 will sometimes have a TYPE_DECL at this point. */
6197 /* Look up the name. */
6198 else
6199 {
6200 tree ambiguous_decls;
6202 /* If we already know that this lookup is ambiguous, then
6203 we've already issued an error message; there's no reason
6204 to check again. */
6207 {
6210 }
6213 none_type,
6214 template_p,
6219 /* If the lookup was ambiguous, an error will already have
6220 been issued. */
6224 /* In Objective-C++, we may have an Objective-C 2.0
6225 dot-syntax for classes here. */
6230 {
6231 tree component;
6238 component);
6239 /* Build a location of the form:
6240 expr.component
6241 ~~~~~^~~~~~~~~
6242 with caret at the start of the component name (at
6243 input_location), ranging from the start of the id_expression
6244 to the end of the component name. */
6245 location_t combined_loc
6250 }
6252 /* In Objective-C++, an instance variable (ivar) may be preferred
6253 to whatever cp_parser_lookup_name() found.
6254 Call objc_lookup_ivar. To avoid exposing cp_expr to the
6255 rest of c-family, we have to do a little extra work to preserve
6256 any location information in cp_expr "decl". Given that
6257 objc_lookup_ivar is implemented in "c-family" and "objc", we
6258 have a trip through the pure "tree" type, rather than cp_expr.
6259 Naively copying it back to "decl" would implicitly give the
6260 new cp_expr value an UNKNOWN_LOCATION for nodes that don't
6261 store an EXPR_LOCATION. Hence we only update "decl" (and
6262 hence its location_t) if we get back a different tree node. */
6264 id_expression);
6268 /* If name lookup gives us a SCOPE_REF, then the
6269 qualifying scope was dependent. */
6271 {
6272 /* At this point, we do not know if DECL is a valid
6273 integral constant expression. We assume that it is
6274 in fact such an expression, so that code like:
6276 template <int N> struct A {
6277 int a[B<N>::i];
6278 };
6280 is accepted. At template-instantiation time, we
6281 will check that B<N>::i is actually a constant. */
6283 }
6284 /* Check to see if DECL is a local variable in a context
6285 where that is forbidden. */
6288 /* DR 2082 permits local variables in unevaluated contexts
6289 within a default argument. */
6291 {
6299 }
6300 }
6302 decl = (finish_id_expression
6304 idk,
6309 template_arg_p,
6314 /* Build a location for an id-expression of the form:
6315 ::ns::id
6316 ~~~~~~^~
6317 or:
6318 id
6319 ^~
6320 i.e. from the start of the first token to the end of the final
6321 token, with the caret at the start of the unqualified-id. */
6325 location_t combined_loc
6330 }
6332 /* Anything else is an error. */
6336 }
6337 }
6345 {
6348 }
6350 /* Complain about missing template keyword when naming a dependent
6351 member template. */
6353 static void
6355 {
6362 "expected %qs keyword before dependent "
6365 }
6367 /* Parse an id-expression.
6369 id-expression:
6370 unqualified-id
6371 qualified-id
6373 qualified-id:
6374 :: [opt] nested-name-specifier template [opt] unqualified-id
6375 :: identifier
6376 :: operator-function-id
6377 :: template-id
6379 Return a representation of the unqualified portion of the
6380 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6381 a `::' or nested-name-specifier.
6383 Often, if the id-expression was a qualified-id, the caller will
6384 want to make a SCOPE_REF to represent the qualified-id. This
6385 function does not do this in order to avoid wastefully creating
6386 SCOPE_REFs when they are not required.
6388 If TEMPLATE_KEYWORD_P is true, then we have just seen the
6389 `template' keyword.
6391 If CHECK_DEPENDENCY_P is false, then names are looked up inside
6392 uninstantiated templates.
6394 If *TEMPLATE_P is non-NULL, it is set to true iff the
6395 `template' keyword is used to explicitly indicate that the entity
6396 named is a template.
6398 If DECLARATOR_P is true, the id-expression is appearing as part of
6399 a declarator, rather than as part of an expression. */
6401 static cp_expr
6408 {
6412 /* Assume the `template' keyword was not used. */
6416 /* Look for the optional `::' operator. */
6417 global_scope_p
6418 = (!template_keyword_p
6423 /* Look for the optional nested-name-specifier. */
6424 nested_name_specifier_p
6427 check_dependency_p,
6429 declarator_p,
6430 template_keyword_p)
6436 /* Peek at the next token. */
6439 /* If there is a nested-name-specifier, then we are looking at
6440 the first qualified-id production. */
6442 {
6443 tree saved_object_scope;
6444 tree saved_qualifying_scope;
6446 /* See if the next token is the `template' keyword. */
6450 /* Name lookup we do during the processing of the
6451 unqualified-id might obliterate SCOPE. */
6454 /* Process the final unqualified-id. */
6456 check_dependency_p,
6457 declarator_p,
6459 /* Restore the SAVED_SCOPE for our caller. */
6463 }
6464 /* Otherwise, if we are in global scope, then we are looking at one
6465 of the other qualified-id productions. */
6467 {
6468 /* If it's an identifier, and the next token is not a "<", then
6469 we can avoid the template-id case. This is an optimization
6470 for this common case. */
6472 && !cp_parser_nth_token_starts_template_argument_list_p
6477 /* Try a template-id. */
6481 declarator_p);
6482 /* If that worked, we're done. */
6486 /* Peek at the next token. (Changes in the token buffer may
6487 have invalidated the pointer obtained above.) */
6491 {
6498 {
6501 }
6502 /* Fall through. */
6507 }
6508 }
6509 else
6510 {
6515 declarator_p,
6516 optional_p);
6517 }
6520 && warn_missing_template_keyword
6521 && !template_keyword_p
6522 /* Don't warn if we're looking inside templates. */
6523 && check_dependency_p
6524 /* In a template argument list a > could be closing
6525 the enclosing targs. */
6528 /* Don't confuse an ill-formed constructor declarator for a missing
6529 template keyword in a return type. */
6533 OPT_Wmissing_template_keyword))
6534 {
6537 /* An operator after the > suggests that the > ends a
6538 template-id; a name or literal suggests that the > is an
6539 operator. */
6543 }
6546 }
6548 /* Parse an unqualified-id.
6550 unqualified-id:
6551 identifier
6552 operator-function-id
6553 conversion-function-id
6554 ~ class-name
6555 template-id
6557 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6558 keyword, in a construct like `A::template ...'.
6560 Returns a representation of unqualified-id. For the `identifier'
6561 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6562 production a BIT_NOT_EXPR is returned; the operand of the
6563 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6564 other productions, see the documentation accompanying the
6565 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6566 names are looked up in uninstantiated templates. If DECLARATOR_P
6567 is true, the unqualified-id is appearing as part of a declarator,
6568 rather than as part of an expression. */
6570 static cp_expr
6576 {
6579 /* Peek at the next token. */
6583 {
6585 {
6586 tree id;
6588 /* We don't know yet whether or not this will be a
6589 template-id. */
6591 /* Try a template-id. */
6593 check_dependency_p,
6594 declarator_p);
6595 /* If it worked, we're done. */
6598 /* Otherwise, it's an ordinary identifier. */
6600 }
6604 check_dependency_p,
6605 declarator_p);
6608 {
6609 tree type_decl;
6610 tree qualifying_scope;
6611 tree object_scope;
6612 tree scope;
6616 /* Consume the `~' token. */
6618 /* Parse the class-name. The standard, as written, seems to
6619 say that:
6621 template <typename T> struct S { ~S (); };
6622 template <typename T> S<T>::~S() {}
6624 is invalid, since `~' must be followed by a class-name, but
6625 `S<T>' is dependent, and so not known to be a class.
6626 That's not right; we need to look in uninstantiated
6627 templates. A further complication arises from:
6629 template <typename T> void f(T t) {
6630 t.T::~T();
6631 }
6633 Here, it is not possible to look up `T' in the scope of `T'
6634 itself. We must look in both the current scope, and the
6635 scope of the containing complete expression.
6637 Yet another issue is:
6639 struct S {
6640 int S;
6641 ~S();
6642 };
6644 S::~S() {}
6646 The standard does not seem to say that the `S' in `~S'
6647 should refer to the type `S' and not the data member
6648 `S::S'. */
6650 /* DR 244 says that we look up the name after the "~" in the
6651 same scope as we looked up the qualifying name. That idea
6652 isn't fully worked out; it's more complicated than that. */
6657 /* Check for invalid scopes. */
6659 {
6663 }
6665 {
6669 scope);
6674 }
6676 {
6682 }
6688 /* Create a location with caret == start at the tilde,
6689 finishing at the end of the peeked token, e.g:
6690 ~token
6691 ^~~~~~. */
6692 location_t loc
6695 /* If the name is of the form "X::~X" it's OK even if X is a
6696 typedef. */
6705 {
6708 }
6710 /* ~auto means the destructor of whatever the object is. */
6712 {
6715 "%<~auto%> only available with "
6719 }
6721 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6722 declarator-id of a constructor or destructor. */
6724 {
6725 auto_diagnostic_group d;
6736 }
6738 /* If there was an explicit qualification (S::~T), first look
6739 in the scope given by the qualification (i.e., S).
6741 Note: in the calls to cp_parser_class_name below we pass
6742 typename_type so that lookup finds the injected-class-name
6743 rather than the constructor. */
6747 {
6752 typename_type,
6755 declarator_p);
6758 }
6759 /* In "N::S::~S", look in "N" as well. */
6761 {
6766 type_decl
6770 typename_type,
6773 declarator_p);
6776 }
6777 /* In "p->S::~T", look in the scope given by "*p" as well. */
6779 {
6784 type_decl
6788 typename_type,
6791 declarator_p);
6794 }
6795 /* Look in the surrounding context. */
6797 {
6803 type_decl
6807 typename_type,
6810 declarator_p);
6813 {
6814 /* We couldn't find a type with this name. If we're parsing
6815 tentatively, fail and try something else. */
6817 {
6820 }
6821 /* Otherwise, accept it and check for a match at instantiation
6822 time. */
6827 }
6828 }
6829 /* If an error occurred, assume that the name of the
6830 destructor is the same as the name of the qualifying
6831 class. That allows us to keep parsing after running
6832 into ill-formed destructor names. */
6838 /* Check that destructor name and scope match. */
6840 {
6847 }
6849 /* [class.dtor]
6851 A typedef-name that names a class shall not be used as the
6852 identifier in the declarator for a destructor declaration. */
6859 type_decl);
6862 }
6866 {
6867 cp_expr id;
6869 /* This could be a template-id, so we try that first. */
6871 /* Try a template-id. */
6874 declarator_p);
6875 /* If that worked, we're done. */
6878 /* We still don't know whether we're looking at an
6879 operator-function-id or a conversion-function-id. */
6881 /* Try an operator-function-id. */
6883 /* If that didn't work, try a conversion-function-id. */
6888 }
6889 /* Fall through. */
6896 }
6897 }
6899 /* Check [temp.names]/5: A name prefixed by the keyword template shall
6900 be a template-id or the name shall refer to a class template or an
6901 alias template. */
6903 static void
6905 {
6915 /* Alias templates are also OK. */
6922 name);
6923 }
6925 /* Parse an (optional) nested-name-specifier.
6927 nested-name-specifier: [C++98]
6928 class-or-namespace-name :: nested-name-specifier [opt]
6929 class-or-namespace-name :: template nested-name-specifier [opt]
6931 nested-name-specifier: [C++0x]
6932 type-name ::
6933 namespace-name ::
6934 nested-name-specifier identifier ::
6935 nested-name-specifier template [opt] simple-template-id ::
6937 PARSER->SCOPE should be set appropriately before this function is
6938 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6939 effect. TYPE_P is TRUE if we non-type bindings should be ignored
6940 in name lookups.
6942 Sets PARSER->SCOPE to the class (TYPE) or namespace
6943 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6944 it unchanged if there is no nested-name-specifier. Returns the new
6945 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6947 If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
6949 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6950 part of a declaration and/or decl-specifier. */
6952 static tree
6959 {
6964 /* Remember where the nested-name-specifier starts. */
6967 {
6970 }
6973 {
6974 tree new_scope;
6975 tree old_scope;
6976 tree saved_qualifying_scope;
6978 /* Spot cases that cannot be the beginning of a
6979 nested-name-specifier. */
6982 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
6983 the already parsed nested-name-specifier. */
6985 {
6986 /* Grab the nested-name-specifier and continue the loop. */
6988 /* If we originally encountered this nested-name-specifier
6989 with CHECK_DEPENDENCY_P set to true, we will not have
6990 resolved TYPENAME_TYPEs, so we must do so here. */
6992 && !check_dependency_p
6994 {
6999 }
7002 }
7004 /* Spot cases that cannot be the beginning of a
7005 nested-name-specifier. On the second and subsequent times
7006 through the loop, we look for the `template' keyword. */
7008 ;
7009 /* A template-id can start a nested-name-specifier. */
7011 ;
7012 /* DR 743: decltype can be used in a nested-name-specifier. */
7014 ;
7015 else
7016 {
7017 /* If the next token is not an identifier, then it is
7018 definitely not a type-name or namespace-name. */
7021 /* If the following token is neither a `<' (to begin a
7022 template-id), nor a `::', then we are not looking at a
7023 nested-name-specifier. */
7029 /* name:name is a valid sequence in an Objective C message. */
7031 {
7035 "found %<:%> in nested-name-specifier, "
7038 }
7041 && !cp_parser_nth_token_starts_template_argument_list_p
7044 }
7046 /* The nested-name-specifier is optional, so we parse
7047 tentatively. */
7050 /* Look for the optional `template' keyword, if this isn't the
7051 first time through the loop. */
7053 {
7055 /* DR1710: "In a qualified-id used as the name in
7056 a typename-specifier, elaborated-type-specifier, using-declaration,
7057 or class-or-decltype, an optional keyword template appearing at
7058 the top level is ignored." */
7060 && typename_keyword_p
7063 }
7065 /* Save the old scope since the name lookup we are about to do
7066 might destroy it. */
7069 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
7070 look up names in "X<T>::I" in order to determine that "Y" is
7071 a template. So, if we have a typename at this point, we make
7072 an effort to look through it. */
7074 && !check_dependency_p
7075 && !typename_keyword_p
7080 /* Parse the qualifying entity. */
7081 new_scope
7083 typename_keyword_p,
7084 template_keyword_p,
7085 check_dependency_p,
7086 type_p,
7087 is_declaration);
7088 /* Look for the `::' token. */
7091 /* If we found what we wanted, we keep going; otherwise, we're
7092 done. */
7094 {
7097 /* Restore the OLD_SCOPE since it was valid before the
7098 failed attempt at finding the last
7099 class-or-namespace-name. */
7103 /* If the next token is a decltype, and the one after that is a
7104 `::', then the decltype has failed to resolve to a class or
7105 enumeration type. Give this error even when parsing
7106 tentatively since it can't possibly be valid--and we're going
7107 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
7108 won't get another chance.*/
7112 {
7118 dtype);
7121 /* As below. */
7124 }
7128 {
7129 /* If we have a non-type template-id followed by ::, it can't
7130 possibly be valid. */
7135 {
7138 {
7145 else
7148 }
7149 else
7150 {
7156 else
7157 {
7158 /* Variable template. */
7162 }
7163 }
7170 /* As below. */
7174 }
7175 }
7179 /* If the next token is an identifier, and the one after
7180 that is a `::', then any valid interpretation would have
7181 found a class-or-namespace-name. */
7187 {
7190 {
7192 {
7193 tree decl;
7194 tree ambiguous_decls;
7197 none_type,
7206 decl);
7208 {
7209 // cp_parser_lookup_name has the same diagnostic,
7210 // thus make sure to emit it at most once.
7213 {
7218 }
7220 }
7221 else
7222 {
7224 cp_parser_name_lookup_error
7227 else
7228 cp_parser_name_lookup_error
7231 }
7232 }
7235 /* Treat this as a successful nested-name-specifier
7236 due to:
7238 [basic.lookup.qual]
7240 If the name found is not a class-name (clause
7241 _class_) or namespace-name (_namespace.def_), the
7242 program is ill-formed. */
7244 }
7246 }
7248 }
7249 /* We've found one valid nested-name-specifier. */
7251 /* Name lookup always gives us a DECL. */
7254 /* Uses of "template" must be followed by actual templates. */
7257 /* If it is a class scope, try to complete it; we are about to
7258 be looking up names inside the class. */
7260 /* Since checking types for dependency can be expensive,
7261 avoid doing it if the type is already complete. */
7263 /* Do not try to complete dependent types. */
7265 {
7267 /* If it is a typedef to current class, use the current
7268 class instead, as the typedef won't have any names inside
7269 it yet. */
7273 }
7274 /* Make sure we look in the right scope the next time through
7275 the loop. */
7277 }
7279 /* If parsing tentatively, replace the sequence of tokens that makes
7280 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
7281 token. That way, should we re-parse the token stream, we will
7282 not have to repeat the effort required to do the parse, nor will
7283 we issue duplicate error messages. */
7285 {
7289 /* Reset the contents of the START token. */
7291 /* Retrieve any deferred checks. Do not pop this access checks yet
7292 so the memory will not be reclaimed during token replacing below. */
7301 /* Purge all subsequent tokens. */
7303 }
7309 }
7311 /* Parse a nested-name-specifier. See
7312 cp_parser_nested_name_specifier_opt for details. This function
7313 behaves identically, except that it will an issue an error if no
7314 nested-name-specifier is present. */
7316 static tree
7322 {
7323 tree scope;
7325 /* Look for the nested-name-specifier. */
7327 typename_keyword_p,
7328 check_dependency_p,
7329 type_p,
7330 is_declaration);
7331 /* If it was not present, issue an error message. */
7333 {
7336 }
7339 }
7341 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7342 this is either a class-name or a namespace-name (which corresponds
7343 to the class-or-namespace-name production in the grammar). For
7344 C++0x, it can also be a type-name that refers to an enumeration
7345 type or a simple-template-id.
7347 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7348 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7349 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7350 TYPE_P is TRUE iff the next name should be taken as a class-name,
7351 even the same name is declared to be another entity in the same
7352 scope.
7354 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7355 specified by the class-or-namespace-name. If neither is found the
7356 ERROR_MARK_NODE is returned. */
7358 static tree
7365 {
7366 tree saved_scope;
7367 tree saved_qualifying_scope;
7368 tree saved_object_scope;
7369 tree scope;
7373 /* DR 743: decltype can appear in a nested-name-specifier. */
7375 {
7379 {
7382 }
7386 }
7388 /* Before we try to parse the class-name, we must save away the
7389 current PARSER->SCOPE since cp_parser_class_name will destroy
7390 it. */
7394 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7395 there is no need to look for a namespace-name. */
7396 only_class_p = template_keyword_p
7401 typename_keyword_p,
7402 template_keyword_p,
7404 check_dependency_p,
7406 is_declaration,
7409 /* If that didn't work, try for a namespace-name. */
7411 {
7412 /* Restore the saved scope. */
7416 /* If we are not looking at an identifier followed by the scope
7417 resolution operator, then this is not part of a
7418 nested-name-specifier. (Note that this function is only used
7419 to parse the components of a nested-name-specifier.) */
7424 }
7427 }
7429 /* Return true if we are looking at a compound-literal, false otherwise. */
7431 static bool
7433 {
7436 /* Skip tokens until the next token is a closing parenthesis.
7437 If we find the closing `)', and the next token is a `{', then
7438 we are looking at a compound-literal. */
7439 bool compound_literal_p
7444 /* Roll back the tokens we skipped. */
7448 }
7450 /* Return true if EXPR is the integer constant zero or a complex constant
7451 of zero, without any folding, but ignoring location wrappers. */
7453 bool
7455 {
7458 }
7460 /* Parse a postfix-expression.
7462 postfix-expression:
7463 primary-expression
7464 postfix-expression [ expression ]
7465 postfix-expression ( expression-list [opt] )
7466 simple-type-specifier ( expression-list [opt] )
7467 typename :: [opt] nested-name-specifier identifier
7468 ( expression-list [opt] )
7469 typename :: [opt] nested-name-specifier template [opt] template-id
7470 ( expression-list [opt] )
7471 postfix-expression . template [opt] id-expression
7472 postfix-expression -> template [opt] id-expression
7473 postfix-expression . pseudo-destructor-name
7474 postfix-expression -> pseudo-destructor-name
7475 postfix-expression ++
7476 postfix-expression --
7477 dynamic_cast < type-id > ( expression )
7478 static_cast < type-id > ( expression )
7479 reinterpret_cast < type-id > ( expression )
7480 const_cast < type-id > ( expression )
7481 typeid ( expression )
7482 typeid ( type-id )
7484 GNU Extension:
7486 postfix-expression:
7487 ( type-id ) { initializer-list , [opt] }
7489 This extension is a GNU version of the C99 compound-literal
7490 construct. (The C99 grammar uses `type-name' instead of `type-id',
7491 but they are essentially the same concept.)
7493 If ADDRESS_P is true, the postfix expression is the operand of the
7494 `&' operator. CAST_P is true if this expression is the target of a
7495 cast.
7497 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
7498 class member access expressions [expr.ref].
7500 Returns a representation of the expression. */
7502 static cp_expr
7506 {
7508 location_t loc;
7514 /* Peek at the next token. */
7519 /* Some of the productions are determined by keywords. */
7522 {
7527 {
7528 tree type;
7529 cp_expr expression;
7533 /* All of these can be handled in the same way from the point
7534 of view of parsing. Begin by consuming the token
7535 identifying the cast. */
7538 /* New types cannot be defined in the cast. */
7540 parser->type_definition_forbidden_message
7543 /* Look for the opening `<'. */
7545 /* Parse the type to which we are casting. */
7549 NULL);
7551 /* Look for the closing `>'. */
7553 /* Restore the old message. */
7556 bool saved_greater_than_is_operator_p
7560 /* And the expression which is being cast. */
7561 matching_parens parens;
7565 RT_CLOSE_PAREN);
7569 parser->greater_than_is_operator_p
7572 /* Only type conversions to integral or enumeration types
7573 can be used in constant-expressions. */
7576 {
7579 }
7581 /* Construct a location e.g. :
7582 reinterpret_cast <int *> (expr)
7583 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7584 ranging from the start of the "*_cast" token to the final closing
7585 paren, with the caret at the start. */
7589 {
7591 postfix_expression
7593 tf_warning_or_error);
7596 postfix_expression
7598 tf_warning_or_error);
7601 postfix_expression
7603 tf_warning_or_error);
7606 postfix_expression
7608 tf_warning_or_error);
7612 }
7613 }
7617 {
7618 tree type;
7622 /* Consume the `typeid' token. */
7624 /* Look for the `(' token. */
7625 matching_parens parens;
7627 /* Types cannot be defined in a `typeid' expression. */
7629 parser->type_definition_forbidden_message
7631 /* We can't be sure yet whether we're looking at a type-id or an
7632 expression. */
7634 /* Try a type-id first. */
7639 /* Look for the `)' token. Otherwise, we can't be sure that
7640 we're not looking at an expression: consider `typeid (int
7641 (3))', for example. */
7643 /* If all went well, simply lookup the type-id. */
7646 /* Otherwise, fall back to the expression variant. */
7647 else
7648 {
7649 tree expression;
7651 /* Look for an expression. */
7653 /* Compute its typeid. */
7655 /* Look for the `)' token. */
7657 }
7658 /* Restore the saved message. */
7660 /* `typeid' may not appear in an integral constant expression. */
7664 /* Construct a location e.g. :
7665 typeid (expr)
7666 ^~~~~~~~~~~~~
7667 ranging from the start of the "typeid" token to the final closing
7668 paren, with the caret at the start. */
7670 {
7671 location_t typeid_loc
7675 }
7676 }
7680 {
7681 tree type;
7682 /* The syntax permitted here is the same permitted for an
7683 elaborated-type-specifier. */
7690 }
7698 {
7706 {
7709 }
7715 {
7718 postfix_expression
7720 else
7721 {
7725 }
7731 tf_warning_or_error);
7732 else
7733 {
7737 }
7745 else
7746 {
7750 }
7755 postfix_expression
7759 postfix_expression
7762 else
7763 {
7767 }
7772 {
7776 }
7777 else
7778 {
7779 postfix_expression
7781 }
7786 }
7788 }
7791 {
7792 tree expression;
7793 tree type;
7794 /* Consume the `__builtin_convertvector' token. */
7796 /* Look for the opening `('. */
7797 matching_parens parens;
7799 /* Now, parse the assignment-expression. */
7801 /* Look for the `,'. */
7803 location_t type_location
7805 /* Parse the type-id. */
7806 {
7809 }
7810 /* Look for the closing `)'. */
7812 postfix_expression
7814 tf_warning_or_error);
7816 }
7819 {
7820 tree expression;
7821 tree type;
7822 /* Consume the `__builtin_bit_cast' token. */
7824 /* Look for the opening `('. */
7825 matching_parens parens;
7827 location_t type_location
7829 /* Parse the type-id. */
7830 {
7833 }
7834 /* Look for the `,'. */
7836 /* Now, parse the assignment-expression. */
7838 /* Look for the closing `)'. */
7840 postfix_expression
7842 tf_warning_or_error);
7844 }
7847 {
7848 tree type;
7850 /* If the next thing is a simple-type-specifier, we may be
7851 looking at a functional cast. We could also be looking at
7852 an id-expression. So, we try the functional cast, and if
7853 that doesn't work we fall back to the primary-expression. */
7855 /* Look for the simple-type-specifier. */
7859 CP_PARSER_FLAGS_NONE);
7861 /* Parse the cast itself. */
7863 postfix_expression
7865 /* If that worked, we're done. */
7869 /* If the functional-cast didn't work out, try a
7870 compound-literal. */
7873 {
7878 matching_parens parens;
7881 /* Avoid calling cp_parser_type_id pointlessly, see comment
7882 in cp_parser_cast_expression about c++/29234. */
7885 else
7886 {
7887 /* Parse the type. */
7893 }
7895 /* If things aren't going well, there's no need to
7896 keep going. */
7898 /* Parse the brace-enclosed initializer list. */
7900 /* If that worked, we're definitely looking at a
7901 compound-literal expression. */
7903 {
7904 /* Warn the user that a compound literal is not
7905 allowed in standard C++. */
7908 /* For simplicity, we disallow compound literals in
7909 constant-expressions. We could
7910 allow compound literals of integer type, whose
7911 initializer was a constant, in constant
7912 expressions. Permitting that usage, as a further
7913 extension, would not change the meaning of any
7914 currently accepted programs. (Of course, as
7915 compound literals are not part of ISO C++, the
7916 standard has nothing to say.) */
7918 NIC_NCC))
7919 {
7922 }
7923 /* Form the representation of the compound-literal. */
7924 postfix_expression
7929 }
7930 }
7932 /* It must be a primary-expression. */
7933 postfix_expression
7936 decltype_p,
7938 }
7940 }
7942 /* Note that we don't need to worry about calling build_cplus_new on a
7943 class-valued CALL_EXPR in decltype when it isn't the end of the
7944 postfix-expression; unary_complex_lvalue will take care of that for
7945 all these cases. */
7947 /* Keep looping until the postfix-expression is complete. */
7949 {
7953 /* It is not a Koenig lookup function call. */
7954 postfix_expression
7957 /* Peek at the next token. */
7961 {
7964 {
7966 "two consecutive %<[%> shall "
7969 }
7970 postfix_expression
7972 postfix_expression,
7974 decltype_p);
7983 /* postfix-expression ( expression-list [opt] ) */
7984 {
7996 tree stripped_expression
7998 is_builtin_constant_p
8001 {
8002 /* The whole point of __builtin_constant_p is to allow
8003 non-constant expressions to appear as arguments. */
8004 saved_integral_constant_expression_p
8006 saved_non_integral_constant_expression_p
8009 }
8012 BUILT_IN_CLASSIFY_TYPE))
8013 {
8014 /* __builtin_classify_type (type) */
8021 NULL);
8024 cp_unevaluated uev;
8026 matching_parens parens;
8031 {
8033 {
8041 }
8042 else
8043 {
8044 postfix_expression
8047 }
8049 }
8050 }
8051 args = (cp_parser_parenthesized_expression_list
8058 {
8059 parser->integral_constant_expression_p
8061 parser->non_integral_constant_expression_p
8063 }
8066 {
8069 }
8071 /* Function calls are not permitted in
8072 constant-expressions. */
8075 NIC_FUNC_CALL))
8076 {
8080 }
8085 {
8087 /* In C++20, we may need to perform ADL for a template
8088 name. */
8091 {
8093 {
8096 postfix_expression
8098 complain);
8099 }
8100 else
8101 postfix_expression
8103 }
8104 /* We do not perform argument-dependent lookup if
8105 normal lookup finds a non-function, in accordance
8106 with the expected resolution of DR 218. */
8109 {
8110 /* Do not do argument dependent lookup if regular
8111 lookup finds a member function or a block-scope
8112 function declaration. [basic.lookup.argdep]/3 */
8116 {
8122 {
8125 }
8126 }
8129 {
8132 postfix_expression
8134 complain);
8135 }
8136 }
8137 }
8139 /* Temporarily set input_location to the combined location
8140 with call expression range, as e.g. build_out_target_exprs
8141 called from convert_default_arg relies on input_location,
8142 so updating it only when the call is fully built results
8143 in inconsistencies between location handling in templates
8144 and outside of templates. */
8147 close_paren_loc);
8153 postfix_expression = (build_offset_ref_call_from_tree
8155 complain));
8156 else
8157 /* All other function calls. */
8158 {
8163 {
8167 }
8169 postfix_expression
8171 disallow_virtual,
8172 koenig_p,
8173 complain);
8174 }
8179 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
8183 }
8188 /* postfix-expression . template [opt] id-expression
8189 postfix-expression . pseudo-destructor-name
8190 postfix-expression -> template [opt] id-expression
8191 postfix-expression -> pseudo-destructor-name */
8193 /* Consume the `.' or `->' operator. */
8196 postfix_expression
8198 postfix_expression,
8205 /* postfix-expression ++ */
8206 /* Consume the `++' token. */
8208 /* Generate a representation for the complete expression. */
8209 postfix_expression
8211 POSTINCREMENT_EXPR);
8212 /* Increments may not appear in constant-expressions. */
8220 /* postfix-expression -- */
8221 /* Consume the `--' token. */
8223 /* Generate a representation for the complete expression. */
8224 postfix_expression
8226 POSTDECREMENT_EXPR);
8227 /* Decrements may not appear in constant-expressions. */
8238 return is_member_access
8239 ? postfix_expression
8241 else
8243 }
8244 }
8245 }
8247 /* Helper function for cp_parser_parenthesized_expression_list and
8248 cp_parser_postfix_open_square_expression. Parse a single element
8249 of parenthesized expression list. */
8251 static cp_expr
8255 {
8259 /* Parse the next assignment-expression. */
8261 {
8262 /* A braced-init-list. */
8267 ? &expr_non_constant_p
8271 }
8273 {
8279 }
8280 else
8283 /* If we have an ellipsis, then this is an expression expansion. */
8286 {
8287 /* Consume the `...'. */
8290 /* Build the argument pack. */
8292 }
8294 }
8296 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8297 by cp_parser_builtin_offsetof. We're looking for
8299 postfix-expression [ expression ]
8300 postfix-expression [ braced-init-list ] (C++11)
8301 postfix-expression [ expression-list[opt] ] (C++23)
8303 FOR_OFFSETOF is set if we're being called in that context, which
8304 changes how we deal with integer constant expressions. */
8306 static tree
8308 tree postfix_expression,
8311 {
8318 /* Consume the `[' token. */
8328 /* Parse the index expression. */
8329 /* ??? For offsetof, there is a question of what to allow here. If
8330 offsetof is not being used in an integral constant expression context,
8331 then we *could* get the right answer by computing the value at runtime.
8332 If we are in an integral constant expression context, then we might
8333 could accept any constant expression; hard to say without analysis.
8334 Rather than open the barn door too wide right away, allow only integer
8335 constant expressions here. */
8340 {
8345 {
8347 {
8348 cp_expr expr
8350 /*cast_p=*/
8352 /*allow_exp_p=*/
8354 /*non_cst_p=*/
8355 NULL);
8362 else
8365 /* If the next token isn't a `,', then we are done. */
8370 {
8373 }
8375 /* Otherwise, consume the `,' and keep going. */
8377 }
8380 }
8382 {
8386 }
8387 else
8391 }
8399 {
8403 }
8406 {
8410 {
8412 {
8413 cp_expr expr
8415 /*cast_p=*/
8417 /*allow_exp_p=*/
8419 /*non_cst_p=*/
8420 NULL);
8424 else
8428 {
8432 }
8433 }
8434 else
8435 length
8439 }
8444 {
8447 }
8448 else
8452 length);
8453 }
8457 /* Look for the closing `]'. */
8460 /* Build the ARRAY_REF. */
8463 tf_warning_or_error
8466 /* When not doing offsetof, array references are not permitted in
8467 constant-expressions. */
8473 }
8475 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8476 dereference of incomplete type, returns true if error_mark_node should
8477 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8478 and *DEPENDENT_P. */
8480 bool
8483 {
8484 /* In a template, be permissive by treating an object expression
8485 of incomplete type as dependent (after a pedwarn). */
8486 diagnostic_t kind = (processing_template_decl
8490 {
8502 /* Don't emit any diagnostic for OVERLOADs. */
8506 /* Avoid clobbering e.g. DECLs. */
8510 }
8522 {
8525 }
8527 }
8529 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8530 by cp_parser_builtin_offsetof. We're looking for
8532 postfix-expression . template [opt] id-expression
8533 postfix-expression . pseudo-destructor-name
8534 postfix-expression -> template [opt] id-expression
8535 postfix-expression -> pseudo-destructor-name
8537 FOR_OFFSETOF is set if we're being called in that context. That sorta
8538 limits what of the above we'll actually accept, but nevermind.
8539 TOKEN_TYPE is the "." or "->" token, which will already have been
8540 removed from the stream. */
8542 static tree
8545 cp_expr postfix_expression,
8547 location_t location)
8548 {
8549 tree name;
8555 /* If this is a `->' operator, dereference the pointer. */
8558 tf_warning_or_error);
8559 /* Check to see whether or not the expression is type-dependent and
8560 not the current instantiation. */
8562 /* The identifier following the `->' or `.' is not qualified. */
8568 /* Enter the scope corresponding to the type of the object
8569 given by the POSTFIX_EXPRESSION. */
8571 {
8573 /* According to the standard, no expression should ever have
8574 reference type. Unfortunately, we do not currently match
8575 the standard in this respect in that our internal representation
8576 of an expression may have reference type even when the standard
8577 says it does not. Therefore, we have to manually obtain the
8578 underlying type here. */
8580 /* The type of the POSTFIX_EXPRESSION must be complete. */
8581 /* Unlike the object expression in other contexts, *this is not
8582 required to be of complete type for purposes of class member
8583 access (5.2.5) outside the member function body. */
8587 {
8593 }
8596 {
8597 /* Let the name lookup machinery know that we are processing a
8598 class member access expression. */
8600 /* If something went wrong, we want to be able to discern that case,
8601 as opposed to the case where there was no SCOPE due to the type
8602 of expression being dependent. */
8605 /* If the SCOPE was erroneous, make the various semantic analysis
8606 functions exit quickly -- and without issuing additional error
8607 messages. */
8610 }
8611 }
8614 {
8616 /* If we don't have a (type-dependent) object of class type, use
8617 typeof to figure out the type of the object. */
8621 }
8623 /* Assume this expression is not a pseudo-destructor access. */
8626 /* If the SCOPE is a scalar type, then, if this is a valid program,
8627 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8628 is type dependent, it can be pseudo-destructor-name or something else.
8629 Try to parse it as pseudo-destructor-name first. */
8631 {
8632 tree s;
8633 tree type;
8636 /* Parse the pseudo-destructor-name. */
8645 {
8647 postfix_expression
8650 }
8651 }
8654 {
8655 /* If the SCOPE is not a scalar type, we are looking at an
8656 ordinary class member access expression, rather than a
8657 pseudo-destructor-name. */
8660 /* Parse the id-expression. */
8661 name = (cp_parser_id_expression
8668 /* In general, build a SCOPE_REF if the member name is qualified.
8669 However, if the name was not dependent and has already been
8670 resolved; there is no need to build the SCOPE_REF. For example;
8672 struct X { void f(); };
8673 template <typename T> void f(T* t) { t->X::f(); }
8675 Even though "t" is dependent, "X::f" is not and has been resolved
8676 to a BASELINK; there is no need to include scope information. */
8678 /* But we do need to remember that there was an explicit scope for
8679 virtual function calls. */
8683 /* If the name is a template-id that names a type, we will get a
8684 TYPE_DECL here. That is invalid code. */
8686 {
8689 }
8690 else
8691 {
8693 {
8695 {
8699 }
8700 else
8703 name,
8704 template_p);
8708 }
8710 adjust_result_of_qualified_name_lookup
8712 postfix_expression
8714 template_p,
8715 tf_warning_or_error);
8716 /* Build a location e.g.:
8717 ptr->access_expr
8718 ~~~^~~~~~~~~~~~~
8719 where the caret is at the deref token, ranging from
8720 the start of postfix_expression to the end of the access expr. */
8721 location_t combined_loc
8724 }
8725 }
8727 /* We no longer need to look up names in the scope of the object on
8728 the left-hand side of the `.' or `->' operator. */
8731 /* Outside of offsetof, these operators may not appear in
8732 constant-expressions. */
8734 && (cp_parser_non_integral_constant_expression
8739 }
8741 /* Parse a parenthesized expression-list.
8743 expression-list:
8744 assignment-expression
8745 expression-list, assignment-expression
8747 attribute-list:
8748 expression-list
8749 identifier
8750 identifier, expression-list
8752 CAST_P is true if this expression is the target of a cast.
8754 ALLOW_EXPANSION_P is true if this expression allows expansion of an
8755 argument pack.
8757 WRAP_LOCATIONS_P is true if expressions within this list for which
8758 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8759 their source locations.
8761 Returns a vector of trees. Each element is a representation of an
8762 assignment-expression. NULL is returned if the ( and or ) are
8763 missing. An empty, but allocated, vector is returned on no
8764 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8765 if we are parsing an attribute list for an attribute that wants a
8766 plain identifier argument, normal_attr for an attribute that wants
8767 an expression, or non_attr if we aren't parsing an attribute list. If
8768 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8769 not all of the expressions in the list were constant.
8770 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8771 will be written to with the location of the closing parenthesis. If
8772 an error occurs, it may or may not be written to. */
8782 {
8787 /* Assume all the expressions will be constant. */
8791 matching_parens parens;
8797 /* Within a parenthesized expression, a `>' token is always
8798 the greater-than operator. */
8799 saved_greater_than_is_operator_p
8808 /* Consume expressions until there are no more. */
8811 {
8812 /* At the beginning of attribute lists, check to see if the
8813 next token is an identifier. */
8821 else
8822 expr
8824 allow_expansion_p,
8825 non_constant_p);
8830 /* Add it to the list. We add error_mark_node
8831 expressions to the list, so that we can still tell if
8832 the correct form for a parenthesized expression-list
8833 is found. That gives better errors. */
8839 /* After the first item, attribute lists look the same as
8840 expression lists. */
8843 get_comma:;
8844 /* If the next token isn't a `,', then we are done. */
8848 /* Otherwise, consume the `,' and keep going. */
8850 }
8856 {
8859 skip_comma:;
8860 /* We try and resync to an unnested comma, as that will give the
8861 user better diagnostics. */
8869 {
8870 parser->greater_than_is_operator_p
8874 }
8875 }
8877 parser->greater_than_is_operator_p
8882 }
8884 /* Parse a pseudo-destructor-name.
8886 pseudo-destructor-name:
8887 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
8888 :: [opt] nested-name-specifier template template-id :: ~ type-name
8889 :: [opt] nested-name-specifier [opt] ~ type-name
8891 If either of the first two productions is used, sets *SCOPE to the
8892 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
8893 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
8894 or ERROR_MARK_NODE if the parse fails. */
8896 static void
8898 tree object,
8901 {
8904 /* Handle ~auto. */
8908 {
8911 "%<~auto%> only available with "
8918 }
8920 /* Assume that things will not work out. */
8923 /* Look for the optional `::' operator. */
8925 /* Look for the optional nested-name-specifier. */
8926 nested_name_specifier_p
8933 /* Now, if we saw a nested-name-specifier, we might be doing the
8934 second production. */
8937 {
8938 /* Consume the `template' keyword. */
8940 /* Parse the template-id. */
8944 class_type,
8946 /* Look for the `::' token. */
8948 }
8949 /* If the next token is not a `~', then there might be some
8950 additional qualification. */
8952 {
8953 /* At this point, we're looking for "type-name :: ~". The type-name
8954 must not be a class-name, since this is a pseudo-destructor. So,
8955 it must be either an enum-name, or a typedef-name -- both of which
8956 are just identifiers. So, we peek ahead to check that the "::"
8957 and "~" tokens are present; if they are not, then we can avoid
8958 calling type_name. */
8962 {
8965 }
8967 /* Look for the type-name. */
8972 /* Look for the `::' token. */
8974 }
8975 else
8978 /* Look for the `~'. */
8981 /* Once we see the ~, this has to be a pseudo-destructor. */
8985 /* Look for the type-name again. We are not responsible for
8986 checking that it matches the first type-name. */
8988 }
8990 /* Parse a unary-expression.
8992 unary-expression:
8993 postfix-expression
8994 ++ cast-expression
8995 -- cast-expression
8996 await-expression
8997 unary-operator cast-expression
8998 sizeof unary-expression
8999 sizeof ( type-id )
9000 alignof ( type-id ) [C++0x]
9001 new-expression
9002 delete-expression
9004 GNU Extensions:
9006 unary-expression:
9007 __extension__ cast-expression
9008 __alignof__ unary-expression
9009 __alignof__ ( type-id )
9010 alignof unary-expression [C++0x]
9011 __real__ cast-expression
9012 __imag__ cast-expression
9013 && identifier
9014 sizeof ( type-id ) { initializer-list , [opt] }
9015 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
9016 __alignof__ ( type-id ) { initializer-list , [opt] }
9018 ADDRESS_P is true iff the unary-expression is appearing as the
9019 operand of the `&' operator. CAST_P is true if this expression is
9020 the target of a cast.
9022 Returns a representation of the expression. */
9024 static cp_expr
9027 {
9031 /* Peek at the next token. */
9033 /* Some keywords give away the kind of expression. */
9035 {
9039 {
9042 {
9050 /* Consume the token. */
9052 /* Parse the operand. */
9055 /* Construct a location e.g. :
9056 alignof (expr)
9057 ^~~~~~~~~~~~~~
9058 with start == caret at the start of the "alignof"/"sizeof"
9059 token, with the endpoint at the final closing paren. */
9060 location_t compound_loc
9066 else
9067 {
9068 /* ISO C++ defines alignof only with types, not with
9069 expressions. So pedwarn if alignof is used with a non-
9070 type expression. However, __alignof__ is ok. */
9073 "ISO C++ does not allow %<alignof%> "
9078 }
9079 /* For SIZEOF_EXPR, just issue diagnostics, but keep
9080 SIZEOF_EXPR with the original operand. */
9082 {
9084 {
9086 {
9089 error_mark_node));
9091 }
9092 else
9097 }
9098 }
9103 }
9115 {
9116 /* The saved value of the PEDANTIC flag. */
9118 tree expr;
9120 /* Save away the PEDANTIC flag. */
9122 /* Parse the cast-expression. */
9124 /* Restore the PEDANTIC flag. */
9128 }
9132 {
9133 tree expression;
9135 /* Consume the `__real__' or `__imag__' token. */
9137 /* Parse the cast-expression. */
9139 /* Create the complete representation. */
9144 tf_warning_or_error);
9145 }
9153 {
9154 tree expr;
9163 matching_parens parens;
9167 parser->type_definition_forbidden_message
9170 saved_integral_constant_expression_p
9172 saved_non_integral_constant_expression_p
9176 saved_greater_than_is_operator_p
9188 parser->greater_than_is_operator_p
9191 parser->integral_constant_expression_p
9193 parser->non_integral_constant_expression_p
9200 /* Construct a location of the form:
9201 noexcept (expr)
9202 ^~~~~~~~~~~~~~~
9203 with start == caret, finishing at the close-paren. */
9204 location_t noexcept_loc
9208 noexcept_loc);
9209 }
9212 {
9213 tree expr;
9216 /* Consume the `co_await' token. */
9218 /* Parse its cast-expression. */
9223 /* Handle [expr.await]. */
9225 }
9229 }
9230 }
9232 /* Look for the `:: new' and `:: delete', which also signal the
9233 beginning of a new-expression, or delete-expression,
9234 respectively. If the next token is `::', then it might be one of
9235 these. */
9237 {
9240 /* See if the token after the `::' is one of the keywords in
9241 which we're interested. */
9243 /* If it's `new', we have a new-expression. */
9246 /* Similarly, for `delete'. */
9249 }
9251 /* Look for a unary operator. */
9253 /* The `++' and `--' operators can be handled similarly, even though
9254 they are not technically unary-operators in the grammar. */
9256 {
9261 /* Handle the GNU address-of-label extension. */
9264 {
9265 tree identifier;
9266 tree expression;
9269 /* Consume the '&&' token. */
9271 /* Look for the identifier. */
9273 /* Construct a location of the form:
9274 &&label
9275 ^~~~~~~
9276 with caret==start at the "&&", finish at the end of the label. */
9277 location_t combined_loc
9279 /* Create an expression representing the address. */
9284 NIC_ADDR_LABEL))
9287 }
9288 }
9290 {
9291 cp_expr cast_expression;
9297 /* Consume the operator token. */
9301 /* Parse the cast-expression. */
9302 cast_expression
9307 pidk);
9309 /* Make a location:
9310 OP_TOKEN CAST_EXPRESSION
9311 ^~~~~~~~~~~~~~~~~~~~~~~~~
9312 with start==caret at the operator token, and
9313 extending to the end of the cast_expression. */
9316 /* Now, build an appropriate representation. */
9318 {
9323 complain);
9324 /* TODO: build_x_indirect_ref does not always honor the
9325 location, so ensure it is set. */
9331 /* Fall through. */
9334 cast_expression,
9336 /* TODO: build_x_unary_op does not always honor the location,
9337 so ensure it is set. */
9345 /* Fall through. */
9347 /* Immediately fold negation of a constant, unless the constant is 0
9348 (since -0 == 0) or it would overflow. */
9350 {
9351 tree stripped_expr
9356 {
9359 stripped_expr);
9361 {
9364 }
9365 }
9366 }
9367 /* Fall through. */
9376 }
9380 non_constant_p))
9384 }
9388 decltype_p,
9389 pidk);
9390 }
9392 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
9393 unary-operator, the corresponding tree code is returned. */
9395 static enum tree_code
9397 {
9399 {
9420 }
9421 }
9423 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9424 Returns a representation of the expression. */
9426 static tree
9428 {
9431 /* Consume the __builtin_has_attribute token. */
9434 matching_parens parens;
9438 /* Types cannot be defined in a `sizeof' expression. Save away the
9439 old message. */
9443 parser->type_definition_forbidden_message
9445 parser->type_definition_forbidden_message_arg
9448 /* The restrictions on constant-expressions do not apply inside
9449 sizeof expressions. */
9450 bool saved_integral_constant_expression_p
9452 bool saved_non_integral_constant_expression_p
9456 /* Do not actually evaluate the expression. */
9462 /* We can't be sure yet whether we're looking at a type-id or an
9463 expression. */
9468 /* Look for the type-id. */
9474 /* If the type-id production did not work out, then we must be
9475 looking at an expression. */
9481 /* Go back to evaluating expressions. */
9485 /* And restore the old one. */
9488 parser->integral_constant_expression_p
9490 parser->non_integral_constant_expression_p
9493 /* Consume the comma if it's there. */
9495 {
9499 }
9501 /* Parse the attribute specification. */
9505 {
9511 else
9512 {
9513 /* Fold constant expressions used in attributes first. */
9516 /* Finally, see if OPER has been declared with ATTR. */
9518 }
9521 }
9522 else
9523 {
9526 }
9528 /* Construct a location e.g. :
9529 __builtin_has_attribute (oper, attr)
9530 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9531 with start == caret at the start of the built-in token,
9532 and with the endpoint at the final closing paren. */
9533 location_t compound_loc
9540 }
9542 /* Parse a new-expression.
9544 new-expression:
9545 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9546 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9548 Returns a representation of the expression. */
9550 static tree
9552 {
9555 tree type;
9558 tree ret;
9562 /* Look for the optional `::' operator. */
9563 global_scope_p
9567 /* Look for the `new' operator. */
9569 /* There's no easy way to tell a new-placement from the
9570 `( type-id )' construct. */
9572 /* Look for a new-placement. */
9574 /* If that didn't work out, there's no new-placement. */
9576 {
9580 }
9582 /* If the next token is a `(', then we have a parenthesized
9583 type-id. */
9585 {
9589 /* Consume the `('. */
9590 matching_parens parens;
9593 /* Parse the type-id. */
9594 parser->type_definition_forbidden_message
9596 {
9599 }
9602 /* Look for the closing `)'. */
9605 /* There should not be a direct-new-declarator in this production,
9606 but GCC used to allowed this, so we check and emit a sensible error
9607 message for this case. */
9609 {
9615 }
9616 }
9617 /* Otherwise, there must be a new-type-id. */
9618 else
9621 /* If the next token is a `(' or '{', then we have a new-initializer. */
9626 else
9629 /* A new-expression may not appear in an integral constant
9630 expression. */
9633 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9634 of a new-type-id or type-id of a new-expression, the new-expression shall
9635 contain a new-initializer of the form ( assignment-expression )".
9636 Additionally, consistently with the spirit of DR 1467, we want to accept
9637 'new auto { 2 }' too. */
9643 {
9645 "initialization of new-expression for type %<auto%> "
9648 }
9649 else
9650 {
9651 /* Construct a location e.g.:
9652 ptr = new int[100]
9653 ^~~~~~~~~~~~
9654 with caret == start at the start of the "new" token, and the end
9655 at the end of the final token we consumed. */
9658 /* Create a representation of the new-expression. */
9661 }
9669 }
9671 /* Parse a new-placement.
9673 new-placement:
9674 ( expression-list )
9676 Returns the same representation as for an expression-list. */
9680 {
9683 /* Parse the expression-list. */
9684 expression_list = (cp_parser_parenthesized_expression_list
9693 }
9695 /* Parse a new-type-id.
9697 new-type-id:
9698 type-specifier-seq new-declarator [opt]
9700 Returns the TYPE allocated. If the new-type-id indicates an array
9701 type, *NELTS is set to the number of elements in the last array
9702 bound; the TYPE will not include the last array bound. */
9704 static tree
9706 {
9707 cp_decl_specifier_seq type_specifier_seq;
9713 /* The type-specifier sequence must not contain type definitions.
9714 (It cannot contain declarations of new types either, but if they
9715 are not definitions we will catch that because they are not
9716 complete.) */
9718 parser->type_definition_forbidden_message
9720 /* Parse the type-specifier-seq. */
9725 /* Restore the old message. */
9731 /* Parse the new-declarator. */
9734 /* Determine the number of elements in the last array dimension, if
9735 any. */
9737 /* Skip down to the last array dimension. */
9742 {
9745 }
9750 {
9753 }
9756 {
9765 else
9767 }
9770 }
9772 /* Parse an (optional) new-declarator.
9774 new-declarator:
9775 ptr-operator new-declarator [opt]
9776 direct-new-declarator
9778 Returns the declarator. */
9782 {
9785 cp_cv_quals cv_quals;
9787 /* We don't know if there's a ptr-operator next, or not. */
9789 /* Look for a ptr-operator. */
9791 /* If that worked, look for more new-declarators. */
9793 {
9796 /* Parse another optional declarator. */
9799 declarator = cp_parser_make_indirect_declarator
9803 }
9805 /* If the next token is a `[', there is a direct-new-declarator. */
9810 }
9812 /* Parse a direct-new-declarator.
9814 direct-new-declarator:
9815 [ expression ]
9816 direct-new-declarator [constant-expression]
9818 */
9822 {
9827 {
9828 tree expression;
9831 /* Look for the opening `['. */
9837 else
9839 /* The standard requires that the expression have integral
9840 type. DR 74 adds enumeration types. We believe that the
9841 real intent is that these expressions be handled like the
9842 expression in a `switch' condition, which also allows
9843 classes with a single conversion to integral or
9844 enumeration type. */
9846 {
9847 expression
9849 expression,
9852 {
9854 "expression in new-declarator must have integral "
9857 }
9858 }
9860 /* Look for the closing `]'. */
9863 /* Add this bound to the declarator. */
9866 /* If the next token is not a `[', then there are no more
9867 bounds. */
9871 }
9874 }
9876 /* Parse a new-initializer.
9878 new-initializer:
9879 ( expression-list [opt] )
9880 braced-init-list
9882 Returns a representation of the expression-list. */
9886 {
9890 {
9896 }
9897 else
9898 expression_list = (cp_parser_parenthesized_expression_list
9904 }
9906 /* Parse a delete-expression.
9908 delete-expression:
9909 :: [opt] delete cast-expression
9910 :: [opt] delete [ ] cast-expression
9912 Returns a representation of the expression. */
9914 static tree
9916 {
9919 tree expression;
9922 /* Look for the optional `::' operator. */
9923 global_scope_p
9927 /* Look for the `delete' keyword. */
9929 /* See if the array syntax is in use. */
9931 {
9932 /* Consume the `[' token. */
9934 /* Look for the `]' token. */
9936 /* Remember that this is the `[]' construct. */
9938 }
9939 else
9942 /* Parse the cast-expression. */
9945 /* A delete-expression may not appear in an integral constant
9946 expression. */
9950 /* Construct a location e.g.:
9951 delete [ ] ptr
9952 ^~~~~~~~~~~~~~
9953 with caret == start at the start of the "delete" token, and
9954 the end at the end of the final token we consumed. */
9961 }
9963 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9964 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9965 0 otherwise. */
9967 static int
9969 {
9972 {
10014 /* In ((type ()) () the last () isn't a valid cast-expression,
10015 so the whole must be parsed as postfix-expression. */
10020 /* '[' may start a primary-expression in obj-c++ and in C++11,
10021 as a lambda-expression, eg, '(void)[]{}'. */
10028 /* '++' and '--' may or may not start a cast-expression:
10030 struct T { void operator++(int); };
10031 void f() { (T())++; }
10033 vs
10035 int a;
10036 (int)++a; */
10041 }
10042 }
10044 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
10045 in the order: const_cast, static_cast, reinterpret_cast.
10047 Don't suggest dynamic_cast.
10049 Return the first legal cast kind found, or NULL otherwise. */
10053 {
10054 tree trial;
10056 /* Reuse the parser logic by attempting to build the various kinds of
10057 cast, with "complain" disabled.
10058 Identify the first such cast that is valid. */
10060 /* Don't attempt to run such logic within template processing. */
10064 /* First try const_cast. */
10069 /* If that fails, try static_cast. */
10074 /* Finally, try reinterpret_cast. */
10076 tf_none);
10080 /* No such cast possible. */
10082 }
10084 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
10085 suggesting how to convert a C-style cast of the form:
10087 (DST_TYPE)ORIG_EXPR
10089 to a C++-style cast.
10091 The primary range of RICHLOC is asssumed to be that of the original
10092 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
10093 of the parens in the C-style cast. */
10095 static void
10098 tree dst_type)
10099 {
10100 /* This function is non-trivial, so bail out now if the warning isn't
10101 going to be emitted. */
10105 /* Try to find a legal C++ cast, trying them in order:
10106 const_cast, static_cast, reinterpret_cast. */
10111 /* Replace the open paren with "CAST_SUGGESTION<". */
10112 pretty_printer pp;
10117 /* Replace the close paren with "> (". */
10120 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
10122 }
10125 /* Parse a cast-expression.
10127 cast-expression:
10128 unary-expression
10129 ( type-id ) cast-expression
10131 ADDRESS_P is true iff the unary-expression is appearing as the
10132 operand of the `&' operator. CAST_P is true if this expression is
10133 the target of a cast.
10135 Returns a representation of the expression. */
10137 static cp_expr
10140 {
10141 /* If it's a `(', then we might be looking at a cast. */
10143 {
10149 /* There's no way to know yet whether or not this is a cast.
10150 For example, `(int (3))' is a unary-expression, while `(int)
10151 3' is a cast. So, we resort to parsing tentatively. */
10153 /* Types may not be defined in a cast. */
10155 parser->type_definition_forbidden_message
10157 /* Consume the `('. */
10158 matching_parens parens;
10163 /* A very tricky bit is that `(struct S) { 3 }' is a
10164 compound-literal (which we permit in C++ as an extension).
10165 But, that construct is not a cast-expression -- it is a
10166 postfix-expression. (The reason is that `(struct S) { 3 }.i'
10167 is legal; if the compound-literal were a cast-expression,
10168 you'd need an extra set of parentheses.) But, if we parse
10169 the type-id, and it happens to be a class-specifier, then we
10170 will commit to the parse at that point, because we cannot
10171 undo the action that is done when creating a new class. So,
10172 then we cannot back up and do a postfix-expression.
10174 Another tricky case is the following (c++/29234):
10176 struct S { void operator () (); };
10178 void foo ()
10179 {
10180 ( S()() );
10181 }
10183 As a type-id we parse the parenthesized S()() as a function
10184 returning a function, groktypename complains and we cannot
10185 back up in this case either.
10187 Therefore, we scan ahead to the closing `)', and check to see
10188 if the tokens after the `)' can start a cast-expression. Otherwise
10189 we are dealing with an unary-expression, a postfix-expression
10190 or something else.
10192 Yet another tricky case, in C++11, is the following (c++/54891):
10194 (void)[]{};
10196 The issue is that usually, besides the case of lambda-expressions,
10197 the parenthesized type-id cannot be followed by '[', and, eg, we
10198 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
10199 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
10200 we don't commit, we try a cast-expression, then an unary-expression.
10202 Save tokens so that we can put them back. */
10205 /* We may be looking at a cast-expression. */
10208 cast_expression
10211 /* Roll back the tokens we skipped. */
10213 /* If we aren't looking at a cast-expression, simulate an error so
10214 that the call to cp_parser_error_occurred below returns true. */
10217 else
10218 {
10221 /* Look for the type-id. */
10223 /* Look for the closing `)'. */
10228 }
10230 /* Restore the saved message. */
10233 /* At this point this can only be either a cast or a
10234 parenthesized ctor such as `(T ())' that looks like a cast to
10235 function returning T. */
10237 {
10238 /* Only commit if the cast-expression doesn't start with
10239 '++', '--', or '[' in C++11. */
10247 pidk);
10250 {
10251 /* Warn about old-style casts, if so requested. */
10256 {
10262 }
10264 /* Only type conversions to integral or enumeration types
10265 can be used in constant-expressions. */
10268 NIC_CAST))
10271 /* Perform the cast. */
10272 /* Make a location:
10273 (TYPE) EXPR
10274 ^~~~~~~~~~~
10275 with start==caret at the open paren, extending to the
10276 end of "expr". */
10278 open_paren_loc,
10282 }
10283 }
10284 else
10286 }
10288 /* If we get here, then it's not a cast, so it must be a
10289 unary-expression. */
10292 }
10294 /* Parse a binary expression of the general form:
10296 pm-expression:
10297 cast-expression
10298 pm-expression .* cast-expression
10299 pm-expression ->* cast-expression
10301 multiplicative-expression:
10302 pm-expression
10303 multiplicative-expression * pm-expression
10304 multiplicative-expression / pm-expression
10305 multiplicative-expression % pm-expression
10307 additive-expression:
10308 multiplicative-expression
10309 additive-expression + multiplicative-expression
10310 additive-expression - multiplicative-expression
10312 shift-expression:
10313 additive-expression
10314 shift-expression << additive-expression
10315 shift-expression >> additive-expression
10317 relational-expression:
10318 shift-expression
10319 relational-expression < shift-expression
10320 relational-expression > shift-expression
10321 relational-expression <= shift-expression
10322 relational-expression >= shift-expression
10324 GNU Extension:
10326 relational-expression:
10327 relational-expression <? shift-expression
10328 relational-expression >? shift-expression
10330 equality-expression:
10331 relational-expression
10332 equality-expression == relational-expression
10333 equality-expression != relational-expression
10335 and-expression:
10336 equality-expression
10337 and-expression & equality-expression
10339 exclusive-or-expression:
10340 and-expression
10341 exclusive-or-expression ^ and-expression
10343 inclusive-or-expression:
10344 exclusive-or-expression
10345 inclusive-or-expression | exclusive-or-expression
10347 logical-and-expression:
10348 inclusive-or-expression
10349 logical-and-expression && inclusive-or-expression
10351 logical-or-expression:
10352 logical-and-expression
10353 logical-or-expression || logical-and-expression
10355 All these are implemented with a single function like:
10357 binary-expression:
10358 simple-cast-expression
10359 binary-expression <token> binary-expression
10361 CAST_P is true if this expression is the target of a cast.
10363 The binops_by_token map is used to get the tree codes for each <token> type.
10364 binary-expressions are associated according to a precedence table. */
10366 #define TOKEN_PRECEDENCE(token) \
10367 (((token->type == CPP_GREATER \
10368 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
10369 && !parser->greater_than_is_operator_p) \
10370 ? PREC_NOT_OPERATOR \
10371 : binops_by_token[token->type].prec)
10373 static cp_expr
10379 {
10380 cp_parser_expression_stack stack;
10383 cp_parser_expression_stack_entry current;
10384 cp_expr rhs;
10388 tree overload;
10390 /* Parse the first expression. */
10401 {
10402 /* Get an operator token. */
10408 {
10410 "%<>>%> operator is treated"
10414 }
10419 /* This is a fold-expression; handle it later. */
10422 /* Popping an entry off the stack means we completed a subexpression:
10423 - either we found a token which is not an operator (`>' where it is not
10424 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10425 will happen repeatedly;
10426 - or, we found an operator which has lower priority. This is the case
10427 where the recursive descent *ascends*, as in `3 * 4 + 5' after
10428 parsing `3 * 4'. */
10430 {
10433 else
10435 }
10437 get_rhs:
10442 /* We used the operator token. */
10445 /* For "false && x" or "true || x", x will never be executed;
10446 disable warnings while evaluating it. */
10451 {
10454 }
10456 /* Extract another operand. It may be the RHS of this expression
10457 or the LHS of a new, higher priority expression. */
10462 /* Get another operator token. Look up its precedence to avoid
10463 building a useless (immediately popped) stack entry for common
10464 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10471 {
10472 /* ... and prepare to parse the RHS of the new, higher priority
10473 expression. Since precedence levels on the stack are
10474 monotonically increasing, we do not have to care about
10475 stack overflows. */
10484 pop:
10486 /* If the stack is not empty, we have parsed into LHS the right side
10487 (`4' in the example above) of an expression we had suspended.
10488 We can use the information on the stack to recover the LHS (`3')
10489 from the stack together with the tree code (`MULT_EXPR'), and
10490 the precedence of the higher level subexpression
10491 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10492 which will be used to actually build the additive expression. */
10497 }
10499 /* Undo the disabling of warnings done above. */
10501 {
10504 }
10509 /* Avoid warning for !!x == y. */
10514 /* Avoid warning for !b == y where b is boolean. */
10518 /* Avoid warning for !!b == y where b is boolean. */
10530 /* Don't warn for named "xor" (as opposed to '^'). */
10534 check_for_xor_used_as_pow
10547 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10548 ERROR_MARK for everything that is not a binary expression.
10549 This makes warn_about_parentheses miss some warnings that
10550 involve unary operators. For unary expressions we should
10551 pass the correct tree_code unless the unary expression was
10552 surrounded by parentheses.
10553 */
10557 {
10560 else
10561 {
10564 current.lhs
10567 == tcc_comparison
10571 }
10572 }
10573 else
10574 {
10580 /* TODO: build_x_binary_op doesn't always honor the location. */
10582 }
10585 /* If the binary operator required the use of an overloaded operator,
10586 then this expression cannot be an integral constant-expression.
10587 An overloaded operator can be used even if both operands are
10588 otherwise permissible in an integral constant-expression if at
10589 least one of the operands is of enumeration type. */
10593 NIC_OVERLOADED))
10595 }
10598 }
10600 static cp_expr
10605 {
10608 }
10610 /* Parse the `? expression : assignment-expression' part of a
10611 conditional-expression. The LOGICAL_OR_EXPR is the
10612 logical-or-expression that started the conditional-expression.
10613 Returns a representation of the entire conditional-expression.
10615 This routine is used by cp_parser_assignment_expression
10616 and cp_parser_conditional_expression.
10618 ? expression : assignment-expression
10620 GNU Extensions:
10622 ? : assignment-expression */
10624 static tree
10626 {
10628 cp_expr assignment_expr;
10632 /* Consume the `?' token. */
10637 {
10640 /* Implicit true clause. */
10642 c_inhibit_evaluation_warnings +=
10645 }
10646 else
10647 {
10650 /* Parse the expression. */
10651 c_inhibit_evaluation_warnings +=
10654 c_inhibit_evaluation_warnings +=
10658 }
10660 /* The next token should be a `:'. */
10662 /* Parse the assignment-expression. */
10664 c_inhibit_evaluation_warnings -=
10667 /* Make a location:
10668 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10669 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10670 with the caret at the "?", ranging from the start of
10671 the logical_or_expr to the end of the assignment_expr. */
10676 /* Build the conditional-expression. */
10678 expr,
10679 assignment_expr,
10680 tf_warning_or_error);
10681 }
10683 /* Parse a conditional-expression.
10685 conditional-expression:
10686 logical-or-expression
10687 logical-or-expression ? expression : assignment-expression
10689 GNU Extensions:
10691 logical-or-expression ? : assignment-expression */
10693 static cp_expr
10695 {
10698 /* If the next token is a `?' then we're actually looking at
10699 a conditional-expression; otherwise we're done. */
10703 }
10705 /* Parse an assignment-expression.
10707 assignment-expression:
10708 conditional-expression
10709 logical-or-expression assignment-operator assignment_expression
10710 throw-expression
10711 yield-expression
10713 CAST_P is true if this expression is the target of a cast.
10714 DECLTYPE_P is true if this expression is the operand of decltype.
10716 Returns a representation for the expression. */
10718 static cp_expr
10721 {
10722 cp_expr expr;
10724 /* If the next token is the `throw' keyword, then we're looking at
10725 a throw-expression. */
10728 /* If the next token is the `co_yield' keyword, then we're looking at
10729 a yield-expression. */
10732 /* Otherwise, it must be that we are looking at a
10733 logical-or-expression. */
10734 else
10735 {
10736 /* Parse the binary expressions (logical-or-expression). */
10738 decltype_p,
10740 /* If the next token is a `?' then we're actually looking at a
10741 conditional-expression. */
10744 else
10745 {
10748 /* If it's an assignment-operator, we're using the second
10749 production. */
10750 enum tree_code assignment_operator
10753 {
10754 /* Parse the right-hand side of the assignment. */
10760 /* An assignment may not appear in a
10761 constant-expression. */
10763 NIC_ASSIGNMENT))
10765 /* Build the assignment expression. Its default
10766 location:
10767 LHS = RHS
10768 ~~~~^~~~~
10769 is the location of the '=' token as the
10770 caret, ranging from the start of the lhs to the
10771 end of the rhs. */
10776 assignment_operator,
10779 /* TODO: build_x_modify_expr doesn't honor the location,
10780 so we must set it here. */
10782 }
10783 }
10784 }
10787 }
10789 /* Parse an (optional) assignment-operator.
10791 assignment-operator: one of
10792 = *= /= %= += -= >>= <<= &= ^= |=
10794 GNU Extension:
10796 assignment-operator: one of
10797 <?= >?=
10799 If the next token is an assignment operator, the corresponding tree
10800 code is returned, and the token is consumed. For example, for
10801 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
10802 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
10803 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
10804 operator, ERROR_MARK is returned. */
10806 static enum tree_code
10808 {
10812 /* Peek at the next token. */
10816 {
10862 /* Nothing else is an assignment operator. */
10864 }
10866 /* An operator followed by ... is a fold-expression, handled elsewhere. */
10871 /* If it was an assignment operator, consume it. */
10876 }
10878 /* Parse an expression.
10880 expression:
10881 assignment-expression
10882 expression , assignment-expression
10884 CAST_P is true if this expression is the target of a cast.
10885 DECLTYPE_P is true if this expression is the immediate operand of decltype,
10886 except possibly parenthesized or on the RHS of a comma (N3276).
10887 WARN_COMMA_P is true if a comma should be diagnosed.
10889 Returns a representation of the expression. */
10891 static cp_expr
10894 {
10899 {
10900 cp_expr assignment_expression;
10902 /* Parse the next assignment-expression. */
10903 assignment_expression
10906 /* We don't create a temporary for a call that is the immediate operand
10907 of decltype or on the RHS of a comma. But when we see a comma, we
10908 need to create a temporary for a call on the LHS. */
10913 assignment_expression
10917 /* If this is the first assignment-expression, we can just
10918 save it away. */
10921 else
10922 {
10923 /* Create a location with caret at the comma, ranging
10924 from the start of the LHS to the end of the RHS. */
10932 }
10933 /* If the next token is not a comma, or we're in a fold-expression, then
10934 we are done with the expression. */
10938 /* Consume the `,'. */
10941 {
10942 /* [depr.comma.subscript]: A comma expression appearing as
10943 the expr-or-braced-init-list of a subscripting expression
10944 is deprecated. A parenthesized comma expression is not
10945 deprecated. */
10947 "top-level comma expression in array subscript "
10950 }
10952 /* A comma operator cannot appear in a constant-expression. */
10955 }
10958 }
10960 /* Parse a constant-expression.
10962 constant-expression:
10963 conditional-expression
10965 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
10966 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
10967 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
10968 is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
10969 greater than 1, this isn't really a constant-expression, only a
10970 potentially constant-evaluated expression. If STRICT_P is true,
10971 only parse a conditional-expression, otherwise parse an
10972 assignment-expression. See below for rationale. */
10974 static cp_expr
10979 {
10980 /* It might seem that we could simply parse the
10981 conditional-expression, and then check to see if it were
10982 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
10983 one that the compiler can figure out is constant, possibly after
10984 doing some simplifications or optimizations. The standard has a
10985 precise definition of constant-expression, and we must honor
10986 that, even though it is somewhat more restrictive.
10988 For example:
10990 int i[(2, 3)];
10992 is not a legal declaration, because `(2, 3)' is not a
10993 constant-expression. The `,' operator is forbidden in a
10994 constant-expression. However, GCC's constant-folding machinery
10995 will fold this operation to an INTEGER_CST for `3'. */
10997 /* Save the old settings. */
10998 bool saved_integral_constant_expression_p
11000 bool saved_allow_non_integral_constant_expression_p
11002 bool saved_non_integral_constant_expression_p
11004 /* We are now parsing a constant-expression. */
11006 parser->allow_non_integral_constant_expression_p
11010 /* A manifestly constant-evaluated expression is evaluated even in an
11011 unevaluated operand. */
11014 /* Although the grammar says "conditional-expression", when not STRICT_P,
11015 we parse an "assignment-expression", which also permits
11016 "throw-expression" and the use of assignment operators. In the case
11017 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
11018 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
11019 actually essential that we look for an assignment-expression.
11020 For example, cp_parser_initializer_clauses uses this function to
11021 determine whether a particular assignment-expression is in fact
11022 constant. */
11023 cp_expr expression;
11026 else
11028 /* Restore the old settings. */
11029 parser->integral_constant_expression_p
11031 parser->allow_non_integral_constant_expression_p
11035 {
11036 /* Require an rvalue constant expression here; that's what our
11037 callers expect. Reference constant expressions are handled
11038 separately in e.g. cp_parser_template_argument. */
11047 }
11050 parser->non_integral_constant_expression_p
11054 }
11056 /* Parse __builtin_offsetof.
11058 offsetof-expression:
11059 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
11061 offsetof-member-designator:
11062 id-expression
11063 | offsetof-member-designator "." id-expression
11064 | offsetof-member-designator "[" expression "]"
11065 | offsetof-member-designator "->" id-expression */
11067 static cp_expr
11069 {
11071 tree type;
11072 cp_expr expr;
11073 cp_id_kind dummy;
11075 location_t finish_loc;
11077 /* We're about to accept non-integral-constant things, but will
11078 definitely yield an integral constant expression. Save and
11079 restore these values around our local parsing. */
11085 /* Consume the "__builtin_offsetof" token. */
11087 /* Consume the opening `('. */
11088 matching_parens parens;
11090 /* Parse the type-id. */
11092 {
11094 parser->type_definition_forbidden_message
11098 }
11099 /* Look for the `,'. */
11103 /* Build the (type *)null that begins the traditional offsetof macro. */
11104 tree object_ptr
11108 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
11112 {
11115 {
11117 /* offsetof-member-designator "[" expression "]" */
11123 /* offsetof-member-designator "->" identifier */
11126 /* FALLTHRU */
11129 /* offsetof-member-designator "." identifier */
11137 /* Consume the ")" token. */
11143 /* Error. We know the following require will fail, but
11144 that gives the proper error message. */
11149 }
11150 }
11152 success:
11153 /* Make a location of the form:
11154 __builtin_offsetof (struct s, f)
11155 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
11156 with caret at the type-id, ranging from the start of the
11157 "_builtin_offsetof" token to the close paren. */
11159 /* The result will be an INTEGER_CST, so we need to explicitly
11160 preserve the location. */
11163 failure:
11169 }
11171 /* Parse a builtin trait expression or type. */
11173 static cp_expr
11175 {
11182 /* Get location of initial token. */
11185 /* Consume the token. */
11188 matching_parens parens;
11191 else
11195 {
11204 }
11206 /* __type_pack_element takes an expression as its first argument and uses
11207 template-id syntax instead of function call syntax (for consistency
11208 with Clang). We special case these properties of __type_pack_element
11209 here and elsewhere. */
11211 else
11212 {
11215 }
11221 {
11225 {
11227 {
11229 "trailing argument to %<__type_pack_element%> "
11232 }
11233 }
11235 }
11237 {
11240 {
11243 }
11247 }
11249 {
11252 {
11256 {
11259 }
11263 }
11267 }
11271 /* cp_parser_enclosed_template_argument_list above already took care
11273 else
11276 /* Construct a location of the form:
11277 __is_trivially_copyable(_Tp)
11278 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
11279 with start == caret, finishing at the close-paren. */
11282 /* Complete the trait expression, which may mean either processing
11283 the trait expr now or saving it for template instantiation. */
11285 {
11293 else
11295 }
11296 }
11298 /* Parse a lambda expression.
11300 lambda-expression:
11301 lambda-introducer lambda-declarator [opt] compound-statement
11302 lambda-introducer < template-parameter-list > requires-clause [opt]
11303 lambda-declarator [opt] compound-statement
11305 Returns a representation of the expression. */
11307 static cp_expr
11309 {
11311 tree type;
11319 {
11320 /* C++20 allows lambdas in unevaluated context, but one in the type of a
11321 non-type parameter is nonsensical.
11323 Distinguish a lambda in the parameter type from a lambda in the
11324 default argument by looking at local_variables_forbidden_p, which is
11325 only set in default arguments. */
11327 {
11332 }
11333 }
11335 {
11337 {
11339 "lambda-expression in unevaluated context"
11342 }
11344 }
11346 {
11348 {
11352 }
11354 }
11356 /* We may be in the middle of deferred access check. Disable
11357 it now. */
11371 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11374 /* Now that we've started the type, add the capture fields for any
11375 explicit captures. */
11378 {
11379 /* Inside the class, surrounding template-parameter-lists do not apply. */
11380 unsigned int saved_num_template_parameter_lists
11384 bool fully_implicit_function_template_p
11388 bool auto_is_implicit_function_template_parm_p
11401 /* The body of a lambda in a discarded statement is not discarded. */
11405 /* Similarly the body of a lambda in immediate function context is not
11406 in immediate function context. */
11410 /* By virtue of defining a local class, a lambda expression has access to
11411 the private variables of enclosing classes. */
11424 {
11427 }
11429 /* The capture list was built up in reverse order; fix that now. */
11444 parser->fully_implicit_function_template_p
11448 parser->auto_is_implicit_function_template_parm_p
11451 }
11453 /* This field is only used during parsing of the lambda. */
11456 /* This lambda shouldn't have any proxies left at this point. */
11458 /* And now that we're done, push proxies for an enclosing lambda. */
11461 /* Update the lambda expression to a range. */
11468 else
11476 }
11478 /* Parse the beginning of a lambda expression.
11480 lambda-introducer:
11481 [ lambda-capture [opt] ]
11483 LAMBDA_EXPR is the current representation of the lambda expression. */
11485 static void
11487 {
11488 /* Need commas after the first capture. */
11491 /* Eat the leading `['. */
11494 /* Record default capture mode. "[&" "[=" "[&," "[=," */
11504 {
11510 }
11516 {
11518 tree capture_id;
11519 tree capture_init_expr;
11523 enum capture_kind_type
11524 {
11525 BY_COPY,
11526 BY_REFERENCE
11527 };
11531 {
11534 }
11538 else
11541 /* Possibly capture `this'. */
11543 {
11548 "explicit by-copy capture of %<this%> "
11549 "with by-copy capture default only available with "
11555 this_identifier);
11556 else
11561 }
11563 /* Possibly capture `*this'. */
11566 {
11570 "%<*this%> capture only available with "
11577 this_identifier);
11578 else
11583 }
11585 /* But reject `&this'. */
11588 {
11594 }
11596 /* Remember whether we want to capture as a reference or not. */
11598 {
11601 }
11606 {
11610 "pack init-capture only available with "
11614 }
11616 /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11619 {
11624 }
11626 /* Get the identifier. */
11631 /* Would be nice to have a cp_parser_skip_to_closing_x for general
11632 delimiters, but I modified this to stop on unnested ']' as well. It
11633 was already changed to stop on unnested '}', so the
11634 "closing_parenthesis" name is no more misleading with my change. */
11635 {
11641 }
11643 /* Find the initializer for this capture. */
11647 {
11648 /* An explicit initializer exists. */
11651 "lambda capture initializers "
11659 {
11662 }
11665 }
11666 else
11667 {
11670 /* Turn the identifier into an id-expression. */
11671 capture_init_expr
11676 {
11679 }
11682 {
11685 capture_init_expr);
11690 }
11693 {
11696 capture_init_expr))
11700 }
11702 capture_init_expr
11703 = finish_id_expression
11705 capture_init_expr,
11719 {
11724 {
11725 /* If what follows is an initializer, the second '...' is
11726 invalid. But for cases like [...xs...], the first one
11727 is invalid. */
11734 }
11735 }
11736 }
11740 {
11745 capture_id);
11749 "capture of %qD redundant with by-reference capture "
11751 }
11753 /* Check for duplicates.
11754 Optimize for the zero or one explicit captures cases and only create
11755 the hash_set after adding second capture. */
11763 else
11764 {
11767 }
11773 else
11778 /* If there is any qualification still in effect, clear it
11779 now; we will be starting fresh with the next capture. */
11783 }
11786 }
11788 /* Parse the (optional) middle of a lambda expression.
11790 lambda-declarator:
11791 ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
11792 lambda-specifiers (C++23)
11794 lambda-specifiers:
11795 decl-specifier-seq [opt] noexcept-specifier [opt]
11796 attribute-specifier-seq [opt] trailing-return-type [opt]
11798 LAMBDA_EXPR is the current representation of the lambda expression. */
11800 static bool
11802 {
11803 /* 5.1.1.4 of the standard says:
11804 If a lambda-expression does not include a lambda-declarator, it is as if
11805 the lambda-declarator were ().
11806 This means an empty parameter list, no attributes, and no exception
11807 specification. */
11818 cp_decl_specifier_seq lambda_specs;
11820 /* A lambda op() is const unless explicitly 'mutable'. */
11823 /* The template-parameter-list is optional, but must begin with
11824 an opening angle if present. */
11826 {
11830 "lambda templates are only available with "
11838 /* We may have a constrained generic lambda; parse the requires-clause
11839 immediately after the template-parameter-list and combine with any
11840 shorthand constraints present. */
11843 {
11848 }
11850 /* We just processed one more parameter list. */
11852 }
11854 /* Committee discussion supports allowing attributes here. */
11857 /* The parameter-declaration-clause is optional (unless
11858 template-parameter-list was given), but must begin with an
11859 opening parenthesis if present. */
11861 {
11862 matching_parens parens;
11867 /* Parse parameters. */
11868 param_list
11869 = cp_parser_parameter_declaration_clause
11872 /* Default arguments shall not be specified in the
11873 parameter-declaration-clause of a lambda-declarator. */
11878 OPT_Wc__14_extensions,
11883 }
11887 /* [expr.prim.lambda.general]
11888 lambda-specifier:
11889 consteval, constexpr, mutable, static
11890 [4] A lambda-specifier-seq shall contain at most one of each
11891 lambda-specifier and shall not contain both constexpr and consteval.
11892 The lambda-specifier-seq shall not contain both mutable and static. */
11896 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
11900 {
11902 "parameter declaration before lambda declaration "
11903 "specifiers only optional with %<-std=c++2b%> or "
11906 }
11907 /* Peek at the params, see if we have an xobj parameter. */
11909 {
11911 /* We still need grokdeclarator to see that this is an xobj function
11912 and finish the rest of the work, don't mutate it. */
11915 /* [expr.prim.lambda.closure-5]
11916 Given a lambda with a lambda-capture, the type of the explicit object
11917 parameter, if any, of the lambda's function call operator (possibly
11918 instantiated from a function call operator template) shall be either:
11919 -- the closure type,
11920 -- a class type derived from the closure type, or
11921 -- a reference to a possibly cv-qualified such type. */
11922 bool const unrelated_with_captures
11925 /* Since a lambda's type is anonymous, we can assume an xobj
11926 parameter is unrelated to the closure if it is non-dependent.
11927 If it is dependent we handle it at instantiation time. */
11930 {
11932 "a lambda with captures may not have an explicit object "
11935 }
11937 /* [expr.prim.lambda.general-4]
11938 If the lambda-declarator contains an explicit object parameter
11939 ([dcl.fct]), then no lambda-specifier in the lambda-specifier-seq
11940 shall be mutable or static. */
11942 {
11943 auto_diagnostic_group d;
11945 "%<mutable%> lambda specifier "
11947 /* Tell the user how to do what they probably meant, maybe fixits
11948 would be appropriate later? */
11950 /* The following hints don't make sense when we already have an
11954 "the passed in closure object will not be mutated because "
11958 "declare the explicit object parameter as non-const "
11960 else
11962 "explicit object parameter is already a mutable "
11964 }
11966 {
11967 auto_diagnostic_group d;
11969 "%<static%> lambda specifier "
11973 }
11974 }
11976 {
11978 }
11980 {
11981 /* [expr.prim.lambda.general-4]
11982 If the lambda-specifier-seq contains static, there shall be no
11983 lambda-capture. */
11988 else
11989 {
11992 }
11993 }
11997 {
11999 "parameter declaration before lambda transaction "
12000 "qualifier only optional with %<-std=c++2b%> or "
12003 }
12005 /* Parse optional exception specification. */
12006 exception_spec
12010 {
12012 "parameter declaration before lambda exception "
12013 "specification only optional with %<-std=c++2b%> or "
12016 }
12018 /* GCC 8 accepted attributes here, and this is the place for standard C++11
12019 attributes that appertain to the function type. */
12022 else
12025 /* Parse optional trailing return type. */
12027 {
12030 "parameter declaration before lambda trailing "
12031 "return type only optional with %<-std=c++2b%> or "
12035 }
12037 /* Also allow GNU attributes at the very end of the declaration, the usual
12038 place for GNU attributes. */
12043 {
12044 /* Parse optional trailing requires clause. */
12047 /* The function parameters must be in scope all the way until after the
12048 trailing-return-type in case of decltype. */
12050 }
12052 /* Create the function call operator.
12054 Messing with declarators like this is no uglier than building up the
12055 FUNCTION_DECL by hand, and this is less likely to get out of sync with
12056 other code. */
12057 {
12058 cp_decl_specifier_seq return_type_specs;
12060 tree fco;
12067 {
12071 else
12073 "lambda only available with %<-std=c++17%> or "
12075 }
12080 {
12084 }
12092 VIRT_SPEC_UNSPECIFIED,
12093 REF_QUAL_NONE,
12094 tx_qual,
12095 exception_spec,
12096 return_type,
12097 trailing_requires_clause,
12098 std_attrs,
12099 UNKNOWN_LOCATION);
12102 declarator,
12105 {
12109 /* Give the object parameter a different name. */
12112 }
12114 {
12118 }
12128 }
12129 }
12131 /* Parse the body of a lambda expression, which is simply
12133 compound-statement
12135 but which requires special handling.
12136 LAMBDA_EXPR is the current representation of the lambda expression. */
12138 static void
12140 {
12142 unsigned char local_variables_forbidden_p
12146 /* The body of a lambda-expression is not a subexpression of the enclosing
12147 expression. */
12148 cp_evaluated ev;
12152 else
12153 /* Still increment function_depth so that we don't GC in the
12154 middle of an expression. */
12162 /* Clear this in case we're in the middle of a default argument. */
12166 {
12171 /* Originally C++11 required us to peek for 'return expr'; and
12172 process it specially here to deduce the return type. N3638
12173 removed the need for that. */
12177 }
12184 else
12186 }
12188 /* Statements [gram.stmt.stmt] */
12190 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
12192 static void
12194 {
12198 /* A concept is never expanded normally. */
12204 }
12206 struct cp_omp_attribute_data
12207 {
12210 c_omp_directive_kind kind;
12211 };
12213 /* Handle omp::directive and omp::sequence attributes in ATTRS
12214 (if any) at the start of a statement or in attribute-declaration. */
12216 static tree
12218 {
12229 {
12230 cnt++;
12232 {
12238 {
12240 "mixing OpenMP directives with attribute and pragma "
12244 }
12246 {
12250 }
12253 {
12261 else
12264 }
12270 {
12272 "unknown OpenMP directive name in %qs attribute "
12276 }
12279 {
12280 /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
12281 depend/doacross clause. */
12294 }
12296 {
12297 /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
12301 paren_depth++;
12303 paren_depth--;
12314 {
12317 }
12318 }
12323 }
12324 cp_omp_attribute_data v = {};
12327 }
12328 else
12341 {
12346 }
12347 else
12348 {
12350 {
12353 }
12354 }
12357 {
12359 "OpenMP construct among %<omp::directive%> attributes"
12360 " requires all %<omp::directive%> attributes on the"
12363 }
12365 {
12367 "multiple OpenMP standalone directives among"
12368 " %<omp::directive%> attributes must be all within the"
12371 }
12377 {
12379 "standalone OpenMP directives in %<omp::directive%> attribute"
12382 }
12384 {
12388 {
12390 "mixing OpenMP directives with attribute and pragma "
12393 }
12394 }
12398 tokens++;
12403 {
12410 cp_token tok = {};
12418 tok = {};
12423 }
12424 cp_token tok = {};
12436 /* Move the current source position to that of the first token in the
12437 new lexer. */
12440 }
12442 /* True if and only if the name is one of the contract types. */
12444 static bool
12446 {
12450 }
12452 /* Handle omp::directive and omp::sequence attributes in *PATTRS
12453 (if any) at the start or after declaration-id of a declaration. */
12455 static void
12459 {
12470 {
12472 {
12479 {
12487 else
12490 }
12500 {
12502 {
12505 }
12507 {
12509 "mixing OpenMP directives with attribute and "
12512 }
12513 }
12514 }
12515 }
12518 {
12523 else
12526 }
12531 {
12540 }
12542 }
12544 /* Parse a statement.
12546 statement:
12547 labeled-statement
12548 expression-statement
12549 compound-statement
12550 selection-statement
12551 iteration-statement
12552 jump-statement
12553 declaration-statement
12554 try-block
12556 C++11:
12558 statement:
12559 labeled-statement
12560 attribute-specifier-seq (opt) expression-statement
12561 attribute-specifier-seq (opt) compound-statement
12562 attribute-specifier-seq (opt) selection-statement
12563 attribute-specifier-seq (opt) iteration-statement
12564 attribute-specifier-seq (opt) jump-statement
12565 declaration-statement
12566 attribute-specifier-seq (opt) try-block
12568 init-statement:
12569 expression-statement
12570 simple-declaration
12571 alias-declaration
12573 TM Extension:
12575 statement:
12576 atomic-statement
12578 IN_COMPOUND is true when the statement is nested inside a
12579 cp_parser_compound_statement.
12581 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12582 is a (possibly labeled) if statement which is not enclosed in braces
12583 and has an else clause. This is used to implement -Wparentheses.
12585 CHAIN is a vector of if-else-if conditions.
12587 Note that this version of parsing restricts assertions to be attached to
12588 empty statements. */
12590 static void
12594 {
12600 /* A copy of IN_COMPOUND which is set to false after seeing a label.
12601 This matters for certain pragmas. */
12604 restart:
12607 /* There is no statement yet. */
12614 /* In obj-c++, seeing '[[' might be the either the beginning of
12615 c++11 attributes, or a nested objc-message-expression. So
12616 let's parse the c++11 attributes tentatively. */
12622 {
12625 }
12628 /* Peek at the next token. */
12631 /* If we have contracts, check that they're valid in this context. */
12633 {
12641 /* Check that assertions are null statements. */
12645 }
12651 {
12655 {
12682 }
12688 {
12690 std_attrs);
12692 }
12693 }
12696 /* Remember the location of the first token in the statement. */
12700 /* If this is a keyword, then that will often determine what kind of
12701 statement we have. */
12703 {
12707 {
12710 /* Looks like a labeled-statement with a case label.
12711 Parse the label, and then use tail recursion to parse
12712 the statement. */
12741 /* Objective-C++ exception-handling constructs. */
12757 /* This must be a namespace alias definition. */
12759 {
12760 /* Attributes should be parsed as part of the
12761 declaration, so let's un-parse them. */
12764 }
12782 /* It might be a keyword like `int' that can start a
12783 declaration-statement. */
12785 }
12786 }
12788 {
12789 /* If the next token is a `:', then we are looking at a
12790 labeled-statement. */
12793 {
12794 /* Looks like a labeled-statement with an ordinary label.
12795 Parse the label, and then use tail recursion to parse
12796 the statement. */
12800 /* If there's no statement, it's not a labeled-statement, just
12801 a label. That's allowed in C++23, but only if we're at the
12802 end of a compound-statement. */
12805 {
12809 "label at end of compound statement only available "
12812 }
12816 }
12817 }
12818 /* Anything that starts with a `{' must be a compound-statement. */
12820 {
12823 }
12824 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
12825 a statement all its own. */
12827 {
12828 do_pragma:;
12831 /* Only certain OpenMP pragmas are attached to statements, and thus
12832 are considered statements themselves. All others are not. In
12833 the context of a compound, accept the pragma as a "statement" and
12834 return so that we can check for a close brace. Otherwise we
12835 require a real statement and must go back and read one. */
12837 {
12841 }
12849 {
12851 {
12858 }
12861 }
12869 }
12871 {
12874 }
12876 /* Everything else must be a declaration-statement or an
12877 expression-statement. Try for the declaration-statement
12878 first, unless we are looking at a `;', in which case we know that
12879 we have an expression-statement. */
12881 {
12883 {
12885 /* Attributes should be parsed as part of the declaration,
12886 so let's un-parse them. */
12891 /* Try to parse the declaration-statement. */
12894 /* If that worked, we're done. */
12897 /* It didn't work, restore the post-attribute position. */
12899 {
12902 {
12907 i++;
12909 {
12915 /* Don't handle OpenMP attribs on keywords that
12916 always start a declaration statement but don't
12917 accept attribute before it and therefore
12918 the tentative cp_parser_declaration_statement
12919 fails to parse because of that. */
12924 }
12927 {
12929 std_attrs
12930 = cp_parser_handle_statement_omp_attributes
12936 }
12937 }
12938 }
12939 }
12940 /* All preceding labels have been parsed at this point. */
12946 /* Look for an expression-statement instead. */
12950 attrs_loc);
12952 /* Handle [[fallthrough]];. */
12954 {
12955 /* The next token after the fallthrough attribute is ';'. */
12957 {
12958 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12960 IFN_FALLTHROUGH,
12963 }
12964 else
12968 }
12970 /* Handle [[assert: ...]]; */
12972 {
12973 /* Add the assertion as a statement in the current block. */
12977 }
12978 }
12980 /* Set the line number for the statement. */
12984 /* Allow "[[fallthrough]];" or "[[assume(cond)]];", but warn otherwise. */
12988 }
12990 /* Append ATTR to attribute list ATTRS. */
12992 tree
12994 {
13000 }
13002 /* Parse the label for a labeled-statement, i.e.
13004 label:
13005 attribute-specifier-seq[opt] identifier :
13006 attribute-specifier-seq[opt] case constant-expression :
13007 attribute-specifier-seq[opt] default :
13009 labeled-statement:
13010 label statement
13012 GNU Extension:
13013 case constant-expression ... constant-expression : statement
13015 When a label is parsed without errors, the label is added to the
13016 parse tree by the finish_* functions, so this function doesn't
13017 have to return the label. */
13019 static void
13021 {
13026 /* The next token should be an identifier. */
13030 {
13033 }
13035 /* Remember whether this case or a user-defined label is allowed to fall
13036 through to. */
13041 {
13043 {
13047 /* Consume the `case' token. */
13049 /* Parse the constant-expression. */
13056 {
13057 /* Consume the `...' token. */
13063 /* We don't need to emit warnings here, as the common code
13064 will do this for us. */
13065 }
13066 else
13070 {
13073 {
13076 }
13077 }
13078 else
13081 expr);
13082 }
13086 /* Consume the `default' token. */
13090 {
13093 {
13096 }
13097 }
13098 else
13103 /* Anything else must be an ordinary label. */
13108 }
13110 /* Require the `:' token. */
13113 /* An ordinary label may optionally be followed by attributes.
13114 However, this is only permitted if the attributes are then
13115 followed by a semicolon. This is because, for backward
13116 compatibility, when parsing
13117 lab: __attribute__ ((unused)) int i;
13118 we want the attribute to attach to "i", not "lab". */
13121 {
13122 tree attrs;
13126 /* And fallthrough always binds to the expression-statement. */
13131 ;
13132 else
13134 }
13140 }
13142 /* Parse an expression-statement.
13144 expression-statement:
13145 expression [opt] ;
13147 Returns the new EXPR_STMT -- or NULL_TREE if the expression
13148 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
13149 indicates whether this expression-statement is part of an
13150 expression statement. */
13152 static tree
13154 {
13159 /* There might be attribute fallthrough. */
13162 /* If the next token is a ';', then there is no expression
13163 statement. */
13165 {
13169 {
13170 /* If we ran into a problem, make sure we complained. */
13175 }
13176 }
13180 /* Handle [[fallthrough]];. */
13182 {
13183 /* The next token after the fallthrough attribute is ';'. */
13185 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
13188 else
13192 }
13194 /* Allow "[[fallthrough]];", but warn otherwise. */
13199 /* Give a helpful message for "A<T>::type t;" and the like. */
13202 {
13209 {
13210 /* A::A a; */
13215 }
13216 }
13218 /* Consume the final `;'. */
13223 /* This is the final expression statement of a statement
13224 expression. */
13230 }
13232 /* Parse a compound-statement.
13234 compound-statement:
13235 { statement-seq [opt] label-seq [opt] }
13237 label-seq:
13238 label
13239 label-seq label
13241 GNU extension:
13243 compound-statement:
13244 { label-declaration-seq [opt] statement-seq [opt] }
13246 label-declaration-seq:
13247 label-declaration
13248 label-declaration-seq label-declaration
13250 Returns a tree representing the statement. */
13252 static tree
13255 {
13256 tree compound_stmt;
13257 matching_braces braces;
13259 /* Consume the `{'. */
13266 /* Begin the compound-statement. */
13268 /* If the next keyword is `__label__' we have a label declaration. */
13271 /* Parse an (optional) statement-seq. */
13274 /* Consume the `}'. */
13277 /* Finish the compound-statement. */
13281 }
13283 /* Diagnose errors related to imperfectly nested loops in an OMP
13284 loop construct. This function is called when such code is seen.
13285 Only issue one such diagnostic no matter how much invalid
13286 intervening code there is in the loop.
13287 FIXME: maybe the location associated with the diagnostic should
13288 be the current parser token instead of the location of the outer loop
13289 nest. */
13291 static void
13293 {
13302 /* Only diagnose errors related to perfect nesting once. */
13304 {
13306 {
13308 "inner loops must be perfectly nested in "
13311 }
13313 {
13315 "inner loops must be perfectly nested with "
13318 }
13320 {
13322 "inner loops must be perfectly nested with "
13325 }
13326 /* TODO: Also reject loops with TILE directive. */
13329 }
13330 }
13332 /* Parse an (optional) statement-seq.
13334 statement-seq:
13335 statement
13336 statement-seq [opt] statement */
13338 static void
13340 {
13343 bool in_omp_loop_block
13346 /* Scan statements until there aren't any more. */
13348 {
13351 /* If we are looking at a `}', then we have run out of
13352 statements; the same is true if we have reached the end
13353 of file, or have stumbled upon a stray '@end'. */
13360 /* If we are in a compound statement and find 'else' then
13361 something went wrong. */
13363 {
13366 else
13367 {
13370 }
13371 }
13373 /* Handle special cases for OMP FOR canonical loop syntax. */
13375 {
13379 {
13380 /* Found the nested loop. */
13384 }
13386 {
13387 /* Prior to implementing the OpenMP 5.1 syntax for canonical
13388 loop form, GCC used to accept an empty statements as not
13389 being intervening code. Continue to do that, as an
13390 extension. */
13391 /* FIXME: Maybe issue a warning or something here? */
13393 }
13395 /* The nested compound statement may contain the next loop, or
13396 it might just be intervening code. */
13397 {
13401 }
13402 else
13403 {
13404 /* This must be intervening code. */
13406 /* Defer calling check_omp_intervening_code on pragmas until
13407 cp_parser_statement, because we can't know until we parse
13408 it whether or not the pragma is a statement. */
13413 }
13415 }
13417 /* Parse the statement. */
13419 }
13420 }
13422 /* Return true if this is the C++20 version of range-based-for with
13423 init-statement. */
13425 static bool
13427 {
13430 /* Save tokens so that we can put them back. */
13433 /* There has to be an unnested ; followed by an unnested :. */
13436 CPP_SEMICOLON,
13440 /* We found the semicolon, eat it now. */
13443 /* Now look for ':' that is not nested in () or {}. */
13446 CPP_COLON,
13449 out:
13450 /* Roll back the tokens we skipped. */
13454 }
13456 /* Return true if we're looking at (init; cond), false otherwise. */
13458 static bool
13460 {
13461 /* Save tokens so that we can put them back. */
13464 /* Look for ';' that is not nested in () or {}. */
13467 CPP_SEMICOLON,
13470 /* Roll back the tokens we skipped. */
13474 }
13476 /* Parse a selection-statement.
13478 selection-statement:
13479 if ( init-statement [opt] condition ) statement
13480 if ( init-statement [opt] condition ) statement else statement
13481 switch ( init-statement [opt] condition ) statement
13483 Returns the new IF_STMT or SWITCH_STMT.
13485 If IF_P is not NULL, *IF_P is set to indicate whether the statement
13486 is a (possibly labeled) if statement which is not enclosed in
13487 braces and has an else clause. This is used to implement
13488 -Wparentheses.
13490 CHAIN is a vector of if-else-if conditions. This is used to implement
13491 -Wduplicated-cond. */
13493 static tree
13496 {
13499 token_indent_info guard_tinfo;
13504 /* Peek at the next token. */
13508 /* See what kind of keyword it is. */
13511 {
13514 {
13515 tree statement;
13516 tree condition;
13521 RID_CONSTEXPR))
13522 {
13527 "%<if constexpr%> only available with "
13529 }
13532 {
13534 RID_CONSTEVAL))
13538 RID_CONSTEVAL))
13539 {
13542 }
13543 }
13545 {
13549 "%<if consteval%> only available with "
13560 {
13563 }
13569 {
13570 location_t before_loc
13576 }
13580 /* If the next token is `else', parse the else-clause. */
13582 RID_ELSE))
13583 {
13587 /* Consume the `else' keyword. */
13593 {
13597 }
13601 guard_tinfo);
13604 {
13605 location_t before_loc
13610 }
13613 }
13617 {
13621 }
13625 }
13627 /* Look for the `('. */
13628 matching_parens parens;
13630 {
13633 }
13635 /* Begin the selection-statement. */
13637 {
13640 }
13641 else
13644 /* Parse the optional init-statement. */
13646 {
13647 tree decl;
13650 OPT_Wc__17_extensions,
13651 "init-statement in selection statements only available "
13654 /* A non-empty init-statement can have arbitrary side
13655 effects. */
13658 }
13660 /* Parse the condition. */
13662 /* Look for the `)'. */
13668 {
13672 /* Add the condition. */
13679 /* Parse the then-clause. */
13683 /* Outside a template, the non-selected branch of a constexpr
13684 if is a 'discarded statement', i.e. unevaluated. */
13689 {
13692 }
13695 guard_tinfo);
13702 {
13706 }
13708 /* If the next token is `else', parse the else-clause. */
13710 RID_ELSE))
13711 {
13715 {
13718 }
13720 guard_tinfo
13722 /* Consume the `else' keyword. */
13725 {
13727 RID_IF)
13729 {
13730 /* We've got "if (COND) else if (COND2)". Start
13731 the condition chain and add COND as the first
13732 element. */
13736 {
13737 /* Wrap it in a NOP_EXPR so that we can set the
13738 location of the condition. */
13740 condition);
13743 }
13744 }
13746 RID_IF))
13747 /* This is if-else without subsequent if. Zap the
13748 condition chain; we would have already warned at
13749 this point. */
13751 }
13753 /* Parse the else-clause. */
13759 /* If we are currently parsing a then-clause, then
13760 IF_P will not be NULL. We set it to true to
13761 indicate that this if statement has an else clause.
13762 This may trigger the Wparentheses warning below
13763 when we get back up to the parent if statement. */
13768 {
13772 }
13773 }
13774 else
13775 {
13776 /* This if statement does not have an else clause. If
13777 NESTED_IF is true, then the then-clause has an if
13778 statement which does have an else clause. We warn
13779 about the potential ambiguity. */
13782 "suggest explicit braces to avoid ambiguous"
13785 /* We don't need the condition chain anymore. */
13787 }
13789 /* Now we're all done with the if-statement. */
13791 }
13792 else
13793 {
13797 /* Add the condition. */
13800 /* Parse the body of the switch-statement. */
13806 guard_tinfo);
13810 /* Now we're all done with the switch-statement. */
13812 }
13815 }
13821 }
13822 }
13824 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
13825 If we have seen at least one decl-specifier, and the next token is not
13826 a parenthesis (after "int (" we might be looking at a functional cast)
13827 neither we are dealing with a concept-check expression then we must be
13828 looking at a declaration. */
13830 static void
13833 {
13842 }
13844 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
13845 The declarator shall not specify a function or an array. Returns
13846 TRUE if the declarator is valid, FALSE otherwise. */
13848 static bool
13851 location_t loc)
13852 {
13856 {
13861 else
13869 }
13870 else
13872 }
13874 /* Parse a condition.
13876 condition:
13877 expression
13878 type-specifier-seq declarator = initializer-clause
13879 type-specifier-seq declarator braced-init-list
13881 GNU Extension:
13883 condition:
13884 type-specifier-seq declarator asm-specification [opt]
13885 attributes [opt] = assignment-expression
13887 Returns the expression that should be tested. */
13889 static tree
13891 {
13892 cp_decl_specifier_seq type_specifiers;
13896 /* Try the declaration first. */
13898 /* New types are not allowed in the type-specifier-seq for a
13899 condition. */
13901 parser->type_definition_forbidden_message
13903 /* Parse the type-specifier-seq. */
13905 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
13908 /* Restore the saved message. */
13911 /* Gather the attributes that were provided with the
13912 decl-specifiers. */
13917 /* If all is well, we might be looking at a declaration. */
13919 {
13920 tree decl;
13921 tree asm_specification;
13922 tree attributes;
13927 /* Parse the declarator. */
13929 CP_PARSER_FLAGS_NONE,
13935 /* Parse the attributes. */
13937 /* Parse the asm-specification. */
13939 /* If the next token is not an `=' or '{', then we might still be
13940 looking at an expression. For example:
13942 if (A(a).x)
13944 looks like a decl-specifier-seq and a declarator -- but then
13945 there is no `=', so this is an expression. */
13950 /* If we did see an `=' or '{', then we are looking at a declaration
13951 for sure. */
13953 {
13954 tree pushed_scope;
13961 /* Create the declaration. */
13968 /* Parse the initializer. */
13970 {
13974 }
13976 {
13977 /* Consume the `='. */
13981 }
13982 else
13983 {
13986 }
13990 /* Process the initializer. */
13993 asm_specification,
13994 flags);
14000 }
14001 }
14002 /* If we didn't even get past the declarator successfully, we are
14003 definitely not looking at a declaration. */
14004 else
14007 /* Otherwise, we are looking at an expression. */
14009 }
14011 /* Parses a for-statement or range-for-statement until the closing ')',
14012 not included. */
14014 static tree
14016 {
14020 /* Begin the for-statement. */
14023 /* Maybe parse the optional init-statement in a range-based for loop. */
14025 /* Checked for diagnostic purposes only. */
14027 {
14028 tree dummy;
14031 {
14033 OPT_Wc__20_extensions,
14034 "range-based %<for%> loops with initializer only "
14037 }
14038 }
14040 /* Parse the initialization. */
14046 else
14048 }
14050 static tree
14053 {
14054 /* Normal for loop */
14057 tree stmt;
14060 /* The init-statement has already been parsed in
14061 cp_parser_init_statement, so no work is needed here. */
14064 /* If there's a condition, process it. */
14068 {
14072 }
14074 {
14078 }
14080 /* Look for the `;'. */
14083 /* If there's an expression, process it. */
14089 }
14091 /* Tries to parse a range-based for-statement:
14093 range-based-for:
14094 decl-specifier-seq declarator : expression
14096 The decl-specifier-seq declarator and the `:' are already parsed by
14097 cp_parser_init_statement. If processing_template_decl it returns a
14098 newly created RANGE_FOR_STMT; if not, it is converted to a
14099 regular FOR_STMT. */
14101 static tree
14104 {
14110 /* Get the range declaration momentarily out of the way so that
14111 the range expression doesn't clash with it. */
14113 {
14115 {
14117 /* For decomposition declaration get all of the corresponding
14118 declarations out of the way. */
14122 {
14130 {
14136 }
14137 }
14138 }
14140 {
14145 }
14146 }
14150 else
14153 /* Put the range declaration(s) back into scope. */
14155 {
14159 }
14161 /* finish_omp_for has its own code for the following, so just
14162 return the range_expr instead. */
14166 /* If in template, STMT is converted to a normal for-statement
14167 at instantiation. If not, it is done just ahead. */
14169 {
14181 /* do_auto_deduction doesn't mess with template init-lists. */
14184 }
14185 else
14186 {
14190 }
14192 }
14194 /* Subroutine of cp_convert_range_for: given the initializer expression,
14195 builds up the range temporary. */
14197 static tree
14199 {
14200 /* Find out the type deduced by the declaration
14201 `auto &&__range = range_expr'. */
14206 /* Create the __range variable. */
14213 }
14215 /* Used by cp_parser_range_for in template context: we aren't going to
14216 do a full conversion yet, but we still need to resolve auto in the
14217 type of the for-range-declaration if present. This is basically
14218 a shortcut version of cp_convert_range_for. */
14220 static void
14222 {
14225 {
14228 iter_type = (cp_parser_perform_range_for_lookup
14231 {
14233 iter_type);
14236 tf_warning_or_error);
14239 tf_warning_or_error,
14240 adc_variable_type);
14243 }
14244 }
14245 }
14247 /* Warns when the loop variable should be changed to a reference type to
14248 avoid unnecessary copying. I.e., from
14250 for (const auto x : range)
14252 where range returns a reference, to
14254 for (const auto &x : range)
14256 if this version doesn't make a copy.
14258 This function also warns when the loop variable is initialized with
14259 a value of a different type resulting in a copy:
14261 int arr[10];
14262 for (const double &x : arr)
14264 DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
14265 This function is never called when processing_template_decl is on. */
14267 static void
14269 {
14281 {
14284 {
14285 auto_diagnostic_group d;
14287 "loop variable %qD of type %qT binds to a temporary "
14290 {
14292 TYPE_QUAL_CONST);
14297 }
14298 }
14300 }
14304 /* Since small trivially copyable types are cheap to copy, we suppress the
14305 warning for them. 64B is a common size of a cache line. */
14311 /* If we can initialize a reference directly, suggest that to avoid the
14312 copy. */
14315 {
14316 auto_diagnostic_group d;
14320 {
14324 }
14325 }
14326 }
14328 /* Converts a range-based for-statement into a normal
14329 for-statement, as per the definition.
14331 for (RANGE_DECL : RANGE_EXPR)
14332 BLOCK
14334 should be equivalent to:
14336 {
14337 auto &&__range = RANGE_EXPR;
14338 for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
14339 __begin != __end;
14340 ++__begin)
14341 {
14342 RANGE_DECL = *__begin;
14343 BLOCK
14344 }
14345 }
14347 If RANGE_EXPR is an array:
14348 BEGIN_EXPR = __range
14349 END_EXPR = __range + ARRAY_SIZE(__range)
14350 Else if RANGE_EXPR has a member 'begin' or 'end':
14351 BEGIN_EXPR = __range.begin()
14352 END_EXPR = __range.end()
14353 Else:
14354 BEGIN_EXPR = begin(__range)
14355 END_EXPR = end(__range);
14357 If __range has a member 'begin' but not 'end', or vice versa, we must
14358 still use the second alternative (it will surely fail, however).
14359 When calling begin()/end() in the third alternative we must use
14360 argument dependent lookup, but always considering 'std' as an associated
14361 namespace. */
14363 tree
14367 {
14375 /* If an error happened previously do nothing or else a lot of
14376 unhelpful errors would be issued. */
14378 else
14379 {
14380 tree range_temp;
14384 /* Can't bind a reference to an array of runtime bound. */
14386 else
14387 {
14392 LOOKUP_ONLYCONVERTING);
14394 }
14397 }
14399 /* The new for initialization statement. */
14401 iter_type);
14407 LOOKUP_ONLYCONVERTING);
14417 LOOKUP_ONLYCONVERTING);
14421 /* The new for condition. */
14428 /* The new increment expression. */
14431 tf_warning_or_error);
14434 /* The declaration is initialized with *__begin inside the loop body. */
14446 }
14448 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
14449 We need to solve both at the same time because the method used
14450 depends on the existence of members begin or end.
14451 Returns the type deduced for the iterator expression. */
14453 static tree
14455 {
14457 {
14460 }
14463 {
14468 }
14470 {
14471 /* If RANGE is an array, we will use pointer arithmetic. */
14474 range,
14478 }
14479 else
14480 {
14481 /* If it is not an array, we must do a bit of magic. */
14491 tf_warning_or_error);
14494 tf_warning_or_error);
14497 {
14498 /* Use the member functions. */
14501 }
14502 else
14503 {
14504 /* Use global functions with ADL. */
14505 releasing_vec vec;
14510 tf_warning_or_error);
14512 tf_warning_or_error);
14514 tf_warning_or_error);
14516 tf_warning_or_error);
14517 }
14519 /* Last common checks. */
14521 {
14522 /* If one of the expressions is an error do no more checks. */
14525 }
14528 /* Can happen, when, eg, in a template context, Koenig lookup
14529 can't resolve begin/end (c++/58503). */
14531 else
14532 {
14534 /* The unqualified type of the __begin and __end temporaries should
14535 be the same, as required by the multiple auto declaration. */
14537 {
14544 /* P0184R0 allows __begin and __end to have different types,
14545 but make sure they are comparable so we can give a better
14547 else
14551 }
14553 }
14554 }
14555 }
14557 /* Helper function for cp_parser_perform_range_for_lookup.
14558 Builds a tree for RANGE.IDENTIFIER(). */
14560 static tree
14562 {
14570 releasing_vec vec;
14574 tf_warning_or_error);
14576 }
14578 /* Parse an iteration-statement.
14580 iteration-statement:
14581 while ( condition ) statement
14582 do statement while ( expression ) ;
14583 for ( init-statement condition [opt] ; expression [opt] )
14584 statement
14586 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
14588 static tree
14591 {
14594 tree statement;
14596 token_indent_info guard_tinfo;
14598 /* Peek at the next token. */
14605 /* Remember whether or not we are already within an iteration
14606 statement. */
14609 /* Special case for OMP loop intervening code. Parsing of permitted
14610 collapsed loop nests is handled elsewhere. */
14612 {
14616 }
14618 /* See what kind of keyword it is. */
14621 {
14623 {
14624 tree condition;
14626 /* Begin the while-statement. */
14628 /* Look for the `('. */
14629 matching_parens parens;
14631 /* Parse the condition. */
14634 /* Look for the `)'. */
14636 /* Parse the dependent statement. */
14642 /* We're done with the while-statement. */
14644 }
14648 {
14649 tree expression;
14651 /* Begin the do-statement. */
14653 /* Parse the body of the do-statement. */
14660 /* Look for the `while' keyword. */
14662 /* Look for the `('. */
14663 matching_parens parens;
14665 /* Parse the expression. */
14667 /* We're done with the do-statement. */
14669 /* Look for the `)'. */
14671 /* Look for the `;'. */
14673 }
14677 {
14678 /* Look for the `('. */
14679 matching_parens parens;
14684 /* Look for the `)'. */
14687 /* Parse the body of the for-statement. */
14694 /* We're done with the for-statement. */
14696 }
14703 }
14706 }
14708 /* Parse an init-statement or the declarator of a range-based-for.
14709 Returns true if a range-based-for declaration is seen.
14711 init-statement:
14712 expression-statement
14713 simple-declaration
14714 alias-declaration */
14716 static bool
14718 {
14719 /* If the next token is a `;', then we have an empty
14720 expression-statement. Grammatically, this is also a
14721 simple-declaration, but an invalid one, because it does not
14722 declare anything. Therefore, if we did not handle this case
14723 specially, we would issue an error message about an invalid
14724 declaration. */
14726 {
14730 /* A colon is used in range-based for. */
14733 /* We're going to speculatively look for a declaration, falling back
14734 to an expression, if necessary. */
14738 {
14744 OPT_Wc__23_extensions,
14745 "alias-declaration in init-statement only "
14747 }
14748 else
14749 /* Parse the declaration. */
14752 decl);
14755 {
14756 /* It is a range-for, consume the ':'. */
14761 OPT_Wc__11_extensions,
14762 "range-based %<for%> loops only available with "
14764 }
14766 /* The ';' is not consumed yet because we told
14767 cp_parser_simple_declaration not to. */
14772 /* If the tentative parse failed, then we shall need to look for an
14773 expression-statement. */
14774 }
14775 /* If we are here, it is an expression-statement. */
14778 }
14780 /* Parse a jump-statement.
14782 jump-statement:
14783 break ;
14784 continue ;
14785 return expression [opt] ;
14786 return braced-init-list ;
14787 coroutine-return-statement;
14788 goto identifier ;
14790 GNU extension:
14792 jump-statement:
14793 goto * expression ;
14795 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
14797 static tree
14799 {
14805 /* Peek at the next token. */
14810 /* See what kind of keyword it is. */
14813 {
14817 {
14834 }
14840 {
14844 /* Fall through. */
14854 }
14860 {
14861 tree expr;
14864 {
14868 }
14871 else
14872 /* If the next token is a `;', then there is no
14873 expression. */
14875 /* Build the return-statement, check co-return first, since type
14876 deduction is not valid there. */
14881 else
14883 /* Look for the final `;'. */
14885 }
14892 {
14896 }
14898 /* Create the goto-statement. */
14900 {
14901 /* Issue a warning about this use of a GNU extension. */
14903 /* Consume the '*' token. */
14905 /* Parse the dependent expression. */
14907 }
14908 else
14910 /* Look for the final `;'. */
14917 }
14920 }
14922 /* Parse a declaration-statement.
14924 declaration-statement:
14925 block-declaration */
14927 static void
14929 {
14932 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14935 /* Parse the block-declaration. */
14938 /* Free any declarators allocated. */
14940 }
14942 /* Some dependent statements (like `if (cond) statement'), are
14943 implicitly in their own scope. In other words, if the statement is
14944 a single statement (as opposed to a compound-statement), it is
14945 none-the-less treated as if it were enclosed in braces. Any
14946 declarations appearing in the dependent statement are out of scope
14947 after control passes that point. This function parses a statement,
14948 but ensures that is in its own scope, even if it is not a
14949 compound-statement.
14951 If IF_P is not NULL, *IF_P is set to indicate whether the statement
14952 is a (possibly labeled) if statement which is not enclosed in
14953 braces and has an else clause. This is used to implement
14954 -Wparentheses.
14956 CHAIN is a vector of if-else-if conditions. This is used to implement
14957 -Wduplicated-cond.
14959 Returns the new statement. */
14961 static tree
14965 {
14966 tree statement;
14969 token_indent_info body_tinfo
14975 /* Mark if () ; with a special NOP_EXPR. */
14977 {
14988 }
14989 /* if a compound is opened, we simply parse the statement directly. */
14992 /* If the token is not a `{', then we must take special action. */
14993 else
14994 {
14995 /* Create a compound-statement. */
14997 /* Parse the dependent-statement. */
15000 /* Finish the dummy compound-statement. */
15002 }
15004 token_indent_info next_tinfo
15013 /* Return the statement. */
15015 }
15017 /* For some dependent statements (like `while (cond) statement'), we
15018 have already created a scope. Therefore, even if the dependent
15019 statement is a compound-statement, we do not want to create another
15020 scope. */
15022 static void
15025 {
15026 /* If the token is a `{', then we must take special action. */
15028 {
15029 token_indent_info body_tinfo
15035 token_indent_info next_tinfo
15044 }
15045 else
15046 {
15047 /* Avoid calling cp_parser_compound_statement, so that we
15048 don't create a new scope. Do everything else by hand. */
15049 matching_braces braces;
15051 /* If the next keyword is `__label__' we have a label declaration. */
15054 /* Parse an (optional) statement-seq. */
15057 }
15058 }
15060 /* Modules */
15062 /* Parse a module-name or module-partition.
15064 module-name:
15065 module-name-qualifier [opt] identifier
15067 module-partition:
15068 : module-name-qualifier [opt] identifier
15070 module-name-qualifier:
15071 identifier .
15072 module-name-qualifier identifier .
15074 Returns a pointer to the module object, or NULL on failure.
15075 For PARTITION_P, PARENT is the module this is a partition of. */
15080 {
15086 {
15088 {
15091 else
15094 }
15102 }
15105 }
15107 /* Parse a module-partition. Defers to cp_parser_module_name. */
15111 {
15113 }
15115 /* Named module-declaration
15116 __module ; PRAGMA_EOL
15117 __module : private ; PRAGMA_EOL (unimplemented)
15118 [__export] __module module-name module-partition [opt]
15119 attr-spec-seq-opt ; PRAGMA_EOL
15120 */
15122 static module_parse
15125 {
15126 /* We're a pseudo pragma. */
15131 {
15135 }
15138 {
15139 /* Start global module fragment. */
15144 }
15149 {
15157 {
15160 }
15161 else
15163 "private module fragment only permitted in purview"
15165 }
15167 {
15168 /* Neither the first declaration, nor in a GMF. */
15171 skip_eol:
15173 }
15174 else
15175 {
15188 }
15191 }
15193 /* Import-declaration
15194 __import module-name attr-spec-seq-opt ; PRAGMA_EOL
15195 __import module-partition attr-spec-seq-opt ; PRAGMA_EOL
15196 __import header-name attr-spec-seq-opt ; PRAGMA_EOL
15197 */
15199 static void
15202 {
15203 /* We're a pseudo pragma. */
15208 {
15211 note_lexer:
15213 " disambiguation, to prevent this being considered a"
15215 skip_eol:
15217 }
15219 {
15222 }
15223 else
15224 {
15228 {
15231 }
15233 {
15234 /* An import specifying a module-partition shall only appear after the
15235 module-declaration in a module unit: [module.import]/4. */
15240 else
15243 }
15244 else
15257 {
15258 /* Module-purview imports must not be from source inclusion
15259 [cpp.import]/7 */
15268 }
15271 }
15272 }
15274 /* export-declaration.
15276 export declaration
15277 export { declaration-seq-opt } */
15279 static void
15281 {
15300 {
15307 }
15308 else
15309 {
15310 /* Explicitly check if the next tokens might be a
15311 module-directive line, so we can give a clearer error message
15312 about why the directive will be rejected. */
15319 }
15322 }
15324 /* Declarations [gram.dcl.dcl] */
15326 /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
15327 is the top-level declaration sequence. That affects whether we
15328 deal with module-preamble.
15330 declaration-seq:
15331 declaration
15332 declaration-seq declaration */
15334 static void
15336 {
15338 {
15344 else
15346 }
15347 }
15349 /* Parse a declaration.
15351 declaration:
15352 block-declaration
15353 function-definition
15354 template-declaration
15355 explicit-instantiation
15356 explicit-specialization
15357 linkage-specification
15358 namespace-definition
15360 C++17:
15361 deduction-guide
15363 modules:
15364 (all these are only allowed at the outermost level, check
15365 that semantically, for better diagnostics)
15366 module-declaration
15367 module-export-declaration
15368 module-import-declaration
15369 export-declaration
15371 GNU extension:
15373 declaration:
15374 __extension__ declaration */
15376 static void
15378 {
15381 /* Check for the `__extension__' keyword. */
15383 {
15384 /* Parse the qualified declaration. */
15386 /* Restore the PEDANTIC flag. */
15390 }
15392 /* Try to figure out what kind of declaration is present. */
15398 {
15400 /* A declaration consisting of a single semicolon is invalid
15401 * before C++11. Allow it unless we're being pedantic. */
15405 }
15409 CPP_SEMICOLON))
15410 {
15415 {
15418 std_attrs);
15420 {
15423 {
15425 CPP_PRAGMA));
15427 }
15429 }
15430 }
15438 }
15440 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
15445 /* Conditionally, allow attributes to precede a linkage specification. */
15447 {
15455 {
15457 /* We might have already been here. */
15459 {
15467 }
15470 }
15471 else
15472 {
15475 }
15476 }
15477 /* If we already had some attributes, and we've added more, then prepend.
15478 Otherwise attributes just contains any that we just read. */
15480 {
15484 }
15486 /* If the next token is `extern' and the following token is a string
15487 literal, then we have a linkage specification. */
15491 /* If the next token is `template', then we have either a template
15492 declaration, an explicit instantiation, or an explicit
15493 specialization. */
15495 {
15496 /* `template <>' indicates a template specialization. */
15500 /* `template <' indicates a template declaration. */
15503 /* Anything else must be an explicit instantiation. */
15504 else
15506 }
15507 /* If the next token is `export', it's new-style modules or
15508 old-style template. */
15510 {
15513 else
15515 }
15517 {
15522 // In module purview this will be ill-formed.
15528 else
15530 }
15531 /* If the next token is `extern', 'static' or 'inline' and the one
15532 after that is `template', we have a GNU extended explicit
15533 instantiation directive. */
15540 /* If the next token is `namespace', check for a named or unnamed
15541 namespace definition. */
15550 /* An unnamed namespace definition. */
15554 /* An inline (associated) namespace definition. */
15558 /* Objective-C++ declaration/definition. */
15565 /* At this point we may have a template declared by a concept
15566 introduction. */
15571 else
15572 /* Try to parse a block-declaration, or a function-definition. */
15575 /* Free any declarators allocated. */
15577 }
15579 /* Parse a namespace-scope declaration. */
15581 static void
15583 {
15587 /* A top-level declaration can consist solely of a #pragma. A
15588 nested declaration cannot, so this is done here and not in
15589 cp_parser_declaration. (A #pragma at block scope is
15590 handled in cp_parser_statement.) */
15592 else
15593 /* Parse the declaration itself. */
15595 }
15597 /* Parse a block-declaration.
15599 block-declaration:
15600 simple-declaration
15601 asm-definition
15602 namespace-alias-definition
15603 using-declaration
15604 using-directive
15606 GNU Extension:
15608 block-declaration:
15609 __extension__ block-declaration
15611 C++0x Extension:
15613 block-declaration:
15614 static_assert-declaration
15616 If STATEMENT_P is TRUE, then this block-declaration is occurring as
15617 part of a declaration-statement. */
15619 static void
15622 {
15625 /* Check for the `__extension__' keyword. */
15627 {
15628 /* Parse the qualified declaration. */
15630 /* Restore the PEDANTIC flag. */
15634 }
15636 /* Peek at the next token to figure out which kind of declaration is
15637 present. */
15640 /* If the next keyword is `asm', we have an asm-definition. */
15642 {
15646 }
15647 /* If the next keyword is `namespace', we have a
15648 namespace-alias-definition. */
15651 /* If the next keyword is `using', we have a
15652 using-declaration, a using-directive, or an alias-declaration. */
15654 {
15659 /* If the token after `using' is `namespace', then we have a
15660 using-directive. */
15666 /* If the second token after 'using' is '=', then we have an
15667 alias-declaration. */
15673 /* Otherwise, it's a using-declaration. */
15674 else
15677 }
15678 /* If the next keyword is `__label__' we have a misplaced label
15679 declaration. */
15681 {
15685 /* If the next token is now a `;', consume it. */
15688 }
15689 /* If the next token is `static_assert' we have a static assertion. */
15692 else
15693 {
15698 /* If the next tokens after attributes is `using namespace', then we have
15699 a using-directive. */
15703 RID_NAMESPACE))
15704 {
15708 }
15709 /* If the next token after attributes is `asm', then we have
15710 an asm-definition. */
15712 {
15716 }
15717 /* Anything else must be a simple-declaration. */
15718 else
15721 }
15722 }
15724 /* Parse a simple-declaration.
15726 simple-declaration:
15727 decl-specifier-seq [opt] init-declarator-list [opt] ;
15728 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15729 brace-or-equal-initializer ;
15731 init-declarator-list:
15732 init-declarator
15733 init-declarator-list , init-declarator
15735 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
15736 function-definition as a simple-declaration.
15738 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15739 parsed declaration if it is an uninitialized single declarator not followed
15740 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15741 if present, will not be consumed. */
15743 static void
15747 {
15748 cp_decl_specifier_seq decl_specifiers;
15757 /* Defer access checks until we know what is being declared; the
15758 checks for names appearing in the decl-specifier-seq should be
15759 done as if we were in the scope of the thing being declared. */
15762 /* Parse the decl-specifier-seq. We have to keep track of whether
15763 or not the decl-specifier-seq declares a named class or
15764 enumeration type, since that is the only case in which the
15765 init-declarator-list is allowed to be empty.
15767 [dcl.dcl]
15769 In a simple-declaration, the optional init-declarator-list can be
15770 omitted only when declaring a class or enumeration, that is when
15771 the decl-specifier-seq contains either a class-specifier, an
15772 elaborated-type-specifier, or an enum-specifier. */
15774 CP_PARSER_FLAGS_OPTIONAL,
15777 /* We no longer need to defer access checks. */
15780 cp_omp_declare_simd_data odsd;
15786 /* In a block scope, a valid declaration must always have a
15787 decl-specifier-seq. By not trying to parse declarators, we can
15788 resolve the declaration/expression ambiguity more quickly. */
15791 {
15794 }
15796 /* If the next two tokens are both identifiers, the code is
15797 erroneous. The usual cause of this situation is code like:
15799 T t;
15801 where "T" should name a type -- but does not. */
15804 {
15805 /* If parsing tentatively, we should commit; we really are
15806 looking at a declaration. */
15808 /* Give up. */
15810 }
15814 /* Look for C++17 decomposition declaration. */
15822 {
15823 tree decl
15825 maybe_range_for_decl,
15828 /* The next token should be either a `,' or a `;'. */
15830 /* If it's a `;', we are done. */
15834 {
15838 }
15839 /* Anything else is an error. */
15840 else
15841 {
15842 /* If we have already issued an error message we don't need
15843 to issue another one. */
15848 /* Skip tokens until we reach the end of the statement. */
15850 /* If the next token is now a `;', consume it. */
15854 }
15855 }
15856 else
15859 tree last_type;
15861 /* NULL_TREE if both variable and function declaration are allowed,
15862 error_mark_node if function declaration are not allowed and
15863 a FUNCTION_DECL that should be diagnosed if it is followed by
15864 variable declarations. */
15865 tree auto_function_declaration;
15868 auto_specifier_p
15872 /* Keep going until we hit the `;' at the end of the simple
15873 declaration. */
15876 CPP_SEMICOLON))
15877 {
15880 tree decl;
15884 {
15885 /* If we are processing next declarator, comma is expected */
15890 {
15894 }
15895 }
15896 else
15899 /* Parse the init-declarator. */
15901 CP_PARSER_FLAGS_NONE,
15904 function_definition_allowed_p,
15906 declares_class_or_enum,
15908 maybe_range_for_decl,
15912 /* If an error occurred while parsing tentatively, exit quickly.
15913 (That usually happens when in the body of a function; each
15914 statement is treated as a declaration-statement until proven
15915 otherwise.) */
15920 {
15921 /* If the init-declarator-list contains more than one
15922 init-declarator, they shall all form declarations of
15923 variables. */
15927 {
15929 "non-variable %qD in declaration with more than one "
15933 }
15934 }
15938 {
15942 {
15943 /* If the list of declarators contains more than one declarator,
15944 the type of each declared variable is determined as described
15945 above. If the type deduced for the template parameter U is not
15946 the same in each deduction, the program is ill-formed. */
15951 }
15952 else
15954 }
15956 /* Handle function definitions specially. */
15958 {
15959 /* If the next token is a `,', then we are probably
15960 processing something like:
15962 void f() {}, *p;
15964 which is erroneous. */
15966 {
15969 "mixing"
15971 }
15972 /* Otherwise, we're done with the list of declarators. */
15973 else
15974 {
15978 }
15979 }
15982 /* The next token should be either a `,' or a `;'. */
15984 /* If it's a `,', there are more declarators to come. */
15987 /* If it's a `;', we are done. */
15991 {
15996 }
15997 /* Anything else is an error. */
15998 else
15999 {
16000 /* If we have already issued an error message we don't need
16001 to issue another one. */
16003 /* grokfndecl sets DECL_INITIAL to error_mark_node for
16004 functions. */
16008 /* Skip tokens until we reach the end of the statement. */
16010 /* If the next token is now a `;', consume it. */
16014 }
16015 /* After the first time around, a function-definition is not
16016 allowed -- even if it was OK at first. For example:
16018 int i, f() {}
16020 is not valid. */
16022 }
16024 /* Issue an error message if no declarators are present, and the
16025 decl-specifier-seq does not itself declare a class or
16026 enumeration: [dcl.dcl]/3. */
16028 {
16030 {
16034 /* Ensure an error is issued anyway when finish_decltype_type,
16035 called via cp_parser_decl_specifier_seq, returns a class or
16036 an enumeration (c++/51786). */
16039 }
16040 /* Perform any deferred access checks. */
16042 }
16044 /* Consume the `;'. */
16045 finish:
16049 {
16055 }
16057 done:
16060 }
16062 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
16063 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
16064 initializer ; */
16066 static tree
16071 {
16076 /* Parse the identifier-list. */
16080 {
16088 }
16092 {
16098 else
16099 {
16102 }
16103 }
16107 "structured bindings only available with "
16110 tree pushed_scope;
16117 NULL_TREE);
16124 cp_expr e;
16125 cp_decl_specifier_seq decl_specs;
16132 {
16136 else
16137 {
16140 }
16141 tree elt_pushed_scope;
16147 {
16148 /* Ensure we've diagnosed redeclaration if we aren't creating
16149 a new VAR_DECL. */
16152 }
16153 else
16157 }
16160 {
16163 }
16167 {
16175 || (is_direct_init
16178 {
16182 }
16185 {
16191 }
16192 }
16194 {
16197 /* Ensure DECL_VALUE_EXPR is created for all the decls but
16198 the underlying DECL. */
16200 }
16206 {
16209 }
16212 }
16214 /* Names of storage classes. */
16217 cp_storage_class_name[] = {
16219 };
16221 /* Parse a decl-specifier-seq.
16223 decl-specifier-seq:
16224 decl-specifier-seq [opt] decl-specifier
16225 decl-specifier attribute-specifier-seq [opt] (C++11)
16227 decl-specifier:
16228 storage-class-specifier
16229 type-specifier
16230 function-specifier
16231 friend
16232 typedef
16234 GNU Extension:
16236 decl-specifier:
16237 attributes
16239 Concepts Extension:
16241 decl-specifier:
16242 concept
16244 Set *DECL_SPECS to a representation of the decl-specifier-seq.
16246 The parser flags FLAGS is used to control type-specifier parsing.
16248 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
16249 flags:
16251 1: one of the decl-specifiers is an elaborated-type-specifier
16252 (i.e., a type declaration)
16253 2: one of the decl-specifiers is an enum-specifier or a
16254 class-specifier (i.e., a type definition)
16256 */
16258 static void
16260 cp_parser_flags flags,
16263 {
16267 cp_decl_spec ds;
16269 /* Clear DECL_SPECS. */
16272 /* Assume no class or enumeration type is declared. */
16275 /* Keep a token that additionally will be used for diagnostics. */
16277 /* Keep reading specifiers until there are no more to read. */
16279 {
16284 /* Peek at the next token. */
16287 /* Save the first token of the decl spec list for error
16288 reporting. */
16291 /* Handle attributes. */
16294 {
16295 /* Parse the attributes. */
16298 /* In a sequence of declaration specifiers, c++11 attributes
16299 appertain to the type that precede them. In that case
16300 [dcl.spec]/1 says:
16302 The attribute-specifier-seq affects the type only for
16303 the declaration it appears in, not other declarations
16304 involving the same type.
16306 But for now let's force the user to position the
16307 attribute either at the beginning of the declaration or
16308 after the declarator-id, which would clearly mean that it
16309 applies to the declarator. */
16311 {
16313 /* The c++11 attribute is at the beginning of the
16314 declaration. It appertains to the entity being
16316 else
16317 {
16319 {
16322 }
16324 {
16325 /* This is an attribute following a
16326 class-specifier. */
16331 }
16332 else
16333 {
16334 decl_specs->std_attributes
16338 }
16340 }
16341 }
16343 decl_specs->attributes
16348 }
16349 /* We know by this point that the token is not part of an attribute. */
16352 /* Special case for "this" specifier, indicating a parm is an xobj parm.
16353 The "this" specifier must be the first specifier in the declaration,
16354 after any attributes. */
16356 {
16359 {
16360 /* Don't emit diagnostics if we have already seen "this",
16361 leave it for set_and_check_decl_spec_loc. */
16363 {
16364 auto_diagnostic_group d;
16366 /* Works, need to add tests for it though. */
16371 "%<this%> must be the first specifier "
16373 }
16374 }
16377 }
16379 /* Assume we will find a decl-specifier keyword. */
16381 /* If the next token is an appropriate keyword, we can simply
16382 add it to the list. */
16384 {
16385 /* decl-specifier:
16386 friend
16387 constexpr
16388 constinit */
16391 {
16396 }
16397 else
16398 {
16400 /* Consume the token. */
16402 }
16427 /* Warn for concept as a decl-specifier. We'll rewrite these as
16428 concept declarations later. */
16430 {
16435 else
16438 }
16440 /* In C++20 a concept definition is just 'concept name = expr;'
16441 Support that syntax as a TS extension by pretending we've seen
16442 the 'bool' specifier. */
16446 {
16450 }
16453 /* function-specifier:
16454 inline
16455 virtual
16456 explicit */
16463 /* decl-specifier:
16464 typedef */
16467 /* Consume the token. */
16473 /* A constructor declarator cannot appear in a typedef. */
16475 /* The "typedef" keyword can only occur in a declaration; we
16476 may as well commit at this point. */
16480 {
16490 }
16493 /* storage-class-specifier:
16494 auto
16495 register
16496 static
16497 extern
16498 mutable
16500 GNU Extension:
16501 thread */
16504 {
16505 /* Consume the token. */
16508 /* Complain about `auto' as a storage specifier, if
16509 we're complaining about C++0x compatibility. */
16513 "%<auto%> changes meaning in C++11; "
16516 /* Set the storage class anyway. */
16518 token);
16519 }
16520 else
16521 /* C++0x auto type-specifier. */
16529 /* Consume the token. */
16532 token);
16535 /* Consume the token. */
16541 /* We did not yet find a decl-specifier yet. */
16544 }
16556 {
16562 "%qD only valid in lambda with %<-std=c++23%> or "
16564 }
16569 /* Constructors are a special case. The `S' in `S()' is not a
16570 decl-specifier; it is the beginning of the declarator. */
16571 constructor_p
16572 = (!found_decl_spec
16573 && constructor_possible_p
16574 && (cp_parser_constructor_declarator_p
16576 ds_friend))));
16578 /* If we don't have a DECL_SPEC yet, then we must be looking at
16579 a type-specifier. */
16581 {
16584 tree type_spec;
16589 type_spec
16591 decl_specs,
16597 /* If this type-specifier referenced a user-defined type
16598 (a typedef, class-name, etc.), then we can't allow any
16599 more such type-specifiers henceforth.
16601 [dcl.spec]
16603 The longest sequence of decl-specifiers that could
16604 possibly be a type name is taken as the
16605 decl-specifier-seq of a declaration. The sequence shall
16606 be self-consistent as described below.
16608 [dcl.type]
16610 As a general rule, at most one type-specifier is allowed
16611 in the complete decl-specifier-seq of a declaration. The
16612 only exceptions are the following:
16614 -- const or volatile can be combined with any other
16615 type-specifier.
16617 -- signed or unsigned can be combined with char, long,
16618 short, or int.
16620 -- ..
16622 Example:
16624 typedef char* Pc;
16625 void g (const int Pc);
16627 Here, Pc is *not* part of the decl-specifier seq; it's
16628 the declarator. Therefore, once we see a type-specifier
16629 (other than a cv-qualifier), we forbid any additional
16630 user-defined types. We *do* still allow things like `int
16631 int' to be considered a decl-specifier-seq, and issue the
16632 error message later. */
16635 /* A constructor declarator cannot follow a type-specifier. */
16637 {
16645 }
16646 }
16648 /* If we still do not have a DECL_SPEC, then there are no more
16649 decl-specifiers. */
16654 {
16658 "standard attributes must precede the decl-specifiers to "
16659 "apply to the declaration, or follow them to apply to "
16661 }
16664 /* After we see one decl-specifier, further decl-specifiers are
16665 always optional. */
16667 }
16669 /* Don't allow a friend specifier with a class definition. */
16674 }
16676 /* Parse an (optional) storage-class-specifier.
16678 storage-class-specifier:
16679 auto
16680 register
16681 static
16682 extern
16683 mutable
16685 GNU Extension:
16687 storage-class-specifier:
16688 thread
16690 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
16692 static tree
16694 {
16696 {
16700 /* Fall through for C++98. */
16708 /* Consume the token. */
16713 }
16714 }
16716 /* Parse an (optional) function-specifier.
16718 function-specifier:
16719 inline
16720 virtual
16721 explicit
16723 C++20 Extension:
16724 explicit(constant-expression)
16726 Returns an IDENTIFIER_NODE corresponding to the keyword used.
16727 Updates DECL_SPECS, if it is non-NULL. */
16729 static tree
16732 {
16735 {
16741 /* 14.5.2.3 [temp.mem]
16743 A member function template shall not be virtual. */
16747 else
16752 {
16754 /* If we see '(', it's C++20 explicit(bool). */
16755 tree expr;
16757 {
16758 matching_parens parens;
16761 /* New types are not allowed in an explicit-specifier. */
16764 parser->type_definition_forbidden_message
16769 "%<explicit(bool)%> only available with %<-std=c++20%> "
16772 /* Parse the constant-expression. */
16775 /* Restore the saved message. */
16778 }
16779 else
16780 /* The explicit-specifier explicit without a constant-expression is
16781 equivalent to the explicit-specifier explicit(true). */
16784 /* [dcl.fct.spec]
16785 "the constant-expression, if supplied, shall be a contextually
16786 converted constant expression of type bool." */
16788 /* We could evaluate it -- mark the decl as appropriate. */
16794 /* The expression was value-dependent. Remember it so that we can
16795 substitute it later. */
16798 }
16802 }
16804 /* Consume the token. */
16806 }
16808 /* Parse a linkage-specification.
16810 linkage-specification:
16811 extern string-literal { declaration-seq [opt] }
16812 extern string-literal declaration */
16814 static void
16816 {
16817 /* Look for the `extern' keyword. */
16818 cp_token *extern_token
16821 /* Look for the string-literal. */
16823 tree linkage;
16826 else
16830 /* Transform the literal into an identifier. If the literal is a
16831 wide-character string, or contains embedded NULs, then we can't
16832 handle it as the user wants. */
16836 {
16838 /* Assume C++ linkage. */
16840 }
16841 else
16844 /* We're now using the new linkage. */
16849 /* Preserve the location of the innermost linkage specification,
16850 tracking the locations of nested specifications via a local. */
16851 location_t saved_location
16853 /* Construct a location ranging from the start of the "extern" to
16854 the end of the string-literal, with the caret at the start, e.g.:
16855 extern "C" {
16856 ^~~~~~~~~~
16857 */
16858 parser->innermost_linkage_specification_location
16863 /* If the next token is a `{', then we're using the first
16864 production. */
16866 {
16870 /* Consume the `{' token. */
16871 matching_braces braces;
16873 /* Parse the declarations. */
16875 /* Look for the closing `}'. */
16877 }
16878 /* Otherwise, there's just one declaration. */
16879 else
16880 {
16883 saved_in_unbraced_linkage_specification_p
16887 parser->in_unbraced_linkage_specification_p
16889 }
16891 /* We're done with the linkage-specification. */
16895 /* Restore location of parent linkage specification, if any. */
16897 }
16899 /* Parse a static_assert-declaration.
16901 static_assert-declaration:
16902 static_assert ( constant-expression , string-literal ) ;
16903 static_assert ( constant-expression ) ; (C++17)
16904 static_assert ( constant-expression, conditional-expression ) ; (C++26)
16906 If MEMBER_P, this static_assert is a class member. */
16908 static void
16910 {
16911 cp_expr condition;
16912 location_t token_loc;
16913 tree message;
16915 /* Peek at the `static_assert' token so we can keep track of exactly
16916 where the static assertion started. */
16919 /* Look for the `static_assert' keyword. */
16921 RT_STATIC_ASSERT))
16924 /* We know we are in a static assertion; commit to any tentative
16925 parse. */
16929 /* Parse the `(' starting the static assertion condition. */
16930 matching_parens parens;
16933 /* Parse the constant-expression. Allow a non-constant expression
16934 here in order to give better diagnostics in finish_static_assert. */
16935 condition
16941 {
16944 "%<static_assert%> without a message "
16946 /* Eat the ')' */
16951 }
16952 else
16953 {
16954 /* Parse the separating `,'. */
16957 /* Parse the message expression. */
16960 {
16968 }
16970 {
16974 "%<static_assert%> with non-string message only "
16980 message);
16981 }
16984 else
16988 /* A `)' completes the static assertion. */
16994 }
16996 /* A semicolon terminates the declaration. */
16999 /* Get the location for the static assertion. Use that of the
17000 condition if available, otherwise, use that of the "static_assert"
17001 token. */
17006 /* Complete the static assertion, which may mean either processing
17007 the static assert now or saving it for template instantiation. */
17010 }
17012 /* Parse the expression in decltype ( expression ). */
17014 static tree
17017 {
17019 tree expr;
17021 /* First, try parsing an id-expression. */
17032 {
17035 cp_id_kind idk;
17039 /* Lookup the name we got back from the id-expression. */
17049 {
17050 /* Complete lookup of the id-expression. */
17051 expr = (finish_id_expression
17064 {
17065 /* We found an id-expression, but it was something that we
17066 should not have found. This is an error, not something
17067 we can recover from, so report the error we found and
17068 we'll recover as gracefully as possible. */
17073 }
17074 }
17079 /* We have an id-expression. */
17081 }
17084 {
17085 /* Abort the id-expression parse. */
17088 /* Parsing tentatively, again. */
17091 /* Parse a class member access. */
17099 /* We have an id-expression. */
17101 }
17104 /* We have parsed the complete id-expression or member access. */
17106 else
17107 {
17108 /* Abort our attempt to parse an id-expression or member access
17109 expression. */
17112 /* Parse a full expression. */
17115 }
17118 }
17120 /* Parse a `decltype' type. Returns the type.
17122 decltype-specifier:
17123 decltype ( expression )
17124 C++14:
17125 decltype ( auto ) */
17127 static tree
17129 {
17134 {
17135 /* Already parsed. */
17138 }
17140 /* Look for the `decltype' token. */
17144 /* Parse the opening `('. */
17145 matching_parens parens;
17149 /* Since we're going to preserve any side-effects from this parse, set up a
17150 firewall to protect our callers from cp_parser_commit_to_tentative_parse
17151 in the expression. */
17154 /* If in_declarator_p, a reparse as an expression might succeed (60361).
17155 Otherwise, commit now for better diagnostics. */
17166 {
17167 /* decltype (auto) */
17170 {
17172 "%<decltype(auto)%> type specifier only available with "
17175 }
17176 }
17177 else
17178 {
17179 /* decltype (expression) */
17181 /* Types cannot be defined in a `decltype' expression. Save away the
17182 old message and set the new one. */
17184 parser->type_definition_forbidden_message
17187 /* The restrictions on constant-expressions do not apply inside
17188 decltype expressions. */
17189 bool saved_integral_constant_expression_p
17191 bool saved_non_integral_constant_expression_p
17195 /* Within a parenthesized expression, a `>' token is always
17196 the greater-than operator. */
17197 bool saved_greater_than_is_operator_p
17201 /* Don't synthesize an implicit template type parameter here. This
17202 could happen with C++23 code like
17204 void f(decltype(new auto{0}));
17206 where we want to deduce the auto right away so that the parameter
17207 is of type 'int *'. */
17211 /* Do not actually evaluate the expression. */
17214 /* Do not warn about problems with the expression. */
17220 /* Go back to evaluating expressions. */
17224 /* The `>' token might be the end of a template-id or
17225 template-parameter-list now. */
17226 parser->greater_than_is_operator_p
17229 /* Restore the old message and the integral constant expression
17230 flags. */
17232 parser->integral_constant_expression_p
17234 parser->non_integral_constant_expression_p
17236 }
17238 /* Parse to the closing `)'. */
17240 {
17244 }
17246 /* If we got a parse error while tentative, bail out now. */
17248 {
17251 }
17254 /* Build auto. */
17256 else
17258 tf_warning_or_error);
17260 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
17261 it again. */
17278 }
17280 /* Special member functions [gram.special] */
17282 /* Parse a conversion-function-id.
17284 conversion-function-id:
17285 operator conversion-type-id
17287 Returns an IDENTIFIER_NODE representing the operator. */
17289 static tree
17291 {
17292 tree type;
17293 tree saved_scope;
17294 tree saved_qualifying_scope;
17295 tree saved_object_scope;
17298 /* Look for the `operator' token. */
17301 /* When we parse the conversion-type-id, the current scope will be
17302 reset. However, we need that information in able to look up the
17303 conversion function later, so we save it here. */
17307 /* We must enter the scope of the class so that the names of
17308 entities declared within the class are available in the
17309 conversion-type-id. For example, consider:
17311 struct S {
17312 typedef int I;
17313 operator I();
17314 };
17316 S::operator I() { ... }
17318 In order to see that `I' is a type-name in the definition, we
17319 must be in the scope of `S'. */
17322 /* Parse the conversion-type-id. */
17324 /* Leave the scope of the class, if any. */
17327 /* Restore the saved scope. */
17331 /* If the TYPE is invalid, indicate failure. */
17335 }
17337 /* Parse a conversion-type-id:
17339 conversion-type-id:
17340 type-specifier-seq conversion-declarator [opt]
17342 Returns the TYPE specified. */
17344 static tree
17346 {
17347 tree attributes;
17348 cp_decl_specifier_seq type_specifiers;
17350 tree type_specified;
17353 /* Parse the attributes. */
17357 parser->type_definition_forbidden_message
17360 /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
17361 optional in conversion-type-id. */
17369 /* If that didn't work, stop. */
17372 /* Parse the conversion-declarator. */
17380 /* Don't give this error when parsing tentatively. This happens to
17381 work because we always parse this definitively once. */
17384 {
17386 {
17389 }
17393 }
17396 }
17398 /* Parse an (optional) conversion-declarator.
17400 conversion-declarator:
17401 ptr-operator conversion-declarator [opt]
17403 */
17407 {
17410 cp_cv_quals cv_quals;
17412 /* We don't know if there's a ptr-operator next, or not. */
17414 /* Try the ptr-operator. */
17417 /* If it worked, look for more conversion-declarators. */
17419 {
17422 /* Parse another optional declarator. */
17425 declarator = cp_parser_make_indirect_declarator
17429 }
17432 }
17434 /* Parse an (optional) ctor-initializer.
17436 ctor-initializer:
17437 : mem-initializer-list */
17439 static void
17441 {
17442 /* If the next token is not a `:', then there is no
17443 ctor-initializer. */
17445 {
17446 /* Do default initialization of any bases and members. */
17450 }
17452 /* Consume the `:' token. */
17454 /* And the mem-initializer-list. */
17456 }
17458 /* Parse a mem-initializer-list.
17460 mem-initializer-list:
17461 mem-initializer ... [opt]
17462 mem-initializer ... [opt] , mem-initializer-list */
17464 static void
17466 {
17471 /* Let the semantic analysis code know that we are starting the
17472 mem-initializer-list. */
17477 /* Loop through the list. */
17479 {
17480 tree mem_initializer;
17483 /* Parse the mem-initializer. */
17485 /* If the next token is a `...', we're expanding member initializers. */
17491 {
17492 /* Consume the `...'. */
17496 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
17497 can be expanded but members cannot. */
17500 {
17505 }
17507 /* Construct the pack expansion type. */
17510 }
17513 {
17517 }
17518 /* Look for a target constructor. */
17522 {
17525 {
17529 }
17531 }
17532 /* Add it to the list, unless it was erroneous. */
17534 {
17537 }
17538 /* If the next token is not a `,', we're done. */
17541 /* Consume the `,' token. */
17543 }
17545 /* Perform semantic analysis. */
17548 }
17550 /* Parse a mem-initializer.
17552 mem-initializer:
17553 mem-initializer-id ( expression-list [opt] )
17554 mem-initializer-id braced-init-list
17556 GNU extension:
17558 mem-initializer:
17559 ( expression-list [opt] )
17561 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
17562 class) or FIELD_DECL (for a non-static data member) to initialize;
17563 the TREE_VALUE is the expression-list. An empty initialization
17564 list is represented by void_list_node. */
17566 static tree
17568 {
17569 tree mem_initializer_id;
17570 tree expression_list;
17571 tree member;
17574 /* Find out what is being initialized. */
17576 {
17580 }
17581 else
17582 {
17586 }
17592 {
17598 }
17599 else
17600 {
17612 }
17625 /* We can't attach the source location of this initializer directly to
17626 the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
17627 within the TREE_TYPE of the list node. */
17628 location_t loc
17635 }
17637 /* Parse a mem-initializer-id.
17639 mem-initializer-id:
17640 :: [opt] nested-name-specifier [opt] class-name
17641 decltype-specifier (C++11)
17642 identifier
17644 Returns a TYPE indicating the class to be initialized for the first
17645 production (and the second in C++11). Returns an IDENTIFIER_NODE
17646 indicating the data member to be initialized for the last production. */
17648 static tree
17650 {
17654 tree id;
17658 /* `typename' is not allowed in this context ([temp.res]). */
17660 {
17662 "keyword %<typename%> not allowed in this context (a qualified "
17665 }
17666 /* Look for the optional `::' operator. */
17667 global_scope_p
17671 /* Look for the optional nested-name-specifier. The simplest way to
17672 implement:
17674 [temp.res]
17676 The keyword `typename' is not permitted in a base-specifier or
17677 mem-initializer; in these contexts a qualified name that
17678 depends on a template-parameter is implicitly assumed to be a
17679 type name.
17681 is to assume that we have seen the `typename' keyword at this
17682 point. */
17683 nested_name_specifier_p
17692 /* If there is a `::' operator or a nested-name-specifier, then we
17693 are definitely looking for a class-name. */
17698 typename_type,
17702 /* Otherwise, we could also be looking for an ordinary identifier. */
17705 /* Try a decltype-specifier. */
17707 else
17708 /* Otherwise, try a class-name. */
17712 none_type,
17716 /* If we found one, we're done. */
17719 /* Otherwise, look for an ordinary identifier. */
17721 }
17723 /* Overloading [gram.over] */
17725 /* Parse an operator-function-id.
17727 operator-function-id:
17728 operator operator
17730 Returns an IDENTIFIER_NODE for the operator which is a
17731 human-readable spelling of the identifier, e.g., `operator +'. */
17733 static cp_expr
17735 {
17737 /* Look for the `operator' keyword. */
17740 /* And then the name of the operator itself. */
17742 }
17744 /* Return an identifier node for a user-defined literal operator.
17745 The suffix identifier is chained to the operator name identifier. */
17747 tree
17749 {
17750 tree identifier;
17758 }
17760 /* Parse an operator.
17762 operator:
17763 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
17764 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
17765 || ++ -- , ->* -> () []
17767 GNU Extensions:
17769 operator:
17770 <? >? <?= >?=
17772 Returns an IDENTIFIER_NODE for the operator which is a
17773 human-readable spelling of the identifier, e.g., `operator +'. */
17775 static cp_expr
17777 {
17782 /* Peek at the next token. */
17787 /* Figure out which operator we have. */
17792 {
17794 {
17795 /* The keyword should be either `new', `delete' or `co_await'. */
17802 else
17805 /* Consume the `new', `delete' or co_await token. */
17808 /* Peek at the next token. */
17810 /* If it's a `[' token then this is the array variant of the
17811 operator. */
17814 {
17815 /* Consume the `[' token. */
17817 /* Look for the `]' token. */
17822 }
17825 }
17988 /* Consume the `?'. */
17990 /* Look for the matching `:'. */
17996 {
17997 /* Consume the `('. */
17998 matching_parens parens;
18000 /* Look for the matching `)'. */
18007 }
18010 /* Consume the `['. */
18012 /* Look for the matching `]'. */
18023 /* FALLTHRU */
18032 {
18033 tree string_tree;
18039 /* Consume the string. */
18045 {
18049 }
18050 else
18051 {
18053 /* Look for the suffix identifier. */
18056 {
18059 }
18061 {
18065 }
18066 else
18067 {
18070 }
18071 }
18076 {
18079 }
18082 {
18085 }
18087 {
18090 }
18091 /* Generate a location of the form:
18092 "" _suffix_identifier
18093 ^~~~~~~~~~~~~~~~~~~~~
18094 with caret == start at the start token, finish at the end of the
18095 suffix identifier. */
18096 location_t combined_loc
18099 }
18102 /* Anything else is an error. */
18104 }
18106 /* If we have selected an identifier, we need to consume the
18107 operator token. */
18109 {
18113 }
18114 /* Otherwise, no valid operator name was present. */
18115 else
18116 {
18119 }
18123 }
18125 /* Parse a template-declaration.
18127 template-declaration:
18128 export [opt] template < template-parameter-list > declaration
18130 If MEMBER_P is TRUE, this template-declaration occurs within a
18131 class-specifier.
18133 The grammar rule given by the standard isn't correct. What
18134 is really meant is:
18136 template-declaration:
18137 export [opt] template-parameter-list-seq
18138 decl-specifier-seq [opt] init-declarator [opt] ;
18139 export [opt] template-parameter-list-seq
18140 function-definition
18142 template-parameter-list-seq:
18143 template-parameter-list-seq [opt]
18144 template < template-parameter-list >
18146 Concept Extensions:
18148 template-parameter-list-seq:
18149 template < template-parameter-list > requires-clause [opt]
18151 requires-clause:
18152 requires logical-or-expression */
18154 static void
18156 {
18157 /* Check for `export'. */
18159 {
18160 /* Consume the `export' token. */
18162 /* Warn that this use of export is deprecated. */
18167 else
18169 }
18172 }
18174 /* Parse a template-parameter-list.
18176 template-parameter-list:
18177 template-parameter
18178 template-parameter-list , template-parameter
18180 Returns a TREE_LIST. Each node represents a template parameter.
18181 The nodes are connected via their TREE_CHAINs. */
18183 static tree
18185 {
18188 /* Don't create wrapper nodes within a template-parameter-list,
18189 since we don't want to have different types based on the
18190 spelling location of constants and decls within them. */
18191 auto_suppress_location_wrappers sentinel;
18195 /* The loop below parses the template parms. We first need to know
18196 the total number of template parms to be able to compute proper
18197 canonical types of each dependent type. So after the loop, when
18198 we know the total number of template parms,
18199 end_template_parm_list computes the proper canonical types and
18200 fixes up the dependent types accordingly. */
18202 {
18203 tree parameter;
18206 location_t parm_loc;
18208 /* Parse the template-parameter. */
18213 /* Add it to the list. */
18216 parm_loc,
18217 parameter,
18218 is_non_type,
18219 is_parameter_pack);
18220 else
18221 {
18224 }
18226 /* If the next token is not a `,', we're done. */
18229 /* Otherwise, consume the `,' token. */
18231 }
18234 }
18236 /* Parse a introduction-list.
18238 introduction-list:
18239 introduced-parameter
18240 introduction-list , introduced-parameter
18242 introduced-parameter:
18243 ...[opt] identifier
18245 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
18246 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
18247 WILDCARD_DECL will also have DECL_NAME set and token location in
18248 DECL_SOURCE_LOCATION. */
18250 static tree
18252 {
18256 {
18265 /* Build placeholder. */
18273 /* If the next token is not a `,', we're done. */
18276 /* Otherwise, consume the `,' token. */
18278 }
18280 /* Convert the vec into a TREE_VEC. */
18283 tree parm;
18289 }
18291 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
18292 is an abstract declarator. */
18296 {
18301 }
18303 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
18304 is an abstract declarator. */
18308 {
18312 else
18314 }
18316 /* Returns true if TYPE would declare a constrained constrained-parameter. */
18320 {
18325 }
18327 /* Returns true if PARM declares a constrained-parameter. */
18331 {
18333 }
18335 /* Check that the type parameter is only a declarator-id, and that its
18336 type is not cv-qualified. */
18338 bool
18341 {
18346 {
18349 }
18351 /* Don't allow cv-qualified type parameters. */
18354 {
18357 }
18360 }
18362 /* Finish parsing/processing a template type parameter and checking
18363 various restrictions. */
18367 tree id,
18369 {
18372 else
18374 }
18376 static tree
18378 {
18379 /* FIXME: This should probably be copied, and we may need to adjust
18380 the template parameter depths. */
18390 }
18392 /* Finish parsing/processing a template template parameter by borrowing
18393 the template parameter list from the prototype parameter. */
18395 static tree
18397 tree proto,
18398 tree id,
18400 {
18404 }
18406 /* Create a new non-type template parameter from the given PARM
18407 declarator. */
18409 static tree
18412 {
18418 }
18420 /* Build a constrained template parameter based on the PARMDECL
18421 declarator. The type of PARMDECL is the constrained type, which
18422 refers to the prototype template parameter that ultimately
18423 specifies the type of the declared parameter. */
18425 static tree
18429 {
18435 /* Build the parameter. Return an error if the declarator was invalid. */
18436 tree parm;
18441 parmdecl);
18442 else
18447 /* Finish the parameter decl and create a node attaching the
18448 default argument and constraint. */
18453 }
18455 /* Returns true if the parsed type actually represents the declaration
18456 of a type template-parameter. */
18458 static bool
18460 {
18463 }
18465 /* Returns true if the parsed type actually represents the declaration of
18466 a template template-parameter. */
18468 static bool
18470 {
18473 }
18475 /* Parse a default argument for a type template-parameter.
18476 Note that diagnostics are handled in cp_parser_template_parameter. */
18478 static tree
18480 {
18483 /* Consume the `=' token. */
18488 /* Tell cp_parser_lambda_expression this is a default argument. */
18492 /* Parse the default-argument. */
18495 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18496 NULL);
18500 {
18504 }
18507 }
18509 /* Parse a default argument for a template template-parameter. */
18511 static tree
18513 {
18518 /* Consume the `='. */
18520 /* Parse the id-expression. */
18522 /* save token before parsing the id-expression, for error
18523 reporting */
18525 tree default_argument
18533 /* If the id-expression was a template-id that refers to
18534 a template-class, we already have the declaration here,
18535 so no further lookup is needed. */
18536 ;
18537 else
18538 /* Look up the name. */
18539 default_argument
18541 none_type,
18547 /* See if the default argument is valid. */
18551 }
18553 /* Parse a template-parameter.
18555 template-parameter:
18556 type-parameter
18557 parameter-declaration
18559 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
18560 the parameter. The TREE_PURPOSE is the default value, if any.
18561 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
18562 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
18563 set to true iff this parameter is a parameter pack. */
18565 static tree
18568 {
18571 tree parm;
18573 /* Assume it is a type parameter or a template parameter. */
18575 /* Assume it not a parameter pack. */
18577 /* Peek at the next token. */
18579 /* If it is `template', we have a type-parameter. */
18582 /* If it is `class' or `typename' we do not know yet whether it is a
18583 type parameter or a non-type parameter. Consider:
18585 template <typename T, typename T::X X> ...
18587 or:
18589 template <class C, class D*> ...
18591 Here, the first parameter is a type parameter, and the second is
18592 a non-type parameter. We can tell by looking at the token after
18593 the identifier -- if it is a `,', `=', or `>' then we have a type
18594 parameter. */
18596 {
18597 /* Peek at the token after `class' or `typename'. */
18599 /* If it's an ellipsis, we have a template type parameter
18600 pack. */
18603 /* If it's an identifier, skip it. */
18606 /* Now, see if the token looks like the end of a template
18607 parameter. */
18612 }
18614 /* Otherwise, it is a non-type parameter or a constrained parameter.
18616 [temp.param]
18618 When parsing a default template-argument for a non-type
18619 template-parameter, the first non-nested `>' is taken as the end
18620 of the template parameter-list rather than a greater-than
18621 operator. */
18622 parameter_declarator
18624 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18631 /* If the parameter declaration is marked as a parameter pack, set
18632 *IS_PARAMETER_PACK to notify the caller. */
18637 {
18638 /* Can happen in some cases of erroneous input (c++/34892). */
18640 /* Consume the `...' for better error recovery. */
18642 }
18644 /* The parameter may have been constrained type parameter. */
18647 parameter_declarator,
18648 is_non_type);
18650 // Now we're sure that the parameter is a non-type parameter.
18661 }
18663 /* Parse a type-parameter.
18665 type-parameter:
18666 class identifier [opt]
18667 class identifier [opt] = type-id
18668 typename identifier [opt]
18669 typename identifier [opt] = type-id
18670 template < template-parameter-list > class identifier [opt]
18671 template < template-parameter-list > class identifier [opt]
18672 = id-expression
18674 GNU Extension (variadic templates):
18676 type-parameter:
18677 class ... identifier [opt]
18678 typename ... identifier [opt]
18680 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
18681 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
18682 the declaration of the parameter.
18684 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
18686 static tree
18688 {
18690 tree parameter;
18692 /* Look for a keyword to tell us what kind of parameter this is. */
18698 {
18701 {
18702 tree identifier;
18703 tree default_argument;
18705 /* If the next token is an ellipsis, we have a template
18706 argument pack. */
18708 {
18709 /* Consume the `...' token. */
18714 }
18716 /* If the next token is an identifier, then it names the
18717 parameter. */
18720 else
18723 /* Create the parameter. */
18726 /* If the next token is an `=', we have a default argument. */
18728 {
18729 default_argument
18732 /* Template parameter packs cannot have default
18733 arguments. */
18735 {
18738 "template parameter pack %qD cannot have a "
18740 else
18742 "template parameter packs cannot have "
18745 }
18748 }
18749 else
18752 /* Create the combined representation of the parameter and the
18753 default argument. */
18755 }
18759 {
18760 tree identifier;
18761 tree default_argument;
18763 /* Look for the `<'. */
18765 /* Parse the template-parameter-list. */
18767 /* Look for the `>'. */
18770 /* If template requirements are present, parse them. */
18772 {
18777 }
18779 /* Look for the `class' or 'typename' keywords. */
18781 /* If the next token is an ellipsis, we have a template
18782 argument pack. */
18784 {
18785 /* Consume the `...' token. */
18790 }
18791 /* If the next token is an `=', then there is a
18792 default-argument. If the next token is a `>', we are at
18793 the end of the parameter-list. If the next token is a `,',
18794 then we are at the end of this parameter. */
18798 {
18800 /* Treat invalid names as if the parameter were nameless. */
18803 }
18804 else
18807 /* Create the template parameter. */
18809 identifier);
18811 /* If the next token is an `=', then there is a
18812 default-argument. */
18814 {
18815 default_argument
18818 /* Template parameter packs cannot have default
18819 arguments. */
18821 {
18824 "template parameter pack %qD cannot "
18826 identifier);
18827 else
18831 }
18832 }
18833 else
18836 /* Create the combined representation of the parameter and the
18837 default argument. */
18839 }
18845 }
18848 }
18850 /* Parse a template-id.
18852 template-id:
18853 template-name < template-argument-list [opt] >
18855 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
18856 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
18857 returned. Otherwise, if the template-name names a function, or set
18858 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
18859 names a class, returns a TYPE_DECL for the specialization.
18861 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
18862 uninstantiated templates. */
18864 static tree
18870 {
18871 tree templ;
18872 tree arguments;
18873 tree template_id;
18878 /* If the next token corresponds to a template-id, there is no need
18879 to reparse it. */
18883 {
18886 }
18888 /* Avoid performing name lookup if there is no possibility of
18889 finding a template-id. */
18892 && !cp_parser_nth_token_starts_template_argument_list_p
18894 {
18897 }
18899 /* Remember where the template-id starts. */
18905 /* Parse the template-name. */
18908 check_dependency_p,
18909 is_declaration,
18910 tag_type,
18913 /* Push any access checks inside the firewall we're about to create. */
18919 /* Since we're going to preserve any side-effects from this parse, set up a
18920 firewall to protect our callers from cp_parser_commit_to_tentative_parse
18921 in the template arguments. */
18925 /* If we find the sequence `[:' after a template-name, it's probably
18926 a digraph-typo for `< ::'. Substitute the tokens and check if we can
18927 parse correctly the argument list. */
18934 {
18936 /* Change `:' into `::'. */
18938 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
18939 CPP_LESS. */
18942 /* Parse the arguments. */
18945 {
18946 /* If we couldn't parse an argument list, then we revert our changes
18947 and return simply an error. Maybe this is not a template-id
18948 after all. */
18953 }
18954 /* Otherwise, emit an error about the invalid digraph, but continue
18955 parsing because we got our argument list. */
18958 {
18961 "%<<:%> is an alternate spelling for %<[%>."
18964 {
18966 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
18969 }
18970 }
18971 }
18972 else
18973 {
18974 /* Look for the `<' that starts the template-argument-list. */
18976 {
18979 }
18980 /* Parse the arguments. */
18985 && !template_keyword_p
18988 {
18989 /* This didn't go well. */
18991 {
18992 /* C++20 says that "function-name < a;" is now ill-formed. */
18994 {
18997 "operand of %<<%> is ill-formed in C++20; wrap the "
18999 }
19000 else
19001 /* We expect "f<targs>" to be followed by "(args)". */
19005 /* Purge all subsequent tokens. */
19007 }
19008 else
19012 }
19013 }
19015 /* Set the location to be of the form:
19016 template-name < template-argument-list [opt] >
19017 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19018 with caret == start at the start of the template-name,
19019 ranging until the closing '>'. */
19020 location_t combined_loc
19023 /* Check for concepts autos where they don't belong. We could
19024 identify types in some cases of identifier TEMPL, looking ahead
19025 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
19026 types. We reject them in functions, but if what we have is an
19027 identifier, even with none_type we can't conclude it's NOT a
19028 type, we have to wait for template substitution. */
19031 /* Build a representation of the specialization. */
19034 TEMPLATE_ID_EXPR,
19038 {
19039 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
19040 template (rather than some instantiation thereof) only if
19041 is not nested within some other construct. For example, in
19042 "template <typename T> void f(T) { A<T>::", A<T> is just an
19043 instantiation of A. */
19044 bool entering_scope
19047 template_id
19049 }
19051 {
19052 /* The caller will decide whether this is a concept check or type
19053 constraint. */
19056 }
19058 {
19062 }
19065 {
19066 /* Some type template in dependent scope. */
19069 TEMPLATE_ID_EXPR,
19072 }
19073 else
19074 {
19075 /* If it's not a class-template or a template-template, it should be
19076 a function-template. */
19082 }
19084 /* If parsing tentatively, replace the sequence of tokens that makes
19085 up the template-id with a CPP_TEMPLATE_ID token. That way,
19086 should we re-parse the token stream, we will not have to repeat
19087 the effort required to do the parse, nor will we issue duplicate
19088 error messages about problems during instantiation of the
19089 template. */
19091 /* Don't do this if we had a parse error in a declarator; re-parsing
19092 might succeed if a name changes meaning (60361). */
19096 {
19097 /* Reset the contents of the START_OF_ID token. */
19101 /* Retrieve any deferred checks. Do not pop this access checks yet
19102 so the memory will not be reclaimed during token replacing below. */
19109 /* Purge all subsequent tokens. */
19112 /* ??? Can we actually assume that, if template_id ==
19113 error_mark_node, we will have issued a diagnostic to the
19114 user, as opposed to simply marking the tentative parse as
19115 failed? */
19118 }
19122 }
19124 /* Like cp_parser_template_id, called in non-type context. */
19126 static tree
19131 {
19136 /* We didn't check the arguments in cp_parser_template_id; do that now. */
19139 }
19141 /* Parse a template-name.
19143 template-name:
19144 identifier
19146 The standard should actually say:
19148 template-name:
19149 identifier
19150 operator-function-id
19152 A defect report has been filed about this issue.
19154 A conversion-function-id cannot be a template name because they cannot
19155 be part of a template-id. In fact, looking at this code:
19157 a.operator K<int>()
19159 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
19160 It is impossible to call a templated conversion-function-id with an
19161 explicit argument list, since the only allowed template parameter is
19162 the type to which it is converting.
19164 If TEMPLATE_KEYWORD_P is true, then we have just seen the
19165 `template' keyword, in a construction like:
19167 T::template f<3>()
19169 In that case `f' is taken to be a template-name, even though there
19170 is no way of knowing for sure.
19172 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
19173 name refers to a set of overloaded functions, at least one of which
19174 is a template, or an IDENTIFIER_NODE with the name of the template,
19175 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
19176 names are looked up inside uninstantiated templates. */
19178 static tree
19185 {
19186 tree identifier;
19187 tree decl;
19190 /* If the next token is `operator', then we have either an
19191 operator-function-id or a conversion-function-id. */
19193 {
19194 /* We don't know whether we're looking at an
19195 operator-function-id or a conversion-function-id. */
19197 /* Try an operator-function-id. */
19199 /* If that didn't work, try a conversion-function-id. */
19201 {
19204 }
19205 }
19206 /* Look for the identifier. */
19207 else
19210 /* If we didn't find an identifier, we don't have a template-id. */
19214 /* If the name immediately followed the `template' keyword, then it
19215 is a template-name. However, if the next token is not `<', then
19216 we do not treat it as a template-name, since it is not being used
19217 as part of a template-id. This enables us to handle constructs
19218 like:
19220 template <typename T> struct S { S(); };
19221 template <typename T> S<T>::S();
19223 correctly. We would treat `S' as a template -- if it were `S<T>'
19224 -- but we do not if there is no `<'. */
19228 {
19229 /* In a declaration, in a dependent context, we pretend that the
19230 "template" keyword was present in order to improve error
19231 recovery. For example, given:
19233 template <typename T> void f(T::X<int>);
19235 we want to treat "X<int>" as a template-id. */
19237 && !template_keyword_p
19239 && check_dependency_p
19241 /* Do not do this for dtors (or ctors), since they never
19242 need the template keyword before their name. */
19244 {
19247 /* Explain what went wrong. */
19249 identifier);
19252 /* If parsing tentatively, find the location of the "<" token. */
19255 /* Parse the template arguments so that we can issue error
19256 messages about them. */
19259 /* Skip tokens until we find a good place from which to
19260 continue parsing. */
19265 /* If parsing tentatively, permanently remove the
19266 template argument list. That will prevent duplicate
19267 error messages from being issued about the missing
19268 "template" keyword. */
19275 }
19277 /* If the "template" keyword is present, then there is generally
19278 no point in doing name-lookup, so we just return IDENTIFIER.
19279 But, if the qualifying scope is non-dependent then we can
19280 (and must) do name-lookup normally. */
19282 {
19288 {
19289 /* We're optimizing away the call to cp_parser_lookup_name, but
19290 we still need to do this. */
19294 }
19295 }
19296 }
19298 /* cp_parser_lookup_name clears OBJECT_TYPE. */
19302 /* Look up the name. */
19304 tag_type,
19307 check_dependency_p,
19313 /* 13.3 [temp.names] A < is interpreted as the delimiter of a
19314 template-argument-list if it follows a name that is not a
19315 conversion-function-id and
19316 - that follows the keyword template or a ~ after a nested-name-specifier or
19317 in a class member access expression, or
19318 - for which name lookup finds the injected-class-name of a class template
19319 or finds any declaration of a template, or
19320 - that is an unqualified name for which name lookup either finds one or
19321 more functions or finds nothing, or
19322 - that is a terminal name in a using-declarator (9.9), in a declarator-id
19323 (9.3.4), or in a type-only context other than a nested-name-specifier
19324 (13.8). */
19326 /* Handle injected-class-name. */
19329 /* If DECL is a template, then the name was a template-name. */
19331 {
19334 {
19336 tree attr;
19339 else
19342 {
19345 }
19348 {
19351 }
19352 }
19353 }
19354 else
19355 {
19356 /* Look through an overload set for any templates. */
19364 /* "an unqualified name for which name lookup either finds one or more
19365 functions or finds nothing". */
19368 && !scope
19371 {
19372 /* The "more functions" case. Just use the OVERLOAD as normally.
19373 We don't use is_overloaded_fn here to avoid considering
19374 BASELINKs. */
19376 /* Name lookup found one function. */
19378 /* Name lookup found nothing. */
19381 }
19383 /* "that follows the keyword template"..."in a type-only context" */
19391 {
19392 /* The name does not name a template. */
19395 }
19398 /* cp_parser_template_id can only handle some TYPE_DECLs. */
19401 /* Repeat the lookup at instantiation time. */
19403 }
19406 }
19408 /* Parse a template-argument-list.
19410 template-argument-list:
19411 template-argument ... [opt]
19412 template-argument-list , template-argument ... [opt]
19414 Returns a TREE_VEC containing the arguments. */
19416 static tree
19418 {
19423 /* Don't create location wrapper nodes within a template-argument-list. */
19424 auto_suppress_location_wrappers sentinel;
19428 /* Even if the template-id appears in an integral
19429 constant-expression, the contents of the argument list do
19430 not. */
19436 /* Parse the arguments. */
19438 do
19439 {
19441 /* Consume the comma. */
19444 /* Parse the template-argument. */
19447 /* If the next token is an ellipsis, we're expanding a template
19448 argument pack. */
19450 {
19452 {
19456 }
19457 /* Consume the `...' token. */
19460 /* Make the argument into a TYPE_PACK_EXPANSION or
19461 EXPR_PACK_EXPANSION. */
19463 }
19466 }
19481 }
19483 /* Parse a template-argument.
19485 template-argument:
19486 assignment-expression
19487 type-id
19488 id-expression
19490 The representation is that of an assignment-expression, type-id, or
19491 id-expression -- except that the qualified id-expression is
19492 evaluated, so that the value returned is either a DECL or an
19493 OVERLOAD.
19495 Although the standard says "assignment-expression", it forbids
19496 throw-expressions or assignments in the template argument.
19497 Therefore, we use "conditional-expression" instead. */
19499 static tree
19501 {
19502 tree argument;
19508 cp_id_kind idk;
19510 /* There's really no way to know what we're looking at, so we just
19511 try each alternative in order.
19513 [temp.arg]
19515 In a template-argument, an ambiguity between a type-id and an
19516 expression is resolved to a type-id, regardless of the form of
19517 the corresponding template-parameter.
19519 Therefore, we try a type-id first. */
19522 /* If there was no error parsing the type-id but the next token is a
19523 '>>', our behavior depends on which dialect of C++ we're
19524 parsing. In C++98, we probably found a typo for '> >'. But there
19525 are type-id which are also valid expressions. For instance:
19527 struct X { int operator >> (int); };
19528 template <int V> struct Foo {};
19529 Foo<X () >> 5> r;
19531 Here 'X()' is a valid type-id of a function type, but the user just
19532 wanted to write the expression "X() >> 5". Thus, we remember that we
19533 found a valid type-id, but we still try to parse the argument as an
19534 expression to see what happens.
19536 In C++0x, the '>>' will be considered two separate '>'
19537 tokens. */
19541 /* Similarly for >= which
19542 cp_parser_next_token_ends_template_argument_p treats for
19543 diagnostics purposes as mistyped > =, but can be valid
19544 after a type-id. */
19546 {
19549 }
19550 else
19551 {
19552 /* If the next token isn't a `,' or a `>', then this argument wasn't
19553 really finished. This means that the argument is not a valid
19554 type-id. */
19557 /* If that worked, we're done. */
19560 }
19561 /* We're still not sure what the argument will be. */
19563 /* Try a template. */
19571 /* If the next token isn't a `,' or a `>', then this argument wasn't
19572 really finished. */
19576 {
19577 /* Figure out what is being referred to. If the id-expression
19578 was for a class template specialization, then we will have a
19579 TYPE_DECL at this point. There is no need to do name lookup
19580 at this point in that case. */
19583 none_type,
19592 }
19594 {
19600 }
19601 /* It must be a non-type argument. In C++17 any constant-expression is
19602 allowed. */
19606 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
19608 -- an integral constant-expression of integral or enumeration
19609 type; or
19611 -- the name of a non-type template-parameter; or
19613 -- the name of an object or function with external linkage...
19615 -- the address of an object or function with external linkage...
19617 -- a pointer to member... */
19618 /* Look for a non-type template parameter. */
19620 {
19632 }
19634 /* If the next token is "&", the argument must be the address of an
19635 object or function with external linkage. */
19638 {
19641 }
19642 /* See if we might have an id-expression. */
19649 {
19652 address_p,
19659 else
19660 {
19661 tree probe;
19664 {
19665 /* Strip the dereference temporarily. */
19668 }
19670 /* If we're in a template, we represent a qualified-id referring
19671 to a static data member as a SCOPE_REF even if the scope isn't
19672 dependent so that we can check access control later. */
19677 {
19678 /* A variable without external linkage might still be a
19679 valid constant-expression, so no error is issued here
19680 if the external-linkage check fails. */
19683 }
19685 /* All overloaded functions are allowed; if the external
19686 linkage test does not pass, an error will be issued
19687 later. */
19688 ;
19692 /* A pointer-to-member. */
19693 ;
19695 ;
19696 else
19700 {
19704 else
19707 }
19708 }
19709 }
19710 /* If the argument started with "&", there are no other valid
19711 alternatives at this point. */
19713 {
19716 }
19718 general_expr:
19719 /* If the argument wasn't successfully parsed as a type-id followed
19720 by '>>', the argument can only be a constant expression now.
19721 Otherwise, we try parsing the constant-expression tentatively,
19722 because the argument could really be a type-id. */
19728 else
19729 {
19730 /* In C++20, we can encounter a braced-init-list. */
19735 /* With C++17 generalized non-type template arguments we need to handle
19736 lvalue constant expressions, too. */
19739 }
19747 /* We did our best to parse the argument as a non type-id, but that
19748 was the only alternative that matched (albeit with a '>' after
19749 it). We can assume it's just a typo from the user, and a
19750 diagnostic will then be issued. */
19752 }
19754 /* Parse an explicit-instantiation.
19756 explicit-instantiation:
19757 template declaration
19759 Although the standard says `declaration', what it really means is:
19761 explicit-instantiation:
19762 template decl-specifier-seq [opt] declarator [opt] ;
19764 Things like `template int S<int>::i = 5, int S<double>::j;' are not
19765 supposed to be allowed. A defect report has been filed about this
19766 issue.
19768 GNU Extension:
19770 explicit-instantiation:
19771 storage-class-specifier template
19772 decl-specifier-seq [opt] declarator [opt] ;
19773 function-specifier template
19774 decl-specifier-seq [opt] declarator [opt] ; */
19776 static void
19778 {
19780 cp_decl_specifier_seq decl_specifiers;
19785 /* Look for an (optional) storage-class-specifier or
19786 function-specifier. */
19788 {
19789 extension_specifier
19792 extension_specifier
19795 }
19797 /* Look for the `template' keyword. */
19799 /* Let the front end know that we are processing an explicit
19800 instantiation. */
19802 /* [temp.explicit] says that we are supposed to ignore access
19803 control while processing explicit instantiation directives. */
19805 /* Parse a decl-specifier-seq. */
19807 CP_PARSER_FLAGS_OPTIONAL,
19811 cp_omp_declare_simd_data odsd;
19817 /* If there was exactly one decl-specifier, and it declared a class,
19818 and there's no declarator, then we have an explicit type
19819 instantiation. */
19821 {
19824 /* Turn access control back on for names used during
19825 template instantiation. */
19830 }
19831 else
19832 {
19834 tree decl;
19836 /* Parse the declarator. */
19837 declarator
19839 CP_PARSER_FLAGS_NONE,
19850 {
19853 "explicit instantiation shall not use"
19857 "explicit instantiation shall not use"
19861 "explicit instantiation shall not use"
19866 /* Turn access control back on for names used during
19867 template instantiation. */
19869 /* Do the explicit instantiation. */
19871 }
19872 else
19873 {
19875 /* Skip the body of the explicit instantiation. */
19877 }
19878 }
19879 /* We're done with the instantiation. */
19885 }
19887 /* Parse an explicit-specialization.
19889 explicit-specialization:
19890 template < > declaration
19892 Although the standard says `declaration', what it really means is:
19894 explicit-specialization:
19895 template <> decl-specifier [opt] init-declarator [opt] ;
19896 template <> function-definition
19897 template <> explicit-specialization
19898 template <> template-declaration */
19900 static void
19902 {
19905 /* Look for the `template' keyword. */
19907 /* Look for the `<'. */
19909 /* Look for the `>'. */
19911 /* We have processed another parameter list. */
19914 /* [temp]
19916 A template ... explicit specialization ... shall not have C
19917 linkage. */
19920 {
19924 /* Give it C++ linkage to avoid confusing other parts of the
19925 front end. */
19927 }
19929 /* Let the front end know that we are beginning a specialization. */
19931 {
19932 /* If the next keyword is `template', we need to figure out
19933 whether or not we're looking a template-declaration. */
19935 {
19940 else
19942 }
19943 else
19944 /* Parse the dependent declaration. */
19950 }
19952 /* We're done with the specialization. */
19955 /* For the erroneous case of a template with C linkage, we pushed an
19956 implicit C++ linkage scope; exit that scope now. */
19960 /* We're done with this parameter list. */
19962 }
19964 /* Preserve the attributes across a garbage collect (by making it a GC
19965 root), which can occur when parsing a member function. */
19969 /* Parse a type-specifier.
19971 type-specifier:
19972 simple-type-specifier
19973 class-specifier
19974 enum-specifier
19975 elaborated-type-specifier
19976 cv-qualifier
19978 GNU Extension:
19980 type-specifier:
19981 __complex__
19983 Returns a representation of the type-specifier. For a
19984 class-specifier, enum-specifier, or elaborated-type-specifier, a
19985 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
19987 The parser flags FLAGS is used to control type-specifier parsing.
19989 If IS_DECLARATION is TRUE, then this type-specifier is appearing
19990 in a decl-specifier-seq.
19992 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
19993 class-specifier, enum-specifier, or elaborated-type-specifier, then
19994 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
19995 if a type is declared; 2 if it is defined. Otherwise, it is set to
19996 zero.
19998 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
19999 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
20000 is set to FALSE. */
20002 static tree
20004 cp_parser_flags flags,
20009 {
20015 /* Assume this type-specifier does not declare a new type. */
20018 /* And that it does not specify a cv-qualifier. */
20021 /* Peek at the next token. */
20024 /* If we're looking at a keyword, we can use that to guide the
20025 production we choose. */
20028 {
20033 /* Look for the enum-specifier. */
20035 /* If that worked, we're done. */
20037 {
20042 type_spec,
20043 token,
20046 }
20047 else
20050 /* Any of these indicate either a class-specifier, or an
20051 elaborated-type-specifier. */
20058 /* Parse tentatively so that we can back up if we don't find a
20059 class-specifier. */
20063 /* Look for the class-specifier. */
20068 /* If that worked, we're done. */
20070 {
20075 type_spec,
20076 token,
20079 }
20081 /* Fall through. */
20082 elaborated_type_specifier:
20083 /* We're declaring (not defining) a class or enum. */
20087 /* Fall through. */
20089 /* Look for an elaborated-type-specifier. */
20090 type_spec
20091 = (cp_parser_elaborated_type_specifier
20094 is_declaration));
20097 type_spec,
20098 token,
20121 /* The `__complex__' keyword is a GNU extension. */
20127 }
20129 /* Handle simple keywords. */
20131 {
20133 {
20136 }
20138 }
20140 /* If we do not already have a type-specifier, assume we are looking
20141 at a simple-type-specifier. */
20143 decl_specs,
20144 flags);
20146 /* If we didn't find a type-specifier, and a type-specifier was not
20147 optional in this context, issue an error message. */
20149 {
20152 }
20155 }
20157 /* Parse a simple-type-specifier.
20159 simple-type-specifier:
20160 :: [opt] nested-name-specifier [opt] type-name
20161 :: [opt] nested-name-specifier template template-id
20162 char
20163 wchar_t
20164 bool
20165 short
20166 int
20167 long
20168 signed
20169 unsigned
20170 float
20171 double
20172 void
20174 C++11 Extension:
20176 simple-type-specifier:
20177 auto
20178 decltype ( expression )
20179 char16_t
20180 char32_t
20181 __underlying_type ( type-id )
20183 C++17 extension:
20185 nested-name-specifier(opt) template-name
20187 GNU Extension:
20189 simple-type-specifier:
20190 __int128
20191 __typeof__ unary-expression
20192 __typeof__ ( type-id )
20193 __typeof__ ( type-id ) { initializer-list , [opt] }
20195 Concepts Extension:
20197 simple-type-specifier:
20198 constrained-type-specifier
20200 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
20201 appropriately updated. */
20203 static tree
20206 cp_parser_flags flags)
20207 {
20212 /* Peek at the next token. */
20215 /* If we're looking at a keyword, things are easy. */
20217 {
20255 {
20258 /* Check if the alternate "__intN__" form has been used instead of
20259 "__intN". */
20263 }
20285 CASE_RID_FLOATN_NX:
20300 {
20301 /* The 'auto' might be the placeholder return type for a function decl
20302 with trailing return type. */
20311 {
20313 {
20320 }
20323 {
20326 }
20329 }
20333 {
20336 }
20339 {
20342 }
20343 else
20347 {
20350 "use of %<auto%> in lambda parameter declaration "
20351 "only available with "
20353 }
20356 "use of %<auto%> in template argument "
20360 "use of %<auto%> in parameter declaration "
20364 "use of %<auto%> in parameter declaration "
20365 "only available with "
20367 }
20368 else
20373 /* Since DR 743, decltype can either be a simple-type-specifier by
20374 itself or begin a nested-name-specifier. Parsing it will replace
20375 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
20376 handling below decide what to do. */
20382 /* Consume the `typeof' token. */
20384 /* Parse the operand to `typeof'. */
20386 /* If it is not already a TYPE, take its type. */
20392 token,
20398 /* If token is a type-yielding built-in traits, parse it. */
20401 {
20405 token,
20409 }
20412 }
20414 /* If token is an already-parsed decltype not followed by ::,
20415 it's a simple-type-specifier. */
20418 {
20421 {
20423 token,
20425 /* Remember that we are handling a decltype in order to
20426 implement the resolution of DR 1510 when the argument
20427 isn't instantiation dependent. */
20429 }
20432 }
20434 /* If the type-specifier was for a built-in type, we're done. */
20436 {
20437 /* Record the type. */
20444 type,
20445 token,
20450 /* Consume the token. */
20456 /* There is no valid C++ program where a non-template type is
20457 followed by a "<". That usually indicates that the user thought
20458 that the type was a template. */
20463 }
20465 /* The type-specifier must be a user-defined type. */
20467 {
20473 /* Don't gobble tokens or issue error messages if this is an
20474 optional type-specifier. */
20478 /* Remember current tentative parsing state -- if we know we need
20479 a type, we can give better diagnostics here. */
20484 /* Look for the optional `::' operator. */
20485 global_p
20489 /* Look for the nested-name specifier. */
20490 qualified_p
20497 /* If we have seen a nested-name-specifier, and the next token
20498 is `template', then we are using the template-id production. */
20501 {
20502 /* Look for the template-id. */
20506 none_type,
20508 /* If the template-id did not name a type, we are out of
20509 luck. */
20511 {
20512 /* ...unless we pretend we have seen 'typename'. */
20516 else
20517 {
20520 }
20521 }
20522 }
20523 /* DR 1812: A < following a qualified-id in a typename-specifier
20524 could safely be assumed to begin a template argument list, so
20525 the template keyword should be optional. */
20527 && qualified_p
20528 && typename_p
20530 {
20536 none_type,
20538 /* This is handled below, so back off. */
20549 }
20551 /* Otherwise, look for a type-name. */
20553 {
20562 }
20565 {
20566 /* Try for a type-constraint with template arguments. We check
20567 decl_specs here to avoid trying this for a functional cast. */
20574 none_type,
20577 {
20582 /* Perhaps it's a concept-check expression. */
20584 }
20585 else
20590 }
20593 {
20594 /* Try class template argument deduction or type-constraint without
20595 template arguments. */
20599 {
20600 location_t loc
20603 none_type,
20615 else
20616 {
20621 }
20622 }
20623 else
20625 }
20627 /* If it didn't work out, we don't have a TYPE. */
20632 /* Keep track of all name-lookups performed in class scopes. */
20634 && !global_p
20635 && !qualified_p
20642 token,
20644 }
20646 /* If we didn't get a type-name, issue an error message. */
20648 {
20651 }
20654 {
20655 /* See if TYPE is an Objective-C type, and if so, parse and
20656 accept any protocol references following it. Do this before
20657 the cp_parser_check_for_invalid_template_id() call, because
20658 Objective-C types can be followed by '<...>' which would
20659 enclose protocol names rather than template arguments, and so
20660 everything is fine. */
20663 {
20667 /* Clobber the "unqualified" type previously entered into
20668 DECL_SPECS with the new, improved protocol-qualified version. */
20673 }
20675 /* There is no valid C++ program where a non-template type is
20676 followed by a "<". That usually indicates that the user
20677 thought that the type was a template. */
20679 none_type,
20681 }
20684 }
20686 /* Parse the remainder of a placholder-type-specifier.
20688 placeholder-type-specifier:
20689 type-constraint_opt auto
20690 type-constraint_opt decltype(auto)
20692 The raw form of the constraint is parsed in cp_parser_simple_type_specifier
20693 and passed as TMPL. This function converts TMPL to an actual type-constraint,
20694 parses the placeholder type, and performs some contextual syntactic analysis.
20696 LOC provides the location of the template name.
20698 TENTATIVE is true if the type-specifier parsing is tentative; in that case,
20699 don't give an error if TMPL isn't a valid type-constraint, as the template-id
20700 might actually be a concept-check,
20702 Note that the Concepts TS allows the auto or decltype(auto) to be
20703 omitted in a constrained-type-specifier. */
20705 static tree
20708 {
20714 /* Get the arguments as written for subsequent analysis. */
20717 {
20720 }
20721 else
20722 /* A concept-name with no arguments can't be an expression. */
20727 /* Get the concept and prototype parameter for the constraint. */
20734 /* As per the standard, require auto or decltype(auto), except in some
20735 cases (template parameter lists, -fconcepts-ts enabled). */
20738 {
20742 {
20744 matching_parens parens;
20748 }
20749 }
20751 /* A type constraint constrains a contextually determined type or type
20752 parameter pack. However, the Concepts TS does allow concepts
20753 to introduce non-type and template template parameters. */
20755 {
20758 {
20760 {
20763 }
20765 }
20766 }
20768 /* In a template parameter list, a type-parameter can be introduced
20769 by type-constraints alone. */
20771 {
20772 /* In a default argument we may not be creating new parameters. */
20774 {
20775 /* If this assert turns out to be false, do error() instead. */
20778 }
20780 }
20782 /* Diagnose issues placeholder issues. */
20786 {
20788 /* Perhaps it's a concept-check expression (c++/91073). */
20795 /* Fall through. This is an error of omission. */
20796 }
20798 {
20799 /* A trailing return type only allows type-constraints. */
20802 }
20804 /* In a parameter-declaration-clause, a placeholder-type-specifier
20805 results in an invented template parameter. */
20807 {
20809 {
20815 }
20818 }
20820 /* Determine if the type should be deduced using template argument
20821 deduction or decltype deduction. Note that the latter is always
20822 used for type-constraints in trailing return types. */
20827 /* Otherwise, this is the type of a variable or return type. */
20830 else
20832 }
20834 /* Parse a type-name.
20836 type-name:
20837 class-name
20838 enum-name
20839 typedef-name
20840 simple-template-id [in c++0x]
20842 enum-name:
20843 identifier
20845 typedef-name:
20846 identifier
20848 Concepts:
20850 type-name:
20851 concept-name
20852 partial-concept-id
20854 concept-name:
20855 identifier
20857 Returns a TYPE_DECL for the type. */
20859 static tree
20861 {
20862 tree type_decl;
20864 /* We can't know yet whether it is a class-name or not. */
20866 /* Try a class-name. */
20868 typename_keyword_p,
20870 none_type,
20874 /* If it's not a class-name, keep looking. */
20876 {
20878 /* It must be a typedef-name or an enum-name. */
20882 /* It is either a simple-template-id representing an
20883 instantiation of an alias template... */
20887 none_type,
20889 /* Note that this must be an instantiation of an alias template
20890 because [temp.names]/6 says:
20892 A template-id that names an alias template specialization
20893 is a type-name.
20895 Whereas [temp.names]/7 says:
20897 A simple-template-id that names a class template
20898 specialization is a class-name.
20900 With concepts, this could also be a partial-concept-id that
20901 declares a non-type template parameter. */
20906 else
20910 /* ... Or a typedef-name or an enum-name. */
20912 }
20915 }
20917 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
20918 or a concept-name.
20920 enum-name:
20921 identifier
20923 typedef-name:
20924 identifier
20926 concept-name:
20927 identifier
20929 Returns a TYPE_DECL for the type. */
20931 static tree
20933 {
20934 tree type_decl;
20935 tree identifier;
20942 /* Look up the type-name. */
20949 {
20950 /* See if this is an Objective-C type. */
20955 }
20957 /* Issue an error if we did not find a type-name. */
20959 /* In Objective-C, we have the complication that class names are
20960 normally type names and start declarations (eg, the
20961 "NSObject" in "NSObject *object;"), but can be used in an
20962 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
20963 is an expression. So, a classname followed by a dot is not a
20964 valid type-name. */
20967 {
20972 }
20973 /* Remember that the name was used in the definition of the
20974 current class so that we can check later to see if the
20975 meaning would have been different after the class was
20976 entirely defined. */
20982 }
20984 /* Parse an elaborated-type-specifier. Note that the grammar given
20985 here incorporates the resolution to DR68.
20987 elaborated-type-specifier:
20988 class-key :: [opt] nested-name-specifier [opt] identifier
20989 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
20990 enum-key :: [opt] nested-name-specifier [opt] identifier
20991 typename :: [opt] nested-name-specifier identifier
20992 typename :: [opt] nested-name-specifier template [opt]
20993 template-id
20995 GNU extension:
20997 elaborated-type-specifier:
20998 class-key attributes :: [opt] nested-name-specifier [opt] identifier
20999 class-key attributes :: [opt] nested-name-specifier [opt]
21000 template [opt] template-id
21001 enum attributes :: [opt] nested-name-specifier [opt] identifier
21003 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
21004 declared `friend'. If IS_DECLARATION is TRUE, then this
21005 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
21006 something is being declared.
21008 Returns the TYPE specified. */
21010 static tree
21014 {
21016 tree identifier;
21019 tree globalscope;
21022 /* For class and enum types the location of the class-key or enum-key. */
21024 /* For a scoped enum, the 'class' or 'struct' keyword id. */
21027 /* See if we're looking at the `enum' keyword. */
21029 {
21030 /* Consume the `enum' token. */
21032 /* Remember that it's an enumeration type. */
21034 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
21035 enums) is used here. */
21039 {
21047 /* Consume the `struct' or `class' and parse it anyway. */
21049 /* Create a combined location for the whole scoped-enum-key. */
21051 }
21052 else
21055 /* Parse the attributes. */
21057 }
21058 /* Or, it might be `typename'. */
21060 RID_TYPENAME))
21061 {
21062 /* Consume the `typename' token. */
21064 /* Remember that it's a `typename' type. */
21066 }
21067 /* Otherwise it must be a class-key. */
21068 else
21069 {
21074 /* Parse the attributes. */
21076 }
21078 /* Look for the `::' operator. */
21081 /* Look for the nested-name-specifier. */
21082 tree nested_name_specifier;
21084 {
21085 nested_name_specifier
21090 is_declaration);
21093 }
21094 else
21095 /* Even though `typename' is not present, the proposed resolution
21096 to Core Issue 180 says that in `class A<T>::B', `B' should be
21097 considered a type-name, even if `A<T>' is dependent. */
21098 nested_name_specifier
21103 is_declaration);
21104 /* For everything but enumeration types, consider a template-id.
21105 For an enumeration type, consider only a plain identifier. */
21107 {
21109 tree decl;
21111 /* Allow the `template' keyword. */
21113 /* If we didn't see `template', we don't know if there's a
21114 template-id or not. */
21117 /* The `template' keyword must follow a nested-name-specifier. */
21119 {
21123 }
21125 /* Parse the template-id. */
21129 tag_type,
21130 is_declaration);
21131 /* If we didn't find a template-id, look for an ordinary
21132 identifier. */
21134 ;
21135 /* We can get here when cp_parser_template_id, called by
21136 cp_parser_class_name with tag_type == none_type, succeeds
21137 and caches a BASELINK. Then, when called again here,
21138 instead of failing and returning an error_mark_node
21139 returns it (see template/typename17.C in C++11).
21140 ??? Could we diagnose this earlier? */
21142 {
21145 }
21146 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
21147 in effect, then we must assume that, upon instantiation, the
21148 template will correspond to a class. */
21152 typename_type,
21154 /* If the `typename' keyword is in effect and DECL is not a type
21155 decl, then type is non existent. */
21157 ;
21159 {
21163 /* If the next token is a semicolon, this must be a specialization,
21164 instantiation, or friend declaration. Check the scope while we
21165 still know whether or not we had a nested-name-specifier. */
21170 }
21173 }
21176 {
21181 {
21184 }
21186 /* For a `typename', we needn't call xref_tag. */
21192 /* Template parameter lists apply only if we are not within a
21193 function parameter list. */
21194 bool template_parm_lists_apply
21203 /* Look up a qualified name in the usual way. */
21205 {
21206 tree decl;
21207 tree ambiguous_decls;
21210 tag_type,
21217 /* If the lookup was ambiguous, an error will already have been
21218 issued. */
21222 /* If we are parsing friend declaration, DECL may be a
21223 TEMPLATE_DECL tree node here. However, we need to check
21224 whether this TEMPLATE_DECL results in valid code. Consider
21225 the following example:
21227 namespace N {
21228 template <class T> class C {};
21229 }
21230 class X {
21231 template <class T> friend class N::C; // #1, valid code
21232 };
21233 template <class T> class Y {
21234 friend class N::C; // #2, invalid code
21235 };
21237 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
21238 name lookup of `N::C'. We see that friend declaration must
21239 be template for the code to be valid. Note that
21240 processing_template_decl does not work here since it is
21241 always 1 for the above two cases. */
21243 decl = (cp_parser_maybe_treat_template_as_class
21248 {
21250 identifier,
21253 }
21256 {
21260 allow_template);
21264 }
21266 /* Forward declarations of nested types, such as
21268 class C1::C2;
21269 class C1::C2::C3;
21271 are invalid unless all components preceding the final '::'
21272 are complete. If all enclosing types are complete, these
21273 declarations become merely pointless.
21275 Invalid forward declarations of nested types are errors
21276 caught elsewhere in parsing. Those that are pointless arrive
21277 here. */
21285 }
21286 else
21287 {
21288 /* An elaborated-type-specifier sometimes introduces a new type and
21289 sometimes names an existing type. Normally, the rule is that it
21290 introduces a new type only if there is not an existing type of
21291 the same name already in scope. For example, given:
21293 struct S {};
21294 void f() { struct S s; }
21296 the `struct S' in the body of `f' is the same `struct S' as in
21297 the global scope; the existing definition is used. However, if
21298 there were no global declaration, this would introduce a new
21299 local class named `S'.
21301 An exception to this rule applies to the following code:
21303 namespace N { struct S; }
21305 Here, the elaborated-type-specifier names a new type
21306 unconditionally; even if there is already an `S' in the
21307 containing scope this declaration names a new type.
21308 This exception only applies if the elaborated-type-specifier
21309 forms the complete declaration:
21311 [class.name]
21313 A declaration consisting solely of `class-key identifier ;' is
21314 either a redeclaration of the name in the current scope or a
21315 forward declaration of the identifier as a class name. It
21316 introduces the name into the current scope.
21318 We are in this situation precisely when the next token is a `;'.
21320 An exception to the exception is that a `friend' declaration does
21321 *not* name a new type; i.e., given:
21323 struct S { friend struct T; };
21325 `T' is not a new type in the scope of `S'.
21327 Also, `new struct S' or `sizeof (struct S)' never results in the
21328 definition of a new type; a new type can only be declared in a
21329 declaration context. */
21331 TAG_how how;
21334 /* Friends have special name lookup rules. */
21338 CPP_SEMICOLON))
21339 /* This is a `class-key identifier ;' */
21341 else
21345 (template_parm_lists_apply
21348 /* An unqualified name was used to reference this type, so
21349 there were no qualifying templates. */
21359 }
21360 }
21365 /* Allow attributes on forward declarations of classes. */
21367 {
21378 {
21382 }
21385 else
21387 "attributes ignored on elaborated-type-specifier that is "
21389 }
21393 else
21394 {
21395 /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
21396 for alias definition. */
21400 decl_class);
21402 /* Indicate whether this class was declared as a `class' or as a
21403 `struct'. */
21406 }
21408 /* A "<" cannot follow an elaborated type specifier. If that
21409 happens, the user was probably trying to form a template-id. */
21414 }
21416 /* Parse an enum-specifier.
21418 enum-specifier:
21419 enum-head { enumerator-list [opt] }
21420 enum-head { enumerator-list , } [C++0x]
21422 enum-head:
21423 enum-key identifier [opt] enum-base [opt]
21424 enum-key nested-name-specifier identifier enum-base [opt]
21426 enum-key:
21427 enum
21428 enum class [C++0x]
21429 enum struct [C++0x]
21431 enum-base: [C++0x]
21432 : type-specifier-seq
21434 opaque-enum-specifier:
21435 enum-key identifier enum-base [opt] ;
21437 GNU Extensions:
21438 enum-key attributes[opt] identifier [opt] enum-base [opt]
21439 { enumerator-list [opt] }attributes[opt]
21440 enum-key attributes[opt] identifier [opt] enum-base [opt]
21441 { enumerator-list, }attributes[opt] [C++0x]
21443 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
21444 if the token stream isn't an enum-specifier after all. */
21446 static tree
21448 {
21449 tree identifier;
21451 tree prev_scope;
21453 tree attributes;
21464 /* Parse tentatively so that we can back up if we don't find a
21465 enum-specifier. */
21468 /* Caller guarantees that the current token is 'enum', an identifier
21469 possibly follows, and the token after that is an opening brace.
21470 If we don't have an identifier, fabricate an anonymous name for
21471 the enumeration being defined. */
21474 /* Parse the "class" or "struct", which indicates a scoped
21475 enumeration type in C++0x. */
21478 {
21482 /* Consume the `struct' or `class' token. */
21486 }
21490 /* Clear the qualification. */
21495 /* Figure out in what scope the declaration is being placed. */
21501 nested_name_specifier
21509 {
21510 tree name;
21514 enum_type,
21519 input_location);
21521 {
21524 {
21525 /* Are template enums allowed in ISO? */
21529 /* ignore a typename reference, for it will be solved by name
21530 in start_enum. */
21532 }
21533 }
21536 else
21537 {
21542 }
21543 }
21544 else
21545 {
21548 else
21549 {
21555 }
21556 }
21559 /* Check for the `:' that denotes a specified underlying type in C++0x.
21560 Note that a ':' could also indicate a bitfield width, however. */
21563 {
21564 cp_decl_specifier_seq type_specifiers;
21566 /* Consume the `:'. */
21570 auto tdf
21574 /* Parse the type-specifier-seq. */
21580 /* At this point this is surely not elaborated type specifier. */
21589 /* If that didn't work, stop. */
21591 {
21597 }
21598 }
21600 /* Look for the `{' but don't consume it yet. */
21602 {
21604 {
21610 }
21611 /* An opaque-enum-specifier must have a ';' here. */
21614 {
21617 OPT_Welaborated_enum_base,
21618 "declaration of enumeration with "
21619 "fixed underlying type and no enumerator list is "
21621 else
21623 }
21624 }
21630 {
21632 {
21636 }
21639 }
21641 /* Issue an error message if type-definitions are forbidden here. */
21644 else
21645 /* Create the new type. We do this before consuming the opening
21646 brace so the enum will be recorded as being on the line of its
21647 tag (or the 'enum' keyword, if there is no tag). */
21651 /* If the next token is not '{' it is an opaque-enum-specifier or an
21652 elaborated-type-specifier. */
21654 {
21659 {
21660 /* The following catches invalid code such as:
21661 enum class S<int>::E { A, B, C }; */
21669 {
21673 nested_name_specifier);
21675 }
21678 {
21680 "%qT for enum declaration does not name a class "
21683 }
21684 /* If that scope does not contain the scope in which the
21685 class was originally declared, the program is invalid. */
21687 nested_name_specifier))
21688 {
21691 "declaration of %qD in namespace %qD which does not "
21694 else
21696 "declaration of %qD in %qD which does not "
21700 }
21701 /* If that scope is the scope where the declaration is being placed
21702 the program is invalid. */
21706 {
21710 }
21711 }
21716 /* Consume the opening brace. */
21717 matching_braces braces;
21724 {
21728 }
21729 else
21730 {
21736 }
21740 /* If the next token is not '}', then there are some enumerators. */
21742 {
21744 /* Don't warn for enum {} a; here. */
21748 }
21749 else
21750 {
21751 /* We've seen a '{' so we know we're in an enum-specifier.
21752 Commit to any tentative parse to get syntax errors. */
21755 }
21757 /* Consume the final '}'. */
21762 }
21763 else
21764 {
21765 /* If a ';' follows, then it is an opaque-enum-specifier
21766 and additional restrictions apply. */
21768 {
21775 }
21776 }
21778 /* Look for trailing attributes to apply to this enumeration, and
21779 apply them if appropriate. */
21781 {
21784 trailing_attr,
21786 }
21788 /* Finish up the enumeration. */
21790 {
21795 }
21798 {
21800 {
21803 }
21806 }
21808 }
21810 /* Parse an enumerator-list. The enumerators all have the indicated
21811 TYPE.
21813 enumerator-list:
21814 enumerator-definition
21815 enumerator-list , enumerator-definition */
21817 static void
21819 {
21821 {
21822 /* Parse an enumerator-definition. */
21825 /* If the next token is not a ',', we've reached the end of
21826 the list. */
21829 /* Otherwise, consume the `,' and keep going. */
21831 /* If the next token is a `}', there is a trailing comma. */
21833 {
21838 }
21839 }
21840 }
21842 /* Parse an enumerator-definition. The enumerator has the indicated
21843 TYPE.
21845 enumerator-definition:
21846 enumerator
21847 enumerator = constant-expression
21849 enumerator:
21850 identifier
21852 GNU Extensions:
21854 enumerator-definition:
21855 enumerator attributes [opt]
21856 enumerator attributes [opt] = constant-expression */
21858 static void
21860 {
21861 tree identifier;
21862 tree value;
21863 location_t loc;
21865 /* Save the input location because we are interested in the location
21866 of the identifier and not the location of the explicit value. */
21869 /* Look for the identifier. */
21874 /* Parse any specified attributes. */
21877 /* If the next token is an '=', then there is an explicit value. */
21879 {
21880 /* Consume the `=' token. */
21882 /* Parse the value. */
21884 }
21885 else
21888 /* If we are processing a template, make sure the initializer of the
21889 enumerator doesn't contain any bare template parameter pack. */
21891 {
21892 /* In a lambda it should work, but doesn't currently. */
21894 {
21897 }
21898 }
21902 /* Create the enumerator. */
21904 }
21906 /* Parse a namespace-name.
21908 namespace-name:
21909 original-namespace-name
21910 namespace-alias
21912 Returns the NAMESPACE_DECL for the namespace. */
21914 static tree
21916 {
21917 tree identifier;
21918 tree namespace_decl;
21922 /* Get the name of the namespace. */
21927 /* Look up the identifier in the currently active scope. Look only
21928 for namespaces, due to:
21930 [basic.lookup.udir]
21932 When looking up a namespace-name in a using-directive or alias
21933 definition, only namespace names are considered.
21935 And:
21937 [basic.lookup.qual]
21939 During the lookup of a name preceding the :: scope resolution
21940 operator, object, function, and enumerator names are ignored.
21942 (Note that cp_parser_qualifying_entity only calls this
21943 function if the token after the name is the scope resolution
21944 operator.) */
21946 none_type,
21952 /* If it's not a namespace, issue an error. */
21955 {
21957 {
21958 auto_diagnostic_group d;
21959 name_hint hint;
21963 identifier,
21966 {
21972 }
21973 else
21975 identifier);
21976 }
21977 else
21980 }
21983 }
21985 /* Parse a namespace-definition.
21987 namespace-definition:
21988 named-namespace-definition
21989 unnamed-namespace-definition
21991 named-namespace-definition:
21992 original-namespace-definition
21993 extension-namespace-definition
21995 original-namespace-definition:
21996 namespace identifier { namespace-body }
21998 extension-namespace-definition:
21999 namespace original-namespace-name { namespace-body }
22001 unnamed-namespace-definition:
22002 namespace { namespace-body } */
22004 static void
22006 {
22007 tree identifier;
22017 {
22020 }
22022 /* Look for the `namespace' keyword. */
22023 cp_token* token
22026 /* Parse any specified attributes before the identifier. */
22030 {
22034 RID_INLINE);
22036 {
22040 "definitions only available with %<-std=c++20%> or "
22043 }
22046 {
22051 "standard attributes on namespaces must precede "
22054 /* Parse any attributes specified after the identifier. */
22056 }
22059 {
22060 /* Don't forget that the innermost namespace might have been
22061 marked as inline. Use |= because we cannot overwrite
22062 IS_INLINE in case the outermost namespace is inline, but
22063 there are no nested inlines. */
22066 }
22070 "nested namespace definitions only available with "
22073 /* Nested namespace names can create new namespaces (unlike
22074 other qualified-ids). */
22079 else
22082 }
22094 /* Start the namespace. */
22101 /* Look for the `{' to validate starting the namespace. */
22102 matching_braces braces;
22104 {
22105 /* Parse the body of the namespace. */
22108 /* Look for the final `}'. */
22110 }
22115 /* Pop the nested namespace definitions. */
22118 }
22120 /* Parse a namespace-body.
22122 namespace-body:
22123 declaration-seq [opt] */
22125 static void
22127 {
22129 }
22131 /* Parse a namespace-alias-definition.
22133 namespace-alias-definition:
22134 namespace identifier = qualified-namespace-specifier ; */
22136 static void
22138 {
22139 tree identifier;
22140 tree namespace_specifier;
22144 /* Look for the `namespace' keyword. */
22146 /* Look for the identifier. */
22150 /* Look for the `=' token. */
22153 {
22155 /* Skip the definition. */
22160 }
22162 /* Look for the qualified-namespace-specifier. */
22163 namespace_specifier
22166 /* Look for the `;' token. */
22169 /* Register the alias in the symbol table. */
22171 }
22173 /* Parse a qualified-namespace-specifier.
22175 qualified-namespace-specifier:
22176 :: [opt] nested-name-specifier [opt] namespace-name
22178 Returns a NAMESPACE_DECL corresponding to the specified
22179 namespace. */
22181 static tree
22183 {
22184 /* Look for the optional `::'. */
22188 /* Look for the optional nested-name-specifier. */
22196 }
22198 /* Subroutine of cp_parser_using_declaration. */
22200 static tree
22202 {
22205 {
22206 /* Create the USING_DECL. */
22215 /* Add it to the list of members in this class. */
22217 }
22218 else
22221 }
22223 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
22224 access declaration.
22226 using-declaration:
22227 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
22228 using :: unqualified-id ;
22230 access-declaration:
22231 qualified-id ;
22233 */
22235 static bool
22238 {
22242 tree identifier;
22243 tree qscope;
22248 {
22251 }
22252 else
22253 {
22254 /* Look for the `using' keyword. */
22257 again:
22258 /* Peek at the next token. */
22260 /* See if it's `typename'. */
22262 {
22263 /* Remember that we've seen it. */
22265 /* Consume the `typename' token. */
22267 }
22268 }
22270 /* Look for the optional global scope qualification. */
22271 global_scope_p
22276 /* If we saw `typename', or didn't see `::', then there must be a
22277 nested-name-specifier present. */
22279 {
22285 {
22288 }
22289 }
22290 /* Otherwise, we could be in either of the two productions. In that
22291 case, treat the nested-name-specifier as optional. */
22292 else
22306 /* If the qualifying scope of an access-declaration isn't a class
22307 or enumeration type then it can't be valid. */
22311 /* Something has already gone wrong; there's no need to parse
22312 further. Since an error has occurred, the return value of
22313 cp_parser_parse_definitely will be false, as required. */
22317 /* Parse the unqualified-id. */
22325 {
22330 }
22332 {
22336 "pack expansion in using-declaration only available "
22339 /* A parameter pack can appear in the qualifying scope, and/or in the
22340 terminal name (if naming a conversion function). Logically they're
22341 part of a single pack expansion of the overall USING_DECL, but we
22342 express them as separate pack expansions within the USING_DECL since
22343 we can't create a pack expansion over a USING_DECL. */
22346 {
22349 }
22353 {
22357 }
22359 {
22360 /* Issue an error in terms using a SCOPE_REF that includes both
22361 components. */
22362 tree name
22367 }
22368 }
22370 /* The function we call to handle a using-declaration is different
22371 depending on what scope we are in. */
22373 ;
22376 /* [namespace.udecl]
22378 A using declaration shall not name a template-id. */
22381 else
22382 {
22386 {
22389 }
22390 }
22394 {
22398 "comma-separated list in using-declaration only available "
22401 }
22403 /* Look for the final `;'. */
22408 "access declarations are deprecated "
22409 "in favour of using-declarations; "
22413 }
22415 /* C++20 using enum declaration.
22417 using-enum-declaration :
22418 using elaborated-enum-specifier ; */
22420 static void
22422 {
22425 /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
22426 breaks one of the motivating examples in using-enum-5.C.
22427 cp_parser_simple_type_specifier seems to be closer to what we actually
22428 want, though that hasn't been properly specified yet. */
22430 /* Consume 'enum'. */
22436 tree type = (cp_parser_simple_type_specifier
22443 {
22446 }
22450 /* The elaborated-enum-specifier shall not name a dependent type and the type
22451 shall have a reachable enum-specifier. */
22465 {
22467 auto_diagnostic_group g;
22471 ;
22474 else
22476 }
22478 /* A using-enum-declaration introduces the enumerator names of the named
22479 enumeration as if by a using-declaration for each enumerator. */
22483 }
22485 /* Parse an alias-declaration.
22487 alias-declaration:
22488 using identifier attribute-specifier-seq [opt] = type-id */
22490 static tree
22492 {
22496 cp_decl_specifier_seq decl_specs;
22500 /* Look for the `using' keyword. */
22501 cp_token *using_token
22523 /* Now we are going to parse the type-id of the declaration. */
22525 /*
22526 [dcl.type]/3 says:
22528 "A type-specifier-seq shall not define a class or enumeration
22529 unless it appears in the type-id of an alias-declaration (7.1.3) that
22530 is not the declaration of a template-declaration."
22532 In other words, if we currently are in an alias template, the
22533 type-id should not define a type.
22535 So let's set parser->type_definition_forbidden_message in that
22536 case; cp_parser_check_type_definition (called by
22537 cp_parser_class_specifier) will then emit an error if a type is
22538 defined in the type-id. */
22540 {
22544 }
22549 /* Restore the error message if need be. */
22555 {
22558 }
22560 /* A typedef-name can also be introduced by an alias-declaration. The
22561 identifier following the using keyword becomes a typedef-name. It has
22562 the same semantics as if it were introduced by the typedef
22563 specifier. In particular, it does not define a new type and it shall
22564 not appear in the type-id. */
22569 {
22572 ds_attribute,
22573 attrs_token);
22574 }
22576 ds_typedef,
22577 using_token);
22579 ds_alias,
22580 using_token);
22587 id_location,
22597 else
22608 /* If decl is a template, return its TEMPLATE_DECL so that it gets
22609 added into the symbol table; otherwise, return the TYPE_DECL. */
22613 {
22617 }
22620 }
22622 /* Parse a using-directive.
22624 using-directive:
22625 attribute-specifier-seq [opt] using namespace :: [opt]
22626 nested-name-specifier [opt] namespace-name ; */
22628 static void
22630 {
22631 tree namespace_decl;
22634 {
22635 /* Error during attribute parsing that resulted in skipping
22636 to next semicolon. */
22639 }
22641 /* Look for the `using' keyword. */
22643 /* And the `namespace' keyword. */
22645 /* Look for the optional `::' operator. */
22647 /* And the optional nested-name-specifier. */
22653 /* Get the namespace being used. */
22656 /* And any specified GNU attributes. */
22660 /* Update the symbol table. */
22663 /* Look for the final `;'. */
22665 }
22667 /* Parse an asm-definition.
22669 asm-qualifier:
22670 volatile
22671 inline
22672 goto
22674 asm-qualifier-list:
22675 asm-qualifier
22676 asm-qualifier-list asm-qualifier
22678 asm-definition:
22679 asm ( string-literal ) ;
22681 GNU Extension:
22683 asm-definition:
22684 asm asm-qualifier-list [opt] ( string-literal ) ;
22685 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
22686 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
22687 : asm-operand-list [opt] ) ;
22688 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
22689 : asm-operand-list [opt]
22690 : asm-clobber-list [opt] ) ;
22691 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
22692 : asm-clobber-list [opt]
22693 : asm-goto-list ) ;
22695 The form with asm-goto-list is valid if and only if the asm-qualifier-list
22696 contains goto, and is the only allowed form in that case. No duplicates are
22697 allowed in an asm-qualifier-list. */
22699 static void
22701 {
22706 tree asm_stmt;
22714 /* Look for the `asm' keyword. */
22717 /* In C++20, unevaluated inline assembly is permitted in constexpr
22718 functions. */
22723 "function only available with %<-std=c++20%> or "
22726 /* Handle the asm-qualifier-list. */
22734 {
22738 {
22741 {
22745 }
22746 else
22747 {
22752 }
22758 {
22762 }
22763 else
22772 {
22776 }
22777 else
22792 }
22794 }
22801 {
22804 }
22806 /* Look for the opening `('. */
22809 /* Look for the string. */
22813 {
22817 }
22819 /* If we're allowing GNU extensions, check for the extended assembly
22820 syntax. Unfortunately, the `:' tokens need not be separated by
22821 a space in C, and so, for compatibility, we tolerate that here
22822 too. Doing that means that we have to treat the `::' operator as
22823 two `:' tokens. */
22828 {
22833 /* The extended syntax was used. */
22836 /* Look for outputs. */
22838 {
22839 /* Consume the `:'. */
22841 /* Parse the output-operands. */
22843 CPP_COLON)
22845 CPP_SCOPE)
22847 CPP_CLOSE_PAREN))
22848 {
22852 }
22853 }
22854 /* If the next token is `::', there are no outputs, and the
22855 next token is the beginning of the inputs. */
22857 /* The inputs are coming next. */
22860 /* Look for inputs. */
22863 {
22864 /* Consume the `:' or `::'. */
22866 /* Parse the output-operands. */
22868 CPP_COLON)
22870 CPP_SCOPE)
22872 CPP_CLOSE_PAREN))
22873 {
22877 }
22878 }
22880 /* The clobbers are coming next. */
22883 /* Look for clobbers. */
22886 {
22888 /* Consume the `:' or `::'. */
22890 /* Parse the clobbers. */
22892 CPP_COLON)
22894 CPP_CLOSE_PAREN))
22896 }
22898 /* The labels are coming next. */
22901 /* Look for labels. */
22904 {
22906 /* Consume the `:' or `::'. */
22908 /* Parse the labels. */
22910 }
22914 }
22918 /* Look for the closing `)'. */
22926 {
22927 /* Create the ASM_EXPR. */
22929 {
22932 /* If the extended syntax was not used, mark the ASM_EXPR. */
22934 {
22940 }
22941 }
22942 else
22944 }
22949 }
22951 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
22952 type that comes from the decl-specifier-seq. */
22954 static tree
22956 {
22959 {
22972 }
22975 }
22977 /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
22978 a construct looks like a variable definition but is actually a function
22979 declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
22980 is the declarator for this function declaration. */
22982 static void
22985 {
22986 /* Only warn if we are declaring a function at block scope. */
22990 /* And only if there is no storage class specified. */
23002 /* Don't warn when the whole declarator (not just the declarator-id!)
23003 was parenthesized. That is, don't warn for int(n()) but do warn
23004 for int(f)(). */
23008 tree type;
23010 {
23015 /* If the return type is void there is no ambiguity. */
23018 }
23020 /* Code like long f(); will have null ->type. If we have any
23021 type-specifiers, pretend we've seen int. */
23023 else
23026 auto_diagnostic_group d;
23031 /* The T t() case. */
23033 {
23035 "empty parentheses were disambiguated as a function "
23037 {
23038 /* () means value-initialization (C++03 and up); {} (C++11 and up)
23039 means value-initialization or aggregate-initialization, nothing
23040 means default-initialization. We can only suggest removing the
23041 parentheses/adding {} if T has a default constructor. */
23043 {
23049 {
23053 else
23056 }
23057 }
23058 }
23060 }
23062 /* If we had (...) or the parameter-list wasn't parenthesized,
23063 we're done. */
23067 /* The T t(X()) case. */
23069 {
23071 "parentheses were disambiguated as a function "
23073 {
23075 /* {}-initialization means that we can use an initializer-list
23076 constructor if no default constructor is available, so don't
23077 suggest using {} for classes that have an initializer_list
23078 constructor. */
23080 {
23085 }
23086 else
23087 {
23091 }
23092 }
23093 }
23094 /* The T t(X(), X()) case. */
23096 "parentheses were disambiguated as a function "
23098 {
23101 {
23106 }
23107 }
23108 }
23110 /* If DECLARATOR with DECL_SPECS is a function declarator that has
23111 the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
23112 has the same meaning as in cp_parser_declarator. */
23114 static void
23119 {
23125 {
23133 {
23137 }
23138 }
23139 }
23141 /* Declarators [gram.dcl.decl] */
23143 /* Parse an init-declarator.
23145 init-declarator:
23146 declarator initializer [opt]
23148 GNU Extension:
23150 init-declarator:
23151 declarator asm-specification [opt] attributes [opt] initializer [opt]
23153 function-definition:
23154 decl-specifier-seq [opt] declarator ctor-initializer [opt]
23155 function-body
23156 decl-specifier-seq [opt] declarator function-try-block
23158 GNU Extension:
23160 function-definition:
23161 __extension__ function-definition
23163 TM Extension:
23165 function-definition:
23166 decl-specifier-seq [opt] declarator function-transaction-block
23168 The parser flags FLAGS is used to control type-specifier parsing.
23170 The DECL_SPECIFIERS apply to this declarator. Returns a
23171 representation of the entity declared. If MEMBER_P is TRUE, then
23172 this declarator appears in a class scope. The new DECL created by
23173 this declarator is returned.
23175 The CHECKS are access checks that should be performed once we know
23176 what entity is being declared (and, therefore, what classes have
23177 befriended it).
23179 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
23180 for a function-definition here as well. If the declarator is a
23181 declarator for a function-definition, *FUNCTION_DEFINITION_P will
23182 be TRUE upon return. By that point, the function-definition will
23183 have been completely parsed.
23185 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
23186 is FALSE.
23188 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
23189 parsed declaration if it is an uninitialized single declarator not followed
23190 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
23191 if present, will not be consumed. If returned, this declarator will be
23192 created with SD_INITIALIZED but will not call cp_finish_decl.
23194 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
23195 and there is an initializer, the pointed location_t is set to the
23196 location of the '=' or `(', or '{' in C++11 token introducing the
23197 initializer. */
23199 static tree
23201 cp_parser_flags flags,
23211 {
23215 tree prefix_attributes;
23217 tree asm_specification;
23218 tree initializer;
23220 tree scope;
23222 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
23223 initialized with "= ..", CPP_OPEN_PAREN if initialized with
23224 "(...)". */
23239 /* Assume that this is not the declarator for a function
23240 definition. */
23244 /* Default arguments are only permitted for function parameters. */
23248 /* Defer access checks while parsing the declarator; we cannot know
23249 what names are accessible until we know what is being
23250 declared. */
23255 /* Parse the declarator. */
23256 declarator
23261 /* Gather up the deferred checks. */
23266 /* If the DECLARATOR was erroneous, there's no need to go
23267 further. */
23271 /* Check that the number of template-parameter-lists is OK. */
23281 /* Figure out what scope the entity declared by the DECLARATOR is
23282 located in. `grokdeclarator' sometimes changes the scope, so
23283 we compute it now. */
23286 /* Perform any lookups in the declared type which were thought to be
23287 dependent, but are not in the scope of the declarator. */
23288 decl_specifiers->type
23291 /* If we're allowing GNU extensions, look for an
23292 asm-specification. */
23294 {
23295 /* Look for an asm-specification. */
23298 }
23299 else
23302 /* Gather the attributes that were provided with the
23303 decl-specifiers. */
23306 /* Look for attributes. */
23310 /* Peek at the next token. */
23316 {
23317 /* Handle C++17 deduction guides. Note that class-scope
23318 non-template deduction guides are instead handled in
23319 cp_parser_member_declaration. */
23321 decl_specifiers,
23322 declarator,
23328 /* Check to see if the token indicates the start of a
23329 function-definition. */
23331 {
23333 {
23334 /* If a function-definition should not appear here, issue an
23335 error message. */
23339 }
23341 location_t func_brace_location
23344 /* Neither attributes nor an asm-specification are allowed
23345 on a function-definition. */
23348 "an %<asm%> specification is not allowed "
23352 "attributes are not allowed "
23354 /* This is a function-definition. */
23357 /* Parse the function definition. */
23360 decl_specifiers,
23361 declarator,
23362 prefix_attributes);
23363 else
23364 decl =
23365 (cp_parser_function_definition_from_specifiers_and_declarator
23369 {
23370 /* This is where the prologue starts... */
23373 }
23376 }
23377 }
23379 {
23380 /* A non-template declaration involving a function parameter list
23381 containing an implicit template parameter will be made into a
23382 template. If the resulting declaration is not going to be an
23383 actual function then finish the template scope here to prevent it.
23384 An error message will be issued once we have a decl to talk about.
23386 FIXME probably we should do type deduction rather than create an
23387 implicit template, but the standard currently doesn't allow it. */
23390 }
23392 /* [dcl.dcl]
23394 Only in function declarations for constructors, destructors, type
23395 conversions, and deduction guides can the decl-specifier-seq be omitted.
23397 We explicitly postpone this check past the point where we handle
23398 function-definitions because we tolerate function-definitions
23399 that are missing their return types in some modes. */
23401 {
23405 }
23407 /* An `=' or an '{' in C++11, indicate an initializer. An '(' may indicate
23408 an initializer as well. */
23412 {
23413 /* Don't get fooled into thinking that F(i)(1)(2) is an initializer.
23414 It isn't; it's an expression. (Here '(i)' would have already been
23415 parsed as a declarator.) */
23418 {
23425 /* If this is an initializer, only a ',' or ';' can follow: either
23426 we have another init-declarator, or we're at the end of an
23427 init-declarator-list which can only be followed by a ';'. */
23432 /* Not an init-declarator. */
23434 }
23446 {
23452 }
23453 }
23454 else
23455 {
23456 /* If the init-declarator isn't initialized and isn't followed by a
23457 `,' or `;', it's not a valid init-declarator. */
23460 {
23463 else
23464 {
23468 }
23469 }
23472 }
23474 /* Because start_decl has side-effects, we should only call it if we
23475 know we're going ahead. By this point, we know that we cannot
23476 possibly be looking at any other construct. */
23479 /* Enter the newly declared entry in the symbol table. If we're
23480 processing a declaration in a class-specifier, we wait until
23481 after processing the initializer. */
23483 {
23491 /* Adjust location of decl if declarator->id_loc is more appropriate:
23492 set, and decl wasn't merged with another decl, in which case its
23493 location would be different from input_location, and more accurate. */
23498 }
23500 /* Enter the SCOPE. That way unqualified names appearing in the
23501 initializer will be looked up in SCOPE. */
23504 /* Perform deferred access control checks, now that we know in which
23505 SCOPE the declared entity resides. */
23507 {
23510 /* If the entity being declared is a function, pretend that we
23511 are in its scope. If it is a `friend', it may have access to
23512 things that would not otherwise be accessible. */
23514 {
23517 }
23519 /* Perform access checks for template parameters. */
23522 /* Perform the access control checks for the declarator and the
23523 decl-specifiers. */
23526 /* Restore the saved value. */
23529 }
23531 /* Parse the initializer. */
23536 {
23538 {
23541 else
23542 {
23543 /* If the declaration was erroneous, we don't really
23544 know what the user intended, so just silently
23545 consume the initializer. */
23552 }
23553 }
23554 else
23555 {
23556 /* We want to record the extra mangling scope for in-class
23557 initializers of class members and initializers of static
23558 data member templates and namespace-scope initializers.
23559 The former involves deferring parsing of the initializer
23560 until end of class as with default arguments. So right
23561 here we only handle the latter two. */
23565 && !member_p
23578 }
23579 }
23581 /* The old parser allows attributes to appear after a parenthesized
23582 initializer. Mark Mitchell proposed removing this functionality
23583 on the GCC mailing lists on 2002-08-13. This parser accepts the
23584 attributes -- but ignores them. Made a permerror in GCC 8. */
23590 {
23593 {
23597 }
23598 }
23600 /* And now complain about a non-function implicit template. */
23605 /* For an in-class declaration, use `grokfield' to create the
23606 declaration. */
23608 {
23610 {
23613 }
23622 }
23624 /* Finish processing the declaration. But, skip member
23625 declarations. */
23627 {
23630 asm_specification,
23631 /* If the initializer is in parentheses, then this is
23632 a direct-initialization, which means that an
23633 `explicit' constructor is OK. Otherwise, an
23634 `explicit' constructor cannot be used. */
23637 }
23640 /* Core issue #226 (C++0x only): A default template-argument
23641 shall not be specified in a friend class template
23642 declaration. */
23651 {
23654 else
23656 }
23663 }
23665 /* Parse a declarator.
23667 declarator:
23668 direct-declarator
23669 ptr-operator declarator
23671 abstract-declarator:
23672 ptr-operator abstract-declarator [opt]
23673 direct-abstract-declarator
23675 GNU Extensions:
23677 declarator:
23678 attributes [opt] direct-declarator
23679 attributes [opt] ptr-operator declarator
23681 abstract-declarator:
23682 attributes [opt] ptr-operator abstract-declarator [opt]
23683 attributes [opt] direct-abstract-declarator
23685 The parser flags FLAGS is used to control type-specifier parsing.
23687 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
23688 detect constructors, destructors, deduction guides, or conversion operators.
23689 It is set to -1 if the declarator is a name, and +1 if it is a
23690 function. Otherwise it is set to zero. Usually you just want to
23691 test for >0, but internally the negative value is used.
23693 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
23694 a decl-specifier-seq unless it declares a constructor, destructor,
23695 or conversion. It might seem that we could check this condition in
23696 semantic analysis, rather than parsing, but that makes it difficult
23697 to handle something like `f()'. We want to notice that there are
23698 no decl-specifiers, and therefore realize that this is an
23699 expression, not a declaration.)
23701 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
23702 the declarator is a direct-declarator of the form "(...)".
23704 MEMBER_P is true iff this declarator is a member-declarator.
23706 FRIEND_P is true iff this declarator is a friend.
23708 STATIC_P is true iff the keyword static was seen. */
23712 cp_parser_declarator_kind dcl_kind,
23713 cp_parser_flags flags,
23717 {
23720 cp_cv_quals cv_quals;
23721 tree class_type;
23724 /* Assume this is not a constructor, destructor, or type-conversion
23725 operator. */
23732 /* Check for the ptr-operator production. */
23734 /* Parse the ptr-operator. */
23740 /* If that worked, then we have a ptr-operator. */
23742 {
23743 /* If a ptr-operator was found, then this declarator was not
23744 parenthesized. */
23747 /* The dependent declarator is optional if we are parsing an
23748 abstract-declarator. */
23752 /* Parse the dependent declarator. */
23758 /* If we are parsing an abstract-declarator, we must handle the
23759 case where the dependent declarator is absent. */
23764 declarator = cp_parser_make_indirect_declarator
23766 }
23767 /* Everything else is a direct-declarator. */
23768 else
23769 {
23772 CPP_OPEN_PAREN);
23776 }
23781 }
23783 /* Parse a direct-declarator or direct-abstract-declarator.
23785 direct-declarator:
23786 declarator-id
23787 direct-declarator ( parameter-declaration-clause )
23788 cv-qualifier-seq [opt]
23789 ref-qualifier [opt]
23790 exception-specification [opt]
23791 direct-declarator [ constant-expression [opt] ]
23792 ( declarator )
23794 direct-abstract-declarator:
23795 direct-abstract-declarator [opt]
23796 ( parameter-declaration-clause )
23797 cv-qualifier-seq [opt]
23798 ref-qualifier [opt]
23799 exception-specification [opt]
23800 direct-abstract-declarator [opt] [ constant-expression [opt] ]
23801 ( abstract-declarator )
23803 Returns a representation of the declarator. DCL_KIND is
23804 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
23805 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
23806 we are parsing a direct-declarator. It is
23807 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
23808 of ambiguity we prefer an abstract declarator, as per
23809 [dcl.ambig.res].
23810 The parser flags FLAGS is used to control type-specifier parsing.
23811 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
23812 as for cp_parser_declarator. */
23816 cp_parser_declarator_kind dcl_kind,
23817 cp_parser_flags flags,
23820 {
23831 {
23832 /* Peek at the next token. */
23835 {
23836 /* This is either a parameter-declaration-clause, or a
23837 parenthesized declarator. When we know we are parsing a
23838 named declarator, it must be a parenthesized declarator
23839 if FIRST is true. For instance, `(int)' is a
23840 parameter-declaration-clause, with an omitted
23841 direct-abstract-declarator. But `((*))', is a
23842 parenthesized abstract declarator. Finally, when T is a
23843 template parameter `(T)' is a
23844 parameter-declaration-clause, and not a parenthesized
23845 named declarator.
23847 We first try and parse a parameter-declaration-clause,
23848 and then try a nested declarator (if FIRST is true).
23850 It is not an error for it not to be a
23851 parameter-declaration-clause, even when FIRST is
23852 false. Consider,
23854 int i (int);
23855 int i (3);
23857 The first is the declaration of a function while the
23858 second is the definition of a variable, including its
23859 initializer.
23861 Having seen only the parenthesis, we cannot know which of
23862 these two alternatives should be selected. Even more
23863 complex are examples like:
23865 int i (int (a));
23866 int i (int (3));
23868 The former is a function-declaration; the latter is a
23869 variable initialization.
23871 Thus again, we try a parameter-declaration-clause, and if
23872 that fails, we back out and return. */
23875 {
23876 tree params;
23881 /* In a member-declarator, the only valid interpretation
23882 of a parenthesis is the start of a
23883 parameter-declaration-clause. (It is invalid to
23884 initialize a static data member with a parenthesized
23885 initializer; only the "=" form of initialization is
23886 permitted.) */
23890 /* Consume the `('. */
23892 matching_parens parens;
23895 {
23896 /* If this is going to be an abstract declarator, we're
23897 in a declarator and we can't have default args. */
23900 }
23904 /* Parse the parameter-declaration-clause. */
23905 params
23907 const location_t parens_end
23910 /* Consume the `)'. */
23913 /* For code like
23914 int x(auto(42));
23915 A a(auto(i), 42);
23916 we have synthesized an implicit template parameter and marked
23917 what we thought was a function as an implicit function template.
23918 But now, having seen the whole parameter list, we know it's not
23919 a function declaration, so undo that. */
23922 /* Don't do this for the inner (). */
23926 /* If all went well, parse the cv-qualifier-seq,
23927 ref-qualifier and the exception-specification. */
23929 {
23930 cp_cv_quals cv_quals;
23931 cp_virt_specifiers virt_specifiers;
23932 cp_ref_qualifier ref_qual;
23933 tree exception_specification;
23934 tree late_return;
23935 tree attrs;
23938 unsigned char local_variables_forbidden_p
23940 /* 'this' is not allowed in static member functions. */
23950 /* Parse the cv-qualifier-seq. */
23952 /* Parse the ref-qualifier. */
23954 /* Parse the tx-qualifier. */
23960 /* DR 1207: 'this' is in scope after the cv-quals. */
23963 /* If it turned out that this is e.g. a pointer to a
23964 function, we don't want to delay noexcept parsing. */
23968 /* Parse the exception-specification. */
23969 exception_specification
23971 flags);
23975 cp_omp_declare_simd_data odsd;
23977 && declarator
23980 {
23984 }
23986 /* In here, we handle cases where attribute is used after
23987 the function declaration. For example:
23988 void func (int x) __attribute__((vector(..))); */
23991 late_return
23993 requires_clause);
23997 /* Parse the virt-specifier-seq. */
24001 parens_start,
24002 parens_end);
24003 /* Create the function-declarator. */
24005 params,
24006 cv_quals,
24007 virt_specifiers,
24008 ref_qual,
24009 tx_qual,
24010 exception_specification,
24011 late_return,
24012 requires_clause,
24013 attrs,
24014 parens_loc);
24016 /* Any subsequent parameter lists are to do with
24017 return type, so are not those of the declared
24018 function. */
24024 /* Restore the state of local_variables_forbidden_p. */
24025 parser->local_variables_forbidden_p
24027 }
24029 /* Remove the function parms from scope. */
24033 /* Repeat the main loop. */
24035 }
24037 /* If this is the first, we can try a parenthesized
24038 declarator. */
24040 {
24047 /* Consume the `('. */
24048 matching_parens parens;
24050 /* Parse the nested declarator. */
24053 declarator
24055 ctor_dtor_or_conv_p,
24061 /* Expect a `)'. */
24069 }
24070 /* Otherwise, we must be done. */
24071 else
24073 }
24077 {
24078 /* Parse an array-declarator. */
24088 /* Consume the `['. */
24090 /* Peek at the next token. */
24092 /* If the next token is `]', then there is no
24093 constant-expression. */
24095 {
24097 bounds
24109 {
24110 /* Normally, the array bound must be an integral constant
24111 expression. However, as an extension, we allow VLAs
24112 in function scopes as long as they aren't part of a
24113 parameter declaration. */
24117 }
24120 {
24121 /* Remember this wasn't a constant-expression. */
24124 }
24125 }
24126 else
24128 /* Look for the closing `]'. */
24130 {
24133 }
24138 }
24140 {
24141 {
24142 tree qualifying_scope;
24143 tree unqualified_name;
24144 tree attrs;
24145 special_function_kind sfk;
24150 /* Parse a declarator-id */
24153 {
24156 /* If we see an ellipsis, we should be looking at a
24157 parameter pack. */
24159 {
24160 /* Consume the `...' */
24164 }
24165 }
24168 unqualified_name
24172 {
24176 {
24177 /* Check whether an error occurred. */
24180 /* We already consumed the ellipsis to mark a
24181 parameter pack, but we have no way to report it,
24182 so abort the tentative parse. We will be exiting
24183 immediately anyway. */
24185 }
24186 else
24192 && (qualifying_scope
24194 {
24197 }
24198 }
24203 {
24208 }
24214 {
24215 /* In the declaration of a member of a template class
24216 outside of the class itself, the SCOPE will sometimes
24217 be a TYPENAME_TYPE. For example, given:
24219 template <typename T>
24220 int S<T>::R::i = 3;
24222 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
24223 this context, we must resolve S<T>::R to an ordinary
24224 type, rather than a typename type.
24226 The reason we normally avoid resolving TYPENAME_TYPEs
24227 is that a specialization of `S' might render
24228 `S<T>::R' not a type. However, if `S' is
24229 specialized, then this `i' will not be used, so there
24230 is no harm in resolving the types here. */
24231 tree type;
24233 /* Resolve the TYPENAME_TYPE. */
24236 /* If that failed, the declarator is invalid. */
24238 {
24241 "cannot define member of dependent typedef "
24243 else
24248 }
24250 }
24255 {
24256 tree class_type;
24261 else
24265 {
24269 {
24270 /* We do not attempt to print the declarator
24271 here because we do not have enough
24272 information about its original syntactic
24273 form. */
24277 }
24280 {
24284 "use %<%T::%D%> instead of %<%T::%D%> to "
24286 class_type,
24291 }
24293 }
24296 {
24303 for an unnamed type, even if the type
24304 got a name for linkage purposes. */
24306 /* Handle correctly (c++/19200):
24308 struct S {
24309 struct T{};
24310 friend void S(T);
24311 };
24313 and also:
24315 namespace N {
24316 void S();
24317 }
24319 struct S {
24320 friend void N::S();
24321 }; */
24324 class_type))
24333 }
24334 }
24336 unqualified_name,
24344 /* We're looking for this case in [temp.res]:
24345 A qualified-id is assumed to name a type if [...]
24346 - it is a decl-specifier of the decl-specifier-seq of a
24347 parameter-declaration in a declarator of a function or
24348 function template declaration, ... */
24354 {
24355 /* ...whose declarator-id is qualified. If it isn't, never
24356 assume the parameters to refer to types. */
24359 else
24360 {
24361 /* Now we have something like
24362 template <typename T> int C::x(S::p);
24363 which can be a function template declaration or a
24364 variable template definition. If name lookup for
24365 the declarator-id C::x finds one or more function
24366 templates, assume S::p to name a type. Otherwise,
24367 don't. */
24368 tree decl
24370 none_type,
24378 /* Allow
24379 template<typename T>
24380 A<T>::A(T::type) { } */
24383 qualifying_scope)))
24385 }
24386 }
24387 }
24389 handle_declarator:;
24392 {
24393 /* Any names that appear after the declarator-id for a
24394 member are looked up in the containing scope. */
24396 {
24397 /* But declarations with qualified-ids can't appear in a
24398 function. */
24402 }
24404 }
24408 /* Default args are only allowed on function
24409 declarations. */
24411 else
24415 }
24416 /* We're done. */
24417 else
24419 }
24421 /* For an abstract declarator, we might wind up with nothing at this
24422 point. That's an error; the declarator is not optional. */
24426 {
24427 /* Record overly parenthesized declarator so we can give a
24428 diagnostic about confusing decl/expr disambiguation. */
24430 {
24431 /* If the open and close parens are on different lines, this
24432 is probably a formatting thing, so ignore. */
24437 }
24442 }
24444 /* If we entered a scope, we must exit it now. */
24452 }
24454 /* Parse a ptr-operator.
24456 ptr-operator:
24457 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24458 * cv-qualifier-seq [opt]
24459 &
24460 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
24461 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24463 GNU Extension:
24465 ptr-operator:
24466 & cv-qualifier-seq [opt]
24468 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
24469 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
24470 an rvalue reference. In the case of a pointer-to-member, *TYPE is
24471 filled in with the TYPE containing the member. *CV_QUALS is
24472 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
24473 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
24474 Note that the tree codes returned by this function have nothing
24475 to do with the types of trees that will be eventually be created
24476 to represent the pointer or reference type being parsed. They are
24477 just constants with suggestive names. */
24478 static enum tree_code
24483 {
24488 /* Assume that it's not a pointer-to-member. */
24490 /* And that there are no cv-qualifiers. */
24493 /* Peek at the next token. */
24496 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
24506 {
24507 /* Consume the `*', `&' or `&&'. */
24510 /* A `*' can be followed by a cv-qualifier-seq, and so can a
24511 `&', if we are allowing GNU extensions. (The only qualifier
24512 that can legally appear after `&' is `restrict', but that is
24513 enforced during semantic analysis. */
24521 }
24522 else
24523 {
24524 /* Try the pointer-to-member case. */
24526 /* Look for the optional `::' operator. */
24529 /* Look for the nested-name specifier. */
24536 /* If we found it, and the next token is a `*', then we are
24537 indeed looking at a pointer-to-member operator. */
24540 {
24541 /* Indicate that the `*' operator was used. */
24549 else
24550 {
24551 /* The type of which the member is a member is given by the
24552 current SCOPE. */
24554 /* The next name will not be qualified. */
24558 /* Look for optional c++11 attributes. */
24562 /* Look for the optional cv-qualifier-seq. */
24564 }
24565 }
24566 /* If that didn't work we don't have a ptr-operator. */
24569 }
24572 }
24574 /* Parse an (optional) cv-qualifier-seq.
24576 cv-qualifier-seq:
24577 cv-qualifier cv-qualifier-seq [opt]
24579 cv-qualifier:
24580 const
24581 volatile
24583 GNU Extension:
24585 cv-qualifier:
24586 __restrict__
24588 Returns a bitmask representing the cv-qualifiers. */
24590 static cp_cv_quals
24592 {
24596 {
24598 cp_cv_quals cv_qualifier;
24600 /* Peek at the next token. */
24602 /* See if it's a cv-qualifier. */
24604 {
24620 }
24626 {
24631 }
24632 else
24633 {
24636 }
24637 }
24640 }
24642 /* Parse an (optional) ref-qualifier
24644 ref-qualifier:
24645 &
24646 &&
24648 Returns cp_ref_qualifier representing ref-qualifier. */
24650 static cp_ref_qualifier
24652 {
24655 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
24660 {
24665 {
24677 }
24682 {
24685 }
24686 else
24687 {
24690 }
24691 }
24694 }
24696 /* Parse an optional tx-qualifier.
24698 tx-qualifier:
24699 transaction_safe
24700 transaction_safe_dynamic */
24702 static tree
24704 {
24707 {
24712 {
24716 {
24719 {
24722 }
24723 else
24725 }
24726 }
24727 }
24729 }
24731 /* Parse an (optional) virt-specifier-seq.
24733 virt-specifier-seq:
24734 virt-specifier virt-specifier-seq [opt]
24736 virt-specifier:
24737 override
24738 final
24740 Returns a bitmask representing the virt-specifiers. */
24742 static cp_virt_specifiers
24744 {
24748 {
24750 cp_virt_specifiers virt_specifier;
24752 /* Peek at the next token. */
24754 /* See if it's a virt-specifier-qualifier. */
24758 {
24761 }
24763 {
24766 }
24768 {
24770 }
24771 else
24775 {
24780 }
24781 else
24782 {
24785 }
24786 }
24788 }
24790 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
24791 is in scope even though it isn't real. */
24793 void
24795 {
24796 tree this_parm;
24799 {
24800 /* We don't clear this between NSDMIs. Is it already what we want? */
24807 }
24810 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
24812 current_class_ref
24815 }
24817 /* Return true iff our current scope is a non-static data member
24818 initializer. */
24820 bool
24822 {
24823 /* We recognize NSDMI context by the context-less 'this' pointer set up
24824 by the function above. */
24830 }
24832 /* True if we're parsing a function declarator. */
24834 bool
24836 {
24837 /* this_entity is NULL for a function parameter scope while parsing the
24838 declarator; it is set when parsing the body of the function. */
24841 }
24843 /* Parse a late-specified return type, if any. This is not a separate
24844 non-terminal, but part of a function declarator, which looks like
24846 -> trailing-type-specifier-seq abstract-declarator(opt)
24848 Returns the type indicated by the type-id.
24850 In addition to this, parse any queued up #pragma omp declare simd
24851 clauses, and #pragma acc routine clauses.
24853 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
24854 function. */
24856 static tree
24859 {
24863 && declarator
24867 && declarator
24870 /* Peek at the next token. */
24872 /* A late-specified return type is indicated by an initial '->'. */
24881 {
24882 /* Consume the ->. */
24886 }
24888 /* Function declarations may be followed by a trailing
24889 requires-clause. */
24893 declarator->attributes
24897 declarator->attributes
24902 }
24904 /* Parse a declarator-id.
24906 declarator-id:
24907 id-expression
24908 :: [opt] nested-name-specifier [opt] type-name
24910 In the `id-expression' case, the value returned is as for
24911 cp_parser_id_expression if the id-expression was an unqualified-id.
24912 If the id-expression was a qualified-id, then a SCOPE_REF is
24913 returned. The first operand is the scope (either a NAMESPACE_DECL
24914 or TREE_TYPE), but the second is still just a representation of an
24915 unqualified-id. */
24917 static tree
24919 {
24920 tree id;
24921 /* The expression must be an id-expression. Assume that qualified
24922 names are the names of types so that:
24924 template <class T>
24925 int S<T>::R::i = 3;
24927 will work; we must treat `S<T>::R' as the name of a type.
24928 Similarly, assume that qualified names are templates, where
24929 required, so that:
24931 template <class T>
24932 int S<T>::R<T>::i = 3;
24934 will work, too. */
24940 optional_p);
24944 }
24946 /* Parse a type-id.
24948 type-id:
24949 type-specifier-seq abstract-declarator [opt]
24951 The parser flags FLAGS is used to control type-specifier parsing.
24953 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
24955 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24956 i.e. we've just seen "->".
24958 Returns the TYPE specified. */
24960 static tree
24964 {
24965 cp_decl_specifier_seq type_specifier_seq;
24968 /* Parse the type-specifier-seq. */
24971 is_trailing_return,
24979 /* A bare template name as a template argument is a template template
24980 argument, not a placeholder, so fail parsing it as a type argument. */
24981 {
24985 }
24989 /* There might or might not be an abstract declarator. */
24991 /* Look for the declarator. */
24992 abstract_declarator
24999 /* Check to see if there really was a declarator. */
25004 /* The concepts TS allows 'auto' as a type-id. */
25007 /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
25008 outside the template-argument-list context here only for the sake of
25009 diagnostic: grokdeclarator then can emit a better error message for
25010 e.g. using T = auto. */
25016 && !auto_typeid_ok
25017 /* None of the valid uses of 'auto' in C++14 involve the type-id
25018 nonterminal, but it is valid in a trailing-return-type. */
25021 {
25022 /* A type-id with type 'auto' is only ok if the abstract declarator
25023 is a function declarator with a late-specified return type.
25025 A type-id with 'auto' is also valid in a trailing-return-type
25026 in a compound-requirement. */
25033 else
25034 {
25036 {
25039 {
25040 auto_diagnostic_group g;
25044 tmpl);
25046 tmpl);
25047 }
25050 auto_node);
25051 else
25053 }
25055 }
25056 }
25059 is_template_arg);
25060 }
25062 /* Wrapper for cp_parser_type_id_1. */
25064 static tree
25067 {
25069 }
25071 /* Wrapper for cp_parser_type_id_1. */
25073 static tree
25075 {
25077 parser->type_definition_forbidden_message
25083 /* cp_parser_type_id_1 checks for auto, but only for
25084 ->auto_is_implicit_function_template_parm_p. */
25086 {
25089 }
25091 }
25093 /* Wrapper for cp_parser_type_id_1. */
25095 static tree
25097 {
25100 }
25102 /* Parse a type-specifier-seq.
25104 type-specifier-seq:
25105 type-specifier type-specifier-seq [opt]
25107 GNU extension:
25109 type-specifier-seq:
25110 attributes type-specifier-seq [opt]
25112 The parser flags FLAGS is used to control type-specifier parsing.
25114 If IS_DECLARATION is true, we are at the start of a "condition" or
25115 exception-declaration, so we might be followed by a declarator-id.
25117 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
25118 i.e. we've just seen "->".
25120 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
25122 static void
25124 cp_parser_flags flags,
25128 {
25132 /* Clear the TYPE_SPECIFIER_SEQ. */
25136 /* In the context of a trailing return type, enum E { } is an
25137 elaborated-type-specifier followed by a function-body, not an
25138 enum-specifier. */
25142 /* Parse the type-specifiers and attributes. */
25144 {
25145 tree type_specifier;
25148 /* Check for attributes first. */
25150 {
25151 /* GNU attributes at the end of a declaration apply to the
25152 declaration as a whole, not to the trailing return type. So look
25153 ahead to see if these attributes are at the end. */
25156 {
25162 }
25163 type_specifier_seq->attributes
25167 }
25169 /* record the token of the beginning of the type specifier seq,
25170 for error reporting purposes*/
25174 /* Look for the type-specifier. */
25176 flags,
25177 type_specifier_seq,
25179 NULL,
25182 {
25183 /* If the first type-specifier could not be found, this is not a
25184 type-specifier-seq at all. */
25186 {
25187 /* Set in_declarator_p to avoid skipping to the semicolon. */
25199 }
25200 /* If subsequent type-specifiers could not be found, the
25201 type-specifier-seq is complete. */
25203 }
25206 /* The standard says that a condition can be:
25208 type-specifier-seq declarator = assignment-expression
25210 However, given:
25212 struct S {};
25213 if (int S = ...)
25215 we should treat the "S" as a declarator, not as a
25216 type-specifier. The standard doesn't say that explicitly for
25217 type-specifier-seq, but it does say that for
25218 decl-specifier-seq in an ordinary declaration. Perhaps it
25219 would be clearer just to allow a decl-specifier-seq here, and
25220 then add a semantic restriction that if any decl-specifiers
25221 that are not type-specifiers appear, the program is invalid. */
25224 }
25225 }
25227 /* Return whether the function currently being declared has an associated
25228 template parameter list. */
25230 static bool
25232 {
25245 }
25247 /* Parse a parameter-declaration-clause.
25249 parameter-declaration-clause:
25250 parameter-declaration-list [opt] ... [opt]
25251 parameter-declaration-list , ...
25253 The parser flags FLAGS is used to control type-specifier parsing.
25255 Returns a representation for the parameter declarations. A return
25256 value of NULL indicates a parameter-declaration-clause consisting
25257 only of an ellipsis. */
25259 static tree
25261 cp_parser_flags flags)
25262 {
25263 tree parameters;
25271 && !processing_template_parmlist
25272 && !processing_explicit_instantiation
25273 /* default_arg_ok_p tracks whether this is a parameter-clause for an
25274 actual function or a random abstract declarator. */
25280 /* Peek at the next token. */
25282 /* Check for trivial parameter-declaration-clauses. */
25284 {
25285 /* Consume the `...' token. */
25288 }
25290 /* There are no parameters. */
25292 /* Check for `(void)', too, which is a special case. */
25296 {
25297 /* Consume the `void' token. */
25299 /* There are no parameters. */
25301 }
25303 /* A vector of parameters that haven't been pushed yet. */
25306 /* Parse the parameter-declaration-list. */
25309 /* If a parse error occurred while parsing the
25310 parameter-declaration-list, then the entire
25311 parameter-declaration-clause is erroneous. */
25315 /* Peek at the next token. */
25317 /* If it's a `,', the clause should terminate with an ellipsis. */
25319 {
25320 /* Consume the `,'. */
25322 /* Expect an ellipsis. */
25323 ellipsis_p
25325 }
25326 /* It might also be `...' if the optional trailing `,' was
25327 omitted. */
25329 {
25330 /* Consume the `...' token. */
25332 /* And remember that we saw it. */
25334 }
25335 else
25338 /* A valid parameter-declaration-clause can only be followed by a ')'.
25339 So it's time to push all the parameters we have seen now that we
25340 know we have a valid declaration. Note that here we may not have
25341 committed yet, nor should we. Pushing here will detect the error
25342 of redefining a parameter. */
25344 {
25348 /* Delayed checking of auto parameters. */
25353 {
25357 }
25358 }
25360 /* Finish the parameter list. */
25365 }
25367 /* Parse a parameter-declaration-list.
25369 parameter-declaration-list:
25370 parameter-declaration
25371 parameter-declaration-list , parameter-declaration
25373 The parser flags FLAGS is used to control type-specifier parsing.
25374 PENDING_DECLS is a vector of parameters that haven't been pushed yet.
25376 Returns a representation of the parameter-declaration-list, as for
25377 cp_parser_parameter_declaration_clause. However, the
25378 `void_list_node' is never appended to the list. */
25380 static tree
25382 cp_parser_flags flags,
25384 {
25390 /* The special considerations that apply to a function within an
25391 unbraced linkage specifications do not apply to the parameters
25392 to the function. */
25393 saved_in_unbraced_linkage_specification_p
25397 /* Look for more parameters. */
25399 {
25404 /* Parse the parameter. */
25405 parameter
25410 /* We don't know yet if the enclosing context is unavailable or deprecated,
25411 so wait and deal with it in grokparms if appropriate. */
25415 {
25418 PARM,
25423 }
25427 /* If a parse error occurred parsing the parameter declaration,
25428 then the entire parameter-declaration-list is erroneous. */
25430 {
25433 }
25440 {
25441 /* We cannot always pushdecl while parsing tentatively because
25442 it may have side effects and we can't be sure yet if we're
25443 parsing a declaration, e.g.:
25445 S foo(int(x), int(x), int{x});
25447 where it's not clear if we're dealing with a constructor call
25448 or a function declaration until we've seen the last argument
25449 which breaks it up.
25450 It's safe to pushdecl so long as it doesn't result in a clash
25451 with an already-pushed parameter. But we don't delay pushing
25452 different parameters to handle
25454 S foo(int(i), decltype(i) j = 42);
25456 which is valid. */
25459 /* See if PARAMETERS already contains a parameter with the same
25460 DECL_NAME as DECL. */
25466 }())
25468 else
25470 }
25473 {
25477 }
25479 /* Add the new parameter to the list. */
25483 /* If the parameters were parenthesized, it's the case of
25484 T foo(X(x)) which looks like a variable definition but
25485 is a function declaration. */
25489 /* Peek at the next token. */
25492 /* These are for Objective-C++ */
25495 /* The parameter-declaration-list is complete. */
25498 {
25501 /* Peek at the next token. */
25503 /* If it's an ellipsis, then the list is complete. */
25506 /* Otherwise, there must be more parameters. Consume the
25507 `,'. */
25509 /* When parsing something like:
25511 int i(float f, double d)
25513 we can tell after seeing the declaration for "f" that we
25514 are not looking at an initialization of a variable "i",
25515 but rather at the declaration of a function "i".
25517 Due to the fact that the parsing of template arguments
25518 (as specified to a template-id) requires backtracking we
25519 cannot use this technique when inside a template argument
25520 list. */
25524 /* However, a parameter-declaration of the form
25525 "float(f)" (which is a valid declaration of a
25526 parameter "f") can also be interpreted as an
25527 expression (the conversion of "f" to "float"). */
25530 }
25531 else
25532 {
25540 }
25541 }
25543 parser->in_unbraced_linkage_specification_p
25546 /* Reset implicit_template_scope if we are about to leave the function
25547 parameter list that introduced it. Note that for out-of-line member
25548 definitions, there will be one or more class scopes before we get to
25549 the template parameter scope. */
25553 {
25557 {
25560 }
25561 }
25564 }
25566 /* Parse a parameter declaration.
25568 parameter-declaration:
25569 decl-specifier-seq ... [opt] declarator
25570 decl-specifier-seq declarator = assignment-expression
25571 decl-specifier-seq ... [opt] abstract-declarator [opt]
25572 decl-specifier-seq abstract-declarator [opt] = assignment-expression
25574 The parser flags FLAGS is used to control type-specifier parsing.
25576 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
25577 declares a template parameter. (In that case, a non-nested `>'
25578 token encountered during the parsing of the assignment-expression
25579 is not interpreted as a greater-than operator.)
25581 Returns a representation of the parameter, or NULL if an error
25582 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
25583 true iff the declarator is of the form "(p)". */
25587 cp_parser_flags flags,
25590 {
25592 cp_decl_specifier_seq decl_specifiers;
25594 tree default_argument;
25599 /* In a template parameter, `>' is not an operator.
25601 [temp.param]
25603 When parsing a default template-argument for a non-type
25604 template-parameter, the first non-nested `>' is taken as the end
25605 of the template parameter-list rather than a greater-than
25606 operator. */
25608 /* Type definitions may not appear in parameter types. */
25610 parser->type_definition_forbidden_message
25617 /* Parse the declaration-specifiers. */
25624 /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form
25625 type-constraint opt auto can be used as a decl-specifier of the
25626 decl-specifier-seq of a parameter-declaration of a function declaration
25627 or lambda-expression..." but we must not synthesize an implicit template
25628 type parameter in its declarator. That is, in "void f(auto[auto{10}]);"
25629 we want to synthesize only the first auto. */
25633 /* Complain about missing 'typename' or other invalid type names. */
25638 /* If an error occurred, there's no reason to attempt to parse the
25639 rest of the declaration. */
25641 {
25644 }
25646 /* Peek at the next token. */
25649 /* If the next token is a `)', `,', `=', `>', or `...', then there
25650 is no declarator. However, when variadic templates are enabled,
25651 there may be a declarator following `...'. */
25656 {
25660 }
25661 /* Otherwise, there should be a declarator. */
25662 else
25663 {
25667 /* After seeing a decl-specifier-seq, if the next token is not a
25668 "(" or "{", there is no possibility that the code is a valid
25669 expression. Therefore, if parsing tentatively, we commit at
25670 this point. */
25672 /* In an expression context, having seen:
25674 (int((char ...
25676 we cannot be sure whether we are looking at a
25677 function-type (taking a "char" as a parameter) or a cast
25678 of some object of type "char" to "int". */
25682 {
25684 {
25687 /* This is a CTAD expression, not a parameter declaration. */
25689 }
25690 else
25692 }
25693 /* Parse the declarator. */
25696 CP_PARSER_DECLARATOR_EITHER,
25697 CP_PARSER_FLAGS_NONE,
25699 parenthesized_p,
25704 /* After the declarator, allow more attributes. */
25705 decl_specifiers.attributes
25709 /* If the declarator is a template parameter pack, remember that and
25710 clear the flag in the declarator itself so we don't get errors
25711 from grokdeclarator. */
25713 {
25716 }
25717 }
25719 /* If the next token is an ellipsis, and we have not seen a declarator
25720 name, and if either the type of the declarator contains parameter
25721 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
25722 for, eg, abbreviated integral type names), then we actually have a
25723 parameter pack expansion expression. Otherwise, leave the ellipsis
25724 for a C-style variadic function. */
25727 bool xobj_param_p
25730 {
25735 }
25740 {
25741 location_t xobj_param
25744 input_location);
25746 "an explicit object parameter cannot "
25748 /* Suppress errors that occur down the line. */
25751 }
25753 /* If a function parameter pack was specified and an implicit template
25754 parameter was introduced during cp_parser_parameter_declaration,
25755 change any implicit parameters introduced into packs. */
25760 {
25768 }
25771 {
25782 {
25783 /* Consume the `...'. */
25787 /* Build a pack expansion type */
25792 else
25794 }
25795 }
25797 /* The restriction on defining new types applies only to the type
25798 of the parameter, not to the default argument. */
25801 /* If the next token is `=', then process a default argument. */
25803 {
25806 /* Used for diagnostics with an xobj parameter. */
25810 /* If we are defining a class, then the tokens that make up the
25811 default argument must be saved and processed later. */
25817 /* A constrained-type-specifier may declare a type
25818 template-parameter. */
25820 default_argument
25823 /* A constrained-type-specifier may declare a
25824 template-template-parameter. */
25826 default_argument
25829 /* Outside of a class definition, we can just parse the
25830 assignment-expression. */
25831 else
25832 default_argument
25836 {
25838 "default arguments are only "
25840 }
25842 || template_parameter_pack_p
25845 {
25846 /* Find the name of the parameter pack. */
25853 template_parm_p
25859 else
25861 template_parm_p
25868 }
25869 }
25870 else
25877 {
25879 {
25880 /* If there is a default_argument, eq_token should always be set. */
25882 location_t param_with_init_loc
25885 input_location);
25887 "an explicit object parameter "
25889 }
25890 /* Xobj parameters can not have default arguments, thus
25891 we can reuse the default argument field to flag the param as such. */
25893 }
25895 /* Generate a location for the parameter, ranging from the start of the
25896 initial token to the end of the final token (using input_location for
25897 the latter, set up by cp_lexer_set_source_position_from_token when
25898 consuming tokens).
25900 If we have a identifier, then use it for the caret location, e.g.
25902 extern int callee (int one, int (*two)(int, int), float three);
25903 ~~~~~~^~~~~~~~~~~~~~
25905 otherwise, reuse the start location for the caret location e.g.:
25907 extern int callee (int one, int (*)(int, int), float three);
25908 ^~~~~~~~~~~~~~~~~
25910 */
25916 input_location);
25919 declarator,
25920 default_argument,
25921 param_loc,
25922 template_parameter_pack_p);
25923 }
25925 /* Parse a default argument and return it.
25927 TEMPLATE_PARM_P is true if this is a default argument for a
25928 non-type template parameter. */
25929 static tree
25931 {
25936 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
25937 set correctly. */
25944 /* Local variable names (and the `this' keyword) may not
25945 appear in a default argument. */
25948 /* Parse the assignment-expression. */
25953 /* The "this" pointer is not valid in a default argument. */
25955 {
25960 }
25962 /* Restore the "this" pointer. */
25964 {
25967 }
25976 }
25978 /* Parse a function-body.
25980 function-body:
25981 compound_statement */
25983 static void
25985 {
25989 }
25991 /* Parse a ctor-initializer-opt followed by a function-body. Return
25992 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
25993 is true we are parsing a function-try-block. */
25995 static void
25998 {
26000 const bool check_body_p
26008 {
26011 "function-try-block body of %<constexpr%> constructor only "
26013 else
26015 "function-try-block body of %<constexpr%> function only "
26017 }
26019 /* Begin the function body. */
26021 /* Parse the optional ctor-initializer. */
26024 /* If we're parsing a constexpr constructor definition, we need
26025 to check that the constructor body is indeed empty. However,
26026 before we get to cp_parser_function_body lot of junk has been
26027 generated, so we can't just check that we have an empty block.
26028 Rather we take a snapshot of the outermost block, and check whether
26029 cp_parser_function_body changed its state. */
26031 {
26035 }
26036 /* Parse the function-body. */
26040 /* Finish the function body. */
26042 }
26044 /* Parse an initializer.
26046 initializer:
26047 = initializer-clause
26048 ( expression-list )
26050 Returns an expression representing the initializer. If no
26051 initializer is present, NULL_TREE is returned.
26053 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
26054 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
26055 set to TRUE if there is no initializer present. If there is an
26056 initializer, and it is not a constant-expression, *NON_CONSTANT_P
26057 is set to true; otherwise it is set to false. */
26059 static tree
26062 {
26064 tree init;
26066 /* Peek at the next token. */
26069 /* Let our caller know whether or not this initializer was
26070 parenthesized. */
26073 /* Assume that the initializer is constant. */
26078 {
26079 /* Consume the `='. */
26081 /* Parse the initializer-clause. */
26083 }
26085 {
26090 non_constant_p);
26095 }
26097 {
26102 }
26103 else
26104 {
26105 /* Anything else is an error. */
26108 }
26114 }
26116 /* Parse an initializer-clause.
26118 initializer-clause:
26119 assignment-expression
26120 braced-init-list
26122 Returns an expression representing the initializer.
26124 If the `assignment-expression' production is used the value
26125 returned is simply a representation for the expression.
26127 Otherwise, calls cp_parser_braced_list. */
26129 static cp_expr
26131 {
26132 cp_expr initializer;
26134 /* Assume the expression is constant. */
26138 /* If it is not a `{', then we are looking at an
26139 assignment-expression. */
26141 {
26142 initializer
26145 non_constant_p);
26146 }
26147 else
26151 }
26153 /* Parse a brace-enclosed initializer list.
26155 braced-init-list:
26156 { initializer-list , [opt] }
26157 { designated-initializer-list , [opt] }
26158 { }
26160 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
26161 the elements of the initializer-list (or NULL, if the last
26162 production is used). The TREE_TYPE for the CONSTRUCTOR will be
26163 NULL_TREE. There is no way to detect whether or not the optional
26164 trailing `,' was provided. NON_CONSTANT_P is as for
26165 cp_parser_initializer. */
26167 static cp_expr
26169 {
26170 tree initializer;
26174 /* Consume the `{' token. */
26175 matching_braces braces;
26177 /* Create a CONSTRUCTOR to represent the braced-initializer. */
26179 /* If it's not a `}', then there is a non-trivial initializer. */
26181 {
26183 /* Parse the initializer list. */
26187 /* A trailing `,' token is allowed. */
26190 }
26193 /* Now, there should be a trailing `}'. */
26200 /* Build a location of the form:
26201 { ... }
26202 ^~~~~~~
26203 with caret==start at the open brace, finish at the close brace. */
26207 }
26209 /* Consume tokens up to, but not including, the next non-nested closing `]'.
26210 Returns true iff we found a closing `]'. */
26212 static bool
26214 {
26218 {
26222 {
26226 /* FALLTHRU */
26229 /* If we've run out of tokens, then there is no closing `]'. */
26243 }
26245 /* Consume the current token, skipping it. */
26247 }
26248 }
26250 /* Consume tokens up to, and including, the next non-nested closing `]'.
26251 Returns true iff we found a closing `]'. */
26253 static bool
26255 {
26260 }
26262 /* Return true if we are looking at an array-designator, false otherwise. */
26264 static bool
26266 {
26267 /* Consume the `['. */
26272 /* Skip tokens until the next token is a closing square bracket.
26273 If we find the closing `]', and the next token is a `=', then
26274 we are looking at an array designator. */
26275 bool array_designator_p
26279 /* Roll back the tokens we skipped. */
26283 }
26285 /* Parse an initializer-list.
26287 initializer-list:
26288 initializer-clause ... [opt]
26289 initializer-list , initializer-clause ... [opt]
26291 C++20 Extension:
26293 designated-initializer-list:
26294 designated-initializer-clause
26295 designated-initializer-list , designated-initializer-clause
26297 designated-initializer-clause:
26298 designator brace-or-equal-initializer
26300 designator:
26301 . identifier
26303 GNU Extension:
26305 initializer-list:
26306 designation initializer-clause ...[opt]
26307 initializer-list , designation initializer-clause ...[opt]
26309 designation:
26310 . identifier =
26311 identifier :
26312 [ constant-expression ] =
26314 Returns a vec of constructor_elt. The VALUE of each elt is an expression
26315 for the initializer. If the INDEX of the elt is non-NULL, it is the
26316 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
26317 as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
26318 are any designators. */
26323 {
26328 /* Assume all of the expressions are constant. */
26335 /* Parse the rest of the list. */
26337 {
26339 tree designator;
26340 tree initializer;
26345 /* Handle the C++20 syntax, '. id ='. */
26353 {
26356 "C++ designated initializers only available with "
26358 /* Consume the `.'. */
26360 /* Consume the identifier. */
26363 /* Consume the `='. */
26365 else
26367 }
26368 /* Also, if the next token is an identifier and the following one is a
26369 colon, we are looking at the GNU designated-initializer
26370 syntax. */
26375 {
26376 /* Warn the user that they are using an extension. */
26379 /* Consume the identifier. */
26381 /* Consume the `:'. */
26383 }
26384 /* Also handle C99 array designators, '[ const ] ='. */
26388 {
26389 /* In C++11, [ could start a lambda-introducer. */
26395 {
26398 }
26399 else
26400 {
26405 }
26410 && (!require_potential_rvalue_constant_expression
26414 /* Warn the user that they are using an extension. */
26417 }
26418 else
26422 {
26425 }
26429 {
26433 }
26437 /* Parse the initializer. */
26440 ? &clause_non_constant_p
26442 /* If any clause is non-constant, so is the entire initializer. */
26447 /* This uses |= rather than = because C_I_D_I could have been set in
26448 cp_parser_functional_cast so we must be careful not to clear the
26449 flag. */
26452 /* If we have an ellipsis, this is an initializer pack
26453 expansion. */
26455 {
26458 /* Consume the `...'. */
26465 /* Turn the initializer into an initializer expansion. */
26467 }
26469 /* Add it to the vector. */
26472 /* If the next token is not a comma, we have reached the end of
26473 the list. */
26477 /* Peek at the next token. */
26479 /* If the next token is a `}', then we're still done. An
26480 initializer-clause can have a trailing `,' after the
26481 initializer-list and before the closing `}'. */
26485 /* Suppress location wrappers in a long initializer to save memory
26486 (14179). The cutoff is chosen arbitrarily. */
26490 /* Look one level down because it's easy. Looking deeper would require
26491 passing down a nelts pointer, and I don't think multi-level massive
26492 initializers are common enough to justify this. */
26498 /* Consume the `,' token. */
26500 }
26502 /* The same identifier shall not appear in multiple designators
26503 of a designated-initializer-list. */
26505 {
26510 {
26512 {
26514 "%<.%s%> designator used multiple times in "
26518 }
26519 else
26521 }
26525 }
26531 }
26533 /* Classes [gram.class] */
26535 /* Parse a class-name.
26537 class-name:
26538 identifier
26539 template-id
26541 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
26542 to indicate that names looked up in dependent types should be
26543 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
26544 keyword has been used to indicate that the name that appears next
26545 is a template. TAG_TYPE indicates the explicit tag given before
26546 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
26547 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
26548 is the class being defined in a class-head. If ENUM_OK is TRUE,
26549 enum-names are also accepted.
26551 Returns the TYPE_DECL representing the class. */
26553 static tree
26562 {
26563 tree decl;
26566 /* All class-names start with an identifier. */
26569 {
26572 }
26574 /* PARSER->SCOPE can be cleared when parsing the template-arguments
26575 to a template-id, so we save it here. Consider object scope too,
26576 so that make_typename_type below can use it (cp_parser_template_name
26577 considers object scope also). This may happen with code like
26579 p->template A<T>::a()
26581 where we first want to look up A<T>::a in the class of the object
26582 expression, as per [basic.lookup.classref]. */
26584 /* This only checks parser->scope to avoid duplicate errors; if
26585 ->object_type is erroneous, go on to give a parse error. */
26589 /* Any name names a type if we're following the `typename' keyword
26590 in a qualified name where the enclosing scope is type-dependent. */
26595 /* Handle the common case (an identifier, but not a template-id)
26596 efficiently. */
26599 {
26603 /* Look for the identifier. */
26607 /* If the next token isn't an identifier, we are certainly not
26608 looking at a class-name. */
26611 /* If we know this is a type-name, there's no need to look it
26612 up. */
26615 else
26616 {
26617 tree ambiguous_decls;
26618 /* If we already know that this lookup is ambiguous, then
26619 we've already issued an error message; there's no reason
26620 to check again. */
26622 {
26625 }
26626 /* If the next token is a `::', then the name must be a type
26627 name.
26629 [basic.lookup.qual]
26631 During the lookup for a name preceding the :: scope
26632 resolution operator, object, function, and enumerator
26633 names are ignored. */
26636 /* Look up the name. */
26638 tag_type,
26641 check_dependency_p,
26645 {
26649 }
26650 }
26651 }
26652 else
26653 {
26654 /* Try a template-id. */
26656 check_dependency_p,
26657 tag_type,
26658 is_declaration);
26661 }
26665 /* If this is a typename, create a TYPENAME_TYPE. */
26667 {
26672 }
26676 /* Check to see that it is really the name of a class. */
26680 /* Situations like this:
26682 template <typename T> struct A {
26683 typename T::template X<int>::I i;
26684 };
26686 are problematic. Is `T::template X<int>' a class-name? The
26687 standard does not seem to be definitive, but there is no other
26688 valid interpretation of the following `::'. Therefore, those
26689 names are considered class-names. */
26690 {
26694 }
26699 /* In Objective-C 2.0, a classname followed by '.' starts a
26700 dot-syntax expression, and it's not a type-name. */
26712 }
26714 /* Make sure that any member-function parameters are in scope.
26715 For instance, a function's noexcept-specifier can use the function's
26716 parameters:
26718 struct S {
26719 void fn (int p) noexcept(noexcept(p));
26720 };
26722 so we need to make sure name lookup can find them. This is used
26723 when we delay parsing of the noexcept-specifier. */
26725 static void
26727 {
26734 {
26738 }
26739 }
26741 /* Undo the effects of inject_parm_decls. */
26743 static void
26745 {
26748 }
26750 /* Parse a class-specifier.
26752 class-specifier:
26753 class-head { member-specification [opt] }
26755 Returns the TREE_TYPE representing the class. */
26757 tree
26759 {
26762 tree type;
26776 /* Parse the class-head. */
26779 /* If the class-head was a semantic disaster, skip the entire body
26780 of the class. */
26782 {
26786 }
26788 /* Look for the `{'. */
26789 matching_braces braces;
26791 {
26794 }
26799 /* Issue an error message if type-definitions are forbidden here. */
26801 /* Remember that we are defining one more class. */
26803 /* Inside the class, surrounding template-parameter-lists do not
26804 apply. */
26805 saved_num_template_parameter_lists
26808 /* We are not in a function body. */
26811 /* Or in a loop. */
26814 /* Or in a switch. */
26817 /* We are not immediately inside an extern "lang" block. */
26818 saved_in_unbraced_linkage_specification_p
26821 /* 'this' from an enclosing non-static member function is unavailable. */
26827 /* Start the class. */
26829 {
26831 /* SCOPE must be a scope nested inside current scope. */
26835 else
26837 }
26841 /* If the type is erroneous, skip the entire body of the class. */
26843 else
26844 /* Parse the member-specification. */
26847 /* Look for the trailing `}'. */
26849 /* Look for trailing attributes to apply to this class. */
26857 /* We've finished a type definition. Check for the common syntax
26858 error of forgetting a semicolon after the definition. We need to
26859 be careful, as we can't just check for not-a-semicolon and be done
26860 with it; the user might have typed:
26862 class X { } c = ...;
26863 class X { } *p = ...;
26865 and so forth. Instead, enumerate all the possible tokens that
26866 might follow this production; if we don't see one of them, then
26867 complain and silently insert the semicolon. */
26868 {
26873 /* Don't try to parse c++11 attributes here. As per the
26874 grammar, that should be a task for
26875 cp_parser_decl_specifier_seq. */
26879 {
26891 /* While it's legal for type qualifiers and storage class
26892 specifiers to follow type definitions in the grammar, only
26893 compiler testsuites contain code like that. Assume that if
26894 we see such code, then what we're really seeing is a case
26895 like:
26897 class X { }
26898 const <type> var = ...;
26900 or
26902 class Y { }
26903 static <type> func (...) ...
26905 i.e. the qualifier or specifier applies to the next
26906 declaration. To do so, however, we need to look ahead one
26907 more token to see if *that* token is a type specifier.
26909 This code could be improved to handle:
26911 class Z { }
26912 static const <type> var = ...; */
26915 {
26918 /* Handling user-defined types here would be nice, but very
26919 tricky. */
26920 want_semicolon
26923 }
26927 }
26929 /* If we don't have a type, then something is very wrong and we
26930 shouldn't try to do anything clever. Likewise for not seeing the
26931 closing brace. */
26933 {
26934 /* Locate the closing brace. */
26935 cp_token_position prev
26940 /* We want to suggest insertion of a ';' immediately *after* the
26941 closing brace, so, if we can, offset the location by 1 column. */
26948 /* If we successfully offset the location, suggest the fix-it. */
26961 else
26964 /* Unget one token and smash it to look as though we encountered
26965 a semicolon in the input stream. */
26970 }
26971 }
26973 /* If this class is not itself within the scope of another class,
26974 then we need to parse the bodies of all of the queued function
26975 definitions. Note that the queued functions defined in a class
26976 are not always processed immediately following the
26977 class-specifier for that class. Consider:
26979 struct A {
26980 struct B { void f() { sizeof (A); } };
26981 };
26983 If `f' were processed before the processing of `A' were
26984 completed, there would be no way to compute the size of `A'.
26985 Note that the nesting we are interested in here is lexical --
26986 not the semantic nesting given by TYPE_CONTEXT. In particular,
26987 for:
26989 struct A { struct B; };
26990 struct A::B { void f() { } };
26992 there is no need to delay the parsing of `A::B::f'. */
26994 {
26995 tree decl;
27002 {
27003 /* Skip default arguments, NSDMIs, etc, in order to improve
27004 error recovery (c++/71169, c++/71832). */
27008 }
27010 /* In a first pass, parse default arguments to the functions.
27011 Then, in a second pass, parse the bodies of the functions.
27012 This two-phased approach handles cases like:
27014 struct S {
27015 void f() { g(); }
27016 void g(int i = 3);
27017 };
27019 */
27021 {
27023 /* If there are default arguments that have not yet been processed,
27024 take care of them now. */
27026 {
27031 }
27032 /* Make sure that any template parameters are in scope. */
27034 /* Parse the default argument expressions. */
27036 /* Remove any template parameters from the symbol table. */
27038 }
27041 /* If there are noexcept-specifiers that have not yet been processed,
27042 take care of them now. Do this before processing NSDMIs as they
27043 may depend on noexcept-specifiers already having been processed. */
27045 {
27048 {
27053 }
27058 /* Make sure that any template parameters are in scope. */
27061 /* Make sure that any member-function parameters are in scope.
27062 This function doesn't expect ccp to be set. */
27066 /* 'this' is not allowed in static member functions. */
27067 unsigned char local_variables_forbidden_p
27072 /* Now we can parse the noexcept-specifier. */
27078 /* Update the fn's type directly -- it might have escaped
27079 beyond this decl :( */
27081 /* Update any instantiations we've already created. We must
27082 keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
27083 so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
27084 in the pattern. */
27089 /* Restore the state of local_variables_forbidden_p. */
27092 /* The finish_struct call above performed various override checking,
27093 but it skipped unparsed noexcept-specifier operands. Now that we
27094 have resolved them, check again. */
27097 /* Remove any member-function parameters from the symbol table. */
27100 /* Remove any template parameters from the symbol table. */
27102 }
27105 /* Now parse any NSDMIs. */
27107 {
27110 {
27115 }
27118 }
27121 /* Now contract attributes. */
27123 {
27126 {
27131 }
27135 /* Make sure that any template parameters are in scope. */
27138 /* Make sure that any member-function parameters are in scope.
27139 This function doesn't expect ccp to be set. */
27143 /* 'this' is not allowed in static member functions. */
27144 unsigned char local_variables_forbidden_p
27149 /* Now we can parse contract conditions. */
27151 {
27154 }
27156 /* Restore the state of local_variables_forbidden_p. */
27159 /* Remove any member-function parameters from the symbol table. */
27162 /* Remove any template parameters from the symbol table. */
27165 /* Perform any deferred contract matching. */
27167 }
27175 /* Now parse the body of the functions. */
27177 {
27178 /* OpenMP UDRs need to be parsed before all other functions. */
27185 }
27186 else
27190 }
27192 /* Put back any saved access checks. */
27195 /* Restore saved state. */
27199 parser->num_template_parameter_lists
27201 parser->in_unbraced_linkage_specification_p
27207 }
27209 /* Parse a class-head.
27211 class-head:
27212 class-key identifier [opt] base-clause [opt]
27213 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
27214 class-key nested-name-specifier [opt] template-id
27215 base-clause [opt]
27217 class-virt-specifier:
27218 final
27220 GNU Extensions:
27221 class-key attributes identifier [opt] base-clause [opt]
27222 class-key attributes nested-name-specifier identifier base-clause [opt]
27223 class-key attributes nested-name-specifier [opt] template-id
27224 base-clause [opt]
27226 Upon return BASES is initialized to the list of base classes (or
27227 NULL, if there are none) in the same form returned by
27228 cp_parser_base_clause.
27230 Returns the TYPE of the indicated class. Sets
27231 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
27232 involving a nested-name-specifier was used, and FALSE otherwise.
27234 Returns error_mark_node if this is not a class-head.
27236 Returns NULL_TREE if the class-head is syntactically valid, but
27237 semantically invalid in a way that means we should skip the entire
27238 body of the class. */
27240 static tree
27243 {
27244 tree nested_name_specifier;
27248 tree attributes;
27249 tree bases;
27259 /* Assume no nested-name-specifier will be present. */
27261 /* Assume no template parameter lists will be used in defining the
27262 type. */
27266 /* Look for the class-key. */
27273 /* Parse the attributes. */
27278 /* If the next token is `::', that is invalid -- but sometimes
27279 people do try to write:
27281 struct ::S {};
27283 Handle this gracefully by accepting the extra qualifier, and then
27284 issuing an error about it later if this really is a
27285 class-head. If it turns out just to be an elaborated type
27286 specifier, remain silent. */
27290 /* It is OK to define an inaccessible class; for example:
27292 class A { class B; };
27293 class A::B {};
27295 So we want to ignore access when parsing the class name.
27296 However, we might be tentatively parsing what is really an
27297 elaborated-type-specifier naming a template-id, e.g.
27299 struct C<&D::m> c;
27301 In this case the tentative parse as a class-head will fail, but not
27302 before cp_parser_template_id splices in a CPP_TEMPLATE_ID token.
27303 Since dk_no_check is sticky, we must instead use dk_deferred so that
27304 any such CPP_TEMPLATE_ID token created during this tentative parse
27305 will correctly capture the access checks imposed by the template-id . */
27308 /* Determine the name of the class. Begin by looking for an
27309 optional nested-name-specifier. */
27311 nested_name_specifier
27317 /* If there was a nested-name-specifier, then there *must* be an
27318 identifier. */
27323 {
27325 /* Although the grammar says `identifier', it really means
27326 `class-name' or `template-name'. You are only allowed to
27327 define a class that has already been declared with this
27328 syntax.
27330 The proposed resolution for Core Issue 180 says that wherever
27331 you see `class T::X' you should treat `X' as a type-name.
27333 We do not know if we will see a class-name, or a
27334 template-name. We look for a class-name first, in case the
27335 class-name is a template-id; if we looked for the
27336 template-name first we would stop after the template-name. */
27343 class_type,
27347 /* If that didn't work, ignore the nested-name-specifier. */
27349 {
27355 }
27356 /* If we could not find a corresponding TYPE, treat this
27357 declaration like an unqualified declaration. */
27360 /* Otherwise, count the number of templates used in TYPE and its
27361 containing scopes. */
27362 else
27364 }
27365 /* Otherwise, the identifier is optional. */
27366 else
27367 {
27368 /* We don't know whether what comes next is a template-id,
27369 an identifier, or nothing at all. */
27371 /* Check for a template-id. */
27376 class_key,
27378 /* If that didn't work, it could still be an identifier. */
27380 {
27382 {
27385 }
27386 else
27388 }
27389 else
27390 {
27393 }
27394 }
27399 {
27401 class_key,
27403 }
27406 /* If it's not a `:' or a `{' then we can't really be looking at a
27407 class-head, since a class-head only appears as part of a
27408 class-specifier. We have to detect this situation before calling
27409 xref_tag, since that has irreversible side-effects. */
27411 {
27415 }
27417 /* At this point, we're going ahead with the class-specifier, even
27418 if some other problem occurs. */
27421 {
27426 }
27427 /* Issue the error about the overly-qualified name now. */
27429 {
27434 }
27436 {
27441 }
27443 {
27444 tree scope;
27447 /* [temp.names]: in a qualified-id formed by a class-head-name, the
27448 keyword template shall not appear at the top level. */
27452 /* Reject typedef-names in class heads. */
27454 {
27457 type);
27460 }
27462 /* Figure out in what scope the declaration is being placed. */
27464 /* If that scope does not contain the scope in which the
27465 class was originally declared, the program is invalid. */
27467 {
27470 "declaration of %qD in namespace %qD which does not "
27473 else
27479 }
27480 /* [dcl.meaning]
27482 A declarator-id shall not be qualified except for the
27483 definition of a ... nested class outside of its class
27484 ... [or] the definition or explicit instantiation of a
27485 class member of a namespace outside of its namespace. */
27489 }
27490 /* An explicit-specialization must be preceded by "template <>". If
27491 it is not, try to recover gracefully. */
27494 && !processing_template_parmlist
27496 {
27497 /* Build a location of this form:
27498 struct typename <ARGS>
27499 ^~~~~~~~~~~~~~~~~~~~~~
27500 with caret==start at the start token, and
27501 finishing at the end of the type. */
27502 location_t reported_loc
27504 class_head_start_location,
27510 "an explicit specialization must be preceded by"
27513 /* Take the same action that would have been taken by
27514 cp_parser_explicit_specialization. */
27517 }
27518 /* There must be no "return" statements between this point and the
27519 end of this function; set "type "to the correct return value and
27520 use "goto done;" to return. */
27521 /* Make sure that the right number of template parameters were
27522 present. */
27524 template_id_p,
27527 {
27528 /* If something went wrong, there is no point in even trying to
27529 process the class-definition. */
27532 }
27534 /* Look up the type. */
27536 {
27540 {
27544 }
27545 else
27546 {
27550 /* Check the scope while we still know whether or not we had a
27551 nested-name-specifier. */
27554 }
27557 }
27559 {
27562 /* Given:
27564 template <typename T> struct S { struct T };
27565 template <typename T> struct S<T>::T { };
27567 we will get a TYPENAME_TYPE when processing the definition of
27568 `S::T'. We need to resolve it to the actual type before we
27569 try to define it. */
27571 {
27574 {
27577 }
27578 }
27582 {
27585 }
27587 /* Enter the scope indicated by the nested-name-specifier. */
27589 /* Get the canonical version of this type. */
27591 /* Call push_template_decl if it seems like we should be defining a
27592 template either from the template headers or the type we're
27593 defining, so that we diagnose both extra and missing headers. */
27597 {
27600 {
27603 }
27604 }
27608 }
27610 {
27611 /* If the class was unnamed, create a dummy name. */
27619 }
27621 /* Diagnose class/struct/union mismatches. */
27625 /* Indicate whether this class was declared as a `class' or as a
27626 `struct'. */
27630 /* If this type was already complete, and we see another definition,
27631 that's an error. Likewise if the type is already being defined:
27632 this can happen, eg, when it's defined from within an expression
27633 (c++/84605). */
27636 {
27638 type);
27640 type);
27643 }
27648 {
27651 {
27652 /* In a lambda this should work, but doesn't currently. */
27655 }
27657 /* Apply attributes now, before any use of the class as a template
27658 argument in its base list. */
27661 }
27663 /* Associate constraints with the type. */
27667 /* We will have entered the scope containing the class; the names of
27668 base classes should be looked up in that context. For example:
27670 struct A { struct B {}; struct C; };
27671 struct A::C : B {};
27673 is valid. */
27675 /* Get the list of base-classes, if there is one. Defer access checking
27676 until the entire list has been seen, as per [class.access.general]. */
27679 {
27685 }
27686 else
27689 /* If we're really defining a class, process the base classes.
27690 If they're invalid, fail. */
27694 /* Now that all bases have been seen and attached to the class, check
27695 accessibility of the types named in the base-clause. This must be
27696 done relative to the class scope, so that we accept e.g.
27698 struct A { protected: struct B {}; };
27699 struct C : A::B, A {}; // OK: A::B is accessible via base A
27701 as per [class.access.general]. */
27708 done:
27709 /* Leave the scope given by the nested-name-specifier. We will
27710 enter the class scope itself while processing the members. */
27715 {
27718 }
27724 out:
27727 }
27729 /* Parse a class-key.
27731 class-key:
27732 class
27733 struct
27734 union
27736 Returns the kind of class-key specified, or none_type to indicate
27737 error. */
27739 static enum tag_types
27741 {
27745 /* Look for the class-key. */
27750 /* Check to see if the TOKEN is a class-key. */
27755 }
27757 /* Parse a type-parameter-key.
27759 type-parameter-key:
27760 class
27761 typename
27762 */
27764 static void
27766 {
27767 /* Look for the type-parameter-key. */
27771 {
27775 /* typename is not allowed in a template template parameter
27776 by the standard until C++17. */
27778 "ISO C++ forbids typename key in template template parameter;"
27780 }
27781 else
27785 }
27787 /* Parse an (optional) member-specification.
27789 member-specification:
27790 member-declaration member-specification [opt]
27791 access-specifier : member-specification [opt] */
27793 static void
27795 {
27797 {
27801 /* Peek at the next token. */
27803 /* If it's a `}', or EOF then we've seen all the members. */
27809 /* See if this token is a keyword. */
27812 {
27816 /* Consume the access-specifier. */
27818 /* Remember which access-specifier is active. */
27820 /* Look for the `:'. */
27825 /* Accept #pragmas at class scope. */
27827 {
27830 }
27832 /* Otherwise, the next construction must be a
27833 member-declaration. */
27835 }
27836 }
27837 }
27839 /* Parse a member-declaration.
27841 member-declaration:
27842 decl-specifier-seq [opt] member-declarator-list [opt] ;
27843 function-definition ; [opt]
27844 :: [opt] nested-name-specifier template [opt] unqualified-id ;
27845 using-declaration
27846 template-declaration
27847 alias-declaration
27849 member-declarator-list:
27850 member-declarator
27851 member-declarator-list , member-declarator
27853 member-declarator:
27854 declarator pure-specifier [opt]
27855 declarator constant-initializer [opt]
27856 identifier [opt] : constant-expression
27858 GNU Extensions:
27860 member-declaration:
27861 __extension__ member-declaration
27863 member-declarator:
27864 declarator attributes [opt] pure-specifier [opt]
27865 declarator attributes [opt] constant-initializer [opt]
27866 identifier [opt] attributes [opt] : constant-expression
27868 C++0x Extensions:
27870 member-declaration:
27871 static_assert-declaration */
27873 static void
27875 {
27876 cp_decl_specifier_seq decl_specifiers;
27877 tree prefix_attributes;
27878 tree decl;
27887 /* Check for the `__extension__' keyword. */
27889 {
27890 /* Recurse. */
27892 /* Restore the old value of the PEDANTIC flag. */
27896 }
27898 /* Check for a template-declaration. */
27900 {
27901 /* An explicit specialization here is an error condition, and we
27902 expect the specialization handler to detect and report this. */
27906 else
27910 }
27911 /* Check for a template introduction. */
27915 /* Check for a using-declaration. */
27917 {
27919 /* Parse the using-declaration. */
27923 else
27924 {
27925 tree decl;
27929 /* Note that if we actually see the '=' token after the
27930 identifier, cp_parser_alias_declaration commits the
27931 tentative parse. In that case, we really expect an
27932 alias-declaration. Otherwise, we expect a using
27933 declaration. */
27934 alias_decl_expected =
27940 else
27943 }
27945 }
27947 /* Check for @defs. */
27949 {
27954 {
27959 }
27961 }
27963 /* If the next token is `static_assert' we have a static assertion. */
27965 {
27968 }
27972 cp_omp_declare_simd_data odsd;
27976 /* Parse the decl-specifier-seq. */
27979 (CP_PARSER_FLAGS_OPTIONAL
27989 /* Check for an invalid type-name. */
27993 /* If there is no declarator, then the decl-specifier-seq should
27994 specify a type. */
27996 {
27997 /* If there was no decl-specifier-seq, and the next token is a
27998 `;', then we have something like:
28000 struct S { ; };
28002 [class.mem]
28004 Each member-declaration shall declare at least one member
28005 name of the class. */
28007 {
28010 {
28014 }
28015 }
28016 else
28017 {
28018 /* See if this declaration is a friend. */
28020 /* If there were decl-specifiers, check to see if there was
28021 a class-declaration. */
28024 /* Nested classes have already been added to the class, but
28025 a `friend' needs to be explicitly registered. */
28027 {
28028 /* If the `friend' keyword was present, the friend must
28029 be introduced with a class-key. */
28032 "in C++03 a class-key must be used "
28034 /* In this case:
28036 template <typename T> struct A {
28037 friend struct A<T>::B;
28038 };
28040 A<T>::B will be represented by a TYPENAME_TYPE, and
28041 therefore not recognized by check_tag_decl. */
28043 {
28047 }
28048 /* Warn if an attribute cannot appear here, as per
28049 [dcl.attr.grammar]/5. But not when declares_class_or_enum:
28050 we ignore attributes in elaborated-type-specifiers. */
28053 {
28058 "that appertains to a friend declaration that "
28060 }
28063 "friend declaration does not name a class or "
28065 else
28068 }
28069 /* If there is no TYPE, an error message will already have
28070 been issued. */
28072 ;
28073 /* An anonymous aggregate has to be handled specially; such
28074 a declaration really declares a data member (with a
28075 particular type), as opposed to a nested class. */
28077 {
28078 /* C++11 9.5/6. */
28081 "a storage class on an anonymous aggregate "
28084 /* Remove constructors and such from TYPE, now that we
28085 know it is an anonymous aggregate. */
28087 /* And make the corresponding data member. */
28090 /* Add it to the class. */
28092 }
28093 else
28094 cp_parser_check_access_in_redeclaration
28097 }
28098 }
28099 else
28100 {
28103 /* Clear attributes from the decl_specifiers but keep them
28104 around as prefix attributes that apply them to the entity
28105 being declared. */
28113 /* See if these declarations will be friends. */
28116 /* Keep going until we hit the `;' at the end of the
28117 declaration. */
28119 {
28121 tree first_attribute;
28122 tree initializer;
28125 /* Peek at the next token. */
28128 /* The following code wants to know early if it is a bit-field
28129 or some other declaration. Attributes can appear before
28130 the `:' token. Skip over them without consuming any tokens
28131 to peek if they are followed by `:'. */
28136 {
28137 size_t n
28140 }
28142 /* Check for a bitfield declaration. */
28148 {
28149 tree identifier;
28150 tree width;
28152 location_t id_location
28157 else
28160 /* Look for attributes that apply to the bitfield. */
28163 /* Consume the `:' token. */
28166 /* Get the width of the bitfield. */
28170 /* In C++20 and as extension for C++11 and above we allow
28171 default member initializers for bit-fields. */
28176 CPP_OPEN_BRACE)))
28177 {
28178 location_t loc
28183 "default member initializers for bit-fields "
28184 "only available with %<-std=c++20%> or "
28189 {
28193 }
28194 }
28195 else
28196 {
28197 /* Look for attributes that apply to the bitfield after
28198 the `:' token and width. This is where GCC used to
28199 parse attributes in the past, pedwarn if there is
28200 a std attribute. */
28203 "ISO C++ allows bit-field attributes only "
28207 }
28211 /* Remember which attributes are prefix attributes and
28212 which are not. */
28214 /* Combine the attributes. */
28217 /* Create the bitfield declaration. */
28220 identifier,
28221 sfk_none,
28222 id_location)
28226 attributes);
28227 }
28228 else
28229 {
28231 tree asm_specification;
28235 /* We can't delay parsing for friends,
28236 alias-declarations, and typedefs, even though the
28237 standard seems to require it. */
28242 /* Parse the declarator. */
28243 declarator
28245 flags,
28251 /* If something went wrong parsing the declarator, make sure
28252 that we at least consume some tokens. */
28254 {
28255 /* Skip to the end of the statement. */
28257 /* If the next token is not a semicolon, that is
28258 probably because we just skipped over the body of
28259 a function. So, we consume a semicolon if
28260 present, but do not issue an error message if it
28261 is not present. */
28263 CPP_SEMICOLON))
28266 }
28268 /* Handle class-scope non-template C++17 deduction guides. */
28271 declarator,
28275 cp_parser_check_for_definition_in_return_type
28279 /* Look for an asm-specification. */
28281 /* Look for attributes that apply to the declaration. */
28283 /* Remember which attributes are prefix attributes and
28284 which are not. */
28286 /* Combine the attributes. */
28289 /* If it's an `=', then we have a constant-initializer or a
28290 pure-specifier. It is not correct to parse the
28291 initializer before registering the member declaration
28292 since the member declaration should be in scope while
28293 its initializer is processed. However, the rest of the
28294 front end does not yet provide an interface that allows
28295 us to handle this correctly. */
28297 {
28298 /* In [class.mem]:
28300 A pure-specifier shall be used only in the declaration of
28301 a virtual function.
28303 A member-declarator can contain a constant-initializer
28304 only if it declares a static member of integral or
28305 enumeration type.
28307 Therefore, if the DECLARATOR is for a function, we look
28308 for a pure-specifier; otherwise, we look for a
28309 constant-initializer. When we call `grokfield', it will
28310 perform more stringent semantics checks. */
28323 {
28324 /* Don't require a constant rvalue in C++11, since we
28325 might want a reference constant. We'll enforce
28326 constancy later. */
28328 /* Parse the initializer. */
28330 }
28331 else
28332 /* Parse the initializer. */
28334 }
28337 {
28338 declarator->init_loc
28342 else
28344 }
28345 /* Detect invalid bit-field cases such as
28347 int *p : 4;
28348 int &&r : 3;
28350 and similar. */
28352 /* If there were no type specifiers, it was a
28353 constructor. */
28355 {
28356 /* This is called for a decent diagnostic only. */
28365 /* Avoid "extra ;" pedwarns. */
28367 CPP_SEMICOLON))
28370 }
28371 /* Otherwise, there is no initializer. */
28372 else
28375 /* See if we are probably looking at a function
28376 definition. We are certainly not looking at a
28377 member-declarator. Calling `grokfield' has
28378 side-effects, so we must not do it unless we are sure
28379 that we are looking at a member-declarator. */
28382 {
28383 /* The grammar does not allow a pure-specifier to be
28384 used when a member function is defined. (It is
28385 possible that this fact is an oversight in the
28386 standard, since a pure function may be defined
28387 outside of the class-specifier. */
28393 declarator,
28394 attributes);
28398 /* If the member was not a friend, declare it here. */
28401 /* Peek at the next token. */
28403 /* If the next token is a semicolon, consume it. */
28405 {
28406 location_t semicolon_loc
28411 "extra %<;%> after in-class "
28413 }
28415 }
28416 else
28420 /* Create the declaration. */
28426 {
28429 else
28431 }
28432 }
28437 /* Reset PREFIX_ATTRIBUTES. */
28439 {
28444 }
28446 /* If there is any qualification still in effect, clear it
28447 now; we will be starting fresh with the next declarator. */
28451 /* If it's a `,', then there are more declarators. */
28453 {
28456 {
28462 }
28463 }
28464 /* If the next token isn't a `;', then we have a parse error. */
28466 CPP_SEMICOLON))
28467 {
28468 /* The next token might be a ways away from where the
28469 actual semicolon is missing. Find the previous token
28470 and use that for our error position. */
28477 /* Assume that the user meant to provide a semicolon. If
28478 we were to cp_parser_skip_to_end_of_statement, we might
28479 skip to a semicolon inside a member function definition
28480 and issue nonsensical error messages. */
28482 }
28485 {
28486 /* Add DECL to the list of members. */
28488 /* Explicitly include, eg, NSDMIs, for better error
28489 recovery (c++/58650). */
28497 /* Add DECL to the queue of NSDMI to be parsed later. */
28499 }
28503 }
28504 }
28507 out:
28510 }
28512 /* Parse a pure-specifier.
28514 pure-specifier:
28515 = 0
28517 Returns INTEGER_ZERO_NODE if a pure specifier is found.
28518 Otherwise, ERROR_MARK_NODE is returned. */
28520 static tree
28522 {
28525 /* Look for the `=' token. */
28528 /* Look for the `0' token. */
28537 /* Accept = default or = delete in c++0x mode. */
28540 {
28543 }
28545 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
28547 {
28552 }
28554 {
28557 }
28560 }
28562 /* Parse a constant-initializer.
28564 constant-initializer:
28565 = constant-expression
28567 Returns a representation of the constant-expression. */
28569 static tree
28571 {
28572 /* Look for the `=' token. */
28576 /* It is invalid to write:
28578 struct S { static const int i = { 7 }; };
28580 */
28582 {
28585 /* Consume the opening brace. */
28586 matching_braces braces;
28588 /* Skip the initializer. */
28590 /* Look for the trailing `}'. */
28594 }
28597 }
28599 /* Derived classes [gram.class.derived] */
28601 /* Parse a base-clause.
28603 base-clause:
28604 : base-specifier-list
28606 base-specifier-list:
28607 base-specifier ... [opt]
28608 base-specifier-list , base-specifier ... [opt]
28610 Returns a TREE_LIST representing the base-classes, in the order in
28611 which they were declared. The representation of each node is as
28612 described by cp_parser_base_specifier.
28614 In the case that no bases are specified, this function will return
28615 NULL_TREE, not ERROR_MARK_NODE. */
28617 static tree
28619 {
28622 /* Look for the `:' that begins the list. */
28625 /* Scan the base-specifier-list. */
28627 {
28629 tree base;
28632 /* Look for the base-specifier. */
28634 /* Look for the (optional) ellipsis. */
28636 {
28637 /* Consume the `...'. */
28641 }
28643 /* Add BASE to the front of the list. */
28645 {
28647 /* Make this a pack expansion type. */
28651 {
28654 }
28655 }
28656 /* Peek at the next token. */
28658 /* If it's not a comma, then the list is complete. */
28661 /* Consume the `,'. */
28663 }
28665 /* PARSER->SCOPE may still be non-NULL at this point, if the last
28666 base class had a qualified name. However, the next name that
28667 appears is certainly not qualified. */
28673 }
28675 /* Parse a base-specifier.
28677 base-specifier:
28678 :: [opt] nested-name-specifier [opt] class-name
28679 virtual access-specifier [opt] :: [opt] nested-name-specifier
28680 [opt] class-name
28681 access-specifier virtual [opt] :: [opt] nested-name-specifier
28682 [opt] class-name
28684 Returns a TREE_LIST. The TREE_PURPOSE will be one of
28685 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
28686 indicate the specifiers provided. The TREE_VALUE will be a TYPE
28687 (or the ERROR_MARK_NODE) indicating the type that was specified. */
28689 static tree
28691 {
28699 tree type;
28701 /* Process the optional `virtual' and `access-specifier'. */
28703 {
28704 /* Peek at the next token. */
28706 /* Process `virtual'. */
28708 {
28710 /* If `virtual' appears more than once, issue an error. */
28712 {
28716 }
28720 /* Consume the `virtual' token. */
28728 /* If more than one access specifier appears, issue an
28729 error. */
28732 {
28736 }
28740 /* Consume the access-specifier. */
28748 }
28749 }
28750 /* It is not uncommon to see programs mechanically, erroneously, use
28751 the 'typename' keyword to denote (dependent) qualified types
28752 as base classes. */
28754 {
28759 else
28761 "keyword %<typename%> not allowed in this context "
28764 }
28766 /* Look for the optional `::' operator. */
28768 /* Look for the nested-name-specifier. The simplest way to
28769 implement:
28771 [temp.res]
28773 The keyword `typename' is not permitted in a base-specifier or
28774 mem-initializer; in these contexts a qualified name that
28775 depends on a template-parameter is implicitly assumed to be a
28776 type name.
28778 is to pretend that we have seen the `typename' keyword at this
28779 point. */
28785 /* If the base class is given by a qualified name, assume that names
28786 we see are type names or templates, as appropriate. */
28792 /* DR 950 allows decltype as a base-specifier. */
28794 else
28795 {
28796 /* Otherwise, look for the class-name. */
28798 class_scope_p,
28799 template_p,
28800 typename_type,
28805 }
28811 }
28813 /* Exception handling [gram.exception] */
28815 /* Save the tokens that make up the noexcept-specifier for a member-function.
28816 Returns a DEFERRED_PARSE. */
28818 static tree
28820 {
28822 /* We want everything up to, including, the final ')'. */
28826 /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
28827 to carry the information we will need. */
28829 /* Save away the noexcept-specifier; we will process it when the
28830 class is complete. */
28835 }
28837 /* Used for late processing of noexcept-specifiers of member-functions.
28838 DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
28839 we saved for later; parse it now. DECL is the declaration of the
28840 member function. */
28842 static tree
28844 {
28845 /* Make sure we've gotten something that hasn't been parsed yet. */
28850 /* Push the saved tokens for the noexcept-specifier onto the parser's
28851 lexer stack. */
28855 /* Parse the cached noexcept-specifier. */
28856 tree parsed_arg
28858 CP_PARSER_FLAGS_NONE,
28863 /* Revert to the main lexer. */
28866 /* Restore the queue. */
28869 /* And we're done. */
28871 }
28873 /* Perform late checking of overriding function with respect to their
28874 noexcept-specifiers. FNDECL is the member function that potentially
28875 overrides some virtual function with the same signature. */
28877 static void
28879 {
28881 tree base_binfo;
28887 {
28896 }
28897 }
28899 /* Parse an (optional) noexcept-specification.
28901 noexcept-specification:
28902 noexcept ( constant-expression ) [opt]
28904 If no noexcept-specification is present, returns NULL_TREE.
28905 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
28906 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
28907 there are no parentheses. CONSUMED_EXPR will be set accordingly.
28908 Otherwise, returns a noexcept specification unless RETURN_COND is true,
28909 in which case a boolean condition is returned instead. The parser flags
28910 FLAGS is used to control parsing. QUALS are qualifiers indicating whether
28911 the (member) function is `const'. */
28913 static tree
28915 cp_parser_flags flags,
28919 {
28923 /* Peek at the next token. */
28926 /* Is it a noexcept-specification? */
28928 {
28929 tree expr;
28931 /* [class.mem]/6 says that a noexcept-specifer (within the
28932 member-specification of the class) is a complete-class context of
28933 a class. So, if the noexcept-specifier has the optional expression,
28934 just save the tokens, and reparse this after we're done with the
28935 class. */
28939 /* No need to delay parsing for a number literal or true/false. */
28951 {
28952 matching_parens parens;
28956 {
28957 /* Types may not be defined in an exception-specification. */
28959 parser->type_definition_forbidden_message
28963 expr
28969 {
28972 }
28974 /* Restore the saved message. */
28976 }
28977 else
28978 {
28981 }
28984 }
28985 else
28986 {
28990 }
28992 /* We cannot build a noexcept-spec right away because this will check
28993 that expr is a constexpr. */
28996 else
28998 }
28999 else
29001 }
29003 /* Parse an (optional) exception-specification.
29005 exception-specification:
29006 throw ( type-id-list [opt] )
29008 Returns a TREE_LIST representing the exception-specification. The
29009 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
29010 control parsing. QUALS are qualifiers indicating whether the (member)
29011 function is `const'. */
29013 static tree
29015 cp_parser_flags flags)
29016 {
29018 tree type_id_list;
29021 /* Peek at the next token. */
29024 /* Is it a noexcept-specification? */
29025 type_id_list
29033 /* If it's not `throw', then there's no exception-specification. */
29039 /* Consume the `throw'. */
29042 /* Look for the `('. */
29043 matching_parens parens;
29046 /* Peek at the next token. */
29048 /* If it's not a `)', then there is a type-id-list. */
29050 {
29051 /* Types may not be defined in an exception-specification. */
29053 parser->type_definition_forbidden_message
29055 /* Parse the type-id-list. */
29057 /* Restore the saved message. */
29061 {
29065 }
29068 "dynamic exception specifications are deprecated in "
29070 }
29071 /* In C++17, throw() is equivalent to noexcept (true). throw()
29072 is deprecated in C++11 and above as well, but is still widely used,
29073 so don't warn about it yet. */
29076 else
29079 /* Look for the `)'. */
29083 }
29085 /* Parse an (optional) type-id-list.
29087 type-id-list:
29088 type-id ... [opt]
29089 type-id-list , type-id ... [opt]
29091 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
29092 in the order that the types were presented. */
29094 static tree
29096 {
29100 {
29102 tree type;
29106 /* Get the next type-id. */
29108 /* Check for invalid 'auto'. */
29110 {
29114 }
29115 /* Parse the optional ellipsis. */
29117 {
29118 /* Consume the `...'. */
29121 /* Turn the type into a pack expansion expression. */
29123 }
29124 /* Add it to the list. */
29126 /* Peek at the next token. */
29128 /* If it is not a `,', we are done. */
29131 /* Consume the `,'. */
29133 }
29136 }
29138 /* Parse a try-block.
29140 try-block:
29141 try compound-statement handler-seq */
29143 static tree
29145 {
29146 tree try_block;
29153 "%<try%> in %<constexpr%> function only "
29163 }
29165 /* Parse a function-try-block.
29167 function-try-block:
29168 try ctor-initializer [opt] function-body handler-seq */
29170 static void
29172 {
29173 tree compound_stmt;
29174 tree try_block;
29176 /* Look for the `try' keyword. */
29179 /* Let the rest of the front end know where we are. */
29181 /* Parse the function-body. */
29182 cp_parser_ctor_initializer_opt_and_function_body
29184 /* We're done with the `try' part. */
29186 /* Parse the handlers. */
29188 /* We're done with the handlers. */
29190 }
29192 /* Parse a handler-seq.
29194 handler-seq:
29195 handler handler-seq [opt] */
29197 static void
29199 {
29201 {
29204 /* Parse the handler. */
29206 /* Peek at the next token. */
29208 /* If it's not `catch' then there are no more handlers. */
29211 }
29212 }
29214 /* Parse a handler.
29216 handler:
29217 catch ( exception-declaration ) compound-statement */
29219 static void
29221 {
29222 tree handler;
29223 tree declaration;
29227 matching_parens parens;
29234 }
29236 /* Parse an exception-declaration.
29238 exception-declaration:
29239 type-specifier-seq declarator
29240 type-specifier-seq abstract-declarator
29241 type-specifier-seq
29242 ...
29244 Returns a VAR_DECL for the declaration, or NULL_TREE if the
29245 ellipsis variant is used. */
29247 static tree
29249 {
29250 cp_decl_specifier_seq type_specifiers;
29254 /* If it's an ellipsis, it's easy to handle. */
29256 {
29257 /* Consume the `...' token. */
29260 }
29262 /* Types may not be defined in exception-declarations. */
29264 parser->type_definition_forbidden_message
29267 /* Parse the type-specifier-seq. */
29272 /* If it's a `)', then there is no declarator. */
29275 else
29277 CP_PARSER_FLAGS_NONE,
29284 /* Restore the saved message. */
29291 }
29293 /* Parse a throw-expression.
29295 throw-expression:
29296 throw assignment-expression [opt]
29298 Returns a THROW_EXPR representing the throw-expression. */
29300 static tree
29302 {
29303 tree expression;
29309 /* Figure out whether or not there is an assignment-expression
29310 following the "throw" keyword. */
29318 else
29321 /* Construct a location e.g.:
29322 throw x
29323 ^~~~~~~
29324 with caret == start at the start of the "throw" token, and
29325 the end at the end of the final token we consumed. */
29331 }
29333 /* Parse a yield-expression.
29335 yield-expression:
29336 co_yield assignment-expression
29337 co_yield braced-init-list
29339 Returns a CO_YIELD_EXPR representing the yield-expression. */
29341 static tree
29343 {
29344 tree expr;
29352 {
29354 /* ??? : probably a moot point? */
29357 }
29358 else
29365 }
29367 /* GNU Extensions */
29369 /* Parse an (optional) asm-specification.
29371 asm-specification:
29372 asm ( string-literal )
29374 If the asm-specification is present, returns a STRING_CST
29375 corresponding to the string-literal. Otherwise, returns
29376 NULL_TREE. */
29378 static tree
29380 {
29381 /* Peek at the next token. */
29383 /* If the next token isn't the `asm' keyword, then there's no
29384 asm-specification. */
29388 /* Consume the `asm' token. */
29390 /* Look for the `('. */
29391 matching_parens parens;
29394 /* Look for the string-literal. */
29399 /* Look for the `)'. */
29403 }
29405 /* Parse an asm-operand-list.
29407 asm-operand-list:
29408 asm-operand
29409 asm-operand-list , asm-operand
29411 asm-operand:
29412 string-literal ( expression )
29413 [ string-literal ] string-literal ( expression )
29415 Returns a TREE_LIST representing the operands. The TREE_VALUE of
29416 each node is the expression. The TREE_PURPOSE is itself a
29417 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
29418 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
29419 is a STRING_CST for the string literal before the parenthesis. Returns
29420 ERROR_MARK_NODE if any of the operands are invalid. */
29422 static tree
29424 {
29429 {
29430 tree name;
29433 {
29434 /* Consume the `[' token. */
29436 /* Read the operand name. */
29441 /* Look for the closing `]'. */
29443 }
29444 else
29446 /* Look for the string-literal. */
29451 /* Look for the `('. */
29452 matching_parens parens;
29454 /* Parse the expression. */
29456 /* Look for the `)'. */
29464 /* Add this operand to the list. */
29466 expression,
29467 asm_operands);
29468 /* If the next token is not a `,', there are no more
29469 operands. */
29472 /* Consume the `,'. */
29474 }
29477 }
29479 /* Parse an asm-clobber-list.
29481 asm-clobber-list:
29482 string-literal
29483 asm-clobber-list , string-literal
29485 Returns a TREE_LIST, indicating the clobbers in the order that they
29486 appeared. The TREE_VALUE of each node is a STRING_CST. */
29488 static tree
29490 {
29494 {
29495 /* Look for the string literal. */
29499 /* Add it to the list. */
29501 /* If the next token is not a `,', then the list is
29502 complete. */
29505 /* Consume the `,' token. */
29507 }
29510 }
29512 /* Parse an asm-label-list.
29514 asm-label-list:
29515 identifier
29516 asm-label-list , identifier
29518 Returns a TREE_LIST, indicating the labels in the order that they
29519 appeared. The TREE_VALUE of each node is a label. */
29521 static tree
29523 {
29527 {
29530 /* Look for the identifier. */
29533 {
29536 {
29542 }
29543 }
29544 /* If the next token is not a `,', then the list is
29545 complete. */
29548 /* Consume the `,' token. */
29550 }
29553 }
29555 /* Return TRUE iff the next tokens in the stream are possibly the
29556 beginning of a GNU extension attribute. */
29558 static bool
29560 {
29562 }
29564 /* Return TRUE iff the next tokens in the stream are possibly the
29565 beginning of a standard C++-11 attribute specifier. */
29567 static bool
29569 {
29571 }
29573 /* Return TRUE iff the next Nth tokens in the stream are possibly the
29574 beginning of a standard C++-11 attribute specifier. */
29576 static bool
29578 {
29586 }
29588 /* Return TRUE iff the next Nth tokens in the stream are possibly the
29589 beginning of a GNU extension attribute. */
29591 static bool
29593 {
29597 }
29599 /* Return true iff the next tokens can be the beginning of either a
29600 GNU attribute list, or a standard C++11 attribute sequence. */
29602 static bool
29604 {
29607 }
29609 /* Return true iff the next Nth tokens can be the beginning of either
29610 a GNU attribute list, or a standard C++11 attribute sequence. */
29612 static bool
29614 {
29617 }
29619 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
29620 of GNU attributes, or return NULL. */
29622 static tree
29624 {
29627 {
29632 else
29634 }
29636 }
29638 /* Parse an (optional) series of attributes.
29640 attributes:
29641 attributes attribute
29643 attribute:
29644 __attribute__ (( attribute-list [opt] ))
29646 The return value is as for cp_parser_gnu_attribute_list. */
29648 static tree
29650 {
29657 {
29659 tree attribute_list;
29662 /* Peek at the next token. */
29664 /* If it's not `__attribute__', then we're done. */
29668 /* Consume the `__attribute__' keyword. */
29670 /* Look for the two `(' tokens. */
29671 matching_parens outer_parens;
29674 matching_parens inner_parens;
29678 /* Peek at the next token. */
29681 /* Parse the attribute-list. */
29683 else
29684 /* If the next token is a `)', then there is no attribute
29685 list. */
29688 /* Look for the two `)' tokens. */
29696 /* Add these new attributes to the list. */
29698 }
29701 }
29703 /* Parse a GNU attribute-list.
29705 attribute-list:
29706 attribute
29707 attribute-list , attribute
29709 attribute:
29710 identifier
29711 identifier ( identifier )
29712 identifier ( identifier , expression-list )
29713 identifier ( expression-list )
29715 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
29716 to an attribute. The TREE_PURPOSE of each node is the identifier
29717 indicating which attribute is in use. The TREE_VALUE represents
29718 the arguments, if any. */
29720 static tree
29722 {
29726 /* Don't create wrapper nodes within attributes: the
29727 handlers don't know how to handle them. */
29728 auto_suppress_location_wrappers sentinel;
29732 {
29734 tree identifier;
29735 tree attribute;
29737 /* Look for the identifier. We also allow keywords here; for
29738 example `__attribute__ ((const))' is legal. */
29742 {
29745 /* Consume the token, but save it since we need it for the
29746 SIMD enabled function parsing. */
29749 /* Save away the identifier that indicates which attribute
29750 this is. */
29752 /* For keywords, use the canonical spelling, not the
29753 parsed identifier. */
29760 /* Peek at the next token. */
29762 /* If it's an `(', then parse the attribute arguments. */
29764 {
29770 vec = cp_parser_parenthesized_expression_list
29776 else
29777 {
29780 }
29781 /* Save the arguments away. */
29783 }
29786 {
29787 /* Add this attribute to the list. */
29790 }
29793 }
29794 /* Unless EXACTLY_ONE is set look for more attributes.
29795 If the next token isn't a `,', we're done. */
29799 /* Consume the comma and keep going. */
29801 }
29804 /* We built up the list in reverse order. */
29806 }
29808 /* Parse arguments of omp::directive attribute.
29810 ( directive-name ,[opt] clause-list[opt] )
29812 For directive just remember the first/last tokens for subsequent
29813 parsing. */
29815 static void
29817 {
29820 {
29826 }
29829 {
29835 }
29846 }
29848 /* Parse arguments of omp::sequence attribute.
29850 ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
29852 static void
29854 {
29855 matching_parens parens;
29857 do
29858 {
29863 {
29867 }
29872 else
29877 {
29886 }
29890 UNKNOWN_LOCATION);
29893 else
29898 }
29903 }
29905 /* Parse a standard C++11 attribute.
29907 The returned representation is a TREE_LIST which TREE_PURPOSE is
29908 the scoped name of the attribute, and the TREE_VALUE is its
29909 arguments list.
29911 Note that the scoped name of the attribute is itself a TREE_LIST
29912 which TREE_PURPOSE is the namespace of the attribute, and
29913 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
29914 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
29915 and which TREE_PURPOSE is directly the attribute name.
29917 Clients of the attribute code should use get_attribute_namespace
29918 and get_attribute_name to get the actual namespace and name of
29919 attributes, regardless of their being GNU or C++11 attributes.
29921 attribute:
29922 attribute-token attribute-argument-clause [opt]
29924 attribute-token:
29925 identifier
29926 attribute-scoped-token
29928 attribute-scoped-token:
29929 attribute-namespace :: identifier
29931 attribute-namespace:
29932 identifier
29934 attribute-argument-clause:
29935 ( balanced-token-seq )
29937 balanced-token-seq:
29938 balanced-token [opt]
29939 balanced-token-seq balanced-token
29941 balanced-token:
29942 ( balanced-token-seq )
29943 [ balanced-token-seq ]
29944 { balanced-token-seq }. */
29946 static tree
29948 {
29955 /* First, parse name of the attribute, a.k.a attribute-token. */
29972 {
29973 /* We are seeing a scoped attribute token. */
29988 else
29989 {
29993 }
29999 NULL_TREE);
30001 }
30003 {
30007 NULL_TREE);
30008 }
30009 else
30010 {
30013 NULL_TREE);
30015 /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
30016 but no longer: we have to be able to tell [[noreturn]] and
30017 __attribute__((noreturn)) apart. */
30018 /* C++14 deprecated attribute is equivalent to GNU's. */
30021 /* C++17 fallthrough attribute is equivalent to GNU's. */
30024 /* C++23 assume attribute is equivalent to GNU's. */
30027 /* Transactional Memory TS optimize_for_synchronized attribute is
30028 equivalent to GNU transaction_callable. */
30032 /* Transactional Memory attributes are GNU attributes. */
30035 }
30037 /* Now parse the optional argument clause of the attribute. */
30040 {
30046 {
30048 attr_id);
30050 }
30052 }
30054 {
30058 /* Maybe we don't expect to see any arguments for this attribute. */
30062 {
30064 attr_id);
30070 }
30074 /* The assume attribute needs special handling of the argument. */
30078 /* A GNU attribute that takes an identifier in parameter. */
30086 /* If this is a fake attribute created to handle -Wno-attributes,
30087 we must skip parsing the arguments. */
30089 {
30091 {
30093 {
30096 }
30098 {
30103 }
30105 {
30111 }
30112 }
30114 /* For unknown attributes, just skip balanced tokens instead of
30115 trying to parse the arguments. Set TREE_VALUE (attribute) to
30116 error_mark_node to distinguish skipped arguments from attributes
30117 with no arguments. */
30122 }
30124 vec = cp_parser_parenthesized_expression_list
30130 else
30131 {
30133 /* e.g. [[attr()]]. */
30136 attr_id);
30139 }
30143 else
30145 }
30148 }
30150 /* Warn if the attribute ATTRIBUTE appears more than once in the
30151 attribute-list ATTRIBUTES. This used to be enforced for certain
30152 attributes, but the restriction was removed in P2156.
30153 LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
30154 found in ATTRIBUTES. */
30156 static bool
30158 {
30167 {
30172 }
30174 }
30176 /* Parse a list of standard C++-11 attributes.
30178 attribute-list:
30179 attribute [opt]
30180 attribute-list , attribute[opt]
30181 attribute ...
30182 attribute-list , attribute ...
30183 */
30185 static tree
30187 {
30192 {
30198 {
30200 {
30203 }
30204 }
30207 {
30213 {
30217 }
30219 {
30224 }
30226 }
30230 }
30233 }
30235 /* Optionally parse a C++20 contract role. A NULL return means that no
30236 contract role was specified.
30238 contract-role:
30239 % default
30240 % identifier
30242 If the identifier does not name a known contract role, it will
30243 be assumed to be default. Returns the identifier for the role
30244 token. */
30246 static tree
30248 {
30258 else
30259 {
30262 }
30265 /* FIXME: Warn about invalid/unknown roles? */
30267 }
30269 /* Parse an optional contract mode.
30271 contract-mode:
30272 contract-semantic
30273 [contract-level] [contract-role]
30275 contract-semantic:
30276 check_never_continue
30277 check_maybe_continue
30278 check_always_continue
30280 contract-level:
30281 default
30282 audit
30283 axiom
30285 contract-role:
30286 default
30287 identifier
30289 This grammar is taken from P1332R0. During parsing, this sets options
30290 on the MODE object to determine the configuration of the contract.
30292 Returns a tree containing the identifiers used in the configuration.
30293 This is either an IDENTIFIER with the literal semantic or a TREE_LIST
30294 whose TREE_VALUE is the contract-level and whose TREE_PURPOSE is the
30295 contract-role, if any. NULL_TREE is returned if no information is
30296 given (i.e., all defaults selected). */
30298 static tree
30301 {
30302 /* The mode is empty; the level and role are default. */
30306 /* There is only a role; the level is default. */
30308 {
30311 }
30313 /* Otherwise, match semantic or level. */
30317 tree config_id;
30319 {
30322 /* Either a named level, a concrete semantic, or an identifier
30323 for a postcondition. */
30328 /* The identifier is the return value for a postcondition. */
30332 }
30334 {
30337 }
30338 else
30339 {
30340 /* We got some other token other than a ':'. */
30343 }
30345 /* Consume the literal semantic or level token. */
30349 {
30351 "expected contract level: "
30354 }
30356 /* We matched an explicit semantic. */
30358 {
30360 {
30364 }
30366 }
30368 /* We matched a level, there may be a role; otherwise this is default. */
30370 {
30373 }
30376 }
30378 static tree
30380 {
30384 }
30386 static bool
30388 {
30390 }
30392 /* Parse a standard C++20 contract attribute specifier.
30394 contract-attribute-specifier:
30395 [ [ assert contract-level [opt] : conditional-expression ] ]
30396 [ [ pre contract-level [opt] : conditional-expression ] ]
30397 [ [ post contract-level [opt] identifier [opt] : conditional-expression ] ]
30399 For free functions, we cannot determine the type of the postcondition
30400 identifier because the we haven't called grokdeclarator yet. In those
30401 cases we parse the postcondition as if the identifier was declared as
30402 'auto <identifier>'. We then instantiate the postcondition once the
30403 return type is known.
30405 For member functions, contracts are in the complete-class context, so the
30406 parse is deferred. We also have the return type avaialable (unless it's
30407 deduced), so we don't need to parse the postcondition in terms of a
30408 placeholder. */
30410 static tree
30412 {
30420 /* Parse the optional mode. */
30423 /* Check for postcondition identifiers. */
30424 cp_expr identifier;
30432 /* Defer the parsing of pre/post contracts inside class definitions. */
30433 tree contract;
30435 current_class_type &&
30437 {
30438 /* Skip until we reach an unenclose ']'. If we ran into an unnested ']'
30439 that doesn't close the attribute, return an error and let the attribute
30440 handling code emit an error for missing ']]'. */
30444 CPP_CLOSE_SQUARE,
30451 /* Build a deferred-parse node. */
30456 /* And its corresponding contract. */
30458 }
30459 else
30460 {
30461 /* Enable location wrappers when parsing contracts. */
30464 /* Build a fake variable for the result identifier. */
30467 {
30471 }
30473 /* Parse the condition, ensuring that parameters or the return variable
30474 aren't flagged for use outside the body of a function. */
30479 /* Try to recover from errors by scanning up to the end of the
30480 attribute. Sometimes we get partially parsed expressions, so
30481 we need to search the condition for errors. */
30485 /* Build the contract. */
30488 /* Leave our temporary scope for the postcondition result. */
30490 {
30493 }
30494 }
30497 {
30500 }
30503 }
30505 /* Parse a contract condition for a deferred contract. */
30508 tree fn,
30509 tree attribute)
30510 {
30513 /* Make sure we've gotten something that hasn't been parsed yet or that
30514 we're not parsing an invalid contract. */
30523 /* Build a fake variable for the result identifier. */
30526 {
30527 /* TODO: Can we guarantee that the identifier has a location? */
30531 {
30534 }
30539 }
30541 /* 'this' is not allowed in preconditions of constructors or in postconditions
30542 of destructors. Note that the previous value of this variable is
30543 established by the calling function, so we need to save it here. */
30548 {
30551 }
30555 /* Push the saved tokens onto the parser's lexer stack. */
30559 /* Parse the condition, ensuring that parameters or the return variable
30560 aren't flagged for use outside the body of a function. */
30565 /* Revert to the main lexer. */
30568 /* Restore the queue. */
30574 /* Commit to changes. */
30577 /* Leave our temporary scope for the postcondition result. */
30579 {
30582 }
30583 }
30585 /* Parse a standard C++-11 attribute specifier.
30587 attribute-specifier:
30588 [ [ attribute-using-prefix [opt] attribute-list ] ]
30589 contract-attribute-specifier
30590 alignment-specifier
30592 attribute-using-prefix:
30593 using attribute-namespace :
30595 alignment-specifier:
30596 alignas ( type-id ... [opt] )
30597 alignas ( alignment-expression ... [opt] ).
30599 Extensions for contracts:
30601 contract-attribute-specifier:
30602 [ [ assert : contract-mode [opt] : conditional-expression ] ]
30603 [ [ pre : contract-mode [opt] : conditional-expression ] ]
30604 [ [ post : contract-mode [opt] identifier [opt] :
30605 conditional-expression ] ]
30607 Return void_list_node if the current token doesn't start an
30608 attribute-specifier to differentiate from NULL_TREE returned e.g.
30609 for [ [ ] ]. */
30611 static tree
30613 {
30619 {
30628 {
30631 }
30633 /* Handle contract-attribute-specs specially. */
30635 {
30640 }
30643 {
30654 {
30657 "attribute using prefix only available "
30663 }
30664 else
30666 }
30670 finish_attrs:
30674 else
30675 /* Warn about parsing c++11 attribute in non-c++11 mode, only
30676 when we are sure that we have actually parsed them. */
30678 }
30679 else
30680 {
30681 tree alignas_expr;
30683 /* Look for an alignment-specifier. */
30694 matching_parens parens;
30702 {
30709 }
30714 /* Handle alignas (pack...). */
30716 {
30719 }
30721 /* Something went wrong, so don't build the attribute. */
30725 /* Missing ')' means the code cannot possibly be valid; go ahead
30726 and commit to make sure we issue a hard error. */
30734 /* Build the C++-11 representation of an 'aligned'
30735 attribute. */
30736 attributes
30739 }
30742 }
30744 /* Parse a standard C++-11 attribute-specifier-seq.
30746 attribute-specifier-seq:
30747 attribute-specifier-seq [opt] attribute-specifier */
30749 static tree
30751 {
30755 /* Don't create wrapper nodes within attributes: the
30756 handlers don't know how to handle them. */
30757 auto_suppress_location_wrappers sentinel;
30760 {
30764 /* Accept [[]][[]]; for which cp_parser_std_attribute_spec
30765 returns NULL_TREE as there are no attributes. */
30773 else
30776 }
30779 }
30781 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
30782 return index of the first token after balanced-token, or N on failure. */
30784 static size_t
30786 {
30789 do
30791 {
30795 /* FALLTHRU */
30797 /* Ran out of tokens. */
30819 }
30822 }
30824 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
30825 return index of the first token after the GNU attribute tokens, or N on
30826 failure. */
30828 static size_t
30830 {
30832 {
30844 }
30846 }
30848 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
30849 next token), return index of the first token after the standard C++11
30850 attribute tokens, or N on failure. */
30852 static size_t
30854 {
30856 {
30859 {
30866 }
30869 {
30874 }
30875 else
30877 }
30879 }
30881 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
30882 as the next token), return index of the first token after the attribute
30883 tokens, or N on failure. */
30885 static size_t
30887 {
30891 }
30893 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
30894 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
30895 current value of the PEDANTIC flag, regardless of whether or not
30896 the `__extension__' keyword is present. The caller is responsible
30897 for restoring the value of the PEDANTIC flag. */
30899 static bool
30901 {
30902 /* Save the old value of the PEDANTIC flag. */
30906 {
30907 /* Consume the `__extension__' token. */
30909 /* We're not being pedantic while the `__extension__' keyword is
30910 in effect. */
30914 }
30917 }
30919 /* Parse a label declaration.
30921 label-declaration:
30922 __label__ label-declarator-seq ;
30924 label-declarator-seq:
30925 identifier , label-declarator-seq
30926 identifier */
30928 static void
30930 {
30931 /* Look for the `__label__' keyword. */
30935 {
30936 tree identifier;
30938 /* Look for an identifier. */
30940 /* If we failed, stop. */
30943 /* Declare it as a label. */
30945 /* If the next token is a `;', stop. */
30948 /* Look for the `,' separating the label declarations. */
30950 }
30952 /* Look for the final `;'. */
30954 }
30956 // -------------------------------------------------------------------------- //
30957 // Concept definitions
30959 static tree
30961 {
30962 /* A concept definition is an unevaluated context. */
30963 cp_unevaluated u;
30970 {
30974 }
30979 {
30983 }
30985 processing_constraint_expression_sentinel parsing_constraint;
30990 /* Consume the trailing ';'. Diagnose the problem if it isn't there,
30991 but continue as if it were. */
30995 }
30997 // -------------------------------------------------------------------------- //
30998 // Requires Clause
31000 /* Diagnose an expression that should appear in ()'s within a requires-clause
31001 and suggest where to place those parentheses. */
31003 static void
31005 {
31007 }
31009 static void
31011 {
31016 }
31018 /* Characterizes the likely kind of expression intended by a mis-written
31019 primary constraint. */
31020 enum primary_constraint_error
31021 {
31022 pce_ok,
31023 pce_maybe_operator,
31024 pce_maybe_postfix
31025 };
31027 /* Returns true if the token(s) following a primary-expression in a
31028 constraint-logical-* expression would require parentheses. */
31030 static primary_constraint_error
31032 {
31035 {
31040 {
31041 /* An equal sign may be part of the definition of a function,
31042 and not an assignment operator, when parsing the expression
31043 for a trailing requires-clause. For example:
31045 template<typename T>
31046 struct S {
31047 S() requires C<T> = default;
31048 };
31050 Don't try to reparse this a binary operator. */
31056 }
31058 /* Arithmetic operators. */
31064 /* Bitwise operators. */
31070 /* Relational operators. */
31078 /* Pointer-to-member. */
31081 /* Assignment operators. */
31092 /* Conditional operator */
31094 /* Unenclosed binary or conditional operator. */
31098 {
31099 /* A primary constraint that precedes the parameter-list of a
31100 lambda expression is followed by an open paren.
31102 []<typename T> requires C (T a, T b) { ... }
31104 Don't try to re-parse this as a postfix expression. */
31109 }
31111 {
31112 /* A primary-constraint-expression followed by a '[[' is not a
31113 postfix expression. */
31118 }
31122 /* Unenclosed postfix operator. */
31126 /* A primary constraint that precedes the lambda-declarator of a
31127 lambda expression is followed by trailing return type.
31129 []<typename T> requires C -> void {}
31131 Don't try to re-parse this as a postfix expression in
31132 C++23 and later. In C++20 ( needs to come in between but we
31133 allow it to be omitted with pedwarn. */
31136 /* Unenclosed postfix operator. */
31138 }
31139 }
31141 /* Returns true if the next token begins a unary expression, preceded by
31142 an operator or keyword. */
31144 static bool
31146 {
31149 {
31160 {
31162 {
31178 }
31179 }
31183 }
31186 }
31188 /* Parse a primary expression within a constraint. */
31190 static cp_expr
31192 {
31193 /* If this looks like a unary expression, parse it as such, but diagnose
31194 it as ill-formed; it requires parens. */
31196 {
31200 }
31203 cp_id_kind idk;
31214 {
31215 /* The primary-expression could be part of an unenclosed non-logical
31216 compound expression. */
31218 }
31220 {
31223 }
31225 /* Retry the parse at a lower precedence. If that succeeds, diagnose the
31226 error, but return the expression as if it were valid. */
31231 else
31234 {
31237 }
31239 /* Otherwise, something has gone very wrong, and we can't generate a more
31240 meaningful diagnostic or recover. */
31243 }
31245 /* Parse a constraint-logical-and-expression.
31247 constraint-logical-and-expression:
31248 primary-expression
31249 constraint-logical-and-expression '&&' primary-expression */
31251 static cp_expr
31253 {
31256 {
31260 }
31262 }
31264 /* Parse a constraint-logical-or-expression.
31266 constraint-logical-or-expression:
31267 constraint-logical-and-expression
31268 constraint-logical-or-expression '||' constraint-logical-and-expression */
31270 static cp_expr
31272 {
31275 {
31279 }
31281 }
31283 /* Parse the expression after a requires-clause. This has a different grammar
31284 than that in the concepts TS. */
31286 static tree
31288 {
31289 processing_constraint_expression_sentinel parsing_constraint;
31296 }
31298 /* Parse a expression after a requires clause.
31300 constraint-expression:
31301 logical-or-expression
31303 The required logical-or-expression must be a constant expression. Note
31304 that we don't check that the expression is constepxr here. We defer until
31305 we analyze constraints and then, we only check atomic constraints. */
31307 static tree
31309 {
31310 processing_constraint_expression_sentinel parsing_constraint;
31319 }
31321 /* Optionally parse a requires clause:
31323 requires-clause:
31324 `requires` constraint-logical-or-expression.
31325 [ConceptsTS]
31326 `requires constraint-expression.
31328 LAMBDA_P is true when the requires-clause is parsed before the
31329 parameter-list of a lambda-declarator. */
31331 static tree
31333 {
31334 /* A requires clause is an unevaluated context. */
31335 cp_unevaluated u;
31339 {
31342 {
31344 "%<requires%> only available with "
31346 /* Parse and discard the requires-clause. */
31349 }
31351 }
31355 {
31356 /* An opening brace following the start of a requires-clause is
31357 ill-formed; the user likely forgot the second `requires' that
31358 would start a requires-expression. */
31363 /* Don't consume the `requires', so that it's reused as the start of a
31364 requires-expression. */
31365 }
31366 else
31371 else
31373 }
31375 /*---------------------------------------------------------------------------
31376 Requires expressions
31377 ---------------------------------------------------------------------------*/
31379 /* Parse a requires expression
31381 requirement-expression:
31382 'requires' requirement-parameter-list [opt] requirement-body */
31384 static tree
31386 {
31390 /* Avoid committing to outer tentative parse. */
31393 /* This is definitely a requires-expression. */
31397 {
31398 /* Local parameters are delared as variables within the scope
31399 of the expression. They are not visible past the end of
31400 the expression. Expressions within the requires-expression
31401 are unevaluated. */
31402 struct scope_sentinel
31403 {
31405 {
31409 }
31412 {
31415 }
31418 /* Parse the optional parameter list. */
31420 {
31424 }
31425 else
31428 /* Parse the requirement body. */
31434 }
31436 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
31437 the parm chain. */
31442 {
31443 /* Perform semantic processing now to diagnose any invalid types and
31444 expressions. */
31449 }
31451 }
31453 /* Parse a parameterized requirement.
31455 requirement-parameter-list:
31456 '(' parameter-declaration-clause ')' */
31458 static tree
31460 {
31461 matching_parens parens;
31465 tree parms = (cp_parser_parameter_declaration_clause
31471 /* Modify the declared parameters by removing their context
31472 so they don't refer to the enclosing scope and explicitly
31473 indicating that they are constraint variables. */
31475 {
31480 {
31483 }
31484 }
31487 }
31489 /* Parse the body of a requirement.
31491 requirement-body:
31492 '{' requirement-list '}' */
31493 static tree
31495 {
31496 matching_braces braces;
31506 }
31508 /* Parse a sequence of requirements.
31510 requirement-seq:
31511 requirement
31512 requirement-seq requirement */
31514 static tree
31516 {
31518 do
31519 {
31523 }
31527 /* If there are no valid requirements, this is not a valid expression. */
31531 /* Reverse the order of requirements so they are analyzed in order. */
31533 }
31535 /* Parse a syntactic requirement or type requirement.
31537 requirement:
31538 simple-requirement
31539 compound-requirement
31540 type-requirement
31541 nested-requirement */
31543 static tree
31545 {
31549 {
31550 /* It's probably a type-requirement. */
31555 /* No, maybe it's something like typename T::type(); */
31560 /* Non-tentative for the error. */
31562 }
31565 else
31567 }
31569 /* Parse a simple requirement.
31571 simple-requirement:
31572 expression ';' */
31574 static tree
31576 {
31587 /* Sometimes we don't get locations, so use the cached token location
31588 as a reasonable approximation. */
31593 {
31596 {
31599 }
31601 {
31605 "if a concept-id is a valid expression; add "
31607 }
31609 }
31612 }
31614 /* Parse a type requirement
31616 type-requirement
31617 nested-name-specifier [opt] required-type-name ';'
31619 required-type-name:
31620 type-name
31621 'template' [opt] simple-template-id */
31623 static tree
31625 {
31629 // Save the scope before parsing name specifiers.
31640 tree type;
31642 {
31651 }
31652 else
31672 }
31674 /* Parse a compound requirement
31676 compound-requirement:
31677 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
31679 static tree
31681 {
31682 /* Parse an expression enclosed in '{ }'s. */
31683 matching_braces braces;
31694 {
31698 }
31700 /* If the expression was invalid, skip the remainder of the requirement. */
31702 {
31706 }
31708 /* Parse the optional noexcept. */
31711 {
31714 }
31716 /* Parse the optional trailing return type. */
31719 {
31725 /* C++20 allows either a type-id or a type-constraint. Parsing
31726 a type-id will subsume the parsing for a type-constraint but
31727 allow for more syntactic forms (e.g., const C<T>*). */
31736 /* Check that we haven't written something like 'const C<T>*'. */
31738 {
31740 {
31745 }
31746 }
31748 /* P1452R2 removed the trailing-return-type option. */
31751 }
31763 }
31765 /* Parse a nested requirement. This is the same as a requires clause.
31767 nested-requirement:
31768 requires-clause */
31770 static tree
31772 {
31784 }
31786 /* Support Functions */
31788 /* Return the appropriate prefer_type argument for lookup_name based on
31789 tag_type. */
31793 {
31795 {
31799 }
31800 }
31802 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
31803 NAME should have one of the representations used for an
31804 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
31805 is returned. If PARSER->SCOPE is a dependent type, then a
31806 SCOPE_REF is returned.
31808 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
31809 returned; the name was already resolved when the TEMPLATE_ID_EXPR
31810 was formed. Abstractly, such entities should not be passed to this
31811 function, because they do not need to be looked up, but it is
31812 simpler to check for this special case here, rather than at the
31813 call-sites.
31815 In cases not explicitly covered above, this function returns a
31816 DECL, OVERLOAD, or baselink representing the result of the lookup.
31817 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
31818 is returned.
31820 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
31821 (e.g., "struct") that was used. In that case bindings that do not
31822 refer to types are ignored.
31824 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
31825 ignored. If IS_TEMPLATE IS 2, the 'template' keyword was specified.
31827 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
31828 are ignored.
31830 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
31831 types.
31833 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
31834 TREE_LIST of candidates if name-lookup results in an ambiguity, and
31835 NULL_TREE otherwise. */
31837 static cp_expr
31844 location_t name_location)
31845 {
31846 tree decl;
31849 /* Assume that the lookup will be unambiguous. */
31853 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
31854 no longer valid. Note that if we are parsing tentatively, and
31855 the parse fails, OBJECT_TYPE will be automatically restored. */
31861 /* A template-id has already been resolved; there is no lookup to
31862 do. */
31866 {
31870 }
31872 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
31873 it should already have been checked to make sure that the name
31874 used matches the type being destroyed. */
31876 {
31877 tree type;
31879 /* Figure out to which type this destructor applies. */
31884 else
31886 /* If that's not a class type, there is no destructor. */
31890 /* In a non-static member function, check implicit this->. */
31893 tf_warning_or_error);
31902 }
31904 /* By this point, the NAME should be an ordinary identifier. If
31905 the id-expression was a qualified name, the qualifying scope is
31906 stored in PARSER->SCOPE at this point. */
31909 /* Perform the lookup. */
31911 {
31917 /* If the SCOPE is dependent, the lookup must be deferred until
31918 the template is instantiated -- unless we are explicitly
31919 looking up names in uninstantiated templates. Even then, we
31920 cannot look up the name if the scope is not a class type; it
31921 might, for example, be a template type parameter. */
31926 /* Defer lookup. */
31928 else
31929 {
31932 /* If PARSER->SCOPE is a dependent type, then it must be a
31933 class type, and we must not be checking dependencies;
31934 otherwise, we would have processed this lookup above. So
31935 that PARSER->SCOPE is not considered a dependent base by
31936 lookup_member, we must enter the scope here. */
31940 /* If the PARSER->SCOPE is a template specialization, it
31941 may be instantiated during name lookup. In that case,
31942 errors may be issued. Even if we rollback the current
31943 tentative parse, those errors are valid. */
31948 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
31949 lookup result and the nested-name-specifier nominates a class C:
31950 * if the name specified after the nested-name-specifier, when
31951 looked up in C, is the injected-class-name of C (Clause 9), or
31952 * if the name specified after the nested-name-specifier is the
31953 same as the identifier or the simple-template-id's template-
31954 name in the last component of the nested-name-specifier,
31955 the name is instead considered to name the constructor of
31956 class C. [ Note: for example, the constructor is not an
31957 acceptable lookup result in an elaborated-type-specifier so
31958 the constructor would not be used in place of the
31959 injected-class-name. --end note ] Such a constructor name
31960 shall be used only in the declarator-id of a declaration that
31961 names a constructor or in a using-declaration. */
31971 }
31973 /* If the scope is a dependent type and either we deferred lookup or
31974 we did lookup but didn't find the name, rememeber the name. */
31977 {
31979 {
31980 tree type;
31982 /* The resolution to Core Issue 180 says that `struct
31983 A::B' should be considered a type-name, even if `A'
31984 is dependent. */
31989 }
31993 CPP_CLOSE_PAREN)))
31997 else
32000 is_template);
32001 }
32004 }
32006 {
32009 /* Look up the name in the scope of the OBJECT_TYPE, unless the
32010 OBJECT_TYPE is not a class. */
32012 /* If the OBJECT_TYPE is a template specialization, it may
32013 be instantiated during name lookup. In that case, errors
32014 may be issued. Even if we rollback the current tentative
32015 parse, those errors are valid. */
32017 name,
32020 tf_warning_or_error);
32021 else
32024 /* If we didn't find a member and have dependent bases, the member lookup
32025 is now dependent. */
32032 /* Look it up in the enclosing context. DR 141: When looking for a
32033 template-name after -> or ., only consider class templates. */
32035 /* DR 141: When looking in the
32036 current enclosing context for a
32037 template-name after -> or ., only
32038 consider class templates. */
32042 /* If we did unqualified lookup of a dependent member-qualified name and
32043 found something, do we want to use it? P1787 clarified that we need
32044 to look in the object scope first even if it's dependent, but for now
32045 let's still use it in some cases.
32046 FIXME remember unqualified lookup result to use if member lookup fails
32047 at instantiation time. */
32049 {
32051 /* Only use the unqualified class template lookup if we're actually
32052 looking at a template arg list. */
32055 }
32057 /* If we know we're looking for a type (e.g. A in p->A::x),
32058 mock up a typename. */
32060 {
32062 typename_type);
32064 }
32068 }
32069 else
32070 {
32075 }
32077 /* If the lookup failed, let our caller know. */
32081 /* If we have resolved the name of a member declaration, check to
32082 see if the declaration is accessible. When the name resolves to
32083 set of overloaded functions, accessibility is checked when
32084 overload resolution is done. If we have a TREE_LIST, then the lookup
32085 is either ambiguous or it found multiple injected-class-names, the
32086 accessibility of which is trivially satisfied.
32088 During an explicit instantiation, access is not checked at all,
32089 as per [temp.explicit]. */
32092 tf_warning_or_error);
32094 /* Pull out the template from an injected-class-name (or multiple). */
32098 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
32100 {
32103 /* The error message we have to print is too complicated for
32104 cp_parser_error, so we incorporate its actions directly. */
32106 {
32108 name);
32110 }
32112 }
32123 }
32125 /* Like cp_parser_lookup_name, but for use in the typical case where
32126 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
32127 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
32129 static tree
32131 {
32133 none_type,
32138 location);
32139 }
32141 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
32142 the current context, return the TYPE_DECL. If TAG_NAME_P is
32143 true, the DECL indicates the class being defined in a class-head,
32144 or declared in an elaborated-type-specifier.
32146 Otherwise, return DECL. */
32148 static tree
32150 {
32151 /* If the TEMPLATE_DECL is being declared as part of a class-head,
32152 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
32154 struct A {
32155 template <typename T> struct B;
32156 };
32158 template <typename T> struct A::B {};
32160 Similarly, in an elaborated-type-specifier:
32162 namespace N { struct X{}; }
32164 struct A {
32165 template <typename T> friend struct N::X;
32166 };
32168 However, if the DECL refers to a class type, and we are in
32169 the scope of the class, then the name lookup automatically
32170 finds the TYPE_DECL created by build_self_reference rather
32171 than a TEMPLATE_DECL. For example, in:
32173 template <class T> struct S {
32174 S s;
32175 };
32177 there is no need to handle such case. */
32183 }
32185 /* If too many, or too few, template-parameter lists apply to the
32186 declarator, issue an error message. Returns TRUE if all went well,
32187 and FALSE otherwise. */
32189 static bool
32192 location_t declarator_location)
32193 {
32195 {
32197 {
32206 {
32207 /* If the DECLARATOR has the form `X<y>' then it uses one
32208 additional level of template parameters. */
32211 }
32213 return cp_parser_check_template_parameters
32215 declarator);
32216 }
32232 }
32234 }
32236 /* NUM_TEMPLATES were used in the current declaration. If that is
32237 invalid, return FALSE and issue an error messages. Otherwise,
32238 return TRUE. If DECLARATOR is non-NULL, then we are checking a
32239 declarator and we can print more accurate diagnostics. */
32241 static bool
32245 location_t location,
32247 {
32248 /* If there are the same number of template classes and parameter
32249 lists, that's OK. */
32252 /* If there are more, but only one more, and the name ends in an identifier,
32253 then we are declaring a primary template. That's OK too. */
32261 /* If there are more template classes than parameter lists, we have
32262 something like:
32264 template <class T> void S<T>::R<T>::f (); */
32266 {
32276 else
32279 }
32280 /* Otherwise, there are too many template parameter lists. We have
32281 something like:
32283 template <class T> template <class U> void S::f(); */
32286 }
32288 /* Parse an optional `::' token indicating that the following name is
32289 from the global namespace. If so, PARSER->SCOPE is set to the
32290 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
32291 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
32292 Returns the new value of PARSER->SCOPE, if the `::' token is
32293 present, and NULL_TREE otherwise. */
32295 static tree
32297 {
32300 /* Peek at the next token. */
32302 /* If we're looking at a `::' token then we're starting from the
32303 global namespace, not our current location. */
32305 {
32306 /* Consume the `::' token. */
32308 /* Set the SCOPE so that we know where to start the lookup. */
32314 }
32316 {
32320 }
32323 }
32325 /* Returns TRUE if the upcoming token sequence is the start of a
32326 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
32327 declarator is preceded by the `friend' specifier. The parser flags FLAGS
32328 is used to control type-specifier parsing. */
32330 static bool
32333 {
32336 tree nested_name_specifier;
32339 /* The common case is that this is not a constructor declarator, so
32340 try to avoid doing lots of work if at all possible. It's not
32341 valid declare a constructor at function scope. */
32344 /* And only certain tokens can begin a constructor declarator. */
32352 /* Parse tentatively; we are going to roll back all of the tokens
32353 consumed here. */
32355 /* Assume that we are looking at a constructor declarator. */
32358 /* Look for the optional `::' operator. */
32361 /* Look for the nested-name-specifier. */
32362 nested_name_specifier
32369 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
32372 {
32377 }
32383 /* Outside of a class-specifier, there must be a
32384 nested-name-specifier. Except in C++17 mode, where we
32385 might be declaring a guiding declaration. */
32392 /* If we have a class scope, this is easy; DR 147 says that S::S always
32393 names the constructor, and no other qualified name could. */
32396 {
32406 }
32407 /* If we still think that this might be a constructor-declarator,
32408 look for a class-name. */
32410 {
32411 /* If we have:
32413 template <typename T> struct S {
32414 S();
32415 };
32417 we must recognize that the nested `S' names a class. */
32421 tree type_decl;
32425 none_type,
32432 {
32438 none_type,
32443 else
32445 }
32447 /* If there was no class-name, then this is not a constructor.
32448 Otherwise, if we are in a class-specifier and we aren't
32449 handling a friend declaration, check that its type matches
32450 current_class_type (c++/38313). Note: error_mark_node
32451 is left alone for error recovery purposes. */
32453 && (outside_class_specifier_p
32459 /* If we're still considering a constructor, we have to see a `(',
32460 to begin the parameter-declaration-clause, followed by either a
32461 `)', an `...', or a decl-specifier. We need to check for a
32462 type-specifier to avoid being fooled into thinking that:
32464 S (f) (int);
32466 is a constructor. (It is actually a function named `f' that
32467 takes one parameter (of type `int') and returns a value of type
32468 `S'. */
32476 /* A parameter declaration begins with a decl-specifier,
32477 which is either the "attribute" keyword, a storage class
32478 specifier, or (usually) a type-specifier. */
32480 /* GNU attributes can actually appear both at the start of
32481 a parameter and parenthesized declarator.
32482 S (__attribute__((unused)) int);
32483 is a constructor, but
32484 S (__attribute__((unused)) foo) (int);
32485 is a function declaration. [[attribute]] can appear in the
32486 first form too, but not in the second form. */
32488 {
32489 tree type;
32495 {
32499 }
32501 /* Names appearing in the type-specifier should be looked up
32502 in the scope of the class. */
32506 {
32509 {
32513 {
32516 }
32517 }
32519 }
32521 /* Inside the constructor parameter list, surrounding
32522 template-parameter-lists do not apply. */
32523 saved_num_template_parameter_lists
32527 /* Look for the type-specifier. It's not optional, but its typename
32528 might be. Unless this is a friend declaration; we don't want to
32529 treat
32531 friend S (T::fn)(int);
32533 as a constructor, but with P0634, we might assume a type when
32534 looking for the type-specifier. It is actually a function named
32535 `T::fn' that takes one parameter (of type `int') and returns a
32536 value of type `S'. Constructors can be friends, but they must
32537 use a qualified name.
32539 Parse with an empty set of declaration specifiers since we're
32540 trying to match a decl-specifier-seq of the first parameter.
32541 This must be non-null so that cp_parser_simple_type_specifier
32542 will recognize a constrained placeholder type such as:
32543 'C<int> auto' where C is a type concept. */
32544 cp_decl_specifier_seq ctor_specs;
32554 parser->num_template_parameter_lists
32557 /* Leave the scope of the class. */
32562 }
32563 }
32565 /* We did not really want to consume any tokens. */
32568 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
32569 declarator-id of a constructor or destructor. */
32572 {
32573 auto_diagnostic_group d;
32578 }
32581 }
32583 /* Parse the definition of the function given by the DECL_SPECIFIERS,
32584 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
32585 they must be performed once we are in the scope of the function.
32587 Returns the function defined. */
32589 static tree
32590 cp_parser_function_definition_from_specifiers_and_declarator
32593 tree attributes,
32595 {
32596 tree fn;
32599 /* Begin the function-definition. */
32602 /* The things we're about to see are not directly qualified by any
32603 template headers we've seen thus far. */
32606 /* If there were names looked up in the decl-specifier-seq that we
32607 did not check, check them now. We must wait until we are in the
32608 scope of the function to perform the checks, since the function
32609 might be a friend. */
32613 {
32618 }
32621 {
32622 /* Skip the entire function. */
32625 }
32627 {
32628 /* Seen already, skip it. An error message has already been output. */
32632 /* If this is a function from a class, pop the nested class. */
32635 }
32636 else
32637 {
32642 }
32645 }
32647 /* Parse the part of a function-definition that follows the
32648 declarator. INLINE_P is TRUE iff this function is an inline
32649 function defined within a class-specifier.
32651 Returns the function defined. */
32653 static tree
32656 {
32657 tree fn;
32662 bool fully_implicit_function_template_p
32665 tree implicit_template_parms
32668 cp_binding_level* implicit_template_scope
32674 /* If the next token is `return', then the code may be trying to
32675 make use of the "named return value" extension that G++ used to
32676 support. */
32679 {
32680 /* Consume the `return' keyword. */
32682 /* Look for the identifier that indicates what value is to be
32683 returned. */
32685 /* Issue an error message. */
32688 /* Skip tokens until we reach the start of the function body. */
32690 {
32697 }
32698 }
32699 /* The `extern' in `extern "C" void f () { ... }' does not apply to
32700 anything declared inside `f'. */
32701 saved_in_unbraced_linkage_specification_p
32704 /* Inside the function, surrounding template-parameter-lists do not
32705 apply. */
32706 saved_num_template_parameter_lists
32710 /* If the next token is `try', `__transaction_atomic', or
32711 `__transaction_relaxed`, then we are looking at either function-try-block
32712 or function-transaction-block. Note that all of these include the
32713 function-body. */
32717 RID_TRANSACTION_RELAXED))
32721 else
32722 cp_parser_ctor_initializer_opt_and_function_body
32725 /* Finish the function. */
32729 && !inline_p
32735 /* Generate code for it, if necessary. */
32738 /* Restore the saved values. */
32739 parser->in_unbraced_linkage_specification_p
32741 parser->num_template_parameter_lists
32745 parser->fully_implicit_function_template_p
32747 parser->implicit_template_parms
32749 parser->implicit_template_scope
32756 }
32758 /* Parse a template-declaration body (following argument list). */
32760 static void
32762 tree parameter_list,
32764 {
32768 /* We just processed one more parameter list. */
32771 /* Get the deferred access checks from the parameter list. These
32772 will be checked once we know what is being declared, as for a
32773 member template the checks must be performed in the scope of the
32774 class containing the member. */
32777 /* Tentatively parse for a new template parameter list, which can either be
32778 the template keyword or a template introduction. */
32787 /* -fconcept-ts 'concept bool' syntax is handled below, in
32788 cp_parser_single_declaration. */
32790 else
32791 {
32794 checks,
32795 member_p,
32799 /* If this is a member template declaration, let the front
32800 end know. */
32802 {
32807 }
32812 }
32813 /* We are done with the current parameter list. */
32818 /* Finish up. */
32821 /* Check the template arguments for a literal operator template. */
32825 {
32829 else
32830 {
32833 {
32840 /* OK, C++20 string literal operator template. We don't need
32841 to warn in lower dialects here because we will have already
32846 }
32848 {
32857 else
32858 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
32860 "ISO C++ did not adopt string literal operator templa"
32862 }
32863 else
32865 }
32867 {
32870 "template %qD has invalid parameter list; expected "
32871 "non-type template parameter pack %<<char...>%> or "
32873 decl);
32874 else
32876 "template %qD has invalid parameter list; expected "
32878 decl);
32879 }
32880 }
32882 /* Register member declarations. */
32885 /* If DECL is a function template, we must return to parse it later.
32886 (Even though there is no definition, there might be default
32887 arguments that need handling.) */
32891 }
32893 /* Parse a template introduction header for a template-declaration. Returns
32894 false if tentative parse fails. */
32896 static bool
32898 {
32908 /* In classes don't parse valid unnamed bitfields as invalid
32909 template introductions. */
32913 /* Look for the optional `::' operator. */
32916 /* Look for the nested-name-specifier. */
32926 /* Look up the concept for which we will be matching
32927 template parameters. */
32939 /* Look for opening brace for introduction. */
32940 matching_braces braces;
32949 /* Build vector of placeholder parameters and grab
32950 matching identifiers. */
32953 /* Look for closing brace for introduction. */
32957 /* The introduction-list shall not be empty. */
32960 {
32961 /* In cp_parser_introduction_list we have already issued an error. */
32963 }
32966 {
32970 }
32972 /* Build and associate the constraint. */
32977 introduction_list,
32978 introduction_loc);
32980 {
32987 member_p);
32989 }
32995 }
32997 /* Parse a normal template-declaration following the template keyword. */
32999 static void
33001 {
33002 tree parameter_list;
33006 /* Look for the `<' token. */
33010 {
33011 /* 14.5.2.2 [temp.mem]
33013 A local class shall not have member templates. */
33018 }
33019 /* [temp]
33021 A template ... shall not have C linkage. */
33023 {
33026 /* Give it C++ linkage to avoid confusing other parts of the
33027 front end. */
33030 }
33031 else
33034 /* We cannot perform access checks on the template parameter
33035 declarations until we know what is being declared, just as we
33036 cannot check the decl-specifier list. */
33039 /* If the next token is `>', then we have an invalid
33040 specialization. Rather than complain about an invalid template
33041 parameter, issue an error message here. */
33043 {
33047 }
33048 else
33049 {
33050 /* Parse the template parameters. */
33052 }
33054 /* Look for the `>'. */
33057 /* Manage template requirements */
33059 {
33064 }
33067 member_p);
33069 /* For the erroneous case of a template with C linkage, we pushed an
33070 implicit C++ linkage scope; exit that scope now. */
33073 }
33075 /* Parse a template-declaration, assuming that the `export' (and
33076 `extern') keywords, if present, has already been scanned. MEMBER_P
33077 is as for cp_parser_template_declaration. */
33079 static bool
33081 {
33083 {
33087 }
33092 }
33094 /* Perform the deferred access checks from a template-parameter-list.
33095 CHECKS is a TREE_LIST of access checks, as returned by
33096 get_deferred_access_checks. */
33098 static void
33099 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
33100 {
33104 }
33106 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
33107 `function-definition' sequence that follows a template header.
33108 If MEMBER_P is true, this declaration appears in a class scope.
33110 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
33111 *FRIEND_P is set to TRUE iff the declaration is a friend. */
33113 static tree
33119 {
33122 cp_decl_specifier_seq decl_specifiers;
33126 /* This function is only used when processing a template
33127 declaration. */
33131 /* Defer access checks until we know what is being declared. */
33134 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
33135 alternative. */
33138 (CP_PARSER_FLAGS_OPTIONAL
33143 cp_omp_declare_simd_data odsd;
33152 /* There are no template typedefs. */
33154 {
33158 }
33160 /* Gather up the access checks that occurred the
33161 decl-specifier-seq. */
33164 /* Check for the declaration of a template class. */
33166 {
33169 {
33172 /* In this case:
33174 struct C {
33175 friend template <typename T> struct A<T>::B;
33176 };
33178 A<T>::B will be represented by a TYPENAME_TYPE, and
33179 therefore not recognized by shadow_tag. */
33181 && !decl
33188 else
33191 /* If this is a declaration, but not a definition, associate
33192 any constraints with the type declaration. Constraints
33193 are associated with definitions in cp_parser_class_specifier. */
33197 /* Perform access checks for template parameters. */
33200 /* Give a helpful diagnostic for
33201 template <class T> struct A { } a;
33202 if we aren't already recovering from an error. */
33205 {
33207 "a class template declaration must not declare "
33211 }
33212 }
33213 }
33215 /* Complain about missing 'typename' or other invalid type names. */
33218 {
33219 /* cp_parser_parse_and_diagnose_invalid_type_name calls
33220 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
33221 the rest of this declaration. */
33224 }
33226 /* If it's not a template class, try for a template function. If
33227 the next token is a `;', then this declaration does not declare
33228 anything. But, if there were errors in the decl-specifiers, then
33229 the error might well have come from an attempted class-specifier.
33230 In that case, there's no need to warn about a missing declarator. */
33234 {
33236 /* We don't delay parsing for friends, though CWG 2510 may change
33237 that. */
33241 flags,
33243 checks,
33245 member_p,
33246 declares_class_or_enum,
33250 /* 7.1.1-1 [dcl.stc]
33252 A storage-class-specifier shall not be specified in an explicit
33253 specialization... */
33255 && explicit_specialization_p
33257 {
33261 }
33265 }
33267 /* Look for a trailing `;' after the declaration. */
33273 out:
33276 /* Clear any current qualification; whatever comes next is the start
33277 of something new. */
33285 }
33287 /* Parse a cast-expression that is not the operand of a unary "&". */
33289 static cp_expr
33291 {
33294 }
33296 /* Parse a functional cast to TYPE. Returns an expression
33297 representing the cast. */
33299 static cp_expr
33301 {
33303 tree expression_list;
33304 cp_expr cast;
33312 {
33322 /* Create a location of the form:
33323 type_name{i, f}
33324 ^~~~~~~~~~~~~~~
33325 with caret == start at the start of the type name,
33326 finishing at the closing brace. */
33331 }
33340 else
33341 {
33344 }
33346 /* Create a location of the form:
33347 float(i)
33348 ^~~~~~~~
33349 with caret == start at the start of the type name,
33350 finishing at the closing paren. */
33354 tf_warning_or_error);
33356 /* [expr.const]/1: In an integral constant expression "only type
33357 conversions to integral or enumeration type can be used". */
33363 NIC_CONSTRUCTOR))
33367 }
33369 /* Save the tokens that make up the body of a member function defined
33370 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
33371 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
33372 specifiers applied to the declaration. Returns the FUNCTION_DECL
33373 for the member function. */
33375 static tree
33379 tree attributes)
33380 {
33383 tree fn;
33386 /* Create the FUNCTION_DECL. */
33390 /* If something went badly wrong, bail out now. */
33392 {
33393 /* If there's a function-body, skip it. */
33398 }
33400 /* Remember it, if there are default args to post process. */
33403 /* Save away the tokens that make up the body of the
33404 function. */
33410 RID_TRANSACTION_ATOMIC))
33411 {
33413 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
33420 {
33426 }
33427 else
33430 {
33434 }
33435 }
33437 /* Handle function try blocks. */
33439 {
33442 }
33443 /* We can have braced-init-list mem-initializers before the fn body. */
33445 {
33448 {
33449 /* cache_group will stop after an un-nested { } pair, too. */
33453 /* variadic mem-inits have ... after the ')'. */
33456 }
33457 }
33459 /* Handle function try blocks. */
33465 /* Save away the inline definition; we will process it when the
33466 class is complete. */
33470 /* We need to know that this was defined in the class, so that
33471 friend templates are handled correctly. */
33474 /* Add FN to the queue of functions to be parsed later. */
33478 }
33480 /* Save the tokens that make up the in-class initializer for a non-static
33481 data member. Returns a DEFERRED_PARSE. */
33483 static tree
33485 {
33487 }
33489 /* Parse a template-argument-list, as well as the trailing ">" (but
33490 not the opening "<"). See cp_parser_template_argument_list for the
33491 return value. */
33493 static tree
33495 {
33496 tree arguments;
33497 tree saved_scope;
33498 tree saved_qualifying_scope;
33499 tree saved_object_scope;
33502 /* [temp.names]
33504 When parsing a template-id, the first non-nested `>' is taken as
33505 the end of the template-argument-list rather than a greater-than
33506 operator. */
33507 saved_greater_than_is_operator_p
33510 /* Parsing the argument list may modify SCOPE, so we save it
33511 here. */
33515 /* We need to evaluate the template arguments, even though this
33516 template-id may be nested within a "sizeof". */
33517 cp_evaluated ev;
33518 /* Parse the template-argument-list itself. */
33523 {
33526 }
33527 else
33529 /* Look for the `>' that ends the template-argument-list. If we find
33530 a '>>' instead, it's probably just a typo. */
33532 {
33534 {
33535 /* In C++0x, a `>>' in a template argument list or cast
33536 expression is considered to be two separate `>'
33537 tokens. So, change the current token to a `>', but don't
33538 consume it: it will be consumed later when the outer
33539 template argument list (or cast expression) is parsed.
33540 Note that this replacement of `>' for `>>' is necessary
33541 even if we are parsing tentatively: in the tentative
33542 case, after calling
33543 cp_parser_enclosed_template_argument_list we will always
33544 throw away all of the template arguments and the first
33545 closing `>', either because the template argument list
33546 was erroneous or because we are replacing those tokens
33547 with a CPP_TEMPLATE_ID token. The second `>' (which will
33548 not have been thrown away) is needed either to close an
33549 outer template argument list or to complete a new-style
33550 cast. */
33553 }
33555 {
33556 /* If we're in a nested template argument list, the '>>' has
33557 to be a typo for '> >'. We emit the error message, but we
33558 continue parsing and we push a '>' as next token, so that
33559 the argument list will be parsed correctly. Note that the
33560 global source location is still on the token before the
33561 '>>', so we need to say explicitly where we want it. */
33569 }
33570 else
33571 {
33572 /* If this is not a nested template argument list, the '>>'
33573 is a typo for '>'. Emit an error message and continue.
33574 Same deal about the token location, but here we can get it
33575 right by consuming the '>>' before issuing the diagnostic. */
33578 "spurious %<>>%>, use %<>%> to terminate "
33580 }
33581 }
33582 /* Similarly for >>= and >=. */
33585 {
33591 {
33594 }
33596 {
33599 else
33602 }
33603 else
33604 {
33607 }
33613 }
33614 else
33616 /* The `>' token might be a greater-than operator again now. */
33617 parser->greater_than_is_operator_p
33619 /* Restore the SAVED_SCOPE. */
33625 }
33627 /* MEMBER_FUNCTION is a member function, or a friend. If default
33628 arguments, or the body of the function have not yet been parsed,
33629 parse them now. */
33631 static void
33633 {
33636 /* If this member is a template, get the underlying
33637 FUNCTION_DECL. */
33641 /* There should not be any class definitions in progress at this
33642 point; the bodies of members are only parsed outside of all class
33643 definitions. */
33645 /* While we're parsing the member functions we might encounter more
33646 classes. We want to handle them right away, but we don't want
33647 them getting mixed up with functions that are currently in the
33648 queue. */
33651 /* Make sure that any template parameters are in scope. */
33654 /* If the body of the function has not yet been parsed, parse it
33655 now. Except if the tokens have been purged (PR c++/39751). */
33658 {
33659 tree function_scope;
33662 /* The function is no longer pending; we are processing it. */
33667 /* If this is a local class, enter the scope of the containing
33668 function. */
33673 /* Push the body of the function onto the lexer stack. */
33676 /* Let the front end know that we going to be defining this
33677 function. */
33681 /* #pragma omp declare reduction needs special parsing. */
33683 {
33688 }
33689 else
33690 /* Now, parse the body of the function. */
33694 /* Leave the scope of the containing function. */
33698 }
33700 /* Remove any template parameters from the symbol table. */
33703 /* Restore the queue. */
33705 }
33707 /* If DECL contains any default args, remember it on the unparsed
33708 functions queue. */
33710 static void
33712 {
33713 tree probe;
33716 probe;
33719 {
33723 }
33725 /* Remember if there is a noexcept-specifier to post process. */
33730 /* Contracts are deferred. */
33733 {
33736 }
33737 }
33739 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
33740 which is either a FIELD_DECL or PARM_DECL. Parse it and return
33741 the result. For a PARM_DECL, PARMTYPE is the corresponding type
33742 from the parameter-type-list. */
33744 static tree
33747 {
33749 tree parsed_arg;
33754 /* Push the saved tokens for the default argument onto the parser's
33755 lexer stack. */
33761 /* Parse the default argument. */
33772 {
33773 /* In a non-template class, check conversions now. In a template,
33774 we'll wait and instantiate these as needed. */
33777 tf_warning_or_error);
33780 else
33782 }
33784 /* If the token stream has not been completely used up, then
33785 there was extra junk after the end of the default
33786 argument. */
33788 {
33791 else
33793 }
33795 /* Revert to the main lexer. */
33799 }
33801 /* FIELD is a non-static data member with an initializer which we saved for
33802 later; parse it now. */
33804 static void
33806 {
33807 tree def;
33814 NULL_TREE);
33820 }
33822 /* FN is a FUNCTION_DECL which may contains a parameter with an
33823 unparsed DEFERRED_PARSE. Parse the default args now. This function
33824 assumes that the current scope is the scope in which the default
33825 argument should be processed. */
33827 static void
33829 {
33832 /* While we're parsing the default args, we might (due to the
33833 statement expression extension) encounter more classes. We want
33834 to handle them right away, but we don't want them getting mixed
33835 up with default args that are currently in the queue. */
33838 /* Local variable names (and the `this' keyword) may not appear
33839 in a default argument. */
33847 /* Gather the PARM_DECLs into a vec so we can keep track of them when
33848 pushdecl clears DECL_CHAIN. */
33849 releasing_vec parms;
33859 {
33861 tree parsed_arg;
33870 /* This can happen for a friend declaration for a function
33871 already declared with default arguments. */
33874 parsed_arg
33876 default_arg,
33880 /* Update any instantiations we've already created. */
33883 }
33887 /* Restore DECL_CHAINs after clobbering by pushdecl. */
33890 {
33893 }
33897 /* Make sure no default arg is missing. */
33900 /* Restore the state of local_variables_forbidden_p. */
33903 /* Restore the queue. */
33905 }
33907 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
33909 sizeof ... ( identifier )
33911 where the 'sizeof' token has already been consumed. */
33913 static tree
33915 {
33916 /* Consume the `...'. */
33920 matching_parens parens;
33924 else
33932 /* The name is not qualified. */
33952 }
33954 /* Parse the operand of `sizeof' (or a similar operator). Returns
33955 either a TYPE or an expression, depending on the form of the
33956 input. The KEYWORD indicates which kind of expression we have
33957 encountered. */
33959 static tree
33961 {
33968 /* If it's a `...', then we are computing the length of a parameter
33969 pack. */
33974 /* Types cannot be defined in a `sizeof' expression. Save away the
33975 old message. */
33978 parser->type_definition_forbidden_message
33980 parser->type_definition_forbidden_message_arg
33983 /* The restrictions on constant-expressions do not apply inside
33984 sizeof expressions. */
33985 saved_integral_constant_expression_p
33987 saved_non_integral_constant_expression_p
33994 /* Do not actually evaluate the expression. */
33997 /* If it's a `(', then we might be looking at the type-id
33998 construction. */
34000 {
34005 /* We can't be sure yet whether we're looking at a type-id or an
34006 expression. */
34009 matching_parens parens;
34012 /* Note: as a GNU Extension, compound literals are considered
34013 postfix-expressions as they are in C99, so they are valid
34014 arguments to sizeof. See comment in cp_parser_cast_expression
34015 for details. */
34018 else
34019 {
34022 /* Look for the type-id. */
34024 /* Look for the closing `)'. */
34027 }
34029 /* If all went well, then we're done. */
34032 else
34033 {
34034 /* Commit to the tentative_firewall so we get syntax errors. */
34038 }
34039 }
34040 else
34043 /* Go back to evaluating expressions. */
34047 /* And restore the old one. */
34050 parser->integral_constant_expression_p
34052 parser->non_integral_constant_expression_p
34056 }
34058 /* If the current declaration has no declarator, return true. */
34060 static bool
34062 {
34063 /* If the next token is a `;' or a `,' then there is no
34064 declarator. */
34067 }
34069 /* Update the DECL_SPECS to reflect the storage class indicated by
34070 KEYWORD. */
34072 static void
34077 {
34078 cp_storage_class storage_class;
34081 {
34099 }
34102 {
34106 }
34108 {
34115 else
34122 }
34127 {
34130 }
34135 /* A storage class specifier cannot be applied alongside a typedef
34136 specifier. If there is a typedef specifier present then set
34137 conflicting_specifiers_p which will trigger an error later
34138 on in grokdeclarator. */
34141 {
34148 }
34149 }
34151 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
34152 is true, the type is a class or enum definition. */
34154 static void
34156 tree type_spec,
34159 {
34162 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
34163 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
34164 this is what happened. In system headers, we ignore these
34165 declarations so that G++ can work with system headers that are not
34166 C++-safe. */
34168 && !type_definition_p
34181 {
34184 ds_redefined_builtin_type_spec,
34185 token);
34187 {
34191 }
34192 }
34195 else
34196 {
34201 }
34202 }
34204 /* True iff TOKEN is the GNU keyword __thread. */
34206 static bool
34208 {
34211 }
34213 /* Set the location for a declarator specifier and check if it is
34214 duplicated.
34216 DECL_SPECS is the sequence of declarator specifiers onto which to
34217 set the location.
34219 DS is the single declarator specifier to set which location is to
34220 be set onto the existing sequence of declarators.
34222 LOCATION is the location for the declarator specifier to
34223 consider. */
34225 static void
34228 {
34237 {
34241 }
34242 else
34243 {
34245 {
34249 else
34250 {
34253 OPT_Wlong_long,
34255 }
34256 }
34258 {
34262 {
34266 }
34267 else
34268 {
34271 }
34272 }
34273 else
34274 {
34275 /* These correspond to cp-tree.h:cp_decl_spec,
34276 changes here should also be reflected there. */
34295 "this"
34296 };
34300 }
34301 }
34302 }
34304 /* Return true iff the declarator specifier DS is present in the
34305 sequence of declarator specifiers DECL_SPECS. */
34307 bool
34309 cp_decl_spec ds)
34310 {
34317 }
34319 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
34320 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
34322 static bool
34324 {
34326 }
34328 /* Issue an error message indicating that TOKEN_DESC was expected.
34329 If KEYWORD is true, it indicated this function is called by
34330 cp_parser_require_keword and the required token can only be
34331 a indicated keyword.
34333 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34334 within any error as the location of an "opening" token matching
34335 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34336 RT_CLOSE_PAREN). */
34338 static void
34340 required_token token_desc,
34342 location_t matching_location)
34343 {
34349 {
34424 }
34427 {
34429 {
34507 }
34508 }
34512 }
34515 /* If the next token is of the indicated TYPE, consume it. Otherwise,
34516 issue an error message indicating that TOKEN_DESC was expected.
34518 Returns the token consumed, if the token had the appropriate type.
34519 Otherwise, returns NULL.
34521 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34522 within any error as the location of an "opening" token matching
34523 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34524 RT_CLOSE_PAREN). */
34529 required_token token_desc,
34530 location_t matching_location)
34531 {
34534 else
34535 {
34536 /* Output the MESSAGE -- unless we're parsing tentatively. */
34539 matching_location);
34541 }
34542 }
34544 /* Skip an entire parameter list from start to finish. The next token must
34545 be the initial "<" of the parameter list. Returns true on success and
34546 false otherwise. */
34548 static bool
34550 {
34551 /* Consume the "<" because cp_parser_skip_to_end_of_template_parameter_list
34552 requires it. */
34555 }
34557 /* Ensure we are at the end of a template parameter list. If we are, return.
34558 If we are not, something has gone wrong, in which case issue an error and
34559 skip to end of the parameter list. */
34561 static void
34563 {
34564 /* Are we ready, yet? If not, issue error message. */
34569 }
34571 /* You should only call this function from inside a template parameter list
34572 (i.e. the current token should at least be the initial "<" of the
34573 parameter list). If you are skipping the entire list, it may be better to
34574 use cp_parser_skip_entire_template_parameter_list.
34576 Tokens are skipped until the final ">" is found, or if we see
34577 '{', '}', ';', or if we find an unbalanced ')' or ']'.
34579 Returns true if we successfully reached the end, and false if
34580 something unexpected happened (e.g. end of file). */
34582 static bool
34584 {
34585 /* Current level of '< ... >'. */
34587 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
34590 /* Skip tokens until the desired token is found. */
34592 {
34593 /* Peek at the next token. */
34595 {
34603 /* C++0x views the `>>' operator as two `>' tokens, but
34604 C++98 does not. */
34607 {
34608 /* We've hit a `>>' where the first `>' closes the
34609 template argument list, and the second `>' is
34610 spurious. Just consume the `>>' and stop; we've
34611 already produced at least one error. */
34614 }
34615 /* Fall through for C++0x, so we handle the second `>' in
34616 the `>>'. */
34621 {
34622 /* We've reached the token we want, consume it and stop. */
34625 }
34644 /* The '>' was probably forgotten, don't look further. */
34649 }
34651 /* Consume this token. */
34653 }
34654 }
34656 /* If the next token is the indicated keyword, consume it. Otherwise,
34657 issue an error message indicating that TOKEN_DESC was expected.
34659 Returns the token consumed, if the token had the appropriate type.
34660 Otherwise, returns NULL. */
34665 required_token token_desc)
34666 {
34670 {
34672 UNKNOWN_LOCATION);
34674 }
34677 }
34679 /* Returns TRUE iff TOKEN is a token that can begin the body of a
34680 function-definition. */
34682 static bool
34684 {
34687 /* A ctor-initializer begins with a `:'. */
34689 /* A function-try-block begins with `try'. */
34691 /* A function-transaction-block begins with `__transaction_atomic'
34692 or `__transaction_relaxed'. */
34695 /* The named return value extension begins with `return'. */
34697 }
34699 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
34700 definition. */
34702 static bool
34704 {
34711 }
34713 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
34714 C++0x) ending a template-argument. */
34716 static bool
34718 {
34726 /* For better diagnostics, treat >>= like that too, that
34727 shouldn't appear non-nested in template arguments. */
34729 }
34731 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
34732 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
34734 static bool
34737 {
34743 /* Check for the sequence `<::' in the original code. It would be lexed as
34744 `[:', where `[' is a digraph, and there is no whitespace before
34745 `:'. */
34747 {
34752 }
34754 }
34756 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
34757 or none_type otherwise. */
34759 static enum tag_types
34761 {
34763 {
34773 }
34774 }
34776 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
34777 or none_type otherwise or if the token is null. */
34779 static enum tag_types
34781 {
34786 {
34794 }
34795 }
34797 /* Diagnose redundant enum-keys. */
34799 static void
34802 {
34808 /* Look up the NAME to see if it unambiguously refers to the TYPE. */
34813 /* The enum-key is redundant for uses of the TYPE that are not
34814 declarations and for which name lookup returns just the type
34815 itself. */
34823 {
34824 /* Avoid issuing the diagnostic for apparently redundant (unscoped)
34825 enum tag in shared C/C++ code in files (such as headers) included
34826 in the main source file. */
34829 LRK_MACRO_DEFINITION_LOCATION,
34833 }
34841 }
34843 /* Describes the set of declarations of a struct, class, or class template
34844 or its specializations. Used for -Wmismatched-tags. */
34846 class class_decl_loc_t
34847 {
34852 {
34854 }
34856 /* Constructs an object for a single declaration of a class with
34857 CLASS_KEY at the current location in the current function (or
34858 at another scope). KEY_REDUNDANT is true if the class-key may
34859 be omitted in the current context without an ambiguity with
34860 another symbol with the same name.
34861 DEF_P is true for a class declaration that is a definition.
34862 CURLOC is the associated location. */
34866 {
34869 key_redundant);
34871 }
34873 /* Copy, assign, and destroy the object. Necessary because LOCVEC
34874 isn't safely copyable and assignable and doesn't release storage
34875 on its own. */
34879 { }
34882 {
34890 }
34893 {
34895 }
34897 /* Issues -Wmismatched-tags for a single class. */
34900 /* Issues -Wmismatched-tags for all classes. */
34903 /* Adds TYPE_DECL to the collection of class decls and diagnoses
34904 redundant tags (if -Wredundant-tags is enabled). */
34907 /* Either adds this decl to the collection of class decls
34908 or diagnoses it, whichever is appropriate. */
34914 {
34916 }
34919 {
34921 }
34924 {
34926 }
34929 {
34931 }
34933 /* True if a definition for the class has been seen. */
34935 {
34937 }
34939 /* The location of a single mention of a class type with the given
34940 class-key. */
34941 struct class_key_loc_t
34942 {
34945 { }
34947 /* The function the type is mentioned in. */
34948 tree func;
34949 /* The exact location. */
34950 location_t loc;
34951 /* The class-key used in the mention of the type. */
34952 tag_types class_key;
34953 /* True when the class-key could be omitted at this location
34954 without an ambiguity with another symbol of the same name. */
34956 };
34957 /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
34959 /* LOCVEC index of the definition or UINT_MAX if none exists. */
34961 /* The class-key the class was last declared with or none_type when
34962 it has been declared with a mismatched key. */
34963 tag_types def_class_key;
34965 /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
34966 description above. */
34969 };
34973 /* Issue an error message if the CLASS_KEY does not match the TYPE.
34974 DEF_P is expected to be set for a definition of class TYPE. DECL_P
34975 is set for a declaration of class TYPE and clear for a reference to
34976 it that is not a declaration of it. */
34978 static void
34982 {
34988 {
34992 type))
34996 }
35001 /* Only consider the true class-keys below and ignore typename_type,
35002 etc. that are not C++ class-keys. */
35009 }
35011 /* Returns the template or specialization of one to which the RECORD_TYPE
35012 TYPE corresponds. */
35014 static tree
35016 {
35019 /* Determine the template or its partial specialization to which TYPE
35020 corresponds. */
35029 }
35032 /* Adds the class TYPE to the collection of class decls and diagnoses
35033 redundant tags (if -Wredundant-tags is enabled).
35034 DEF_P is expected to be set for a definition of class TYPE. DECL_P
35035 is set for a (likely, based on syntactic context) declaration of class
35036 TYPE and clear for a reference to it that is not a declaration of it. */
35038 void
35041 {
35044 /* Look up the NAME to see if it unambiguously refers to the TYPE
35045 and set KEY_REDUNDANT if so. */
35050 /* The class-key is redundant for uses of the CLASS_TYPE that are
35051 neither definitions of it nor declarations, and for which name
35052 lookup returns just the type itself. */
35063 {
35064 /* Avoid issuing the diagnostic for apparently redundant struct
35065 and union class-keys in shared C/C++ code in files (such as
35066 headers) included in the main source file. */
35069 LRK_MACRO_DEFINITION_LOCATION,
35073 }
35075 /* Set if a declaration of TYPE has previously been seen or if it must
35076 exist in a precompiled header. */
35080 {
35083 {
35084 /* TYPE_DECL is the first declaration or definition of the type
35085 (outside precompiled headers -- see below). Just create
35086 a new entry for it and return unless it's a declaration
35087 involving a template that may need to be diagnosed by
35088 -Wredundant-tags. */
35092 }
35093 else
35094 {
35095 /* TYPE was previously defined in some unknown precompiled header.
35096 Simply add a record of its definition at an unknown location and
35097 proceed below to add a reference to it at the current location.
35098 (Declarations in precompiled headers that are not definitions
35099 are ignored.) */
35100 tag_types def_key
35105 }
35106 }
35108 /* A prior declaration of TYPE_DECL has been seen. */
35111 {
35118 type);
35119 }
35122 /* Do nothing if this is the first declaration of the type. */
35126 /* Do nothing if the class-key in this declaration matches
35127 the definition. */
35131 def_p);
35132 }
35134 /* Either adds this DECL corresponding to the TYPE_DECL to the collection
35135 of class decls or diagnoses it, whichever is appropriate. */
35137 void
35139 tag_types class_key,
35142 {
35143 /* Reset the CLASS_KEY associated with this type on mismatch.
35144 This is an optimization that lets the diagnostic code skip
35145 over classes that use the same class-key in all declarations. */
35149 /* Set IDXDEF to the index of the vector corresponding to
35150 the definition. */
35154 /* Append a record of this declaration to the vector. */
35156 redundant);
35162 /* As a space optimization diagnose declarations of a class
35163 whose definition has been seen and purge the LOCVEC of
35164 all entries except the definition. */
35167 {
35173 }
35174 else
35175 /* Pop the entry pushed above for this declaration. */
35177 }
35179 /* Issues -Wmismatched-tags for a single class. */
35181 void
35183 {
35187 /* Number of uses of the class. */
35190 /* The class (or template) declaration guiding the decisions about
35191 the diagnostic. For ordinary classes it's the same as THIS. For
35192 uses of instantiations of templates other than their declarations
35193 it points to the record for the declaration of the corresponding
35194 primary template or partial specialization. */
35199 {
35200 /* For implicit instantiations of a primary template look up
35201 the primary or partial specialization and use it as
35202 the expected class-key rather than using the class-key of
35203 the first reference to the instantiation. The primary must
35204 be (and inevitably is) at index zero. */
35207 /* It's possible that we didn't find SPEC. Consider:
35209 template<typename T> struct A {
35210 template<typename U> struct W { };
35211 };
35212 struct A<int>::W<int> w; // #1
35214 where while parsing A and #1 we've stashed
35215 A<T>
35216 A<T>::W<U>
35217 A<int>::W<int>
35218 into CLASS2LOC. If TYPE is A<int>::W<int>, specialization_of
35219 will yield A<int>::W<U> which may be in CLASS2LOC if we had
35220 an A<int> class specialization, but otherwise won't be in it.
35221 So try to look up A<T>::W<U>. */
35223 {
35226 }
35227 /* Now we really should have found something. */
35229 }
35230 /* Skip declarations that consistently use the same class-key. */
35234 /* Set if a definition for the class has been seen. */
35237 /* The index of the declaration whose class-key this declaration
35238 is expected to match. It's either the class-key of the class
35239 definition if one exists or the first declaration otherwise. */
35242 /* The class-key the class is expected to be declared with: it's
35243 either the key used in its definition or the first declaration
35244 if no definition has been provided.
35245 For implicit instantiations of a primary template it's
35246 the class-key used to declare the primary with. The primary
35247 must be at index zero. */
35251 /* Advance IDX to the first declaration that either is not
35252 a definition or that doesn't match the first declaration
35253 if no definition is provided. */
35258 /* Save the current function before changing it below. */
35260 /* Set the function declaration to print in diagnostic context. */
35268 auto_diagnostic_group d;
35269 /* Issue a warning for the first mismatched declaration.
35270 Avoid using "%#qT" since the class-key for the same type will
35271 be the same regardless of which one was used in the declaraion. */
35275 {
35276 /* Suggest how to avoid the warning for each instance since
35277 the guidance may be different depending on context. */
35279 (key_redundant_p
35282 xpectkstr);
35284 /* Also point to the first declaration or definition that guided
35285 the decision to issue the warning above. */
35287 (def_p
35291 }
35293 /* Issue warnings for the remaining inconsistent declarations. */
35295 {
35297 /* Skip over the declarations that match either the definition
35298 if one was provided or the first declaration. */
35304 /* Set the function declaration to print in diagnostic context. */
35309 /* Suggest how to avoid the warning for each instance since
35310 the guidance may be different depending on context. */
35312 (key_redundant_p
35315 xpectkstr);
35316 }
35318 /* Restore the current function in case it was replaced above. */
35320 }
35322 /* Issues -Wmismatched-tags for all classes. Called at the end
35323 of processing a translation unit, after declarations of all class
35324 types and their uses have been recorded. */
35326 void
35328 {
35329 /* CLASS2LOC should be empty if both -Wmismatched-tags and
35330 -Wredundant-tags are disabled. */
35332 || warn_redundant_tags
35335 /* Save the current function before changing on return. It should
35336 be null at this point. */
35340 {
35341 /* Iterate over the collected class/struct/template declarations. */
35344 {
35348 }
35349 }
35352 }
35354 /* Issue an error message if DECL is redeclared with different
35355 access than its original declaration [class.access.spec/3].
35356 This applies to nested classes, nested class templates and
35357 enumerations [class.mem/1]. */
35359 static void
35361 {
35373 }
35375 /* Look for the `template' keyword, as a syntactic disambiguator.
35376 Return TRUE iff it is present, in which case it will be
35377 consumed. */
35379 static bool
35381 {
35383 {
35384 /* In C++98 the `template' keyword can only be used within templates;
35385 outside templates the parser can always figure out what is a
35386 template and what is not. In C++11, per the resolution of DR 468,
35387 `template' is allowed in cases where it is not strictly necessary. */
35390 {
35393 "in C++98 %<template%> (as a disambiguator) is only "
35395 /* If this part of the token stream is rescanned, the same
35396 error message would be generated. So, we purge the token
35397 from the stream. */
35400 }
35401 else
35402 {
35403 /* Consume the `template' keyword. */
35406 }
35407 }
35409 }
35411 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
35412 set PARSER->SCOPE, and perform other related actions. */
35414 static void
35416 {
35419 /* Get the stored value. */
35421 /* Set the scope from the stored value. */
35426 }
35428 /* Consume tokens up through a non-nested END token. Returns TRUE if we
35429 encounter the end of a block before what we were looking for. */
35431 static bool
35435 {
35437 {
35440 /* Abort a parenthesized expression if we encounter a semicolon. */
35444 /* If we've reached the end of the file, stop. */
35450 /* We've hit the end of an enclosing block, so there's been some
35451 kind of syntax error. */
35454 /* Consume the token. */
35456 /* See if it starts a new group. */
35458 {
35460 /* In theory this should probably check end == '}', but
35461 cp_parser_save_member_function_body needs it to exit
35462 after either '}' or ')' when called with ')'. */
35465 }
35467 {
35471 }
35476 }
35477 }
35479 /* Like above, for caching a default argument or NSDMI. Both of these are
35480 terminated by a non-nested comma, but it can be unclear whether or not a
35481 comma is nested in a template argument list unless we do more parsing.
35482 In order to handle this ambiguity, when we encounter a ',' after a '<'
35483 we try to parse what follows as a parameter-declaration-list (in the
35484 case of a default argument) or a member-declarator (in the case of an
35485 NSDMI). If that succeeds, then we stop caching. */
35487 static tree
35489 {
35494 tree default_argument;
35496 /* Add tokens until we have processed the entire default
35497 argument. We add the range [first_token, token). */
35500 {
35501 /* For list-initialization, this is straightforward. */
35504 }
35506 {
35509 /* Peek at the next token. */
35511 /* What we do depends on what token we have. */
35513 {
35514 /* In valid code, a default argument must be
35515 immediately followed by a `,' `)', or `...'. */
35518 {
35519 /* If we've seen a '<', we might be in a
35520 template-argument-list. Until Core issue 325 is
35521 resolved, we don't know how this situation ought
35522 to be handled, so try to DTRT. We check whether
35523 what comes after the comma is a valid parameter
35524 declaration list. If it is, then the comma ends
35525 the default argument; otherwise the default
35526 argument continues. */
35530 /* Set ITALP so cp_parser_parameter_declaration_list
35531 doesn't decide to commit to this parse. */
35538 {
35539 /* Parse declarators until we reach a non-comma or
35540 somthing that cannot be an initializer.
35541 Just checking whether we're looking at a single
35542 declarator is insufficient. Consider:
35543 int var = tuple<T,U>::x;
35544 The template parameter 'U' looks exactly like a
35545 declarator. */
35546 do
35547 {
35551 CP_PARSER_FLAGS_NONE,
35560 }
35562 /* If we met an '=' or ';' then the original comma
35563 was the end of the NSDMI. Otherwise assume
35564 we're still in the NSDMI. */
35567 }
35568 else
35569 {
35572 tree t = cp_parser_parameter_declaration_list
35578 }
35585 }
35586 /* FALLTHRU */
35589 /* If we run into a non-nested `;', `}', or `]',
35590 then the code is invalid -- but the default
35591 argument is certainly over. */
35596 /* Handle correctly int n = sizeof ... ( p ); */
35599 /* Update DEPTH, if necessary. */
35614 /* This might be the comparison operator, or it might
35615 start a template argument list. */
35622 /* Fall through for C++0x, which treats the `>>'
35623 operator like two `>' tokens in certain
35624 cases. */
35629 {
35630 /* This might be an operator, or it might close a
35631 template argument list. But if a previous '<'
35632 started a template argument list, this will have
35633 closed it, so we can't be in one anymore. */
35637 }
35640 /* If we run out of tokens, issue an error message. */
35648 /* In these cases, we should look for template-ids.
35649 For example, if the default argument is
35650 `X<int, double>()', we need to do name lookup to
35651 figure out whether or not `X' is a template; if
35652 so, the `,' does not end the default argument.
35654 That is not yet done. */
35659 }
35661 /* If we've reached the end, stop. */
35665 /* Add the token to the token block. */
35667 }
35669 /* Create a DEFERRED_PARSE to represent the unparsed default
35670 argument. */
35677 }
35679 /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
35681 location_t
35683 {
35688 }
35690 /* Begin parsing tentatively. We always save tokens while parsing
35691 tentatively so that if the tentative parsing fails we can restore the
35692 tokens. */
35694 static void
35696 {
35697 /* Enter a new parsing context. */
35699 /* Begin saving tokens. */
35701 /* In order to avoid repetitive access control error messages,
35702 access checks are queued up until we are no longer parsing
35703 tentatively. */
35705 }
35707 /* Commit to the currently active tentative parse. */
35709 static void
35711 {
35715 /* Mark all of the levels as committed. */
35718 {
35725 }
35726 }
35728 /* Commit to the topmost currently active tentative parse.
35730 Note that this function shouldn't be called when there are
35731 irreversible side-effects while in a tentative state. For
35732 example, we shouldn't create a permanent entry in the symbol
35733 table, or issue an error message that might not apply if the
35734 tentative parse is aborted. */
35736 static void
35738 {
35743 {
35751 }
35752 }
35754 /* Abort the currently active tentative parse. All consumed tokens
35755 will be rolled back, and no diagnostics will be issued. */
35757 static void
35759 {
35763 /* Now, pretend that we want to see if the construct was
35764 successfully parsed. */
35766 }
35768 /* Stop parsing tentatively. If a parse error has occurred, restore the
35769 token stream. Otherwise, commit to the tokens we have consumed.
35770 Returns true if no error occurred; false otherwise. */
35772 static bool
35774 {
35778 /* Remember whether or not an error occurred, since we are about to
35779 destroy that information. */
35781 /* Remove the topmost context from the stack. */
35784 /* If no parse errors occurred, commit to the tentative parse. */
35786 {
35787 /* Commit to the tokens read tentatively, unless that was
35788 already done. */
35793 }
35794 /* Otherwise, if errors occurred, roll back our state so that things
35795 are just as they were before we began the tentative parse. */
35796 else
35797 {
35800 }
35801 /* Add the context to the front of the free list. */
35806 }
35808 /* Returns true if we are parsing tentatively and are not committed to
35809 this tentative parse. */
35811 static bool
35813 {
35816 }
35818 /* Returns nonzero iff an error has occurred during the most recent
35819 tentative parse. */
35821 static bool
35823 {
35826 }
35828 /* Returns nonzero if GNU extensions are allowed. */
35830 static bool
35832 {
35834 }
35835 \f
35836 /* Objective-C++ Productions */
35839 /* Parse an Objective-C expression, which feeds into a primary-expression
35840 above.
35842 objc-expression:
35843 objc-message-expression
35844 objc-string-literal
35845 objc-encode-expression
35846 objc-protocol-expression
35847 objc-selector-expression
35849 Returns a tree representation of the expression. */
35851 static cp_expr
35853 {
35854 /* Try to figure out what kind of declaration is present. */
35858 {
35868 {
35880 }
35881 /* FALLTHRU */
35887 }
35890 }
35892 /* Parse an Objective-C message expression.
35894 objc-message-expression:
35895 [ objc-message-receiver objc-message-args ]
35897 Returns a representation of an Objective-C message. */
35899 static tree
35901 {
35914 /* Construct a location e.g.
35915 [self func1:5]
35916 ^~~~~~~~~~~~~~
35917 ranging from the '[' to the ']', with the caret at the start. */
35923 }
35925 /* Parse an objc-message-receiver.
35927 objc-message-receiver:
35928 expression
35929 simple-type-specifier
35931 Returns a representation of the type or expression. */
35933 static tree
35935 {
35936 tree rcv;
35938 /* An Objective-C message receiver may be either (1) a type
35939 or (2) an expression. */
35943 /* If that worked out, fine. */
35950 CP_PARSER_FLAGS_NONE);
35957 }
35959 /* Parse the arguments and selectors comprising an Objective-C message.
35961 objc-message-args:
35962 objc-selector
35963 objc-selector-args
35964 objc-selector-args , objc-comma-args
35966 objc-selector-args:
35967 objc-selector [opt] : assignment-expression
35968 objc-selector-args objc-selector [opt] : assignment-expression
35970 objc-comma-args:
35971 assignment-expression
35972 objc-comma-args , assignment-expression
35974 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
35975 selector arguments and TREE_VALUE containing a list of comma
35976 arguments. */
35978 static tree
35980 {
35986 {
35992 /* Detect if we have a unary selector. */
36001 sel_args
36006 }
36008 /* Handle non-selector arguments, if any. */
36010 {
36011 tree arg;
36016 addl_args
36021 }
36024 {
36027 }
36030 }
36032 /* Parse an Objective-C encode expression.
36034 objc-encode-expression:
36035 @encode objc-typename
36037 Returns an encoded representation of the type argument. */
36039 static cp_expr
36041 {
36042 tree type;
36047 matching_parens parens;
36054 {
36058 }
36060 /* This happens if we find @encode(T) (where T is a template
36061 typename or something dependent on a template typename) when
36062 parsing a template. In that case, we can't compile it
36063 immediately, but we rather create an AT_ENCODE_EXPR which will
36064 need to be instantiated when the template is used.
36065 */
36067 {
36071 }
36074 /* Build a location of the form:
36075 @encode(int)
36076 ^~~~~~~~~~~~
36077 with caret==start at the @ token, finishing at the close paren. */
36081 }
36083 /* Parse an Objective-C @defs expression. */
36085 static tree
36087 {
36088 tree name;
36091 matching_parens parens;
36097 }
36099 /* Parse an Objective-C protocol expression.
36101 objc-protocol-expression:
36102 @protocol ( identifier )
36104 Returns a representation of the protocol expression. */
36106 static tree
36108 {
36109 tree proto;
36113 matching_parens parens;
36118 /* Build a location of the form:
36119 @protocol(prot)
36120 ^~~~~~~~~~~~~~~
36121 with caret==start at the @ token, finishing at the close paren. */
36126 }
36128 /* Parse an Objective-C selector expression.
36130 objc-selector-expression:
36131 @selector ( objc-method-signature )
36133 objc-method-signature:
36134 objc-selector
36135 objc-selector-seq
36137 objc-selector-seq:
36138 objc-selector :
36139 objc-selector-seq objc-selector :
36141 Returns a representation of the method selector. */
36143 static tree
36145 {
36152 matching_parens parens;
36158 {
36167 {
36168 /* Detect if we have a unary selector. */
36170 {
36173 }
36174 else
36175 {
36177 }
36178 }
36183 {
36184 sel_seq
36187 sel_seq
36190 }
36191 else
36192 sel_seq
36197 }
36199 finish_selector:
36203 /* Build a location of the form:
36204 @selector(func)
36205 ^~~~~~~~~~~~~~~
36206 with caret==start at the @ token, finishing at the close paren. */
36209 /* TODO: objc_build_selector_expr doesn't always honor the location. */
36212 }
36214 /* Parse a list of identifiers.
36216 objc-identifier-list:
36217 identifier
36218 objc-identifier-list , identifier
36220 Returns a TREE_LIST of identifier nodes. */
36222 static tree
36224 {
36225 tree identifier;
36226 tree list;
36237 {
36244 identifier));
36246 }
36249 }
36251 /* Parse an Objective-C alias declaration.
36253 objc-alias-declaration:
36254 @compatibility_alias identifier identifier ;
36256 This function registers the alias mapping with the Objective-C front end.
36257 It returns nothing. */
36259 static void
36261 {
36269 }
36271 /* Parse an Objective-C class forward-declaration.
36273 objc-class-declaration:
36274 @class objc-identifier-list ;
36276 The function registers the forward declarations with the Objective-C
36277 front end. It returns nothing. */
36279 static void
36281 {
36284 {
36285 tree id;
36295 else
36297 }
36299 }
36301 /* Parse a list of Objective-C protocol references.
36303 objc-protocol-refs-opt:
36304 objc-protocol-refs [opt]
36306 objc-protocol-refs:
36307 < objc-identifier-list >
36309 Returns a TREE_LIST of identifiers, if any. */
36311 static tree
36313 {
36317 {
36321 }
36324 }
36326 /* Parse a Objective-C visibility specification. */
36328 static void
36330 {
36334 {
36349 }
36351 /* Eat '@private'/'@protected'/'@public'. */
36353 }
36355 /* Parse an Objective-C method type. Return 'true' if it is a class
36356 (+) method, and 'false' if it is an instance (-) method. */
36360 {
36363 else
36365 }
36367 /* Parse an Objective-C protocol qualifier. */
36369 static tree
36371 {
36384 {
36389 }
36392 }
36394 /* Parse an Objective-C typename. */
36396 static tree
36398 {
36402 {
36405 matching_parens parens;
36409 /* An ObjC type name may consist of just protocol qualifiers, in which
36410 case the type shall default to 'id'. */
36412 {
36415 /* If the type could not be parsed, an error has already
36416 been produced. For error recovery, behave as if it had
36417 not been specified, which will use the default type
36418 'id'. */
36420 {
36422 /* We need to skip to the closing parenthesis as
36423 cp_parser_type_id() does not seem to do it for
36424 us. */
36429 }
36430 }
36434 }
36437 }
36439 /* Check to see if TYPE refers to an Objective-C selector name. */
36441 static bool
36443 {
36449 }
36451 /* Parse an Objective-C selector. */
36453 static tree
36455 {
36459 {
36462 }
36464 /* C++ operator names are allowed to appear in ObjC selectors. */
36466 {
36479 }
36480 }
36482 /* Parse an Objective-C params list. */
36484 static tree
36486 {
36492 {
36502 /* Detect if we have a unary selector. */
36505 {
36508 }
36512 {
36513 /* Something went quite wrong. There should be a colon
36514 here, but there is not. Stop parsing parameters. */
36516 }
36518 /* New ObjC allows attributes on parameters too. */
36523 params
36526 type_name,
36527 identifier,
36528 parm_attr));
36531 }
36534 {
36537 }
36539 /* We allow tail attributes for the method. */
36541 {
36549 }
36552 {
36555 }
36557 }
36559 /* Parse the non-keyword Objective-C params. */
36561 static tree
36564 {
36570 {
36572 tree parm;
36578 {
36583 }
36585 /* TODO: parse attributes for tail parameters. */
36595 }
36597 /* We allow tail attributes for the method. */
36599 {
36601 {
36606 }
36607 else
36608 /* We have an error, but parse the attributes, so that we can
36609 carry on. */
36615 }
36618 }
36620 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
36622 static void
36624 {
36627 /* If the next token is `extern' and the following token is a string
36628 literal, then we have a linkage specification. */
36630 && cp_parser_is_pure_string_literal
36633 /* Handle #pragma, if any. */
36636 /* Allow stray semicolons. */
36639 /* Mark methods as optional or required, when building protocols. */
36641 {
36644 }
36646 {
36649 }
36652 /* Other stray characters must generate errors. */
36654 {
36658 }
36659 /* Finally, try to parse a block-declaration, or a function-definition. */
36660 else
36662 }
36664 /* Parse a method signature. */
36666 static tree
36668 {
36684 }
36686 static bool
36688 {
36689 tree tattr;
36694 /* If the attributes are followed by a method introducer, this is not allowed.
36695 Dump the attributes and flag the situation. */
36700 /* Otherwise, the attributes introduce some interstitial code, possibly so
36701 rewind to allow that check. */
36704 }
36706 /* Parse an Objective-C method prototype list. */
36708 static void
36710 {
36714 {
36716 {
36721 else
36725 {
36729 }
36732 }
36738 OPT_Wattributes,
36740 else
36741 /* Allow for interspersed non-ObjC++ code. */
36745 }
36749 else
36753 }
36755 /* Parse an Objective-C method definition list. */
36757 static void
36759 {
36761 {
36765 {
36768 }
36770 {
36773 }
36775 {
36779 tree attribute;
36783 else
36784 {
36788 /* For historical reasons, we accept an optional semicolon. */
36794 tree meth
36798 }
36799 }
36800 /* The following case will be removed once @synthesize is
36801 completely implemented. */
36812 else
36813 /* Allow for interspersed non-ObjC++ code. */
36815 }
36818 }
36820 /* Parse Objective-C ivars. */
36822 static void
36824 {
36835 {
36836 cp_decl_specifier_seq declspecs;
36838 tree prefix_attributes;
36846 CP_PARSER_FLAGS_OPTIONAL,
36850 /* auto, register, static, extern, mutable. */
36852 {
36855 }
36857 /* thread_local. */
36859 {
36862 }
36864 /* typedef. */
36866 {
36869 }
36874 /* Keep going until we hit the `;' at the end of the
36875 declaration. */
36877 {
36882 /* Check for a (possibly unnamed) bitfield declaration. */
36890 {
36891 /* Get the name of the bitfield. */
36896 eat_colon:
36898 /* Get the width of the bitfield. */
36899 width
36901 }
36902 else
36903 {
36904 /* Parse the declarator. */
36905 declarator
36907 CP_PARSER_FLAGS_NONE,
36913 }
36915 /* Look for attributes that apply to the ivar. */
36917 /* Remember which attributes are prefix attributes and
36918 which are not. */
36920 /* Combine the attributes. */
36924 /* Create the bitfield declaration. */
36927 else
36932 /* Add the instance variable. */
36936 /* Reset PREFIX_ATTRIBUTES. */
36938 {
36943 }
36948 {
36951 }
36953 }
36957 }
36962 /* Do not consume the RID_AT_END, so it will be read again as terminating
36963 the @interface of @implementation. */
36967 /* For historical reasons, we accept an optional semicolon. */
36970 }
36972 /* Parse an Objective-C protocol declaration. */
36974 static void
36976 {
36982 {
36987 }
36989 /* See if we have a forward declaration or a definition. */
36992 /* Try a forward declaration first. */
36994 {
36996 {
36997 tree id;
37007 else
37009 }
37011 }
37013 /* Ok, we got a full-fledged definition (or at least should). */
37014 else
37015 {
37020 }
37021 }
37023 /* Parse an Objective-C superclass or category. */
37025 static void
37030 {
37036 {
37039 }
37041 {
37042 matching_parens parens;
37045 /* If there is no category name, and this is an @interface, we
37046 have a class extension. */
37048 {
37051 }
37052 else
37056 }
37057 }
37059 /* Parse an Objective-C class interface. */
37061 static void
37063 {
37071 {
37072 /* It's hard to recover because even if valid @interface stuff
37073 is to follow, we can't compile it (or validate it) if we
37074 don't even know which class it refers to. Let's assume this
37075 was a stray '@interface' token in the stream and skip it.
37076 */
37078 }
37083 /* We have either a class or a category on our hands. */
37086 else
37087 {
37089 /* Handle instance variable declarations, if any. */
37092 }
37095 }
37097 /* Parse an Objective-C class implementation. */
37099 static void
37101 {
37108 {
37109 /* It's hard to recover because even if valid @implementation
37110 stuff is to follow, we can't compile it (or validate it) if
37111 we don't even know which class it refers to. Let's assume
37112 this was a stray '@implementation' token in the stream and
37113 skip it.
37114 */
37116 }
37120 /* We have either a class or a category on our hands. */
37123 else
37124 {
37126 /* Handle instance variable declarations, if any. */
37129 }
37132 }
37134 /* Consume the @end token and finish off the implementation. */
37136 static void
37138 {
37141 }
37143 /* Parse an Objective-C declaration. */
37145 static void
37147 {
37148 /* Try to figure out what kind of declaration is present. */
37153 {
37169 }
37172 {
37195 }
37196 }
37198 /* Parse an Objective-C try-catch-finally statement.
37200 objc-try-catch-finally-stmt:
37201 @try compound-statement objc-catch-clause-seq [opt]
37202 objc-finally-clause [opt]
37204 objc-catch-clause-seq:
37205 objc-catch-clause objc-catch-clause-seq [opt]
37207 objc-catch-clause:
37208 @catch ( objc-exception-declaration ) compound-statement
37210 objc-finally-clause:
37211 @finally compound-statement
37213 objc-exception-declaration:
37214 parameter-declaration
37215 '...'
37217 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
37219 Returns NULL_TREE.
37221 PS: This function is identical to c_parser_objc_try_catch_finally_statement
37222 for C. Keep them in sync. */
37224 static tree
37226 {
37227 location_t location;
37228 tree stmt;
37233 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
37234 node, lest it get absorbed into the surrounding block. */
37240 {
37244 matching_parens parens;
37250 {
37251 /* We have "@catch (...)" (where the '...' are literally
37252 what is in the code). Skip the '...'.
37253 parameter_declaration is set to NULL_TREE, and
37254 objc_being_catch_clauses() knows that that means
37255 '...'. */
37258 }
37259 else
37260 {
37261 /* We have "@catch (NSException *exception)" or something
37262 like that. Parse the parameter declaration. */
37267 else
37272 }
37275 else
37276 {
37277 /* If there was no open parenthesis, we are recovering from
37278 an error, and we are trying to figure out what mistake
37279 the user has made. */
37281 /* If there is an immediate closing parenthesis, the user
37282 probably forgot the opening one (ie, they typed "@catch
37283 NSException *e)". Parse the closing parenthesis and keep
37284 going. */
37288 /* If these is no immediate closing parenthesis, the user
37289 probably doesn't know that parenthesis are required at
37290 all (ie, they typed "@catch NSException *e"). So, just
37291 forget about the closing parenthesis and keep going. */
37292 }
37296 }
37298 {
37301 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
37302 node, lest it get absorbed into the surrounding block. */
37306 }
37309 }
37311 /* Parse an Objective-C synchronized statement.
37313 objc-synchronized-stmt:
37314 @synchronized ( expression ) compound-statement
37316 Returns NULL_TREE. */
37318 static tree
37320 {
37321 location_t location;
37328 matching_parens parens;
37333 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
37334 node, lest it get absorbed into the surrounding block. */
37339 }
37341 /* Parse an Objective-C throw statement.
37343 objc-throw-stmt:
37344 @throw assignment-expression [opt] ;
37346 Returns a constructed '@throw' statement. */
37348 static tree
37350 {
37362 }
37364 /* Parse an Objective-C statement. */
37366 static tree
37368 {
37369 /* Try to figure out what kind of declaration is present. */
37373 {
37384 }
37387 }
37389 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
37390 look ahead to see if an objc keyword follows the attributes. This
37391 is to detect the use of prefix attributes on ObjC @interface and
37392 @protocol. */
37394 static bool
37396 {
37401 {
37405 else
37408 }
37411 }
37413 /* This routine is a minimal replacement for
37414 c_parser_struct_declaration () used when parsing the list of
37415 types/names or ObjC++ properties. For example, when parsing the
37416 code
37418 @property (readonly) int a, b, c;
37420 this function is responsible for parsing "int a, int b, int c" and
37421 returning the declarations as CHAIN of DECLs.
37423 TODO: Share this code with cp_parser_objc_class_ivars. It's very
37424 similar parsing. */
37425 static tree
37427 {
37429 cp_decl_specifier_seq declspecs;
37431 tree prefix_attributes;
37434 CP_PARSER_FLAGS_NONE,
37441 /* auto, register, static, extern, mutable. */
37443 {
37446 }
37448 /* thread_local. */
37450 {
37453 }
37455 /* typedef. */
37457 {
37460 }
37465 /* Keep going until we hit the `;' at the end of the declaration. */
37467 {
37472 /* Parse the declarator. */
37474 CP_PARSER_FLAGS_NONE,
37477 /* Look for attributes that apply to the ivar. */
37479 /* Remember which attributes are prefix attributes and
37480 which are not. */
37482 /* Combine the attributes. */
37492 /* Reset PREFIX_ATTRIBUTES. */
37494 {
37499 }
37506 {
37509 }
37510 else
37512 }
37514 }
37516 /* Parse an Objective-C @property declaration. The syntax is:
37518 objc-property-declaration:
37519 '@property' objc-property-attributes[opt] struct-declaration ;
37521 objc-property-attributes:
37522 '(' objc-property-attribute-list ')'
37524 objc-property-attribute-list:
37525 objc-property-attribute
37526 objc-property-attribute-list, objc-property-attribute
37528 objc-property-attribute
37529 'getter' = identifier
37530 'setter' = identifier
37531 'readonly'
37532 'readwrite'
37533 'assign'
37534 'retain'
37535 'copy'
37536 'nonatomic'
37538 For example:
37539 @property NSString *name;
37540 @property (readonly) id object;
37541 @property (retain, nonatomic, getter=getTheName) id name;
37542 @property int a, b, c;
37544 PS: This function is identical to
37545 c_parser_objc_at_property_declaration for C. Keep them in sync. */
37546 static void
37548 {
37549 /* Parse the optional attribute list.
37551 A list of parsed, but not verified, attributes. */
37557 /* Parse the optional attribute list... */
37559 {
37560 /* Eat the '('. */
37561 matching_parens parens;
37566 /* Allow empty @property attribute lists, but with a warning. */
37568 location_t attr_comb;
37570 {
37574 }
37575 else
37577 {
37584 {
37591 }
37602 /* Account for accepting the 'class' keyword in this context. */
37604 else
37608 enum objc_property_attribute_kind prop_kind
37610 property_attribute_info *prop
37614 tree meth_name;
37616 {
37621 attr_name);
37622 else
37630 {
37633 attr_name);
37636 }
37644 {
37647 attr_name);
37650 }
37652 /* Get the end of the method name, and consume the name. */
37655 /* Because method names may contain C++ keywords, we have a
37656 routine to fetch them (this also consumes the token). */
37660 {
37662 {
37664 attr_end);
37668 }
37669 else
37670 {
37674 }
37676 attr_end);
37677 }
37678 else
37680 attr_end);
37682 /* Updated location including all that was successfully
37683 parsed. */
37686 }
37688 /* If we see a comma here, then keep going - even if we already
37689 saw a syntax error. For simple mistakes e.g. (asign, getter=x)
37690 this makes a more useful output and avoid spurious warnings
37691 about missing attributes that are, in fact, specified after the
37692 one with the syntax error. */
37695 else
37697 }
37703 }
37705 /* 'properties' is the list of properties that we read. Usually a
37706 single one, but maybe more (eg, in "@property int a, b, c;" there
37707 are three).
37708 TODO: Update this parsing so that it accepts (erroneous) bitfields so
37709 that we can issue a meaningful and consistent (between C/C++) error
37710 message from objc_add_property_declaration (). */
37717 else
37718 {
37719 /* Comma-separated properties are chained together in reverse order;
37720 add them one by one. */
37724 prop_attr_list);
37725 }
37728 }
37730 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
37732 objc-synthesize-declaration:
37733 @synthesize objc-synthesize-identifier-list ;
37735 objc-synthesize-identifier-list:
37736 objc-synthesize-identifier
37737 objc-synthesize-identifier-list, objc-synthesize-identifier
37739 objc-synthesize-identifier
37740 identifier
37741 identifier = identifier
37743 For example:
37744 @synthesize MyProperty;
37745 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
37747 PS: This function is identical to c_parser_objc_at_synthesize_declaration
37748 for C. Keep them in sync.
37749 */
37750 static void
37752 {
37754 location_t loc;
37759 {
37763 {
37766 }
37768 {
37772 {
37775 }
37776 }
37777 else
37782 else
37784 }
37787 }
37789 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
37791 objc-dynamic-declaration:
37792 @dynamic identifier-list ;
37794 For example:
37795 @dynamic MyProperty;
37796 @dynamic MyProperty, AnotherProperty;
37798 PS: This function is identical to c_parser_objc_at_dynamic_declaration
37799 for C. Keep them in sync.
37800 */
37801 static void
37803 {
37805 location_t loc;
37810 {
37811 tree property;
37814 {
37817 }
37821 else
37823 }
37826 }
37828 \f
37829 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
37831 /* Returns name of the next clause.
37832 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
37833 the token is not consumed. Otherwise appropriate pragma_omp_clause is
37834 returned and the token is consumed. */
37836 static pragma_omp_clause
37838 {
37854 {
37859 {
38080 }
38081 }
38087 }
38089 /* Validate that a clause of the given type does not already exist. */
38091 static void
38094 {
38097 }
38099 /* OpenMP 2.5:
38100 variable-list:
38101 identifier
38102 variable-list , identifier
38104 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
38105 colon). An opening parenthesis will have been consumed by the caller.
38107 If KIND is nonzero, create the appropriate node and install the decl
38108 in OMP_CLAUSE_DECL and add the node to the head of the list.
38110 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
38111 return the list created.
38113 COLON can be NULL if only closing parenthesis should end the list,
38114 or pointer to bool which will receive false if the list is terminated
38115 by closing parenthesis or true if the list is terminated by colon.
38117 The optional ALLOW_DEREF argument is true if list items can use the deref
38118 (->) operator. */
38120 struct omp_dim
38121 {
38123 location_t loc;
38127 };
38129 static tree
38133 {
38139 {
38142 }
38144 {
38149 /* This condition doesn't include OMP_CLAUSE_DEPEND or
38150 OMP_CLAUSE_AFFINITY since lvalue ("locator list") parsing for those is
38151 handled further down the function. */
38156 {
38162 /* This code rewrites a parsed expression containing various tree
38163 codes used to represent array accesses into a more uniform nest of
38164 OMP_ARRAY_SECTION nodes before it is processed by
38165 semantics.cc:handle_omp_array_sections_1. It might be more
38166 efficient to move this logic to that function instead, analysing
38167 the parsed expression directly rather than this preprocessed
38168 form. */
38171 {
38173 {
38178 }
38183 {
38188 {
38191 }
38193 {
38197 }
38199 {
38204 }
38205 }
38207 /* Bare references have their own special handling, so remove
38208 the explicit dereference added by convert_from_reference. */
38215 }
38217 {
38220 /* If we have "*foo" and
38221 - it's an indirection of a reference, "unconvert" it, i.e.
38222 strip the indirection (to just "foo").
38223 - it's an indirection of a pointer, turn it into
38224 "foo[0:1]". */
38230 integer_one_node);
38231 }
38233 {
38240 }
38246 }
38250 {
38256 }
38260 {
38261 cp_id_kind idk;
38264 }
38269 CPP_CLOSE_PAREN)))
38270 {
38273 }
38274 else
38275 {
38282 {
38287 }
38291 else
38294 {
38300 }
38301 }
38305 ;
38307 {
38309 {
38311 /* The OpenACC cache directive explicitly only allows "array
38312 elements or subarrays". */
38314 {
38318 }
38319 /* FALLTHROUGH. */
38323 start_component_ref:
38326 {
38327 cpp_ttype ttype
38330 location_t loc
38335 decl = (cp_parser_postfix_dot_deref_expression
38338 }
38339 /* FALLTHROUGH. */
38349 {
38357 {
38360 /* Later handling is not prepared to see through these. */
38362 }
38364 parser->colon_corrects_to_scope_p
38367 {
38370 }
38371 else
38372 {
38373 /* Look for `:'. */
38375 {
38380 }
38383 else
38386 CPP_CLOSE_SQUARE))
38387 {
38389 /* Later handling is not prepared to see through these. */
38391 }
38392 }
38393 /* Look for the closing `]'. */
38395 RT_CLOSE_SQUARE))
38396 {
38401 }
38404 }
38409 && !array_section_p
38412 {
38414 {
38418 }
38420 }
38421 else
38429 }
38432 {
38436 {
38437 depend_lvalue:
38441 }
38442 else
38444 }
38446 build_clause:
38451 }
38452 else
38455 get_comma:
38459 }
38465 {
38469 }
38472 {
38475 /* Try to resync to an unnested comma. Copied from
38476 cp_parser_parenthesized_expression_list. */
38477 skip_comma:
38486 }
38489 }
38491 /* Similarly, but expect leading and trailing parenthesis. This is a very
38492 common case for omp clauses. */
38494 static tree
38497 {
38499 {
38501 {
38507 }
38508 else
38510 list);
38511 }
38515 map_lvalue);
38517 }
38519 /* OpenACC 2.0:
38520 copy ( variable-list )
38521 copyin ( variable-list )
38522 copyout ( variable-list )
38523 create ( variable-list )
38524 delete ( variable-list )
38525 present ( variable-list )
38527 OpenACC 2.6:
38528 no_create ( variable-list )
38529 attach ( variable-list )
38530 detach ( variable-list ) */
38532 static tree
38534 tree list)
38535 {
38538 {
38576 /* "The 'host' clause is a synonym for the 'self' clause." */
38582 }
38590 }
38592 /* OpenACC 2.0:
38593 deviceptr ( variable-list ) */
38595 static tree
38597 {
38601 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
38602 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
38603 variable-list must only allow for pointer variables. */
38606 {
38613 }
38616 }
38618 /* OpenACC 2.5:
38619 auto
38620 finalize
38621 independent
38622 nohost
38623 seq */
38625 static tree
38627 tree list)
38628 {
38635 }
38637 /* OpenACC:
38638 num_gangs ( expression )
38639 num_workers ( expression )
38640 vector_length ( expression ) */
38642 static tree
38645 {
38648 matching_parens parens;
38656 {
38661 }
38669 }
38671 /* OpenACC:
38673 gang [( gang-arg-list )]
38674 worker [( [num:] int-expr )]
38675 vector [( [length:] int-expr )]
38677 where gang-arg is one of:
38679 [num:] int-expr
38680 static: size-expr
38682 and size-expr may be:
38684 *
38685 int-expr
38686 */
38688 static tree
38690 omp_clause_code kind,
38692 {
38701 {
38702 matching_parens parens;
38705 do
38706 {
38710 /* Gang static argument. */
38713 {
38721 {
38724 }
38726 /* Check for the '*' argument. */
38730 CPP_CLOSE_PAREN)))
38731 {
38736 {
38739 }
38741 }
38742 }
38743 /* Worker num: argument and vector length: arguments. */
38747 {
38750 }
38752 /* Now collect the actual argument. */
38754 {
38757 }
38769 {
38772 }
38774 }
38779 }
38793 cleanup_error:
38796 }
38798 /* OpenACC 2.0:
38799 tile ( size-expr-list ) */
38801 static tree
38803 {
38807 /* Collapse and tile are mutually exclusive. (The spec doesn't say
38808 so, but the spec authors never considered such a case and have
38809 differing opinions on what it might mean, including 'not
38810 allowed'.) */
38813 clause_loc);
38818 do
38819 {
38826 {
38829 }
38830 else
38834 }
38837 /* Consume the trailing ')'. */
38845 }
38847 /* OpenACC 2.0
38848 Parse wait clause or directive parameters. */
38850 static tree
38852 {
38862 {
38864 {
38867 }
38869 }
38876 {
38880 {
38883 else
38884 {
38891 }
38892 }
38893 }
38896 }
38898 /* OpenACC:
38899 wait [( int-expr-list )] */
38901 static tree
38903 {
38908 else
38909 {
38915 }
38918 }
38920 /* OpenMP 3.0:
38921 collapse ( constant-expression ) */
38923 static tree
38925 {
38927 location_t loc;
38928 HOST_WIDE_INT n;
38931 matching_parens parens;
38949 {
38952 }
38961 }
38963 /* OpenMP 2.5:
38964 default ( none | shared )
38966 OpenMP 5.1:
38967 default ( private | firstprivate )
38969 OpenACC:
38970 default ( none | present ) */
38972 static tree
38975 {
38977 tree c;
38979 matching_parens parens;
38983 {
38986 }
38988 {
38993 {
39020 }
39023 }
39024 else
39025 {
39026 invalid_kind:
39029 else
39032 }
39049 }
39051 /* OpenMP 3.1:
39052 final ( expression ) */
39054 static tree
39056 {
39059 matching_parens parens;
39078 }
39080 /* OpenMP 5.1:
39081 indirect [( expression )]
39082 */
39084 static tree
39086 location_t location)
39087 {
39088 tree t;
39091 {
39092 matching_parens parens;
39107 }
39108 else
39118 }
39120 /* OpenMP 2.5:
39121 if ( expression )
39123 OpenMP 4.5:
39124 if ( directive-name-modifier : expression )
39126 directive-name-modifier:
39127 parallel | task | taskloop | target data | target | target update
39128 | target enter data | target exit data
39130 OpenMP 5.0:
39131 directive-name-modifier:
39132 ... | simd | cancel */
39134 static tree
39137 {
39141 matching_parens parens;
39146 {
39162 {
39165 {
39178 else
39179 {
39180 location_t loc
39185 }
39188 {
39190 {
39195 }
39197 {
39198 location_t loc
39202 }
39203 }
39204 }
39205 }
39207 {
39209 {
39212 }
39213 else
39214 {
39216 {
39217 location_t loc
39220 }
39222 }
39223 }
39224 }
39236 {
39239 {
39242 {
39254 }
39256 p);
39258 }
39260 {
39263 else
39266 }
39269 {
39273 }
39274 }
39282 }
39284 /* OpenMP 3.1:
39285 mergeable */
39287 static tree
39290 {
39291 tree c;
39294 location);
39299 }
39301 /* OpenMP 2.5:
39302 nowait */
39304 static tree
39307 {
39308 tree c;
39315 }
39317 /* OpenMP 2.5:
39318 num_threads ( expression ) */
39320 static tree
39322 location_t location)
39323 {
39326 matching_parens parens;
39346 }
39348 /* OpenMP 4.5:
39349 num_tasks ( expression )
39351 OpenMP 5.1:
39352 num_tasks ( strict : expression ) */
39354 static tree
39356 location_t location)
39357 {
39360 matching_parens parens;
39367 {
39370 {
39374 }
39375 }
39394 }
39396 /* OpenMP 4.5:
39397 grainsize ( expression )
39399 OpenMP 5.1:
39400 grainsize ( strict : expression ) */
39402 static tree
39404 location_t location)
39405 {
39408 matching_parens parens;
39415 {
39418 {
39422 }
39423 }
39442 }
39444 /* OpenMP 4.5:
39445 priority ( expression ) */
39447 static tree
39449 location_t location)
39450 {
39453 matching_parens parens;
39473 }
39475 /* OpenMP 4.5:
39476 hint ( expression ) */
39478 static tree
39480 {
39483 matching_parens parens;
39490 {
39498 }
39511 }
39513 /* OpenMP 5.1:
39514 filter ( integer-expression ) */
39516 static tree
39518 {
39521 matching_parens parens;
39539 }
39541 /* OpenMP 4.5:
39542 defaultmap ( tofrom : scalar )
39544 OpenMP 5.0:
39545 defaultmap ( implicit-behavior [ : variable-category ] ) */
39547 static tree
39549 location_t location)
39550 {
39554 enum omp_clause_defaultmap_kind category
39557 matching_parens parens;
39564 {
39565 invalid_behavior:
39567 "%<tofrom%>, %<firstprivate%>, %<none%> "
39570 }
39571 else
39572 {
39575 }
39578 {
39582 else
39589 else
39598 else
39605 else
39612 else
39621 else
39627 }
39631 {
39636 {
39637 invalid_category:
39641 }
39646 {
39652 else
39659 else
39666 else
39672 }
39675 }
39688 {
39698 {
39716 }
39719 p);
39720 else
39724 }
39731 out_err:
39736 }
39738 /* OpenMP 5.0:
39739 order ( concurrent )
39741 OpenMP 5.1:
39742 order ( order-modifier : concurrent )
39744 order-modifier:
39745 reproducible
39746 unconstrained */
39748 static tree
39750 {
39756 matching_parens parens;
39762 {
39769 else
39770 {
39774 }
39777 }
39779 {
39782 }
39783 else
39784 {
39787 }
39789 {
39792 }
39804 out_err:
39809 }
39811 /* OpenMP 5.0:
39812 bind ( teams | parallel | thread ) */
39814 static tree
39816 location_t location)
39817 {
39818 tree c;
39822 matching_parens parens;
39827 {
39828 invalid:
39832 }
39833 else
39834 {
39837 }
39848 /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
39854 out_err:
39859 }
39861 /* OpenMP 2.5:
39862 ordered
39864 OpenMP 4.5:
39865 ordered ( constant-expression ) */
39867 static tree
39870 {
39872 HOST_WIDE_INT n;
39878 {
39879 matching_parens parens;
39896 {
39898 "ordered argument needs positive constant integer "
39901 }
39902 }
39908 }
39910 /* OpenMP 2.5:
39911 reduction ( reduction-operator : variable-list )
39913 reduction-operator:
39914 One of: + * - & ^ | && ||
39916 OpenMP 3.1:
39918 reduction-operator:
39919 One of: + * - & ^ | && || min max
39921 OpenMP 4.0:
39923 reduction-operator:
39924 One of: + * - & ^ | && ||
39925 id-expression
39927 OpenMP 5.0:
39928 reduction ( reduction-modifier, reduction-operator : variable-list )
39929 in_reduction ( reduction-operator : variable-list )
39930 task_reduction ( reduction-operator : variable-list ) */
39932 static tree
39935 {
39945 {
39948 {
39951 }
39954 {
39962 {
39965 }
39966 }
39967 }
39970 {
39980 }
39984 else
39985 {
39996 {
40026 }
40027 else
40028 {
40030 resync_fail:
40035 }
40036 }
40042 NULL);
40044 {
40051 }
40054 }
40056 /* OpenMP 2.5:
40057 schedule ( schedule-kind )
40058 schedule ( schedule-kind , expression )
40060 schedule-kind:
40061 static | dynamic | guided | runtime | auto
40063 OpenMP 4.5:
40064 schedule ( schedule-modifier : schedule-kind )
40065 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
40067 schedule-modifier:
40068 simd
40069 monotonic
40070 nonmonotonic */
40072 static tree
40074 {
40078 matching_parens parens;
40086 {
40095 else
40101 {
40104 }
40105 else
40106 {
40109 }
40110 }
40115 {
40120 {
40141 }
40142 }
40147 else
40153 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
40155 {
40159 }
40162 {
40177 else
40182 }
40194 invalid_kind:
40196 resync_fail:
40201 }
40203 /* OpenMP 3.0:
40204 untied */
40206 static tree
40209 {
40210 tree c;
40217 }
40219 /* OpenMP 4.0:
40220 inbranch
40221 notinbranch */
40223 static tree
40226 {
40231 }
40233 /* OpenMP 4.0:
40234 parallel
40235 for
40236 sections
40237 taskgroup */
40239 static tree
40243 {
40247 }
40249 /* OpenMP 4.5:
40250 nogroup */
40252 static tree
40255 {
40260 }
40262 /* OpenMP 4.5:
40263 simd
40264 threads */
40266 static tree
40270 {
40275 }
40277 /* OpenMP 4.0:
40278 num_teams ( expression )
40280 OpenMP 5.1:
40281 num_teams ( expression : expression ) */
40283 static tree
40285 location_t location)
40286 {
40289 matching_parens parens;
40300 {
40304 }
40321 }
40323 /* OpenMP 4.0:
40324 thread_limit ( expression ) */
40326 static tree
40328 location_t location)
40329 {
40332 matching_parens parens;
40352 }
40354 /* OpenMP 4.0:
40355 aligned ( variable-list )
40356 aligned ( variable-list : constant-expression ) */
40358 static tree
40360 {
40364 matching_parens parens;
40372 {
40382 }
40388 }
40390 /* OpenMP 5.0:
40391 allocate ( variable-list )
40392 allocate ( expression : variable-list )
40394 OpenMP 5.1:
40395 allocate ( allocator-modifier : variable-list )
40396 allocate ( allocator-modifier , allocator-modifier : variable-list )
40398 allocator-modifier:
40399 allocator ( expression )
40400 align ( expression ) */
40402 static tree
40404 {
40408 matching_parens parens;
40418 {
40424 matching_parens parens2;
40428 {
40432 }
40433 else
40434 {
40438 }
40442 {
40445 }
40449 }
40450 else
40453 {
40459 }
40462 {
40469 }
40470 else
40471 {
40475 }
40482 {
40485 }
40488 }
40490 /* OpenMP 2.5:
40491 lastprivate ( variable-list )
40493 OpenMP 5.0:
40494 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
40496 static tree
40498 {
40506 {
40511 {
40515 }
40516 }
40525 }
40527 /* OpenMP 4.0:
40528 linear ( variable-list )
40529 linear ( variable-list : expression )
40531 OpenMP 4.5:
40532 linear ( modifier ( variable-list ) )
40533 linear ( modifier ( variable-list ) : expression )
40535 modifier:
40536 val
40537 ref
40538 uval
40540 OpenMP 5.2:
40541 linear ( variable-list : modifiers-list )
40543 modifiers:
40544 val
40545 ref
40546 uval
40547 step ( expression ) */
40549 static tree
40552 {
40558 matching_parens parens;
40563 {
40574 {
40577 }
40578 else
40580 }
40585 else
40586 {
40595 }
40598 {
40602 {
40612 {
40616 }
40620 CPP_CLOSE_PAREN)))
40622 }
40626 {
40628 {
40639 {
40645 }
40647 {
40648 location_t step_loc
40651 matching_parens parens2;
40653 {
40659 CPP_CLOSE_PAREN))
40660 {
40661 cp_token *token
40669 tok_loc);
40671 {
40674 }
40677 }
40683 }
40684 else
40686 }
40687 else
40690 {
40693 }
40695 }
40698 }
40702 {
40713 {
40716 }
40719 }
40730 }
40733 {
40737 }
40740 }
40742 /* OpenMP 4.0:
40743 safelen ( constant-expression ) */
40745 static tree
40747 location_t location)
40748 {
40751 matching_parens parens;
40770 }
40772 /* OpenMP 4.0:
40773 simdlen ( constant-expression ) */
40775 static tree
40777 location_t location)
40778 {
40781 matching_parens parens;
40800 }
40802 /* OpenMP 4.5:
40803 vec:
40804 identifier [+/- integer]
40805 vec , identifier [+/- integer]
40806 */
40808 static tree
40811 {
40815 {
40818 }
40821 {
40827 {
40830 {
40838 }
40839 }
40840 }
40843 {
40850 else
40851 {
40852 t = cp_parser_lookup_name_simple
40857 id_loc);
40858 }
40864 {
40867 }
40871 {
40874 }
40878 {
40881 }
40884 add_to_vector:
40886 {
40890 }
40897 }
40900 {
40907 }
40909 }
40911 /* OpenMP 5.0:
40912 detach ( event-handle ) */
40914 static tree
40916 {
40917 matching_parens parens;
40933 else
40934 {
40937 else
40942 }
40955 }
40957 /* OpenMP 5.0:
40958 iterators ( iterators-definition )
40960 iterators-definition:
40961 iterator-specifier
40962 iterator-specifier , iterators-definition
40964 iterator-specifier:
40965 identifier = range-specification
40966 iterator-type identifier = range-specification
40968 range-specification:
40969 begin : end
40970 begin : end : step */
40972 static tree
40974 {
40978 matching_parens parens;
40982 bool saved_colon_corrects_to_scope_p
40984 bool saved_colon_doesnt_start_class_def_p
40987 do
40988 {
40989 tree iter_type;
40993 else
40994 {
40997 parser->type_definition_forbidden_message
41003 }
41007 {
41010 }
41030 {
41033 }
41048 {
41051 }
41053 }
41057 parser->colon_doesnt_start_class_def_p
41067 }
41069 /* OpenMP 5.0:
41070 affinity ( [aff-modifier :] variable-list )
41071 aff-modifier:
41072 iterator ( iterators-definition ) */
41074 static tree
41076 {
41079 matching_parens parens;
41084 {
41089 CPP_OPEN_PAREN)));
41091 {
41094 }
41096 {
41100 {
41108 }
41109 }
41110 }
41114 {
41117 {
41122 }
41123 }
41125 }
41127 /* OpenMP 4.0:
41128 depend ( depend-kind : variable-list )
41130 depend-kind:
41131 in | out | inout
41133 OpenMP 4.5:
41134 depend ( source )
41136 depend ( sink : vec )
41138 OpenMP 5.0:
41139 depend ( depend-modifier , depend-kind: variable-list )
41141 depend-kind:
41142 in | out | inout | mutexinoutset | depobj
41144 depend-modifier:
41145 iterator ( iterators-definition ) */
41147 static tree
41149 {
41154 matching_parens parens;
41158 do
41159 {
41167 {
41172 }
41189 else
41192 }
41200 {
41205 }
41208 {
41219 }
41225 {
41231 }
41232 else
41233 {
41238 {
41242 else
41244 }
41247 {
41252 }
41253 }
41256 invalid_kind:
41258 resync_fail:
41265 }
41267 /* OpenMP 5.2:
41268 doacross ( source : )
41269 doacross ( source : omp_cur_iteration )
41271 doacross ( sink : vec )
41272 doacross ( sink : omp_cur_iteration - logical_iteration ) */
41274 static tree
41276 {
41277 tree nlist;
41280 matching_parens parens;
41285 {
41286 invalid_kind:
41288 resync_fail:
41293 }
41302 else
41311 {
41313 {
41318 }
41323 }
41324 else
41332 }
41334 /* OpenMP 4.0:
41335 from ( variable-list )
41336 to ( variable-list )
41338 OpenMP 5.1:
41339 from ( [present :] variable-list )
41340 to ( [present :] variable-list ) */
41342 static tree
41344 tree list)
41345 {
41355 {
41359 }
41367 }
41369 /* OpenMP 4.0:
41370 map ( map-kind : variable-list )
41371 map ( variable-list )
41373 map-kind:
41374 alloc | to | from | tofrom
41376 OpenMP 4.5:
41377 map-kind:
41378 alloc | to | from | tofrom | release | delete
41380 map ( always [,] map-kind: variable-list )
41382 OpenMP 5.0:
41383 map ( [map-type-modifier[,] ...] map-kind: variable-list )
41385 map-type-modifier:
41386 always | close */
41388 static tree
41390 {
41401 {
41403 {
41406 }
41409 pos++;
41410 pos++;
41411 }
41417 {
41420 {
41423 }
41427 {
41429 {
41436 }
41438 }
41440 {
41442 {
41449 }
41451 }
41453 {
41455 {
41462 }
41464 }
41465 else
41466 {
41474 }
41477 }
41481 {
41505 else
41506 {
41512 }
41515 }
41518 {
41522 }
41524 /* We introduce a scope here so that errors parsing e.g. "always", "close"
41525 tokens do not propagate to later directives that might use them
41526 legally. */
41536 }
41538 /* OpenMP 4.0:
41539 device ( expression )
41541 OpenMP 5.0:
41542 device ( [device-modifier :] integer-expression )
41544 device-modifier:
41545 ancestor | device_num */
41547 static tree
41549 location_t location)
41550 {
41554 matching_parens parens;
41560 {
41564 {
41567 /* A requires directive with the reverse_offload clause must be
41568 specified. */
41570 {
41572 "preceded by %<requires%> directive "
41576 }
41577 }
41579 ;
41580 else
41581 {
41585 }
41588 }
41607 }
41609 /* OpenMP 4.0:
41610 dist_schedule ( static )
41611 dist_schedule ( static , expression ) */
41613 static tree
41615 location_t location)
41616 {
41619 matching_parens parens;
41630 {
41641 }
41645 /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
41646 "dist_schedule", location); */
41652 invalid_kind:
41654 resync_fail:
41659 }
41661 /* OpenMP 4.0:
41662 proc_bind ( proc-bind-kind )
41664 proc-bind-kind:
41665 primary | master | close | spread
41666 where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
41668 static tree
41670 location_t location)
41671 {
41672 tree c;
41679 {
41691 else
41693 }
41694 else
41703 location);
41708 invalid_kind:
41710 resync_fail:
41715 }
41717 /* OpenMP 5.0:
41718 device_type ( host | nohost | any ) */
41720 static tree
41722 location_t location)
41723 {
41724 tree c;
41731 {
41741 else
41743 }
41744 else
41753 location);
41758 invalid_kind:
41760 resync_fail:
41765 }
41767 /* OpenACC:
41768 async [( int-expr )] */
41770 static tree
41772 {
41779 {
41780 matching_parens parens;
41789 }
41799 }
41801 /* OpenACC 2.7:
41802 self [( expression )] */
41804 static tree
41806 {
41807 tree t;
41810 {
41811 matching_parens parens;
41816 {
41821 }
41822 }
41823 else
41828 {
41831 }
41837 }
41839 /* Parse all OpenACC clauses. The set clauses allowed by the directive
41840 is a bitmask in MASK. Return the list of clauses found. */
41842 static tree
41846 {
41850 /* Don't create location wrapper nodes within OpenACC clauses. */
41851 auto_suppress_location_wrappers sentinel;
41854 {
41855 location_t here;
41856 pragma_omp_clause c_kind;
41857 omp_clause_code code;
41868 {
41875 clauses);
41928 clauses);
41933 clauses);
41951 clauses);
41956 clauses);
41969 clauses);
41976 clauses);
41982 clauses);
41990 clauses);
41994 clauses
42001 /* OpenACC compute construct */
42003 else
42004 /* OpenACC 'update' directive */
42010 clauses);
42019 clauses);
42025 OMP_CLAUSE_VECTOR,
42032 clauses);
42041 OMP_CLAUSE_WORKER,
42047 }
42052 {
42053 /* Remove the invalid clause(s) from the list to avoid
42054 confusing the rest of the compiler. */
42057 }
42058 }
42060 saw_error:
42068 }
42070 /* Parse all OpenMP clauses. The set clauses allowed by the directive
42071 is a bitmask in MASK. Return the list of clauses found.
42072 FINISH_P set if finish_omp_clauses should be called.
42073 NESTED non-zero if clauses should be terminated by closing paren instead
42074 of end of pragma. If it is 2, additionally commas are required in between
42075 the clauses. */
42077 static tree
42081 {
42086 /* Don't create location wrapper nodes within OpenMP clauses. */
42087 auto_suppress_location_wrappers sentinel;
42090 {
42091 pragma_omp_clause c_kind;
42099 {
42104 "clauses in %<simd%> trait should be separated "
42106 }
42112 {
42129 clauses);
42148 clauses);
42168 clauses);
42173 clauses);
42178 clauses);
42183 clauses);
42192 clauses
42243 clauses);
42247 clauses
42259 clauses);
42263 clauses
42265 OMP_CLAUSE_TASK_REDUCTION,
42281 clauses);
42286 OMP_CLAUSE_NOTINBRANCH,
42295 {
42296 clause_not_first:
42300 }
42329 {
42331 clauses);
42335 }
42336 else
42338 clauses);
42343 clauses);
42348 clauses);
42370 {
42375 }
42436 clauses
42442 clauses
42449 clauses);
42455 }
42460 {
42461 /* Remove the invalid clause(s) from the list to avoid
42462 confusing the rest of the compiler. */
42465 }
42466 }
42467 saw_error:
42471 {
42474 else
42476 }
42478 }
42480 /* OpenMP 2.5:
42481 structured-block:
42482 statement
42484 In practice, we're also interested in adding the statement to an
42485 outer node. So it is convenient if we work around the fact that
42486 cp_parser_statement calls add_stmt. */
42488 static unsigned
42490 {
42493 /* Only move the values to IN_OMP_BLOCK if they weren't false.
42494 This preserves the "not within loop or switch" style error messages
42495 for nonsense cases like
42496 void foo() {
42497 #pragma omp single
42498 break;
42499 }
42500 */
42505 }
42507 static void
42509 {
42511 }
42513 static tree
42515 {
42524 }
42526 /* OpenMP 5.x:
42527 # pragma omp allocate (list) clauses
42529 OpenMP 5.0 clause:
42530 allocator (omp_allocator_handle_t expression)
42532 OpenMP 5.1 additional clause:
42533 align (constant-expression)] */
42535 static void
42537 {
42543 do
42544 {
42551 matching_parens parens;
42557 {
42560 }
42565 {
42568 }
42570 {
42573 /* FIXME: Remove when adding check to semantics.cc; cf FIXME below. */
42577 {
42579 "positive constant power of two integer "
42582 }
42584 {
42587 {
42592 {
42594 "positive constant power of two integer "
42597 }
42598 }
42599 }
42600 }
42602 {
42605 }
42606 else
42607 {
42610 }
42617 {
42620 }
42622 /* FIXME: When implementing properly, delete the align/allocate expr error
42623 check above and add one in semantics.cc (to properly handle templates).
42624 Base this on the allocator/align modifiers check for the 'allocate' clause
42625 in semantics.cc's finish_omp_clauses. */
42627 }
42629 /* OpenMP 2.5:
42630 # pragma omp atomic new-line
42631 expression-stmt
42633 expression-stmt:
42634 x binop= expr | x++ | ++x | x-- | --x
42635 binop:
42636 +, *, -, /, &, ^, |, <<, >>
42638 where x is an lvalue expression with scalar type.
42640 OpenMP 3.1:
42641 # pragma omp atomic new-line
42642 update-stmt
42644 # pragma omp atomic read new-line
42645 read-stmt
42647 # pragma omp atomic write new-line
42648 write-stmt
42650 # pragma omp atomic update new-line
42651 update-stmt
42653 # pragma omp atomic capture new-line
42654 capture-stmt
42656 # pragma omp atomic capture new-line
42657 capture-block
42659 read-stmt:
42660 v = x
42661 write-stmt:
42662 x = expr
42663 update-stmt:
42664 expression-stmt | x = x binop expr
42665 capture-stmt:
42666 v = expression-stmt
42667 capture-block:
42668 { v = x; update-stmt; } | { update-stmt; v = x; }
42670 OpenMP 4.0:
42671 update-stmt:
42672 expression-stmt | x = x binop expr | x = expr binop x
42673 capture-stmt:
42674 v = update-stmt
42675 capture-block:
42676 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
42678 OpenMP 5.1:
42679 # pragma omp atomic compare new-line
42680 conditional-update-atomic
42682 # pragma omp atomic compare capture new-line
42683 conditional-update-capture-atomic
42685 conditional-update-atomic:
42686 cond-expr-stmt | cond-update-stmt
42687 cond-expr-stmt:
42688 x = expr ordop x ? expr : x;
42689 x = x ordop expr ? expr : x;
42690 x = x == e ? d : x;
42691 cond-update-stmt:
42692 if (expr ordop x) { x = expr; }
42693 if (x ordop expr) { x = expr; }
42694 if (x == e) { x = d; }
42695 ordop:
42696 <, >
42697 conditional-update-capture-atomic:
42698 v = cond-expr-stmt
42699 { v = x; cond-expr-stmt }
42700 { cond-expr-stmt v = x; }
42701 { v = x; cond-update-stmt }
42702 { cond-update-stmt v = x; }
42703 if (x == e) { x = d; } else { v = x; }
42704 { r = x == e; if (r) { x = d; } }
42705 { r = x == e; if (r) { x = d; } else { v = x; } }
42707 where x, r and v are lvalue expressions with scalar type,
42708 expr, e and d are expressions with scalar type and e might be
42709 the same as v. */
42711 static void
42713 {
42729 {
42735 {
42740 enum omp_memory_order new_memory_order
42756 {
42760 }
42768 {
42769 matching_parens parens;
42776 {
42786 }
42789 {
42793 else
42795 }
42796 else
42806 }
42818 {
42822 }
42823 else
42824 {
42827 "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
42828 "%<seq_cst%>, %<acq_rel%>, %<release%>, "
42830 }
42832 {
42834 {
42835 /* OpenACC permits 'update capture'. */
42842 else
42844 }
42846 {
42849 else
42851 }
42853 {
42856 else
42858 }
42860 {
42863 else
42865 }
42867 {
42870 else
42872 }
42875 }
42876 }
42878 }
42884 {
42888 else
42890 }
42892 {
42896 }
42898 {
42901 }
42903 {
42906 }
42910 {
42911 omp_requires_mask
42916 {
42926 {
42928 "%<acquire%> clause implicitly provided by a "
42931 }
42932 else
42937 {
42939 "%<release%> clause implicitly provided by a "
42942 }
42943 else
42948 {
42958 }
42962 }
42963 }
42964 else
42966 {
42969 {
42973 }
42979 {
42983 }
42989 }
42991 memory_order
42996 {
43006 else
43011 {
43012 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
43013 opcode. */
43018 }
43022 {
43025 }
43029 else
43030 {
43038 {
43042 }
43043 }
43046 }
43048 restart:
43050 {
43053 matching_parens parens;
43057 tree cmp_expr;
43060 else
43068 {
43074 }
43076 ;
43078 {
43082 }
43085 {
43087 "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
43090 }
43101 {
43104 }
43109 else
43122 {
43124 {
43127 }
43129 {
43134 }
43135 else
43137 }
43142 {
43147 }
43148 else
43149 {
43150 bad_if:
43154 }
43157 {
43161 {
43165 }
43193 /* Signal to c_finish_omp_atomic that in
43194 if (x == e) { x = d; } else { v = x; }
43195 case the store to v should be conditional. */
43197 }
43199 {
43202 }
43208 }
43212 {
43219 /* FALLTHROUGH */
43231 /* FALLTHROUGH */
43248 /* Undo effects of boolean_increment for post {in,de}crement. */
43250 /* FALLTHRU */
43254 {
43255 /* Undo effects of boolean_increment. */
43257 {
43258 /* This is pre or post increment. */
43263 && !structured_block
43269 }
43270 }
43271 /* FALLTHRU */
43274 {
43277 }
43279 {
43314 {
43318 }
43323 {
43329 {
43334 }
43336 {
43350 {
43352 {
43357 }
43358 else
43360 }
43365 || !structured_block
43366 || v
43372 {
43374 {
43380 }
43381 }
43389 {
43393 cond_expr:
43395 bool saved_colon_corrects_to_scope_p
43399 parser->colon_corrects_to_scope_p
43404 {
43406 {
43408 {
43412 }
43414 {
43415 opcode
43419 }
43420 }
43421 else
43422 {
43425 {
43426 opcode
43431 }
43432 }
43433 }
43435 "invalid form of "
43438 }
43442 }
43447 {
43454 }
43458 }
43462 {
43465 {
43473 }
43475 {
43480 }
43524 }
43527 {
43529 "invalid form of "
43532 }
43543 {
43545 {
43547 "invalid form of "
43550 }
43552 }
43558 }
43565 }
43566 stmt_done:
43568 {
43581 }
43583 {
43587 }
43588 done:
43590 {
43593 }
43601 invalid_compare:
43603 /* FALLTHRU */
43604 saw_error:
43609 {
43613 {
43617 }
43618 }
43619 }
43622 /* OpenMP 2.5:
43623 # pragma omp barrier new-line */
43625 static void
43627 {
43630 }
43632 /* OpenMP 2.5:
43633 # pragma omp critical [(name)] new-line
43634 structured-block
43636 OpenMP 4.5:
43637 # pragma omp critical [(name) [hint(expression)]] new-line
43638 structured-block */
43640 #define OMP_CRITICAL_CLAUSE_MASK \
43641 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
43643 static tree
43645 {
43649 {
43650 matching_parens parens;
43666 }
43673 }
43675 /* OpenMP 5.0:
43676 # pragma omp depobj ( depobj ) depobj-clause new-line
43678 depobj-clause:
43679 depend (dependence-type : locator)
43680 destroy
43681 update (dependence-type)
43683 OpenMP 5.2 additionally:
43684 destroy ( depobj )
43686 dependence-type:
43687 in
43688 out
43689 inout
43690 mutexinout */
43692 static void
43694 {
43696 matching_parens parens;
43698 {
43701 }
43716 {
43722 {
43723 /* Don't create location wrapper nodes within the depend clause. */
43724 auto_suppress_location_wrappers sentinel;
43730 }
43732 {
43734 matching_parens c_parens;
43737 {
43744 "the %<destroy%> expression %qE should be the same "
43751 }
43752 }
43754 {
43755 matching_parens c_parens;
43757 {
43758 location_t c2_loc
43761 {
43776 }
43778 {
43782 }
43788 }
43789 else
43791 }
43792 }
43794 {
43797 }
43801 }
43804 /* OpenMP 2.5:
43805 # pragma omp flush flush-vars[opt] new-line
43807 flush-vars:
43808 ( variable-list )
43810 OpenMP 5.0:
43811 # pragma omp flush memory-order-clause new-line */
43813 static void
43815 {
43821 {
43832 else
43834 "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
43837 }
43839 {
43842 "%<flush%> list specified together with memory order "
43845 }
43849 }
43851 /* Helper function, to parse omp for increment expression. */
43853 static tree
43855 {
43860 {
43863 }
43866 {
43878 }
43880 /* If decl is an iterator, preserve LHS and RHS of the relational
43881 expr until finish_omp_for. */
43892 }
43894 /* Helper function, to parse omp for increment expression. */
43896 static tree
43898 {
43902 cp_id_kind idk;
43906 {
43915 }
43924 {
43929 }
43936 {
43940 }
43953 do
43954 {
43961 {
43963 {
43966 else
43969 }
43970 else
43975 }
43976 }
43980 {
43986 }
43987 else
43991 }
43993 /* Parse the initialization statement of an OpenMP for loop. Range-for
43994 is handled separately in cp_convert_omp_range_for.
43996 On entry SL is the current statement list. Parsing of some forms
43997 of initialization pops this list and stores its contents in either INIT
43998 or THIS_PRE_BODY, and sets SL to null. Initialization for class
43999 iterators is added directly to SL and it is not popped until later.
44001 On return, DECL is set if the initialization is by binding the
44002 iteration variable. If the initialization is by assignment, REAL_DECL
44003 is set to point to a variable in an outer scope. ORIG_INIT is set
44004 if the iteration variable is of class type; this is a copy saved for
44005 error checking in finish_omp_for.
44007 Return true if the resulting construct should have an
44008 OMP_CLAUSE_PRIVATE added to it. */
44010 static tree
44018 {
44024 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
44026 init-expr:
44027 var = lb
44028 integer-type var = lb
44029 random-access-iterator-type var = lb
44030 pointer-type var = lb
44031 */
44032 cp_decl_specifier_seq type_specifiers;
44034 /* First, try to parse as an initialized declaration. See
44035 cp_parser_condition, from whence the bulk of this is copied. */
44043 {
44044 /* If parsing a type specifier seq succeeded, then this
44045 MUST be a initialized declaration. */
44050 CP_PARSER_DECLARATOR_NAMED,
44051 CP_PARSER_FLAGS_NONE,
44063 else
44064 {
44074 {
44076 CPP_OPEN_PAREN))
44079 else
44080 /* Trigger an error. */
44085 }
44089 {
44097 {
44100 auto_node);
44105 }
44108 asm_specification,
44109 LOOKUP_ONLYCONVERTING);
44112 /* In the case of a class iterator, do not pop sl here.
44113 Both class initialization and finalization must happen in
44114 the enclosing init block scope. For now set the init
44115 expression to null; it'll be filled in properly in
44116 finish_omp_for before stuffing it in the OMP_FOR. */
44120 {
44124 {
44126 /* Move lambda DECL_EXPRs to the enclosing block. */
44128 {
44132 {
44136 }
44138 }
44140 {
44145 }
44146 }
44147 }
44148 }
44149 else
44150 /* This is an initialized declaration of non-class,
44151 non-parameterized type iteration variable. */
44152 {
44153 /* Consume '='. */
44157 non_class:
44160 else
44163 asm_specification,
44164 LOOKUP_ONLYCONVERTING);
44167 }
44171 }
44172 }
44173 else
44174 {
44175 cp_id_kind idk;
44176 /* If parsing a type specifier sequence failed, then
44177 this MUST be a simple expression. */
44183 && decl
44186 {
44197 {
44202 }
44207 }
44209 && decl
44212 {
44213 tree rhs;
44222 tf_warning_or_error));
44225 }
44226 else
44227 {
44232 {
44236 }
44237 }
44240 }
44242 }
44244 /* Helper for cp_parser_omp_loop_nest, handle one range-for loop
44245 including introducing new temporaries for the range start and end,
44246 doing auto deduction, and processing decomposition variables.
44248 This function is also called from pt.cc during template instantiation.
44249 In that case SL is NULL_TREE, otherwise it is the current statement
44250 list. */
44251 void
44255 {
44261 {
44265 /* do_auto_deduction doesn't mess with template init-lists. */
44267 {
44271 {
44276 {
44281 }
44282 }
44284 }
44289 {
44292 }
44294 }
44299 /* If an error happened previously do nothing or else a lot of
44300 unhelpful errors would be issued. */
44302 else
44303 {
44304 tree range_temp;
44308 /* Can't bind a reference to an array of runtime bound. */
44310 else
44311 {
44317 LOOKUP_ONLYCONVERTING);
44320 }
44323 }
44334 LOOKUP_ONLYCONVERTING);
44336 /* The new for initialization statement. */
44344 else
44345 {
44348 }
44351 LOOKUP_ONLYCONVERTING);
44353 /* The new for condition. */
44356 else
44362 /* The new increment expression. */
44365 else
44368 tf_warning_or_error);
44372 /* Defer popping sl here. */
44376 {
44381 {
44387 }
44388 }
44392 {
44396 {
44400 {
44406 }
44407 }
44408 }
44410 /* The output ORIG_DECL is not a decl. Instead, it is a tree structure
44411 that holds decls for variables implementing the iterator, represented
44412 as a TREE_LIST whose TREE_CHAIN is a vector. The first two elements
44413 of the vector are decls of scratch variables for the range start and
44414 end that will eventually be bound in the implicit scope surrounding
44415 the whole loop nest. The remaining elements are decls of derived
44416 decomposition variables that are bound inside the loop body. This
44417 structure is further mangled by finish_omp_for into the form required
44418 for the OMP_FOR_ORIG_DECLS field of the OMP_FOR tree node. */\
44427 {
44429 {
44430 /* If cp_finish_decomp was called with processing_template_decl
44431 temporarily set to 1, then decomp names will have deduced
44432 name but the DECL_VALUE_EXPR will be dependent. Hide those
44433 from folding of other loop initializers e.g. for warning
44434 purposes until cp_finish_omp_range_for. */
44439 }
44442 }
44444 }
44446 /* Helper for cp_parser_omp_for_loop, finalize part of range for
44447 inside of the collapsed body. */
44449 void
44451 {
44458 {
44463 {
44464 /* Undo temporary clearing of DECL_HAS_VALUE_EXPR_P done
44465 by cp_convert_omp_range_for above. */
44469 {
44473 }
44474 }
44475 }
44477 /* The declaration is initialized with *__begin inside the loop body. */
44485 }
44487 /* Return true if next tokens contain a standard attribute that contains
44488 omp::directive (DIRECTIVE). */
44490 static bool
44493 {
44501 {
44509 }
44514 location_t last_loc
44523 {
44525 {
44529 cnt++;
44533 {
44537 }
44538 }
44539 }
44541 {
44544 }
44546 {
44548 "%<[[omp::directive(%s)]]%> must be the only specified "
44552 }
44557 }
44559 /* Parse an OpenMP structured block sequence. KIND is the corresponding
44560 separating directive. */
44562 static tree
44565 {
44571 {
44584 kind == PRAGMA_OMP_SCAN
44589 }
44593 }
44596 /* OpenMP 5.0:
44598 scan-loop-body:
44599 { structured-block scan-directive structured-block } */
44601 static void
44603 {
44607 matching_braces braces;
44614 else
44615 {
44617 "%<#pragma omp scan%> with zero preceding executable "
44620 }
44626 {
44636 {
44643 }
44645 {
44648 }
44649 else
44654 }
44655 else
44661 else
44662 {
44665 "%<#pragma omp scan%> with zero succeeding executable "
44668 }
44670 clauses);
44674 }
44677 /* This function parses a single level of a loop nest, invoking itself
44678 recursively if necessary.
44680 loop-nest :: for (...) loop-body
44681 loop-body :: loop-nest
44682 | { [intervening-code] loop-body [intervening-code] }
44683 | final-loop-body
44684 intervening-code :: structured-block-sequence
44685 final-loop-body :: structured-block
44687 For a collapsed loop nest, only a single OMP_FOR is built, pulling out
44688 all the iterator information from the inner loops into vectors in the
44689 parser->omp_for_parse_state structure.
44691 In the "range for" case, it is transformed into a regular "for" iterator
44692 by introducing some temporary variables for the begin/end,
44693 as well as bindings of the actual iteration variables which are
44694 injected into the body of the loop.
44696 Initialization code for iterator variables may end up either in the
44697 init vector (simple assignments), in omp_for_parse_state->pre_body
44698 (decl_exprs for iterators bound in the for statement), or in the
44699 scope surrounding this level of loop initialization.
44701 The scopes of class iterator variables and their finalizers need to
44702 be adjusted after parsing so that all of the initialization happens
44703 in a scope surrounding all of the intervening and body code. For
44704 this reason we separately store the initialization and body blocks
44705 for each level of loops in the omp_for_parse_state structure and
44706 reassemble/reorder them in cp_parser_omp_for. See additional
44707 comments there about the use of placeholders, etc. */
44709 static tree
44711 {
44716 tree init_scope;
44721 location_t loc;
44729 /* We have already matched the FOR token but not consumed it yet. */
44733 /* Forbid break/continue in the loop initializer, condition, and
44734 increment expressions. */
44738 /* We are not in intervening code now. */
44741 /* Don't create location wrapper nodes within an OpenMP "for"
44742 statement. */
44743 auto_suppress_location_wrappers sentinel;
44745 matching_parens parens;
44752 integer_zero_node);
44755 /* The init_block acts as a container for this level of loop goo. */
44759 /* Wrap a scope around this entire level of loop to hold bindings
44760 of loop iteration variables. We can't insert them directly
44761 in the containing scope because that would cause their visibility to
44762 be incorrect with respect to intervening code after this loop.
44763 We will combine the nested init_scopes in postprocessing after the
44764 entire loop is parsed. */
44767 /* Now we need another level of statement list container to capture the
44768 initialization (and possible finalization) bits. In some cases this
44769 container may be popped off during initializer parsing to store code in
44770 INIT or THIS_PRE_BODY, depending on the form of initialization. If
44771 we have a class iterator we will pop it at the end of parsing this
44772 level, so the cleanups are handled correctly. */
44776 {
44777 /* Save tokens so that we can put them back. */
44780 /* Look for ':' that is not nested in () or {}. */
44781 is_range_for
44784 CPP_COLON,
44785 /*consume_paren=*/
44788 /* Roll back the tokens we skipped. */
44792 {
44793 bool saved_colon_corrects_to_scope_p
44796 /* A colon is used in range-based for. */
44799 /* Parse the declaration. */
44801 /*function_definition_allowed_p=*/
44803 parser->colon_corrects_to_scope_p
44817 "%<ordered%> clause with parameter on "
44821 }
44822 }
44824 add_private_clause
44830 /* If the iteration variable was introduced via a declaration in the
44831 for statement, DECL points at it. Otherwise DECL is null and
44832 REAL_DECL is a variable previously declared in an outer scope.
44833 Make REAL_DECL point at the iteration variable no matter where it
44834 was introduced. */
44838 /* Some clauses treat iterator variables specially. */
44843 {
44849 {
44853 }
44856 {
44857 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
44861 {
44865 }
44866 else
44867 {
44870 }
44872 }
44873 else
44874 {
44879 }
44880 }
44883 {
44884 tree c;
44886 {
44895 decl);
44900 decl);
44901 }
44903 {
44910 else
44915 {
44918 /* For linear, signal that we need to fill up
44919 the so far unknown linear step. */
44922 }
44923 }
44924 }
44933 {
44934 /* If decl is an iterator, preserve the operator on decl
44935 until finish_omp_for. */
44937 && ((processing_template_decl
44942 else
44945 }
44947 parse_close_paren:
44953 /* We've parsed all the for (...) stuff now. Store the bits. */
44959 {
44962 }
44964 {
44966 omp_for_parse_state->orig_declv
44969 }
44976 /* Start a nested block for the loop body. */
44978 integer_zero_node);
44986 {
44990 }
44993 {
44994 /* This is the open brace in the loop-body grammar production. Rather
44995 than trying to special-case braces, just parse it as a compound
44996 statement and handle the nested loop-body case there. Note that
44997 when we see a further open brace inside the compound statement
44998 loop-body, we don't know whether it is the start of intervening
44999 code that is a compound statement, or a level of braces
45000 surrounding a nested loop-body. Use the WANT_NESTED_LOOP state
45001 bit to ensure we have only one nested loop at each level. */
45008 {
45009 /* We have already parsed the whole loop body and not found a
45010 nested loop. */
45014 }
45016 }
45017 else
45018 {
45019 /* This is the final-loop-body case in the grammar: we have something
45020 that is not a FOR and not an open brace. */
45022 {
45023 /* If we were expecting a nested loop, give an error and mark
45024 that parsing has failed, and try to recover by parsing the
45025 body as regular code without further collapsing. */
45029 }
45032 /* Generate the parts of range for that belong in the loop body,
45033 to be executed on every iteration. This includes setting the
45034 user-declared decomposition variables from the compiler-generated
45035 temporaries that are the real iteration variables for OMP_FOR.
45036 FIXME: Not sure if this is correct with respect to visibility
45037 of the variables from intervening code. However, putting this
45038 code in each level of loop instead of all around the innermost
45039 body also makes the decomposition variables visible to the
45040 inner for init/bound/step exressions, which is not supposed to
45041 happen and causes test failures. */
45044 {
45049 }
45051 /* Now parse the final-loop-body for the innermost loop. */
45055 else
45058 }
45063 /* Pop and remember the body block. Add the body placeholder
45064 to the surrounding statement list instead. This is just a unique
45065 token that will be replaced when we reassemble the generated
45066 code for the entire omp for statement. */
45071 /* Pop and remember the init block. */
45078 /* Return the init placeholder rather than the remembered init block.
45079 Again, this is just a unique cookie that will be used to reassemble
45080 code pieces when the entire omp for statement has been parsed. */
45082 }
45084 /* Worker for find_structured_blocks. *TP points to a STATEMENT_LIST
45085 and ITER is the element that is or contains a nested loop. This
45086 function moves the statements before and after ITER into
45087 OMP_STRUCTURED_BLOCKs and modifies *TP. */
45088 static void
45090 {
45094 {
45099 TSI_SAME_STMT);
45100 i++;
45102 }
45103 else
45104 {
45108 }
45113 TSI_SAME_STMT);
45114 }
45116 /* Helper to find and mark structured blocks in intervening code for a
45117 single loop level with markers for later error checking. *TP is the
45118 piece of code to be marked and INNER is the inner loop placeholder.
45119 Returns true if INNER was found (recursively) in *TP. */
45120 static bool
45122 {
45128 {
45130 {
45132 /* The normal case is that there is no intervening code and we
45133 do not have to insert any OMP_STRUCTURED_BLOCK markers. */
45135 {
45139 }
45140 }
45142 }
45147 else
45149 }
45151 /* Helpers used for relinking tree structures: In tree rooted at
45152 CONTEXT, replace ORIG with REPLACEMENT. If FLATTEN is true, try to combine
45153 nested BIND_EXPRs. Gives an assertion if it fails to find ORIG. */
45156 tree orig;
45157 tree repl;
45159 };
45161 static tree
45164 {
45167 {
45170 }
45171 /* Remove redundant BIND_EXPRs with no bindings even when not specifically
45172 trying to flatten. */
45177 {
45180 }
45184 {
45186 {
45187 /* Merge binding lists for two directly nested BIND_EXPRs,
45188 keeping the outer one. */
45193 }
45195 /* There might be a statement list containing cleanup_points
45196 etc between the two levels of BIND_EXPR. We can still merge
45197 them, again keeping the outer BIND_EXPR. */
45200 {
45203 {
45208 }
45209 }
45210 }
45212 }
45214 static void
45216 {
45229 }
45231 /* Walker to patch up the BLOCK_NODE hierarchy after the above surgery.
45232 *DP is is the parent block. */
45234 static tree
45236 {
45239 /* BIND_EXPR_BLOCK may be null if the expression is not a
45240 full-expression; if there's no block, no patching is necessary
45241 for this node. */
45243 {
45246 {
45250 }
45255 }
45258 }
45260 /* Parse the restricted form of the for statement allowed by OpenMP. */
45262 static tree
45265 {
45266 tree ret;
45274 tree result;
45281 {
45284 }
45287 {
45290 }
45297 {
45303 }
45309 {
45312 }
45314 /* Initialize parse state for recursive descent. */
45339 /* Bomb out early if there was an error (not enough loops, etc). */
45341 {
45344 }
45346 /* Relink the init and body blocks that were built during parsing. At
45347 this point we have a structure nested like
45348 init 0
45349 body 0
45350 init 1
45351 body 1
45352 init 2
45353 body 2
45354 and we want to turn it into
45355 init 0
45356 init 1
45357 init 2
45358 omp_for
45359 body 0
45360 body 1
45361 body 2
45362 We also need to flatten the init blocks, as some code for later
45363 processing of combined directives gets confused otherwise. */
45370 /* First insert markers for structured blocks for intervening code in
45371 the loop bodies. */
45373 {
45377 }
45379 /* Do the substitution from the inside out. */
45381 {
45388 }
45390 /* Generate the OMP_FOR. Note finish_omp_for adds the OMP_FOR
45391 (and possibly other stuff) to the current statement list but
45392 returns a pointer to the OMP_FOR itself, or null in case of error. */
45400 /* Check for errors involving lb/ub/incr expressions referencing
45401 variables declared in intervening code. */
45407 {
45408 /* Splice the omp_for into the nest of init blocks. */
45413 /* Some later processing for combined directives assumes
45414 that the BIND_EXPR containing range for variables appears
45415 at top level in the OMP_FOR body. Fix that up if it's
45416 not the case, e.g. because there is intervening code. */
45420 /* Clean up the block subblock/superblock links. Per comment in
45421 begin_compound_stmt, "we don't build BLOCK nodes when processing
45422 templates", so skip this step in that case. */
45424 {
45428 }
45430 /* Finally record the result. */
45432 }
45436 }
45438 /* Helper function for OpenMP parsing, split clauses and call
45439 finish_omp_clauses on each of the set of clauses afterwards. */
45441 static void
45444 {
45450 i == C_OMP_CLAUSE_SPLIT_TARGET
45452 }
45454 /* OpenMP 5.0:
45455 #pragma omp loop loop-clause[optseq] new-line
45456 for-loop */
45458 #define OMP_LOOP_CLAUSE_MASK \
45459 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45460 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45461 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45462 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45463 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
45464 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45466 static tree
45470 {
45481 {
45484 }
45496 }
45498 /* OpenMP 4.0:
45499 #pragma omp simd simd-clause[optseq] new-line
45500 for-loop */
45502 #define OMP_SIMD_CLAUSE_MASK \
45503 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
45504 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
45505 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45506 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
45507 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45508 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45509 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45510 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45511 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
45512 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
45513 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45515 static tree
45519 {
45530 {
45533 }
45545 }
45547 /* OpenMP 2.5:
45548 #pragma omp for for-clause[optseq] new-line
45549 for-loop
45551 OpenMP 4.0:
45552 #pragma omp for simd for-simd-clause[optseq] new-line
45553 for-loop */
45555 #define OMP_FOR_CLAUSE_MASK \
45556 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45557 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45558 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45559 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45560 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45561 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
45562 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
45563 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
45564 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45565 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45566 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45568 static tree
45572 {
45579 /* parallel for{, simd} disallows nowait clause, but for
45580 target {teams distribute ,}parallel for{, simd} it should be accepted. */
45583 /* Composite distribute parallel for{, simd} disallows ordered clause. */
45588 {
45593 {
45617 }
45618 }
45620 {
45623 }
45625 /* Composite distribute parallel for disallows linear clause. */
45632 {
45635 }
45647 }
45652 /* OpenMP 2.5:
45653 # pragma omp master new-line
45654 structured-block */
45656 static tree
45660 {
45668 {
45673 {
45693 }
45694 }
45696 {
45699 }
45702 {
45706 }
45707 else
45712 }
45714 /* OpenMP 5.1:
45715 # pragma omp masked masked-clauses new-line
45716 structured-block */
45718 #define OMP_MASKED_CLAUSE_MASK \
45719 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
45721 static tree
45725 {
45734 {
45739 {
45760 }
45761 }
45763 {
45766 }
45771 {
45774 }
45778 clauses);
45779 }
45781 /* OpenMP 2.5:
45782 # pragma omp ordered new-line
45783 structured-block
45785 OpenMP 4.5:
45786 # pragma omp ordered ordered-clauses new-line
45787 structured-block */
45789 #define OMP_ORDERED_CLAUSE_MASK \
45790 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
45791 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
45793 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
45794 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
45795 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DOACROSS))
45797 static bool
45800 {
45808 {
45813 {
45815 {
45818 }
45820 {
45822 "%qs clause may only be used in compound "
45826 }
45827 tree clauses
45829 OMP_ORDERED_DEPEND_CLAUSE_MASK,
45833 }
45834 }
45836 tree clauses
45847 }
45849 /* OpenMP 2.5:
45851 section-scope:
45852 { section-sequence }
45854 section-sequence:
45855 section-directive[opt] structured-block
45856 section-sequence section-directive structured-block */
45858 static tree
45860 {
45865 matching_braces braces;
45872 != PRAGMA_OMP_SECTION
45874 {
45876 PRAGMA_OMP_SECTION);
45879 }
45882 {
45892 {
45896 }
45898 {
45901 }
45904 PRAGMA_OMP_SECTION);
45907 }
45918 }
45920 /* OpenMP 2.5:
45921 # pragma omp sections sections-clause[optseq] newline
45922 sections-scope */
45924 #define OMP_SECTIONS_CLAUSE_MASK \
45925 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45929 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45930 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
45932 static tree
45935 {
45947 {
45950 }
45957 }
45959 /* OpenMP 2.5:
45960 # pragma omp parallel parallel-clause[optseq] new-line
45961 structured-block
45962 # pragma omp parallel for parallel-for-clause[optseq] new-line
45963 structured-block
45964 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
45965 structured-block
45967 OpenMP 4.0:
45968 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
45969 structured-block */
45971 #define OMP_PARALLEL_CLAUSE_MASK \
45972 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
45973 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45974 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45975 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
45976 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
45977 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
45978 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45979 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
45980 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45981 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
45983 static tree
45987 {
45994 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
46000 {
46008 if_p);
46012 if_p);
46015 block);
46020 }
46021 /* When combined with distribute, parallel has to be followed by for.
46022 #pragma omp target parallel is allowed though. */
46026 {
46030 }
46032 {
46036 {
46050 block);
46053 /* masked does have just filter clause, but during gimplification
46054 isn't represented by a gimplification omp context, so for
46055 #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
46056 so that
46057 #pragma omp parallel masked
46058 #pragma omp taskloop simd lastprivate (x)
46059 isn't confused with
46060 #pragma omp parallel masked taskloop simd lastprivate (x) */
46064 }
46066 {
46080 block);
46083 /* master doesn't have any clauses and during gimplification
46084 isn't represented by a gimplification omp context, so for
46085 #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
46086 so that
46087 #pragma omp parallel master
46088 #pragma omp taskloop simd lastprivate (x)
46089 isn't confused with
46090 #pragma omp parallel master taskloop simd lastprivate (x) */
46094 }
46096 {
46111 block);
46116 }
46118 {
46121 }
46123 {
46133 block);
46136 }
46137 }
46139 {
46142 }
46147 {
46150 }
46159 }
46161 /* OpenMP 2.5:
46162 # pragma omp single single-clause[optseq] new-line
46163 structured-block */
46165 #define OMP_SINGLE_CLAUSE_MASK \
46166 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46167 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46168 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
46169 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46170 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46172 static tree
46174 {
46185 }
46187 /* OpenMP 5.1:
46188 # pragma omp scope scope-clause[optseq] new-line
46189 structured-block */
46191 #define OMP_SCOPE_CLAUSE_MASK \
46192 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46193 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46194 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46195 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46196 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46198 static tree
46200 {
46211 }
46213 /* OpenMP 3.0:
46214 # pragma omp task task-clause[optseq] new-line
46215 structured-block */
46217 #define OMP_TASK_CLAUSE_MASK \
46218 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46219 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
46220 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
46221 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46222 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46223 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46224 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
46225 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
46226 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46227 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
46228 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46229 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
46230 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
46231 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
46233 static tree
46235 {
46247 }
46249 /* OpenMP 3.0:
46250 # pragma omp taskwait new-line
46252 OpenMP 5.0:
46253 # pragma omp taskwait taskwait-clause[opt] new-line */
46255 #define OMP_TASKWAIT_CLAUSE_MASK \
46256 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46257 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46259 static void
46261 {
46262 tree clauses
46267 {
46274 }
46275 else
46277 }
46279 /* OpenMP 3.1:
46280 # pragma omp taskyield new-line */
46282 static void
46284 {
46287 }
46289 /* OpenMP 4.0:
46290 # pragma omp taskgroup new-line
46291 structured-block
46293 OpenMP 5.0:
46294 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
46296 #define OMP_TASKGROUP_CLAUSE_MASK \
46297 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46298 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
46300 static tree
46302 {
46303 tree clauses
46308 if_p),
46309 clauses);
46310 }
46313 /* OpenMP 2.5:
46314 # pragma omp threadprivate (variable-list) */
46316 static void
46318 {
46319 tree vars;
46325 }
46327 /* OpenMP 4.0:
46328 # pragma omp cancel cancel-clause[optseq] new-line */
46330 #define OMP_CANCEL_CLAUSE_MASK \
46331 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
46332 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
46333 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
46334 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
46335 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
46337 static void
46339 {
46343 }
46345 /* OpenMP 4.0:
46346 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
46348 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
46349 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
46350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
46351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
46352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
46354 static bool
46357 {
46358 tree clauses;
46362 {
46367 {
46370 }
46371 }
46373 {
46377 }
46380 {
46385 else
46389 }
46392 OMP_CANCELLATION_POINT_CLAUSE_MASK,
46394 pragma_tok);
46397 }
46399 /* OpenMP 4.0:
46400 #pragma omp distribute distribute-clause[optseq] new-line
46401 for-loop */
46403 #define OMP_DISTRIBUTE_CLAUSE_MASK \
46404 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46405 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46406 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46407 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
46408 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46409 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46410 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
46412 static tree
46416 {
46425 {
46433 else
46436 {
46442 {
46446 else
46449 }
46455 else
46469 }
46470 }
46472 {
46475 }
46480 {
46483 }
46495 }
46497 /* OpenMP 4.0:
46498 # pragma omp teams teams-clause[optseq] new-line
46499 structured-block */
46501 #define OMP_TEAMS_CLAUSE_MASK \
46502 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46503 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46504 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46505 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46506 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
46507 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
46508 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46509 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
46511 static tree
46515 {
46524 {
46528 {
46554 }
46556 {
46582 }
46583 }
46585 {
46588 }
46593 {
46596 }
46606 }
46608 /* OpenMP 4.0:
46609 # pragma omp target data target-data-clause[optseq] new-line
46610 structured-block */
46612 #define OMP_TARGET_DATA_CLAUSE_MASK \
46613 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46614 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46615 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46616 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
46617 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
46619 static tree
46621 {
46623 omp_requires_mask
46626 tree clauses
46632 {
46635 {
46661 "%<#pragma omp target data%> with map-type other "
46662 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
46666 }
46671 }
46674 {
46677 "%<#pragma omp target data%> must contain at least "
46678 "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
46681 }
46692 }
46694 /* OpenMP 4.5:
46695 # pragma omp target enter data target-enter-data-clause[optseq] new-line
46696 structured-block */
46698 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
46699 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46700 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46701 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46702 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46703 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46705 static bool
46708 {
46711 {
46716 {
46719 }
46720 }
46722 {
46726 }
46729 {
46735 }
46738 omp_requires_mask
46741 tree clauses
46747 {
46750 {
46784 "%<#pragma omp target enter data%> with map-type other "
46788 }
46790 }
46793 {
46796 "%<#pragma omp target enter data%> must contain at least "
46799 }
46807 }
46809 /* OpenMP 4.5:
46810 # pragma omp target exit data target-enter-data-clause[optseq] new-line
46811 structured-block */
46813 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
46814 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46815 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46816 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46817 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46818 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46820 static bool
46823 {
46826 {
46831 {
46834 }
46835 }
46837 {
46841 }
46844 {
46850 }
46853 omp_requires_mask
46856 tree clauses
46864 {
46867 {
46901 "%<#pragma omp target exit data%> with map-type other "
46902 "than %<from%>, %<tofrom%>, %<release%> or %<delete%> "
46906 }
46908 }
46911 {
46914 "%<#pragma omp target exit data%> must contain at least "
46917 }
46925 }
46927 /* OpenMP 4.0:
46928 # pragma omp target update target-update-clause[optseq] new-line */
46930 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
46931 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
46932 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
46933 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46934 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46936 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46938 static bool
46941 {
46943 {
46949 }
46951 tree clauses
46956 {
46958 "%<#pragma omp target update%> must contain at least one "
46961 }
46964 omp_requires_mask
46973 }
46975 /* OpenMP 4.0:
46976 # pragma omp target target-clause[optseq] new-line
46977 structured-block */
46979 #define OMP_TARGET_CLAUSE_MASK \
46980 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46981 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46982 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46983 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46984 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
46985 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46986 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46987 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
46988 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46989 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
46990 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
46991 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR)\
46992 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR))
46994 static bool
46997 {
46999 omp_requires_mask
47003 {
47015 {
47023 {
47024 tree stmt;
47026 {
47029 OMP_TARGET_CLAUSE_MASK,
47034 OMP_TARGET_CLAUSE_MASK,
47039 OMP_TARGET_CLAUSE_MASK,
47044 }
47046 }
47051 {
47055 if_p);
47060 if_p);
47065 if_p);
47069 }
47075 /* For combined target teams, ensure the num_teams and
47076 thread_limit clause expressions are evaluated on the host,
47077 before entering the target construct. */
47086 {
47089 tf_none);
47096 OMP_CLAUSE_FIRSTPRIVATE);
47101 }
47106 }
47108 {
47111 }
47113 {
47117 }
47119 {
47122 }
47124 {
47127 }
47129 {
47132 }
47133 }
47135 {
47138 }
47145 {
47151 }
47160 }
47162 /* OpenACC 2.0:
47163 # pragma acc cache (variable-list) new-line
47164 */
47166 static tree
47168 {
47169 /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
47170 clauses. */
47171 auto_suppress_location_wrappers sentinel;
47187 }
47189 /* OpenACC 2.0:
47190 # pragma acc data oacc-data-clause[optseq] new-line
47191 structured-block */
47193 #define OACC_DATA_CLAUSE_MASK \
47194 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47195 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47196 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47197 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47198 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47199 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47200 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
47201 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47202 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47203 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47204 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
47206 static tree
47208 {
47221 }
47223 /* OpenACC 2.0:
47224 # pragma acc host_data <clauses> new-line
47225 structured-block */
47227 #define OACC_HOST_DATA_CLAUSE_MASK \
47228 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
47229 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47230 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
47232 static tree
47234 {
47242 {
47246 }
47254 }
47256 /* OpenACC 2.0:
47257 # pragma acc declare oacc-data-clause[optseq] new-line
47258 */
47260 #define OACC_DECLARE_CLAUSE_MASK \
47261 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47262 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47263 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47264 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47265 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47266 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
47267 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
47268 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
47270 static tree
47272 {
47282 {
47286 }
47289 {
47293 {
47297 }
47300 {
47312 {
47314 "%qD must be a global variable in "
47316 decl);
47319 }
47324 {
47328 }
47330 {
47332 "invalid use of %<extern%> variable %qD "
47336 }
47338 {
47340 "invalid use of %<global%> variable %qD "
47344 }
47346 }
47349 /* This seems to ignore the existence of cleanup scopes?
47350 What is the meaning for local extern decls? The local
47351 extern is in this scope, but it is referring to a decl that
47352 is namespace scope. */
47355 {
47358 }
47360 {
47362 "%qD must be a variable declared in the same scope as "
47366 }
47369 {
47371 /* We need to mark the aliased decl, as that is the entity
47372 that is being referred to. This won't work for
47373 dependent variables, but it didn't work for them before
47374 DECL_LOCAL_DECL_P was a thing either. But then
47375 dependent local extern variable decls are as rare as
47376 hen's teeth. */
47384 {
47389 }
47391 tree id;
47394 else
47400 {
47403 {
47406 {
47410 }
47411 }
47412 }
47413 }
47414 }
47427 }
47429 /* OpenACC 2.0:
47430 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
47432 or
47434 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
47436 LOC is the location of the #pragma token.
47437 */
47439 #define OACC_ENTER_DATA_CLAUSE_MASK \
47440 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47441 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47442 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47443 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47444 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47445 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47447 #define OACC_EXIT_DATA_CLAUSE_MASK \
47448 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47449 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47450 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47451 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
47452 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
47453 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
47454 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47456 static tree
47459 {
47468 {
47473 }
47480 else
47485 {
47489 }
47497 }
47499 /* OpenACC 2.0:
47500 # pragma acc loop oacc-loop-clause[optseq] new-line
47501 structured-block */
47503 #define OACC_LOOP_CLAUSE_MASK \
47504 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
47505 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47506 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47507 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
47508 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
47509 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
47510 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
47511 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
47512 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
47513 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
47515 static tree
47518 {
47528 {
47534 }
47541 /* Later processing of combined acc loop constructs gets confused
47542 by an extra level of empty nested BIND_EXPRs, so flatten them. */
47551 }
47553 /* OpenACC 2.0:
47554 # pragma acc kernels oacc-kernels-clause[optseq] new-line
47555 structured-block
47557 or
47559 # pragma acc parallel oacc-parallel-clause[optseq] new-line
47560 structured-block
47562 OpenACC 2.6:
47564 # pragma acc serial oacc-serial-clause[optseq] new-line
47565 */
47567 #define OACC_KERNELS_CLAUSE_MASK \
47568 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47569 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47570 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47571 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47572 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47573 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47574 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47575 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47576 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47577 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47578 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
47579 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
47580 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47581 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47582 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
47583 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47585 #define OACC_PARALLEL_CLAUSE_MASK \
47586 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47587 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47588 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47589 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47590 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47591 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47592 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47593 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47594 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
47595 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47596 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47597 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
47598 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
47599 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47600 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47601 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47602 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47603 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
47604 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47606 #define OACC_SERIAL_CLAUSE_MASK \
47607 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47608 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47609 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47610 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47611 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47612 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47613 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47614 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47615 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47616 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47617 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47618 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
47619 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47620 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47621 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47622 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47624 static tree
47627 {
47628 omp_clause_mask mask;
47631 {
47649 }
47652 {
47656 {
47659 tree clauses;
47664 }
47665 }
47676 }
47678 /* OpenACC 2.0:
47679 # pragma acc update oacc-update-clause[optseq] new-line
47680 */
47682 #define OACC_UPDATE_CLAUSE_MASK \
47683 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
47685 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
47686 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47687 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
47688 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47689 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
47691 static tree
47693 {
47700 {
47702 "%<#pragma acc update%> must contain at least one "
47705 }
47713 }
47715 /* OpenACC 2.0:
47716 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
47718 LOC is the location of the #pragma token.
47719 */
47721 #define OACC_WAIT_CLAUSE_MASK \
47722 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
47724 static tree
47726 {
47740 }
47742 /* OpenMP 4.0:
47743 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
47745 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
47746 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
47747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
47748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
47749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
47750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
47751 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
47753 static void
47757 {
47759 cp_omp_declare_simd_data data;
47761 {
47769 /* It is safe to take the address of a local variable; it will only be
47770 used while this scope is live. */
47772 }
47774 {
47776 "%<#pragma omp declare %s%> followed by "
47781 }
47783 /* Store away all pragma tokens. */
47792 {
47796 {
47809 }
47814 "%<#pragma omp declare %s%> not immediately followed by "
47819 }
47820 }
47822 /* OpenMP 5.0:
47824 trait-selector:
47825 trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
47827 trait-score:
47828 score(score-expression)
47830 Note that this function returns a list of trait selectors for the
47831 trait-selector-set SET. */
47833 static tree
47836 {
47838 do
47839 {
47840 tree selector;
47844 else
47845 {
47848 }
47850 enum omp_ts_code sel
47854 {
47855 /* Per the spec, "Implementations can ignore specified selectors
47856 that are not those described in this section"; however, we
47857 must record such selectors because they cause match failures. */
47859 OPT_Wopenmp,
47869 {
47872 }
47873 else
47875 }
47883 tree t;
47886 {
47888 {
47892 }
47894 matching_parens parens;
47901 {
47908 {
47912 matching_parens parens2;
47921 "%<score%> cannot be specified in traits "
47925 {
47936 else
47938 }
47939 }
47940 else
47944 }
47947 {
47951 {
47955 properties);
47956 }
47957 else
47958 {
47961 }
47964 do
47965 {
47970 {
47973 }
47978 else
47979 {
47983 }
47989 else
47991 }
47996 /* FIXME: this is bogus, the expression need
47997 not be constant. */
48000 {
48007 else
48009 properties);
48010 }
48011 else
48016 {
48018 {
48020 "selector may not be specified in "
48023 }
48024 properties
48026 OMP_DECLARE_SIMD_CLAUSE_MASK,
48028 }
48030 {
48031 /* FIXME: The "requires" selector was added in OpenMP 5.1.
48032 Currently only the now-deprecated syntax
48033 from OpenMP 5.0 is supported. */
48037 }
48038 else
48043 }
48049 }
48053 {
48056 }
48062 else
48064 }
48068 }
48070 /* OpenMP 5.0:
48072 trait-set-selector[,trait-set-selector[,...]]
48074 trait-set-selector:
48075 trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
48077 trait-set-selector-name:
48078 constructor
48079 device
48080 implementation
48081 user */
48083 static tree
48086 {
48088 do
48089 {
48092 setp
48097 {
48100 }
48107 matching_braces braces;
48111 tree selectors
48114 {
48117 }
48125 else
48127 }
48133 }
48135 /* Assumption clauses:
48136 OpenMP 5.1
48137 absent (directive-name-list)
48138 contains (directive-name-list)
48139 holds (expression)
48140 no_openmp
48141 no_openmp_routines
48142 no_parallelism */
48144 static void
48147 {
48162 {
48175 {
48180 }
48182 {
48187 }
48189 {
48194 }
48196 {
48198 matching_parens parens;
48200 {
48212 }
48213 }
48215 {
48217 matching_parens parens;
48219 {
48220 do
48221 {
48224 location_t dloc
48227 {
48228 tree id;
48233 CPP_KEYWORD))
48234 {
48235 enum rid rid
48239 }
48240 else
48243 }
48246 else
48247 {
48260 else
48261 {
48266 "mentioned in both %<absent%> and "
48274 ? &absent_head
48277 "mentioned multiple times in %qs "
48284 }
48287 }
48290 else
48292 }
48299 }
48300 }
48302 {
48309 }
48310 else
48311 {
48315 }
48316 }
48318 }
48320 /* OpenMP 5.1
48321 # pragma omp assume clauses[optseq] new-line */
48323 static void
48325 {
48328 }
48330 /* OpenMP 5.1
48331 # pragma omp assumes clauses[optseq] new-line */
48333 static bool
48335 {
48338 }
48340 /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
48341 that into "omp declare variant base" attribute. */
48343 static tree
48345 tree attrs)
48346 {
48347 matching_parens parens;
48349 {
48350 fail:
48353 }
48358 cp_expr varid
48366 tree variant;
48373 else
48374 {
48375 tree ambiguous_decls;
48383 }
48387 {
48389 variant
48397 }
48412 {
48415 }
48427 {
48429 match_loc);
48438 }
48443 }
48446 /* Finalize #pragma omp declare simd clauses after direct declarator has
48447 been parsed, and put that into "omp declare simd" attribute. */
48449 static tree
48451 {
48457 {
48462 }
48467 {
48478 {
48481 pragma_tok);
48489 }
48490 else
48491 {
48493 attrs
48495 }
48497 }
48501 {
48507 {
48509 {
48516 {
48524 else
48527 }
48533 {
48535 "unknown OpenMP directive name in "
48540 }
48544 {
48546 "OpenMP directive other than %<declare simd%> "
48547 "or %<declare variant%> appertains to a "
48550 }
48553 {
48555 "mixing OpenMP directives with attribute and "
48558 }
48563 {
48566 }
48568 cp_token tok = {};
48576 tok = {};
48581 tok = {};
48593 /* Move the current source position to that of the first token
48594 in the new lexer. */
48604 {
48612 pragma_tok);
48616 cl);
48621 }
48622 else
48623 {
48625 attrs
48627 attrs);
48628 }
48631 }
48633 }
48634 else
48636 }
48642 }
48644 /* D should be DEFERRED_PARSE from omp::decl attribute. If it contains
48645 a threadprivate, groupprivate, allocate or declare target directive,
48646 return true and parse it for DECL. */
48648 bool
48650 {
48656 {
48664 else
48667 }
48673 {
48675 "unknown OpenMP directive name in "
48678 }
48680 /* && dir->id != PRAGMA_OMP_GROUPPRIVATE */
48694 cp_token tok = {};
48702 tok = {};
48707 tok = {};
48719 /* Move the current source position to that of the first token in the
48720 new lexer. */
48725 }
48727 /* Helper for cp_parser_omp_declare_target, handle one to or link clause
48728 on #pragma omp declare target. Return false if errors were reported. */
48730 static bool
48733 {
48736 tree id;
48738 {
48741 }
48742 else
48745 {
48748 "%qD specified both in declare target %<link%> and %qs"
48750 else
48752 "%qD specified both in declare target %<link%> and "
48755 }
48757 {
48764 {
48767 {
48771 }
48772 }
48773 }
48777 {
48781 {
48784 }
48785 }
48787 {
48791 {
48794 }
48795 }
48797 {
48801 {
48805 }
48806 }
48808 }
48810 /* OpenMP 4.0:
48811 # pragma omp declare target new-line
48812 declarations and definitions
48813 # pragma omp end declare target new-line
48815 OpenMP 4.5:
48816 # pragma omp declare target ( extended-list ) new-line
48818 # pragma omp declare target declare-target-clauses[seq] new-line */
48820 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
48821 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
48822 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \
48823 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
48824 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
48825 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
48827 static void
48829 {
48837 clauses
48842 {
48844 clauses);
48847 }
48848 else
48849 {
48850 cp_omp_declare_target_attr a
48855 }
48857 {
48862 }
48864 {
48879 }
48885 "%<device_type%> clause must specify 'any' when used with "
48887 }
48889 /* OpenMP 5.1
48890 # pragma omp begin assumes clauses[optseq] new-line
48892 # pragma omp begin declare target clauses[optseq] new-line */
48894 #define OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK \
48895 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
48896 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
48898 static void
48900 {
48904 {
48907 }
48909 {
48913 {
48916 }
48918 {
48920 tree clauses
48922 OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK,
48924 pragma_tok);
48928 {
48933 }
48934 cp_omp_declare_target_attr a
48937 }
48938 else
48939 {
48942 }
48943 }
48945 {
48950 }
48951 else
48952 {
48955 }
48956 }
48958 /* OpenMP 4.0:
48959 # pragma omp end declare target new-line
48961 OpenMP 5.1:
48962 # pragma omp end assumes new-line */
48964 static void
48966 {
48970 {
48973 }
48975 {
48979 {
48982 }
48985 else
48986 {
48990 }
48994 "%<#pragma omp end declare target%> without corresponding "
48995 "%<#pragma omp declare target%> or "
48997 else
48998 {
48999 cp_omp_declare_target_attr
49002 {
49005 "%qs in attribute syntax terminated "
49010 else
49012 "%qs in pragma syntax terminated "
49017 }
49018 }
49019 }
49021 {
49028 else
49029 {
49030 cp_omp_begin_assumes_data
49033 {
49036 "%qs in attribute syntax terminated "
49039 else
49041 "%qs in pragma syntax terminated "
49044 }
49045 }
49046 }
49047 else
49048 {
49052 }
49053 }
49055 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
49056 expression and optional initializer clause of
49057 #pragma omp declare reduction. We store the expression(s) as
49058 either 3, 6 or 7 special statements inside of the artificial function's
49059 body. The first two statements are DECL_EXPRs for the artificial
49060 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
49061 expression that uses those variables.
49062 If there was any INITIALIZER clause, this is followed by further statements,
49063 the fourth and fifth statements are DECL_EXPRs for the artificial
49064 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
49065 constructor variant (first token after open paren is not omp_priv),
49066 then the sixth statement is a statement with the function call expression
49067 that uses the OMP_PRIV and optionally OMP_ORIG variable.
49068 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
49069 to initialize the OMP_PRIV artificial variable and there is seventh
49070 statement, a DECL_EXPR of the OMP_PRIV statement again. */
49072 static bool
49074 {
49086 tree combiner;
49107 {
49110 }
49113 {
49115 matching_parens parens;
49121 {
49124 }
49140 {
49144 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
49148 == CPP_CLOSE_PAREN
49151 {
49155 }
49161 }
49162 else
49163 {
49165 /* Don't create location wrapper nodes here. */
49166 auto_suppress_location_wrappers sentinel;
49181 {
49186 }
49188 tree arg;
49201 }
49214 }
49218 UNKNOWN_LOCATION);
49221 }
49223 /* OpenMP 4.0
49224 #pragma omp declare reduction (reduction-id : typename-list : expression) \
49225 initializer-clause[opt] new-line
49227 initializer-clause:
49228 initializer (omp_priv initializer)
49229 initializer (function-name (argument-list)) */
49231 static void
49234 {
49244 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
49251 {
49283 }
49295 /* Types may not be defined in declare reduction type list. */
49298 parser->type_definition_forbidden_message
49304 saved_colon_doesnt_start_class_def_p
49309 {
49313 ;
49331 else
49336 else
49338 }
49340 /* Restore the saved message. */
49343 parser->colon_doesnt_start_class_def_p
49348 {
49349 fail:
49352 }
49358 {
49359 tree fntype
49362 NULL_TREE);
49379 {
49383 }
49389 {
49392 }
49394 {
49396 {
49402 }
49409 }
49410 else
49411 {
49414 /* We should never meet a matched duplicate decl. */
49416 }
49421 else
49424 {
49427 }
49435 else
49436 {
49440 }
49445 {
49453 }
49461 }
49465 done:
49466 /* Free any declarators allocated. */
49468 }
49470 /* OpenMP 4.0
49471 #pragma omp declare simd declare-simd-clauses[optseq] new-line
49472 #pragma omp declare reduction (reduction-id : typename-list : expression) \
49473 initializer-clause[opt] new-line
49474 #pragma omp declare target new-line
49476 OpenMP 5.0
49477 #pragma omp declare variant (identifier) match (context-selector) */
49479 static bool
49482 {
49484 {
49489 {
49494 }
49496 {
49501 }
49504 {
49507 context);
49509 }
49511 {
49514 }
49516 {
49520 }
49521 }
49526 }
49528 /* OpenMP 5.0
49529 #pragma omp requires clauses[optseq] new-line */
49531 static bool
49533 {
49538 {
49544 {
49559 {
49562 matching_parens parens;
49564 {
49566 {
49571 this_req
49574 this_req
49577 this_req
49580 this_req
49583 this_req
49585 }
49587 {
49589 "expected %<acq_rel%>, %<acquire%>, "
49592 {
49599 CPP_CLOSE_PAREN))
49602 }
49603 }
49604 else
49611 /*consume_paren=*/
49615 {
49618 }
49619 }
49621 }
49622 else
49623 {
49625 "%<unified_shared_memory%>, "
49626 "%<dynamic_allocators%>, "
49627 "%<reverse_offload%> "
49631 }
49635 {
49637 {
49644 }
49646 {
49650 }
49653 {
49656 this_req
49658 (omp_requires_mask
49660 }
49664 "lexically after first %<atomic%> construct "
49667 omp_requires_mask
49670 }
49671 }
49673 }
49679 }
49682 /* OpenMP 5.1:
49683 #pragma omp nothing new-line */
49685 static void
49687 {
49689 }
49692 /* OpenMP 5.1
49693 #pragma omp error clauses[optseq] new-line */
49695 static bool
49698 {
49706 {
49719 };
49727 {
49730 }
49732 {
49737 }
49741 matching_parens parens;
49743 {
49745 {
49749 else
49751 tf_warning_or_error,
49752 LOOKUP_NORMAL);
49753 }
49754 else
49755 {
49757 {
49765 }
49767 {
49772 {
49779 CPP_CLOSE_PAREN))
49782 }
49783 }
49784 else
49786 }
49792 /*consume_paren=*/
49796 {
49798 {
49801 }
49802 else
49804 }
49806 {
49808 {
49811 }
49812 else
49814 }
49815 }
49816 else
49818 }
49828 {
49830 {
49834 }
49835 tree fndecl
49844 }
49851 {
49855 }
49859 else
49863 }
49865 /* OpenMP 4.5:
49866 #pragma omp taskloop taskloop-clause[optseq] new-line
49867 for-loop
49869 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
49870 for-loop */
49872 #define OMP_TASKLOOP_CLAUSE_MASK \
49873 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
49874 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
49875 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
49876 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
49877 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
49878 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
49879 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
49880 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
49881 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
49882 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
49883 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
49884 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
49885 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
49886 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
49887 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
49888 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
49889 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
49891 static tree
49895 {
49902 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
49903 clause. */
49908 {
49913 {
49937 }
49938 }
49940 {
49943 }
49948 {
49951 }
49958 if_p);
49964 }
49967 /* OpenACC 2.0:
49968 # pragma acc routine oacc-routine-clause[optseq] new-line
49969 function-definition
49971 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
49972 */
49974 #define OACC_ROUTINE_CLAUSE_MASK \
49975 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
49976 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
49977 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
49978 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
49979 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
49981 /* Parse the OpenACC routine pragma. This has an optional '( name )'
49982 component, which must resolve to a declared namespace-scope
49983 function. The clauses are either processed directly (for a named
49984 function), or defered until the immediatley following declaration
49985 is parsed. */
49987 static void
49990 {
49992 /* The checking for "another pragma following this one" in the "no optional
49993 '( name )'" case makes sure that we dont re-enter. */
49996 cp_oacc_routine_data data;
50002 /* It is safe to take the address of a local variable; it will only be
50003 used while this scope is live. */
50006 /* Look for optional '( name )'. */
50008 {
50009 matching_parens parens;
50012 /* We parse the name as an id-expression. If it resolves to
50013 anything other than a non-overloaded function at namespace
50014 scope, it's an error. */
50030 {
50034 }
50036 data.clauses
50040 /* The clauses are in reverse order; fix that to make later diagnostic
50041 emission easier. */
50047 {
50052 }
50054 /* Perhaps we should use the same rule as declarations in different
50055 namespaces? */
50057 {
50062 }
50065 {
50069 }
50073 }
50075 {
50076 /* Store away all pragma tokens. */
50084 /* Emit a helpful diagnostic if there's another pragma following this
50085 one. */
50087 {
50090 /* ..., and then just keep going. */
50092 }
50094 /* We only have to consider the pragma_external case here. */
50099 else
50102 }
50103 }
50105 /* Finalize #pragma acc routine clauses after direct declarator has
50106 been parsed. */
50108 static tree
50110 {
50115 {
50117 "%<#pragma acc routine%> not immediately followed by "
50120 }
50136 /* The clauses are in reverse order; fix that to make later diagnostic
50137 emission easier. */
50140 /* Later, cp_finalize_oacc_routine will process the clauses. */
50144 }
50146 /* Apply any saved OpenACC routine clauses to a just-parsed
50147 declaration. */
50149 static void
50151 {
50153 {
50154 /* Keep going if we're in error reporting mode. */
50160 {
50162 {
50164 "%<#pragma acc routine%> not immediately followed by"
50168 }
50172 }
50174 int compatible
50179 {
50182 }
50184 {
50185 }
50186 else
50187 {
50189 {
50198 }
50200 /* Set the routine's level of parallelism. */
50204 /* Add an "omp declare target" attribute. */
50209 }
50210 }
50211 }
50213 /* Main entry point to OpenMP statement pragmas. */
50215 static void
50217 {
50218 tree stmt;
50223 {
50251 if_p);
50271 if_p);
50276 if_p);
50281 if_p);
50286 if_p);
50291 if_p);
50296 if_p);
50308 if_p);
50322 if_p);
50327 if_p);
50334 }
50337 }
50338 \f
50339 /* Transactional Memory parsing routines. */
50341 /* Parse a transaction attribute.
50343 txn-attribute:
50344 attribute
50345 [ [ identifier ] ]
50347 We use this instead of cp_parser_attributes_opt for transactions to avoid
50348 the pedwarn in C++98 mode. */
50350 static tree
50352 {
50367 {
50371 /* For keywords, use the canonical spelling,
50372 not the parsed identifier. */
50376 }
50377 else
50381 error1:
50384 }
50386 /* Parse a __transaction_atomic or __transaction_relaxed statement.
50388 transaction-statement:
50389 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
50390 compound-statement
50391 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
50392 */
50394 static tree
50396 {
50407 else
50408 {
50412 }
50414 /* Parse a noexcept specification. */
50418 {
50419 /* cancel-and-throw is unimplemented. */
50422 }
50423 else
50425 CP_PARSER_FLAGS_NONE,
50430 /* Keep track if we're in the lexical scope of an outer transaction. */
50442 }
50444 /* Parse a __transaction_atomic or __transaction_relaxed expression.
50446 transaction-expression:
50447 __transaction_atomic txn-noexcept-spec[opt] ( expression )
50448 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
50449 */
50451 static tree
50453 {
50466 keyword == RID_TRANSACTION_RELAXED
50480 /* Set this early. This might mean that we allow transaction_cancel in
50481 an expression that we find out later actually has to be a constexpr.
50482 However, we expect that cxx_constant_value will be able to deal with
50483 this; also, if the noexcept has no constexpr, then what we parse next
50484 really is a transaction's body. */
50487 /* Parse a noexcept specification. */
50489 CP_PARSER_FLAGS_NONE,
50496 {
50497 matching_parens parens;
50504 }
50505 else
50506 {
50507 /* The only expression that is available got parsed for the noexcept
50508 already. noexcept is true then. */
50511 }
50520 }
50522 /* Parse a function-transaction-block.
50524 function-transaction-block:
50525 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
50526 function-body
50527 __transaction_atomic txn-attribute[opt] function-try-block
50528 __transaction_relaxed ctor-initializer[opt] function-body
50529 __transaction_relaxed function-try-block
50530 */
50532 static void
50534 {
50549 else
50550 {
50554 }
50562 else
50563 cp_parser_ctor_initializer_opt_and_function_body
50569 }
50571 /* Parse a __transaction_cancel statement.
50573 cancel-statement:
50574 __transaction_cancel txn-attribute[opt] ;
50575 __transaction_cancel txn-attribute[opt] throw-expression ;
50577 ??? Cancel and throw is not yet implemented. */
50579 static tree
50581 {
50587 RT_TRANSACTION_CANCEL);
50594 /* ??? Parse cancel-and-throw here. */
50599 {
50603 }
50605 {
50609 }
50611 {
50614 {
50620 }
50621 }
50623 {
50627 }
50633 }
50634 \f
50636 /* Special handling for the first token or line in the file. The first
50637 thing in the file might be #pragma GCC pch_preprocess, which loads a
50638 PCH file, which is a GC collection point. So we need to handle this
50639 first pragma without benefit of an existing lexer structure.
50641 Always returns one token to the caller in *FIRST_TOKEN. This is
50642 either the true first token of the file, or the first token after
50643 the initial pragma. */
50645 static void
50647 {
50655 {
50659 }
50661 /* Skip to the end of the pragma. */
50663 {
50666 do
50669 }
50671 /* Now actually load the PCH file. */
50675 /* Read one more token to return to our caller. We have to do this
50676 after reading the PCH file in, since its pointers have to be
50677 live. */
50679 }
50681 /* Parse a pragma GCC ivdep. */
50683 static bool
50685 {
50688 }
50690 /* Parse a pragma GCC unroll. */
50692 static tree
50694 {
50700 }
50702 /* Parse a pragma GCC novector. */
50704 static bool
50706 {
50709 }
50711 /* Normal parsing of a pragma token. Here we can (and must) use the
50712 regular lexer. */
50714 static bool
50716 {
50719 tree stmt;
50731 {
50737 }
50741 {
50749 {
50760 }
50765 {
50776 }
50781 {
50792 }
50797 {
50809 }
50814 {
50826 }
50831 {
50843 }
50862 {
50868 }
50876 {
50882 }
50890 {
50895 }
50901 {
50907 }
50915 {
50921 }
50963 {
50965 "%<#pragma omp requires%> may only be used at file or "
50969 }
50974 {
50976 "%<#pragma omp assumes%> may only be used at file or "
50980 }
51016 "%<#pragma omp scan%> may only be used in "
51022 "%<#pragma omp section%> may only be used in "
51029 {
51036 {
51048 }
51051 {
51054 pragma_str);
51056 }
51060 do
51061 {
51063 {
51065 {
51070 }
51072 {
51077 }
51079 {
51084 }
51088 }
51091 }
51098 {
51101 }
51104 }
51111 bad_stmt:
51114 }
51118 }
51120 /* Helper for pragma_lex in preprocess-only mode; in this mode, we have not
51121 populated the lexer with any tokens (the tokens rather being read by
51122 c-ppoutput.c's machinery), so we need to read enough tokens now to handle
51123 a pragma. */
51124 static void
51126 {
51131 /* Read the rest of the tokens comprising the pragma line. */
51133 do
51134 {
51141 }
51143 /* The interface the pragma parsers have to the lexer. */
51145 enum cpp_ttype
51147 {
51163 else
51164 {
51168 }
51171 }
51173 void
51175 {
51176 /* We have already read all the tokens, so we just need to discard
51177 them here. */
51181 }
51183 \f
51184 /* External interface. */
51186 /* Parse one entire translation unit. */
51188 void
51190 {
51198 /* cp_lexer_new_main is called before doing any GC allocation
51199 because tokenization might load a PCH file. */
51208 }
51210 /* Create an identifier for a generic parameter type (a synthesized
51211 template parameter implied by `auto' or a concept identifier). */
51214 static tree
51216 {
51220 }
51222 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
51223 (creating a new template parameter list if necessary). Returns the newly
51224 created template type parm. */
51226 static tree
51228 {
51229 /* A requires-clause is not a function and cannot have placeholders. */
51231 {
51234 }
51238 /* We are either continuing a function template that already contains implicit
51239 template parameters, creating a new fully-implicit function template, or
51240 extending an existing explicit function template with implicit template
51241 parameters. */
51249 {
51253 }
51254 else
51255 {
51256 /* Roll back to the existing template parameter scope (in the case of
51257 extending an explicit function template) or introduce a new template
51258 parameter scope ahead of the function parameter scope (or class scope
51259 in the case of out-of-line member definitions). The function scope is
51260 added back after template parameter synthesis below. */
51265 {
51268 }
51270 {
51271 /* If not defining a class, then any class scope is a scope level in
51272 an out-of-line member definition. In this case simply wind back
51273 beyond the first such scope to inject the template parameter list.
51274 Otherwise wind back to the class being defined. The latter can
51275 occur in class member friend declarations such as:
51277 class A {
51278 void foo (auto);
51279 };
51280 class B {
51281 friend void A::foo (auto);
51282 };
51284 The template parameter list synthesized for the friend declaration
51285 must be injected in the scope of 'B'. This can also occur in
51286 erroneous cases such as:
51288 struct A {
51289 struct B {
51290 void foo (auto);
51291 };
51292 void B::foo (auto) {}
51293 };
51295 Here the attempted definition of 'B::foo' within 'A' is ill-formed
51296 but, nevertheless, the template parameter list synthesized for the
51297 declarator should be injected into the scope of 'A' as if the
51298 ill-formed template was specified explicitly. */
51301 {
51304 }
51305 }
51311 {
51312 /* Introduce a new template parameter list for implicit template
51313 parameters. */
51317 parser->implicit_template_scope
51324 }
51325 else
51326 {
51327 /* Synthesize implicit template parameters at the end of the explicit
51328 template parameter list. */
51335 parser->implicit_template_parms
51337 }
51338 }
51340 /* Synthesize a new template parameter and track the current template
51341 parameter chain with implicit_template_parms. */
51347 /* Synthesize the type template parameter. */
51355 /* Attach the constraint to the parm before processing. */
51358 tree new_parm
51360 input_location,
51361 node,
51364 // Process_template_parm returns the list of parms, and
51365 // parser->implicit_template_parms holds the final node of the parm
51366 // list. We really want to manipulate the newly appended element.
51373 // Record the last implicit parm node
51376 /* Mark the synthetic declaration "virtual". This is used when
51377 comparing template-heads to determine if whether an abbreviated
51378 function template is equivalent to an explicit template.
51380 Note that DECL_ARTIFICIAL is used elsewhere for template
51381 parameters. */
51387 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
51390 /* If creating a fully implicit function template, start the new implicit
51391 template parameter list with this synthesized type, otherwise grow the
51392 current template parameter list. */
51395 {
51401 }
51402 else
51403 {
51408 }
51410 /* If the new parameter was constrained, we need to add that to the
51411 constraints in the template parameter list. */
51413 {
51417 }
51422 }
51424 /* Finish the declaration of a fully implicit function template. Such a
51425 template has no explicit template parameter list so has not been through the
51426 normal template head and tail processing. synthesize_implicit_template_parm
51427 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
51428 provided if the declaration is a class member such that its template
51429 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
51430 form is returned. Otherwise NULL_TREE is returned. */
51432 static tree
51434 {
51439 {
51443 }
51455 }
51457 /* Like finish_fully_implicit_template, but to be used in error
51458 recovery, rearranging scopes so that we restore the state we had
51459 before synthesize_implicit_template_parm inserted the implement
51460 template parms scope. */
51462 static void
51464 {
51469 {
51478 }
51479 else
51485 }
51487 /* Helper function for diagnostics that have complained about things
51488 being used with 'extern "C"' linkage.
51490 Attempt to issue a note showing where the 'extern "C"' linkage began. */
51492 void
51494 {
51498 }