| blob | d71522dcd74ddbc1b9192b16225a936a357ae25a |
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. */
1318 {
1322 }
1325 {
1328 }
1331 }
1333 /* Return the next token, and advance the lexer's next_token pointer
1334 to point to the next non-purged token. */
1338 {
1341 do
1342 {
1345 }
1350 /* Provide debugging output. */
1352 {
1356 }
1359 }
1361 /* Permanently remove the next token from the token stream, and
1362 advance the next_token pointer to refer to the next non-purged
1363 token. */
1365 static void
1367 {
1376 do
1377 tok++;
1380 }
1382 /* Permanently remove all tokens after TOK, up to, but not
1383 including, the token that will be returned next by
1384 cp_lexer_peek_token. */
1386 static void
1388 {
1394 {
1399 }
1400 }
1402 /* Begin saving tokens. All tokens consumed after this point will be
1403 preserved. */
1405 static void
1407 {
1408 /* Provide debugging output. */
1413 }
1415 /* Commit to the portion of the token stream most recently saved. */
1417 static void
1419 {
1420 /* Provide debugging output. */
1425 }
1427 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1428 to the token stream. Stop saving tokens. */
1430 static void
1432 {
1433 /* Provide debugging output. */
1438 }
1440 /* Determines what saved_token_sentinel does when going out of scope. */
1443 STS_COMMIT,
1444 STS_ROLLBACK,
1445 STS_DONOTHING
1446 };
1448 /* RAII wrapper around the above functions, with sanity checking (the token
1449 stream should be the same at the point of instantiation as it is at the
1450 point of destruction).
1452 Creating a variable saves tokens. MODE determines what happens when the
1453 object is destroyed. STS_COMMIT commits tokens (default),
1454 STS_ROLLBACK rolls-back and STS_DONOTHING does nothing. Calling
1455 rollback() will immediately roll-back tokens and set MODE to
1456 STS_DONOTHING. */
1458 struct saved_token_sentinel
1459 {
1462 saved_token_sentinel_mode mode;
1466 {
1469 }
1471 {
1473 cp_lexer_set_source_position_from_token
1476 }
1478 {
1485 }
1486 };
1488 /* Print a representation of the TOKEN on the STREAM. */
1490 static void
1492 {
1493 /* We don't use cpp_type2name here because the parser defines
1494 a few tokens of its own. */
1496 /* cpplib-defined token types */
1497 #define OP(e, s) #e,
1498 #define TK(e, s) #e,
1499 TTYPE_TABLE
1500 #undef OP
1501 #undef TK
1502 /* C++ parser token types - see "Manifest constants", above. */
1506 };
1508 /* For some tokens, print the associated data. */
1510 {
1512 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1513 For example, `struct' is mapped to an INTEGER_CST. */
1516 /* fall through */
1534 /* If we have a name for the token, print it out. Otherwise, we
1535 simply give the numeric code. */
1538 else
1541 }
1542 }
1544 DEBUG_FUNCTION void
1546 {
1549 }
1551 DEBUG_FUNCTION void
1553 {
1556 else
1558 }
1561 /* Start emitting debugging information. */
1563 static void
1565 {
1572 }
1574 /* Stop emitting debugging information. */
1576 static void
1578 {
1585 }
1587 /* Create a new cp_token_cache, representing a range of tokens. */
1591 {
1596 }
1598 /* Diagnose if #pragma omp declare simd isn't followed immediately
1599 by function declaration or definition. */
1603 {
1605 {
1610 }
1611 }
1613 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1614 and put that into "omp declare simd" attribute. */
1618 {
1620 {
1622 {
1625 }
1627 {
1630 }
1631 }
1632 }
1634 /* Similarly, but for use in declaration parsing functions
1635 which call cp_parser_handle_directive_omp_attributes. */
1639 {
1646 "%<declare %s%> directive not immediately followed by "
1650 }
1652 /* Diagnose if #pragma acc routine isn't followed immediately by function
1653 declaration or definition. */
1657 {
1659 {
1661 "%<#pragma acc routine%> not immediately followed by "
1664 }
1665 }
1666 \f
1667 /* Decl-specifiers. */
1669 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1671 static void
1673 {
1675 }
1677 /* Declarators. */
1679 /* Nothing other than the parser should be creating declarators;
1680 declarators are a semi-syntactic representation of C++ entities.
1681 Other parts of the front end that need to create entities (like
1682 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1696 /* An erroneous declarator. */
1699 /* The obstack on which declarators and related data structures are
1700 allocated. */
1703 /* Alloc BYTES from the declarator memory pool. */
1707 {
1709 }
1711 /* Allocate a declarator of the indicated KIND. Clear fields that are
1712 common to all declarators. */
1716 {
1730 }
1732 /* Make a declarator for a generalized identifier. If
1733 QUALIFYING_SCOPE is non-NULL, the identifier is
1734 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1735 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1736 is, if any. */
1741 {
1744 /* It is valid to write:
1746 class C { void f(); };
1747 typedef C D;
1748 void D::f();
1750 The standard is not clear about whether `typedef const C D' is
1751 legal; as of 2002-09-15 the committee is considering that
1752 question. EDG 3.0 allows that syntax. Therefore, we do as
1753 well. */
1768 }
1770 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1771 of modifiers such as const or volatile to apply to the pointer
1772 type, represented as identifiers. ATTRIBUTES represent the attributes that
1773 appertain to the pointer or reference. */
1775 cp_declarator *
1777 tree attributes)
1778 {
1786 {
1790 }
1791 else
1797 }
1799 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1800 represent the attributes that appertain to the pointer or
1801 reference. */
1803 cp_declarator *
1806 {
1814 {
1818 }
1819 else
1825 }
1827 /* Like make_pointer_declarator -- but for a pointer to a non-static
1828 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1829 appertain to the pointer or reference. */
1831 cp_declarator *
1834 tree attributes)
1835 {
1844 {
1847 }
1848 else
1854 }
1856 /* Make a declarator for the function given by TARGET, with the
1857 indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1858 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1859 indicates what exceptions can be thrown. STD_ATTRS contains
1860 attributes that appertain to the function type. */
1862 cp_declarator *
1864 tree parms,
1865 cp_cv_quals cv_qualifiers,
1866 cp_virt_specifiers virt_specifiers,
1867 cp_ref_qualifier ref_qualifier,
1868 tree tx_qualifier,
1869 tree exception_specification,
1870 tree late_return_type,
1871 tree requires_clause,
1872 tree std_attrs,
1873 location_t parens_loc)
1874 {
1889 {
1893 }
1894 else
1900 }
1902 /* Make a declarator for an array of BOUNDS elements, each of which is
1903 defined by ELEMENT. */
1905 cp_declarator *
1907 {
1914 {
1918 }
1919 else
1923 }
1925 /* Determine whether the declarator we've seen so far can be a
1926 parameter pack, when followed by an ellipsis. */
1927 static bool
1929 {
1931 /* We already saw an ellipsis. */
1934 /* Search for a declarator name, or any other declarator that goes
1935 after the point where the ellipsis could appear in a parameter
1936 pack. If we find any of these, then this declarator cannot be
1937 made into a parameter pack. */
1940 {
1942 {
1955 }
1956 }
1959 }
1963 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1964 DECLARATOR and DEFAULT_ARGUMENT. */
1966 cp_parameter_declarator *
1969 tree default_argument,
1970 location_t loc,
1972 {
1980 else
1988 }
1990 /* Returns true iff DECLARATOR is a declaration for a function. */
1992 static bool
1994 {
1996 {
2005 }
2007 }
2009 /* The parser. */
2011 /* Overview
2012 --------
2014 A cp_parser parses the token stream as specified by the C++
2015 grammar. Its job is purely parsing, not semantic analysis. For
2016 example, the parser breaks the token stream into declarators,
2017 expressions, statements, and other similar syntactic constructs.
2018 It does not check that the types of the expressions on either side
2019 of an assignment-statement are compatible, or that a function is
2020 not declared with a parameter of type `void'.
2022 The parser invokes routines elsewhere in the compiler to perform
2023 semantic analysis and to build up the abstract syntax tree for the
2024 code processed.
2026 The parser (and the template instantiation code, which is, in a
2027 way, a close relative of parsing) are the only parts of the
2028 compiler that should be calling push_scope and pop_scope, or
2029 related functions. The parser (and template instantiation code)
2030 keeps track of what scope is presently active; everything else
2031 should simply honor that. (The code that generates static
2032 initializers may also need to set the scope, in order to check
2033 access control correctly when emitting the initializers.)
2035 Methodology
2036 -----------
2038 The parser is of the standard recursive-descent variety. Upcoming
2039 tokens in the token stream are examined in order to determine which
2040 production to use when parsing a non-terminal. Some C++ constructs
2041 require arbitrary look ahead to disambiguate. For example, it is
2042 impossible, in the general case, to tell whether a statement is an
2043 expression or declaration without scanning the entire statement.
2044 Therefore, the parser is capable of "parsing tentatively." When the
2045 parser is not sure what construct comes next, it enters this mode.
2046 Then, while we attempt to parse the construct, the parser queues up
2047 error messages, rather than issuing them immediately, and saves the
2048 tokens it consumes. If the construct is parsed successfully, the
2049 parser "commits", i.e., it issues any queued error messages and
2050 the tokens that were being preserved are permanently discarded.
2051 If, however, the construct is not parsed successfully, the parser
2052 rolls back its state completely so that it can resume parsing using
2053 a different alternative.
2055 Future Improvements
2056 -------------------
2058 The performance of the parser could probably be improved substantially.
2059 We could often eliminate the need to parse tentatively by looking ahead
2060 a little bit. In some places, this approach might not entirely eliminate
2061 the need to parse tentatively, but it might still speed up the average
2062 case. */
2064 /* Flags that are passed to some parsing functions. These values can
2065 be bitwise-ored together. */
2067 enum
2068 {
2069 /* No flags. */
2071 /* The construct is optional. If it is not present, then no error
2072 should be issued. */
2074 /* When parsing a type-specifier, treat user-defined type-names
2075 as non-type identifiers. */
2077 /* When parsing a type-specifier, do not try to parse a class-specifier
2078 or enum-specifier. */
2080 /* When parsing a decl-specifier-seq, only allow type-specifier or
2081 constexpr. */
2083 /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
2084 for C++20 consteval or for C++23 static. */
2086 /* When parsing a decl-specifier-seq, allow missing typename. */
2088 /* When parsing of the noexcept-specifier should be delayed. */
2090 /* When parsing a consteval declarator. */
2092 };
2094 /* This type is used for parameters and variables which hold
2095 combinations of the above flags. */
2098 /* The different kinds of declarators we want to parse. */
2100 enum cp_parser_declarator_kind
2101 {
2102 /* We want an abstract declarator. */
2103 CP_PARSER_DECLARATOR_ABSTRACT,
2104 /* We want a named declarator. */
2105 CP_PARSER_DECLARATOR_NAMED,
2106 /* We don't mind, but the name must be an unqualified-id. */
2107 CP_PARSER_DECLARATOR_EITHER
2108 };
2110 /* The precedence values used to parse binary expressions. The minimum value
2111 of PREC must be 1, because zero is reserved to quickly discriminate
2112 binary operators from other tokens. */
2114 enum cp_parser_prec
2115 {
2116 PREC_NOT_OPERATOR,
2117 PREC_LOGICAL_OR_EXPRESSION,
2118 PREC_LOGICAL_AND_EXPRESSION,
2119 PREC_INCLUSIVE_OR_EXPRESSION,
2120 PREC_EXCLUSIVE_OR_EXPRESSION,
2121 PREC_AND_EXPRESSION,
2122 PREC_EQUALITY_EXPRESSION,
2123 PREC_RELATIONAL_EXPRESSION,
2124 PREC_SPACESHIP_EXPRESSION,
2125 PREC_SHIFT_EXPRESSION,
2126 PREC_ADDITIVE_EXPRESSION,
2127 PREC_MULTIPLICATIVE_EXPRESSION,
2128 PREC_PM_EXPRESSION,
2129 NUM_PREC_VALUES = PREC_PM_EXPRESSION
2130 };
2132 /* A mapping from a token type to a corresponding tree node type, with a
2133 precedence value. */
2135 struct cp_parser_binary_operations_map_node
2136 {
2137 /* The token type. */
2139 /* The corresponding tree code. */
2141 /* The precedence of this operator. */
2143 };
2145 struct cp_parser_expression_stack_entry
2146 {
2147 /* Left hand side of the binary operation we are currently
2148 parsing. */
2149 cp_expr lhs;
2150 /* Original tree code for left hand side, if it was a binary
2151 expression itself (used for -Wparentheses). */
2153 /* Tree code for the binary operation we are parsing. */
2155 /* Precedence of the binary operation we are parsing. */
2157 /* Location of the binary operation we are parsing. */
2158 location_t loc;
2159 /* Flags from the operator token. */
2161 };
2163 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
2164 entries because precedence levels on the stack are monotonically
2165 increasing. */
2169 /* Used for parsing OMP for loops.
2171 Some notes on flags used for context:
2172 parser->omp_for_parse_state is non-null anywhere inside the OMP FOR
2173 construct, except for the final-loop-body.
2174 The want_nested_loop flag is true if inside a {} sequence where
2175 a loop-nest (or another {} sequence containing a loop-nest) is expected,
2176 but has not yet been seen. It's false when parsing intervening code
2177 statements or their substatements that cannot contain a loop-nest.
2178 The in_intervening_code flag is true when parsing any intervening code,
2179 including substatements, and whether or not want_nested_loop is true.
2181 And, about error handling:
2182 The saw_intervening_code flag is set if the loop is not perfectly
2183 nested, even in the usual case where this is not an error.
2184 perfect_nesting_fail is set if an error has been diagnosed because an
2185 imperfectly-nested loop was found where a perfectly-nested one is
2186 required (we diagnose this only once).
2187 fail is set if any kind of structural error in the loop nest
2188 has been found and diagnosed.
2189 */
2193 tree pre_body;
2194 tree orig_declv;
2198 location_t for_loc;
2199 releasing_vec init_blockv;
2200 releasing_vec body_blockv;
2201 releasing_vec init_placeholderv;
2202 releasing_vec body_placeholderv;
2210 tree clauses;
2212 tree ordered_cl;
2213 };
2215 /* Prototypes. */
2217 /* Constructors and destructors. */
2222 /* Class variables. */
2226 /* The operator-precedence table used by cp_parser_binary_expression.
2227 Transformed into an associative array (binops_by_token) by
2228 cp_parser_new. */
2263 };
2265 /* The same as binops, but initialized by cp_parser_new so that
2266 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2267 for speed. */
2270 /* Constructors and destructors. */
2272 /* Construct a new context. The context below this one on the stack
2273 is given by NEXT. */
2277 {
2280 /* Allocate the storage. */
2282 {
2283 /* Pull the first entry from the free list. */
2287 }
2288 else
2291 /* No errors have occurred yet in this context. */
2293 /* If this is not the bottommost context, copy information that we
2294 need from the previous context. */
2296 {
2297 /* If, in the NEXT context, we are parsing an `x->' or `x.'
2298 expression, then we are parsing one in this context, too. */
2300 /* Thread the stack. */
2302 }
2305 }
2307 /* Managing the unparsed function queues. */
2309 #define unparsed_funs_with_default_args \
2310 parser->unparsed_queues->last ().funs_with_default_args
2311 #define unparsed_funs_with_definitions \
2312 parser->unparsed_queues->last ().funs_with_definitions
2313 #define unparsed_nsdmis \
2314 parser->unparsed_queues->last ().nsdmis
2315 #define unparsed_noexcepts \
2316 parser->unparsed_queues->last ().noexcepts
2317 #define unparsed_contracts \
2318 parser->unparsed_queues->last ().contracts
2320 static void
2322 {
2323 cp_unparsed_functions_entry e
2326 }
2328 static void
2330 {
2333 }
2335 /* Prototypes. */
2337 /* Routines to parse various constructs.
2339 Those that return `tree' will return the error_mark_node (rather
2340 than NULL_TREE) if a parse error occurs, unless otherwise noted.
2341 Sometimes, they will return an ordinary node if error-recovery was
2342 attempted, even though a parse error occurred. So, to check
2343 whether or not a parse error occurred, you should always use
2344 cp_parser_error_occurred. If the construct is optional (indicated
2345 either by an `_opt' in the name of the function that does the
2346 parsing or via a FLAGS parameter), then NULL_TREE is returned if
2347 the construct is not present. */
2349 /* Lexical conventions [gram.lex] */
2351 static tree finish_userdef_string_literal
2354 /* Basic concepts [gram.basic] */
2358 /* Expressions [gram.expr] */
2360 static cp_expr cp_parser_primary_expression
2362 static cp_expr cp_parser_id_expression
2364 static cp_expr cp_parser_unqualified_id
2366 static tree cp_parser_nested_name_specifier_opt
2368 static tree cp_parser_nested_name_specifier
2370 static tree cp_parser_qualifying_entity
2372 static cp_expr cp_parser_postfix_expression
2374 static tree cp_parser_postfix_open_square_expression
2376 static tree cp_parser_postfix_dot_deref_expression
2381 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2384 static void cp_parser_pseudo_destructor_name
2386 static cp_expr cp_parser_unary_expression
2388 static enum tree_code cp_parser_unary_operator
2390 static tree cp_parser_has_attribute_expression
2392 static tree cp_parser_new_expression
2396 static tree cp_parser_new_type_id
2404 static tree cp_parser_delete_expression
2406 static cp_expr cp_parser_cast_expression
2408 static cp_expr cp_parser_binary_expression
2410 static tree cp_parser_question_colon_clause
2413 static cp_expr cp_parser_assignment_expression
2415 static enum tree_code cp_parser_assignment_operator_opt
2417 static cp_expr cp_parser_expression
2419 static cp_expr cp_parser_constant_expression
2421 static cp_expr cp_parser_builtin_offsetof
2423 static cp_expr cp_parser_lambda_expression
2425 static void cp_parser_lambda_introducer
2427 static bool cp_parser_lambda_declarator_opt
2429 static void cp_parser_lambda_body
2432 /* Statements [gram.stmt.stmt] */
2434 static void cp_parser_statement
2436 static void cp_parser_label_for_labeled_statement
2438 static tree cp_parser_expression_statement
2440 static tree cp_parser_compound_statement
2442 static void cp_parser_statement_seq_opt
2444 static tree cp_parser_selection_statement
2446 static tree cp_parser_condition
2448 static tree cp_parser_iteration_statement
2450 static bool cp_parser_init_statement
2452 static tree cp_parser_for
2454 static tree cp_parser_c_for
2456 static tree cp_parser_range_for
2458 static void do_range_for_auto_deduction
2460 static tree cp_parser_perform_range_for_lookup
2462 static tree cp_parser_range_for_member_function
2464 static tree cp_parser_jump_statement
2466 static void cp_parser_declaration_statement
2469 static tree cp_parser_implicitly_scoped_statement
2471 static void cp_parser_already_scoped_statement
2474 /* State of module-declaration parsing. */
2475 enum module_parse
2476 {
2479 _MP_UNUSED,
2489 };
2491 static module_parse cp_parser_module_declaration
2493 static void cp_parser_import_declaration
2496 /* Declarations [gram.dcl.dcl] */
2498 static void cp_parser_declaration_seq_opt
2500 static void cp_parser_declaration
2502 static void cp_parser_toplevel_declaration
2504 static void cp_parser_block_declaration
2506 static void cp_parser_simple_declaration
2508 static void cp_parser_decl_specifier_seq
2510 static tree cp_parser_storage_class_specifier_opt
2512 static tree cp_parser_function_specifier_opt
2514 static tree cp_parser_type_specifier
2517 static tree cp_parser_simple_type_specifier
2519 static tree cp_parser_placeholder_type_specifier
2521 static tree cp_parser_type_name
2523 static tree cp_parser_nonclass_name
2525 static tree cp_parser_elaborated_type_specifier
2527 static tree cp_parser_enum_specifier
2529 static void cp_parser_enumerator_list
2531 static void cp_parser_enumerator_definition
2533 static tree cp_parser_namespace_name
2535 static void cp_parser_namespace_definition
2537 static void cp_parser_namespace_body
2539 static tree cp_parser_qualified_namespace_specifier
2541 static void cp_parser_namespace_alias_definition
2543 static bool cp_parser_using_declaration
2545 static void cp_parser_using_directive
2547 static void cp_parser_using_enum
2549 static tree cp_parser_alias_declaration
2551 static void cp_parser_asm_definition
2553 static void cp_parser_linkage_specification
2555 static void cp_parser_static_assert
2557 static tree cp_parser_decltype
2559 static tree cp_parser_decomposition_declaration
2562 /* Declarators [gram.dcl.decl] */
2564 static tree cp_parser_init_declarator
2574 static enum tree_code cp_parser_ptr_operator
2576 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2578 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2580 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2582 static tree cp_parser_tx_qualifier_opt
2584 static tree cp_parser_late_return_type_opt
2586 static tree cp_parser_declarator_id
2588 static tree cp_parser_type_id
2590 static tree cp_parser_template_type_arg
2593 static tree cp_parser_type_id_1
2595 static void cp_parser_type_specifier_seq
2597 static tree cp_parser_parameter_declaration_clause
2599 static tree cp_parser_parameter_declaration_list
2603 static tree cp_parser_default_argument
2605 static void cp_parser_function_body
2607 static tree cp_parser_initializer
2609 static cp_expr cp_parser_initializer_clause
2611 static cp_expr cp_parser_braced_list
2616 static void cp_parser_ctor_initializer_opt_and_function_body
2619 static tree cp_parser_late_parsing_omp_declare_simd
2622 static tree cp_parser_late_parsing_oacc_routine
2625 static tree synthesize_implicit_template_parm
2627 static tree finish_fully_implicit_template
2629 static void abort_fully_implicit_template
2632 /* Classes [gram.class] */
2634 static tree cp_parser_class_name
2636 static tree cp_parser_class_specifier
2638 static tree cp_parser_class_head
2640 static enum tag_types cp_parser_class_key
2642 static void cp_parser_type_parameter_key
2644 static void cp_parser_member_specification_opt
2646 static void cp_parser_member_declaration
2648 static tree cp_parser_pure_specifier
2650 static tree cp_parser_constant_initializer
2653 /* Derived classes [gram.class.derived] */
2655 static tree cp_parser_base_clause
2657 static tree cp_parser_base_specifier
2660 /* Special member functions [gram.special] */
2662 static tree cp_parser_conversion_function_id
2664 static tree cp_parser_conversion_type_id
2668 static void cp_parser_ctor_initializer_opt
2670 static void cp_parser_mem_initializer_list
2672 static tree cp_parser_mem_initializer
2674 static tree cp_parser_mem_initializer_id
2677 /* Overloading [gram.over] */
2679 static cp_expr cp_parser_operator_function_id
2681 static cp_expr cp_parser_operator
2684 /* Templates [gram.temp] */
2686 static void cp_parser_template_declaration
2688 static tree cp_parser_template_parameter_list
2690 static tree cp_parser_template_parameter
2692 static tree cp_parser_type_parameter
2694 static tree cp_parser_template_id
2696 static tree cp_parser_template_id_expr
2698 static tree cp_parser_template_name
2700 static tree cp_parser_template_argument_list
2702 static tree cp_parser_template_argument
2704 static void cp_parser_explicit_instantiation
2706 static void cp_parser_explicit_specialization
2709 /* Exception handling [gram.except] */
2711 static tree cp_parser_try_block
2713 static void cp_parser_function_try_block
2715 static void cp_parser_handler_seq
2717 static void cp_parser_handler
2719 static tree cp_parser_exception_declaration
2721 static tree cp_parser_throw_expression
2723 static tree cp_parser_exception_specification_opt
2725 static tree cp_parser_type_id_list
2727 static tree cp_parser_noexcept_specification_opt
2730 /* GNU Extensions */
2732 static tree cp_parser_asm_specification_opt
2734 static tree cp_parser_asm_operand_list
2736 static tree cp_parser_asm_clobber_list
2738 static tree cp_parser_asm_label_list
2740 static bool cp_next_tokens_can_be_attribute_p
2742 static bool cp_next_tokens_can_be_gnu_attribute_p
2744 static bool cp_next_tokens_can_be_std_attribute_p
2746 static bool cp_nth_tokens_can_be_std_attribute_p
2748 static bool cp_nth_tokens_can_be_gnu_attribute_p
2750 static bool cp_nth_tokens_can_be_attribute_p
2752 static tree cp_parser_attributes_opt
2754 static tree cp_parser_gnu_attributes_opt
2756 static tree cp_parser_gnu_attribute_list
2758 static tree cp_parser_std_attribute
2760 static tree cp_parser_std_attribute_spec
2762 static tree cp_parser_std_attribute_spec_seq
2764 static size_t cp_parser_skip_std_attribute_spec_seq
2766 static size_t cp_parser_skip_attributes_opt
2768 static bool cp_parser_extension_opt
2770 static void cp_parser_label_declaration
2773 /* Concept Extensions */
2775 static tree cp_parser_concept_definition
2777 static tree cp_parser_constraint_expression
2779 static tree cp_parser_requires_clause_opt
2781 static tree cp_parser_requires_expression
2783 static tree cp_parser_requirement_parameter_list
2785 static tree cp_parser_requirement_body
2787 static tree cp_parser_requirement_seq
2789 static tree cp_parser_requirement
2791 static tree cp_parser_simple_requirement
2793 static tree cp_parser_compound_requirement
2795 static tree cp_parser_type_requirement
2797 static tree cp_parser_nested_requirement
2800 /* Transactional Memory Extensions */
2802 static tree cp_parser_transaction
2804 static tree cp_parser_transaction_expression
2806 static void cp_parser_function_transaction
2808 static tree cp_parser_transaction_cancel
2811 /* Coroutine extensions. */
2813 static tree cp_parser_yield_expression
2816 /* Contracts */
2818 static void cp_parser_late_contract_condition
2822 pragma_external,
2823 pragma_member,
2824 pragma_objc_icode,
2825 pragma_stmt,
2826 pragma_compound
2827 };
2828 static bool cp_parser_pragma
2831 /* Objective-C++ Productions */
2833 static tree cp_parser_objc_message_receiver
2835 static tree cp_parser_objc_message_args
2837 static tree cp_parser_objc_message_expression
2839 static cp_expr cp_parser_objc_encode_expression
2841 static tree cp_parser_objc_defs_expression
2843 static tree cp_parser_objc_protocol_expression
2845 static tree cp_parser_objc_selector_expression
2847 static cp_expr cp_parser_objc_expression
2849 static bool cp_parser_objc_selector_p
2851 static tree cp_parser_objc_selector
2853 static tree cp_parser_objc_protocol_refs_opt
2855 static void cp_parser_objc_declaration
2857 static tree cp_parser_objc_statement
2859 static bool cp_parser_objc_valid_prefix_attributes
2861 static void cp_parser_objc_at_property_declaration
2863 static void cp_parser_objc_at_synthesize_declaration
2865 static void cp_parser_objc_at_dynamic_declaration
2867 static tree cp_parser_objc_struct_declaration
2870 /* Utility Routines */
2872 static cp_expr cp_parser_lookup_name
2874 static tree cp_parser_lookup_name_simple
2876 static tree cp_parser_maybe_treat_template_as_class
2878 static bool cp_parser_check_declarator_template_parameters
2880 static bool cp_parser_check_template_parameters
2882 static cp_expr cp_parser_simple_cast_expression
2884 static tree cp_parser_global_scope_opt
2886 static bool cp_parser_constructor_declarator_p
2888 static tree cp_parser_function_definition_from_specifiers_and_declarator
2890 static tree cp_parser_function_definition_after_declarator
2892 static bool cp_parser_template_declaration_after_export
2894 static void cp_parser_perform_template_parameter_access_checks
2896 static tree cp_parser_single_declaration
2898 static cp_expr cp_parser_functional_cast
2900 static tree cp_parser_save_member_function_body
2902 static tree cp_parser_save_nsdmi
2904 static tree cp_parser_enclosed_template_argument_list
2906 static void cp_parser_save_default_args
2908 static void cp_parser_late_parsing_for_member
2910 static tree cp_parser_late_parse_one_default_arg
2912 static void cp_parser_late_parsing_nsdmi
2914 static void cp_parser_late_parsing_default_args
2916 static tree cp_parser_sizeof_operand
2918 static cp_expr cp_parser_trait
2920 static bool cp_parser_declares_only_class_p
2922 static void cp_parser_set_storage_class
2924 static void cp_parser_set_decl_spec_type
2926 static void set_and_check_decl_spec_loc
2929 static bool cp_parser_friend_p
2931 static void cp_parser_required_error
2937 static bool cp_parser_token_starts_function_definition_p
2939 static bool cp_parser_next_token_starts_class_definition_p
2941 static bool cp_parser_next_token_ends_template_argument_p
2943 static bool cp_parser_nth_token_starts_template_argument_list_p
2945 static enum tag_types cp_parser_token_is_class_key
2947 static enum tag_types cp_parser_token_is_type_parameter_key
2950 static void cp_parser_check_class_key
2952 static void cp_parser_check_access_in_redeclaration
2954 static bool cp_parser_optional_template_keyword
2956 static void cp_parser_pre_parsed_nested_name_specifier
2958 static bool cp_parser_cache_group
2960 static tree cp_parser_cache_defarg
2962 static void cp_parser_parse_tentatively
2964 static void cp_parser_commit_to_tentative_parse
2966 static void cp_parser_commit_to_topmost_tentative_parse
2968 static void cp_parser_abort_tentative_parse
2970 static bool cp_parser_parse_definitely
2974 static bool cp_parser_uncommitted_to_tentative_parse_p
2976 static void cp_parser_error
2978 static void cp_parser_name_lookup_error
2980 static bool cp_parser_simulate_error
2982 static bool cp_parser_check_type_definition
2984 static void cp_parser_check_for_definition_in_return_type
2986 static void cp_parser_check_for_invalid_template_id
2988 static bool cp_parser_non_integral_constant_expression
2990 static void cp_parser_diagnose_invalid_type_name
2992 static bool cp_parser_parse_and_diagnose_invalid_type_name
2994 static int cp_parser_skip_to_closing_parenthesis
2996 static void cp_parser_skip_to_end_of_statement
2998 static void cp_parser_consume_semicolon_at_end_of_statement
3000 static void cp_parser_skip_to_end_of_block_or_statement
3002 static bool cp_parser_skip_to_closing_brace
3004 static bool cp_parser_skip_entire_template_parameter_list
3006 static void cp_parser_require_end_of_template_parameter_list
3008 static bool cp_parser_skip_to_end_of_template_parameter_list
3010 static void cp_parser_skip_to_pragma_eol
3012 static bool cp_parser_error_occurred
3014 static bool cp_parser_allow_gnu_extensions_p
3016 static bool cp_parser_is_pure_string_literal
3018 static bool cp_parser_is_string_literal
3020 static bool cp_parser_is_keyword
3022 static tree cp_parser_make_typename_type
3026 static bool cp_parser_compound_literal_p
3028 static bool cp_parser_array_designator_p
3030 static bool cp_parser_init_statement_p
3032 static bool cp_parser_skip_up_to_closing_square_bracket
3034 static bool cp_parser_skip_to_closing_square_bracket
3039 // -------------------------------------------------------------------------- //
3040 // Unevaluated Operand Guard
3041 //
3042 // Implementation of an RAII helper for unevaluated operand parsing.
3044 {
3047 }
3050 {
3053 }
3055 // -------------------------------------------------------------------------- //
3056 // Tentative Parsing
3058 /* Returns nonzero if we are parsing tentatively. */
3062 {
3064 }
3066 /* Returns nonzero if TOKEN is a string literal. */
3068 static bool
3070 {
3076 }
3078 /* Returns nonzero if TOKEN is a string literal
3079 of a user-defined string literal. */
3081 static bool
3083 {
3090 }
3092 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
3094 static bool
3096 {
3098 }
3100 /* Helper function for cp_parser_error.
3101 Having peeked a token of kind TOK1_KIND that might signify
3102 a conflict marker, peek successor tokens to determine
3103 if we actually do have a conflict marker.
3104 Specifically, we consider a run of 7 '<', '=' or '>' characters
3105 at the start of a line as a conflict marker.
3106 These come through the lexer as three pairs and a single,
3107 e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
3108 If it returns true, *OUT_LOC is written to with the location/range
3109 of the marker. */
3111 static bool
3114 {
3125 /* It must be at the start of the line. */
3130 /* We have a conflict marker. Construct a location of the form:
3131 <<<<<<<
3132 ^~~~~~~
3133 with start == caret, finishing at the end of the marker. */
3138 }
3140 /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
3141 RT_CLOSE_PAREN. */
3145 {
3147 {
3155 }
3156 }
3158 /* Attempt to convert TOKEN_DESC from a required_token to an
3159 enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
3161 static enum cpp_ttype
3163 {
3165 {
3186 /* Use CPP_EOF as a "no completions possible" code. */
3188 }
3189 }
3192 /* Subroutine of cp_parser_error and cp_parser_required_error.
3194 Issue a diagnostic of the form
3195 FILE:LINE: MESSAGE before TOKEN
3196 where TOKEN is the next token in the input stream. MESSAGE
3197 (specified by the caller) is usually of the form "expected
3198 OTHER-TOKEN".
3200 This bypasses the check for tentative passing, and potentially
3201 adds material needed by cp_parser_required_error.
3203 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
3204 suggesting insertion of the missing token.
3206 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
3207 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
3208 location. */
3210 static void
3212 required_token missing_token_desc,
3213 location_t matching_location)
3214 {
3216 /* This diagnostic makes more sense if it is tagged to the line
3217 of the token we just peeked at. */
3221 {
3226 }
3228 /* If this is actually a conflict marker, report it as such. */
3232 {
3233 location_t loc;
3235 {
3238 /* Consume tokens until the end of the source line. */
3240 {
3254 }
3256 }
3257 }
3259 auto_diagnostic_group d;
3266 {
3267 /* Potentially supply a fix-it hint, suggesting to add the
3268 missing token immediately after the *previous* token.
3269 This may move the primary location within richloc. */
3273 prev_token_loc);
3275 /* If matching_location != UNKNOWN_LOCATION, highlight it.
3276 Attempt to consolidate diagnostics by printing it as a
3277 secondary range within the main diagnostic. */
3279 added_matching_location
3281 }
3283 /* If we were parsing a string-literal and there is an unknown name
3284 token right after, then check to see if that could also have been
3285 a literal string by checking the name against a list of known
3286 standard string literal constants defined in header files. If
3287 there is one, then add that as an hint to the error message. */
3288 name_hint h;
3292 {
3299 token_name,
3300 header_hint));
3301 }
3303 /* Actually emit the error. */
3305 /* Because c_parser_error does not understand
3306 CPP_KEYWORD, keywords are treated like
3307 identifiers. */
3312 {
3313 /* If we weren't able to consolidate matching_location, then
3314 print it as a secondary diagnostic. */
3319 }
3320 }
3322 /* If not parsing tentatively, issue a diagnostic of the form
3323 FILE:LINE: MESSAGE before TOKEN
3324 where TOKEN is the next token in the input stream. MESSAGE
3325 (specified by the caller) is usually of the form "expected
3326 OTHER-TOKEN". */
3328 static void
3330 {
3333 }
3335 /* Issue an error about name-lookup failing. NAME is the
3336 IDENTIFIER_NODE DECL is the result of
3337 the lookup (as returned from cp_parser_lookup_name). DESIRED is
3338 the thing that we hoped to find. */
3340 static void
3342 tree name,
3343 tree decl,
3344 name_lookup_error desired,
3345 location_t location)
3346 {
3347 /* If name lookup completely failed, tell the user that NAME was not
3348 declared. */
3350 {
3363 else
3365 }
3367 {
3369 {
3386 }
3387 }
3389 {
3391 {
3401 name);
3405 }
3406 }
3407 else
3408 {
3410 {
3423 }
3424 }
3425 }
3427 /* If we are parsing tentatively, remember that an error has occurred
3428 during this tentative parse. Returns true if the error was
3429 simulated; false if a message should be issued by the caller. */
3431 static bool
3433 {
3435 {
3438 }
3440 }
3442 /* This function is called when a type is defined. If type
3443 definitions are forbidden at this point, an error message is
3444 issued. */
3446 static bool
3448 {
3449 /* If types are forbidden here, issue a message. */
3451 {
3452 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3453 or %qs in the message need to be interpreted. */
3457 }
3459 }
3461 /* This function is called when the DECLARATOR is processed. The TYPE
3462 was a type defined in the decl-specifiers. If it is invalid to
3463 define a type in the decl-specifiers for DECLARATOR, an error is
3464 issued. TYPE_LOCATION is the location of TYPE and is used
3465 for error reporting. */
3467 static void
3470 {
3471 /* [dcl.fct] forbids type definitions in return types.
3472 Unfortunately, it's not easy to know whether or not we are
3473 processing a return type until after the fact. */
3481 {
3486 type);
3487 }
3488 }
3490 /* A type-specifier (TYPE) has been parsed which cannot be followed by
3491 "<" in any valid C++ program. If the next token is indeed "<",
3492 issue a message warning the user about what appears to be an
3493 invalid attempt to form a template-id. LOCATION is the location
3494 of the type-specifier (TYPE) */
3496 static void
3498 tree type,
3500 location_t location)
3501 {
3505 {
3511 {
3514 else
3516 }
3517 else
3519 /* Remember the location of the invalid "<". */
3522 /* Consume the "<". */
3524 /* Parse the template arguments. */
3526 /* Permanently remove the invalid template arguments so that
3527 this error message is not issued again. */
3530 }
3531 }
3533 /* If parsing an integral constant-expression, issue an error message
3534 about the fact that THING appeared and return true. Otherwise,
3535 return false. In either case, set
3536 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3538 static bool
3540 non_integral_constant thing)
3541 {
3544 {
3546 {
3549 {
3552 "ISO C++ forbids using a floating-point literal "
3557 "enumeration type cannot appear in a "
3648 }
3652 }
3653 }
3655 }
3657 /* Emit a diagnostic for an invalid type name. This function commits
3658 to the current active tentative parse, if any. (Otherwise, the
3659 problematic construct might be encountered again later, resulting
3660 in duplicate error messages.) LOCATION is the location of ID. */
3662 static void
3664 location_t location)
3665 {
3668 /* Try to lookup the identifier. */
3675 /* If the lookup was ambiguous, an error will already have
3676 been issued. */
3678 /* If the lookup found a template-name, it means that the user forgot
3679 to specify an argument list. Emit a useful error message. */
3681 {
3682 auto_diagnostic_group d;
3685 decl);
3690 }
3694 /* Something like 'unsigned A a;' */
3697 {
3698 /* Issue an error message. */
3699 auto_diagnostic_group d;
3700 name_hint hint;
3704 {
3710 }
3711 else
3713 /* If we're in a template class, it's possible that the user was
3714 referring to a type from a base class. For example:
3716 template <typename T> struct A { typedef T X; };
3717 template <typename T> struct B : public A<T> { X x; };
3719 The user should have said "typename A<T>::X". */
3728 {
3731 id);
3734 id);
3735 else
3738 }
3755 {
3758 {
3762 {
3763 /* Go from a particular instantiation of the
3764 template (which will have an empty TYPE_FIELDs),
3765 to the main version. */
3771 {
3776 }
3777 }
3778 }
3779 found:;
3780 }
3781 }
3782 /* Here we diagnose qualified-ids where the scope is actually correct,
3783 but the identifier does not resolve to a valid type name. */
3785 {
3787 {
3788 auto_diagnostic_group d;
3789 name_hint hint;
3798 {
3801 "%qE in namespace %qE does not name a template"
3804 else
3808 }
3810 {
3813 "%qE in namespace %qE does not name a template"
3816 else
3818 "%qE in namespace %qE does not name a template"
3821 }
3822 else
3823 {
3826 "%qE in namespace %qE does not name a type"
3829 else
3833 }
3836 }
3839 {
3840 /* A<T>::A<T>() */
3841 auto_diagnostic_group d;
3847 }
3850 {
3855 "need %<typename%> before %<%T::%D::%E%> because "
3859 id,
3862 else
3866 }
3868 {
3869 auto_diagnostic_group d;
3881 else
3887 }
3888 else
3890 }
3891 }
3893 /* Check for a common situation where a type-name should be present,
3894 but is not, and issue a sensible error message. Returns true if an
3895 invalid type-name was detected.
3897 The situation handled by this function are variable declarations of the
3898 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3899 Usually, `ID' should name a type, but if we got here it means that it
3900 does not. We try to emit the best possible error message depending on
3901 how exactly the id-expression looks like. */
3903 static bool
3905 {
3906 tree id;
3909 /* Avoid duplicate error about ambiguous lookup. */
3911 {
3915 }
3924 /* If the next token is a (, this is a function with no explicit return
3925 type, i.e. constructor, destructor or conversion op. */
3928 {
3931 }
3935 /* Emit a diagnostic for the invalid type. */
3937 out:
3938 /* If we aren't in the middle of a declarator (i.e. in a
3939 parameter-declaration-clause), skip to the end of the declaration;
3940 there's no point in trying to process it. */
3944 }
3946 /* Consume tokens up to, and including, the next non-nested closing `)'.
3947 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3948 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3949 found an unnested token of that type. */
3951 static int
3954 cpp_ttype or_ttype,
3956 {
3967 {
3970 /* Have we found what we're looking for before the closing paren? */
3976 {
3980 /* FALLTHRU */
3982 /* If we've run out of tokens, then there is no closing `)'. */
3985 /* This is good for lambda expression capture-lists. */
3995 /* This matches the processing in skip_to_end_of_statement. */
4015 {
4019 }
4029 condop_depth--;
4035 /* FALLTHROUGH */
4038 /* We fell into a pragma. Skip it, and continue. */
4044 }
4046 /* Consume the token. */
4048 }
4049 }
4051 /* Consume tokens up to, and including, the next non-nested closing `)'.
4052 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
4053 are doing error recovery. Returns -1 if OR_COMMA is true and we
4054 found an unnested token of that type. */
4056 static int
4061 {
4065 }
4067 /* Consume tokens until we reach the end of the current statement.
4068 Normally, that will be just before consuming a `;'. However, if a
4069 non-nested `}' comes first, then we stop before consuming that. */
4071 static void
4073 {
4076 /* Unwind generic function template scope if necessary. */
4081 {
4085 {
4089 /* FALLTHRU */
4091 /* If we've run out of tokens, stop. */
4095 /* If the next token is a `;', we have reached the end of the
4096 statement. */
4102 /* If this is a non-nested '}', stop before consuming it.
4103 That way, when confronted with something like:
4105 { 3 + }
4107 we stop before consuming the closing '}', even though we
4108 have not yet reached a `;'. */
4112 /* If it is the closing '}' for a block that we have
4113 scanned, stop -- but only after consuming the token.
4114 That way given:
4116 void f g () { ... }
4117 typedef int I;
4119 we will stop after the body of the erroneously declared
4120 function, but before consuming the following `typedef'
4121 declaration. */
4123 {
4126 }
4136 /* FALLTHROUGH */
4139 /* We fell into a pragma. Skip it, and continue or return. */
4147 }
4149 /* Consume the token. */
4151 }
4152 }
4154 /* This function is called at the end of a statement or declaration.
4155 If the next token is a semicolon, it is consumed; otherwise, error
4156 recovery is attempted. */
4158 static void
4160 {
4161 /* Look for the trailing `;'. */
4163 {
4164 /* If there is additional (erroneous) input, skip to the end of
4165 the statement. */
4167 /* If the next token is now a `;', consume it. */
4170 }
4171 }
4173 /* Skip tokens until we have consumed an entire block, or until we
4174 have consumed a non-nested `;'. */
4176 static void
4178 {
4181 /* Unwind generic function template scope if necessary. */
4186 {
4190 {
4194 /* FALLTHRU */
4196 /* If we've run out of tokens, stop. */
4200 /* Stop if this is an unnested ';'. */
4206 /* Stop if this is an unnested '}', or closes the outermost
4207 nesting level. */
4208 nesting_depth--;
4216 /* Nest. */
4217 nesting_depth++;
4223 /* FALLTHROUGH */
4226 /* Skip it, and continue or return. */
4234 }
4236 /* Consume the token. */
4238 }
4239 }
4241 /* Skip tokens until a non-nested closing curly brace is the next
4242 token, or there are no more tokens. Return true in the first case,
4243 false otherwise. */
4245 static bool
4247 {
4251 {
4255 {
4259 /* FALLTHRU */
4261 /* If we've run out of tokens, stop. */
4265 /* If the next token is a non-nested `}', then we have reached
4266 the end of the current block. */
4272 /* If it the next token is a `{', then we are entering a new
4273 block. Consume the entire block. */
4279 }
4281 /* Consume the token. */
4283 }
4284 }
4286 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4287 parameter is the PRAGMA token, allowing us to purge the entire pragma
4288 sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4289 forwards (not error recovery). */
4291 static void
4293 {
4296 do
4297 {
4298 /* The preprocessor makes sure that a PRAGMA_EOL token appears
4299 before an EOF token, even when the EOF is on the pragma line.
4300 We should never get here without being inside a deferred
4301 pragma. */
4304 }
4308 {
4312 {
4314 /* Put the current source position back where it was before this
4315 lexer was pushed. */
4317 }
4318 }
4319 }
4321 /* Require pragma end of line, resyncing with it as necessary. The
4322 arguments are as for cp_parser_skip_to_pragma_eol. */
4324 static void
4326 {
4332 {
4334 /* Put the current source position back where it was before this
4335 lexer was pushed. */
4337 }
4338 }
4340 /* This is a simple wrapper around make_typename_type. When the id is
4341 an unresolved identifier node, we can provide a superior diagnostic
4342 using cp_parser_diagnose_invalid_type_name. */
4344 static tree
4346 location_t id_location)
4347 {
4348 tree result;
4350 {
4356 }
4358 }
4360 /* This is a wrapper around the
4361 make_{pointer,ptrmem,reference}_declarator functions that decides
4362 which one to call based on the CODE and CLASS_TYPE arguments. The
4363 CODE argument should be one of the values returned by
4364 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4365 appertain to the pointer or reference. */
4369 cp_cv_quals cv_qualifiers,
4371 tree attributes)
4372 {
4379 else
4389 }
4391 /* Create a new C++ parser. */
4395 {
4396 /* Initialize the binops_by_token so that we can get the tree
4397 directly from the token. */
4405 /* For now, we always accept GNU extensions. */
4408 /* The `>' token is a greater-than operator, not the end of a
4409 template-id. */
4414 /* We are not parsing a constant-expression. */
4419 /* Local variable names are not forbidden. */
4422 /* We are not processing an `extern "C"' declaration. */
4425 /* We are not processing a declarator. */
4428 /* We are not processing a template-argument-list. */
4431 /* We are not in an iteration statement. */
4434 /* We are not in a switch statement. */
4437 /* We are not parsing a type-id inside an expression. */
4440 /* String literals should be translated to the execution character set. */
4443 /* We are not parsing a function body. */
4446 /* We can correct until told otherwise. */
4449 /* The unparsed function queue is empty. */
4452 /* There are no classes being defined. */
4455 /* No template parameters apply. */
4458 /* Special parsing data structures. */
4462 /* Disallow OpenMP array sections in expressions. */
4465 /* Not declaring an implicit function template. */
4471 /* Allow constrained-type-specifiers. */
4474 /* We haven't yet seen an 'extern "C"'. */
4478 }
4480 /* Create a cp_lexer structure which will emit the tokens in CACHE
4481 and push it onto the parser's lexer stack. This is used for delayed
4482 parsing of in-class method bodies and default arguments, and should
4483 not be confused with tentative parsing. */
4484 static void
4486 {
4491 /* Move the current source position to that of the first token in the
4492 new lexer. */
4494 }
4496 /* Pop the top lexer off the parser stack. This is never used for the
4497 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4498 static void
4500 {
4505 /* Put the current source position back where it was before this
4506 lexer was pushed. */
4508 }
4510 /* Lexical conventions [gram.lex] */
4512 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4513 identifier. */
4515 static cp_expr
4517 {
4520 /* Look for the identifier. */
4522 /* Return the value. */
4525 else
4527 }
4529 /* Worker for cp_parser_string_literal, cp_parser_userdef_string_literal
4530 and cp_parser_unevaluated_string_literal.
4531 Do not call this directly; use either of the above.
4533 Parse a sequence of adjacent string constants. Return a
4534 TREE_STRING representing the combined, nul-terminated string
4535 constant. If TRANSLATE is true, translate the string to the
4536 execution character set. If WIDE_OK is true, a wide string is
4537 valid here. If UDL_OK is true, a string literal with user-defined
4538 suffix can be used in this context. If UNEVAL is true, diagnose
4539 numeric and conditional escape sequences in it if pedantic.
4541 C++98 [lex.string] says that if a narrow string literal token is
4542 adjacent to a wide string literal token, the behavior is undefined.
4543 However, C99 6.4.5p4 says that this results in a wide string literal.
4544 We follow C99 here, for consistency with the C front end.
4546 This code is largely lifted from lex_string() in c-lex.cc.
4548 FUTURE: ObjC++ will need to handle @-strings here. */
4550 static cp_expr
4554 {
4555 tree value;
4563 tree string_tree;
4569 {
4572 }
4577 {
4579 {
4583 }
4587 }
4588 else
4589 {
4592 }
4595 /* Try to avoid the overhead of creating and destroying an obstack
4596 for the common case of just one string. */
4599 {
4607 {
4611 }
4612 else
4616 }
4617 else
4618 {
4624 do
4625 {
4627 count++;
4632 {
4635 {
4638 }
4641 {
4646 }
4648 }
4649 else
4653 {
4657 {
4661 "concatenation of string literals with "
4663 }
4664 }
4673 {
4675 {
4679 }
4683 }
4684 else
4685 {
4689 }
4690 }
4693 /* A string literal built by concatenation has its caret=start at
4694 the start of the initial string, and its finish at the finish of
4695 the final string literal. */
4699 }
4702 {
4705 }
4711 {
4715 {
4719 }
4722 {
4730 else
4742 }
4747 {
4752 else
4754 }
4755 }
4756 else
4757 /* cpp_interpret_string has issued an error. */
4761 {
4764 }
4767 }
4769 /* Parse a sequence of adjacent string constants. Return a TREE_STRING
4770 representing the combined, nul-terminated string constant. If
4771 TRANSLATE is true, translate the string to the execution character set.
4772 If WIDE_OK is true, a wide string is valid here.
4774 This function issues an error if a user defined string literal is
4775 encountered; use cp_parser_userdef_string_literal if UDLs are allowed. */
4779 {
4784 }
4786 /* Parse a string literal or user defined string literal.
4788 user-defined-string-literal :
4789 string-literal ud-suffix
4791 If LOOKUP_UDLIT, perform a lookup for a suitable template function. */
4795 {
4799 }
4801 /* Parse an unevaluated string literal.
4803 unevaluated-string:
4804 string-literal */
4808 {
4813 }
4815 /* Look up a literal operator with the name and the exact arguments. */
4817 static tree
4819 {
4825 {
4829 {
4836 {
4846 }
4850 /* May be this should be sufficient_parms_p instead,
4851 depending on how exactly should user-defined literals
4852 work in presence of default arguments on the literal
4853 operator parameters. */
4856 }
4857 }
4860 }
4862 /* Parse a user-defined char constant. Returns a call to a user-defined
4863 literal operator taking the character as an argument. */
4865 static cp_expr
4867 {
4875 /* Build up a call to the user-defined operator */
4876 /* Lookup the name we got back from the id-expression. */
4877 releasing_vec args;
4881 {
4885 }
4888 }
4890 /* A subroutine of cp_parser_userdef_numeric_literal to
4891 create a char... template parameter pack from a string node. */
4893 static tree
4895 {
4896 tree charvec;
4903 /* Fill in CHARVEC with all of the parameters. */
4906 {
4915 }
4917 /* Build the argument packs. */
4923 }
4925 /* A subroutine of cp_parser_userdef_numeric_literal to
4926 create a char... template parameter pack from a string node. */
4928 static tree
4930 {
4931 tree charvec;
4942 /* First template parm is character type. */
4945 /* Fill in CHARVEC with all of the parameters. */
4952 /* Build the argument packs. */
4958 }
4960 /* Parse a user-defined numeric constant. returns a call to a user-defined
4961 literal operator. */
4963 static cp_expr
4965 {
4975 /* Look for a literal operator taking the exact type of numeric argument
4976 as the literal value. */
4977 releasing_vec args;
4981 {
4983 tf_warning_or_error);
4986 {
4989 long_long_unsigned_type_node);
4990 }
4991 else
4992 {
4996 long_double_type_node);
5000 }
5003 }
5005 /* If the numeric argument didn't work, look for a raw literal
5006 operator taking a const char* argument consisting of the number
5007 in string format. */
5012 {
5014 tf_warning_or_error);
5016 }
5018 /* If the raw literal didn't work, look for a non-type template
5019 function with parameter pack char.... Call the function with
5020 template parameter characters representing the number. */
5024 {
5027 {
5029 num_string);
5031 }
5034 tf_warning_or_error);
5036 }
5038 /* In C++14 the standard library defines complex number suffixes that
5039 conflict with GNU extensions. Prefer them if <complex> is #included. */
5049 {
5053 {
5054 /* No <complex>, so pedwarn and use GNU semantics. */
5057 }
5058 }
5060 bool complained
5067 {
5069 "(from %<<complex>%>) to enable the C++14 user-defined literal "
5074 }
5081 else
5082 {
5083 /* Use the built-in semantics. */
5084 tree type;
5086 {
5089 else
5091 }
5099 }
5102 /* Avoid repeated diagnostics. */
5105 }
5107 /* Parse a user-defined string constant. Returns a call to a user-defined
5108 literal operator taking a character pointer and the length of the string
5109 as arguments. */
5111 static tree
5113 {
5119 tree decl;
5121 /* Build up a call to the user-defined operator. */
5122 /* Lookup the name we got back from the id-expression. */
5123 releasing_vec args;
5130 tf_warning_or_error);
5132 /* Look for a suitable template function, either (C++20) with a single
5133 parameter of class type, or (N3599) with typename parameter CharT and
5134 parameter pack CharT... */
5138 {
5139 /* Use resolve_nondeduced_context to try to choose one form of template
5140 or the other. */
5147 else
5148 {
5153 }
5157 tf_warning_or_error);
5158 }
5163 }
5166 /* Basic concepts [gram.basic] */
5168 /* Parse a translation-unit.
5170 translation-unit:
5171 declaration-seq [opt] */
5173 static void
5175 {
5178 /* Create the declarator obstack. */
5180 /* Create the error declarator. */
5182 /* Create the empty parameter list. */
5184 UNKNOWN_LOCATION);
5185 /* Remember where the base of the declarator obstack lies. */
5197 /* Parse until EOF. */
5199 {
5202 /* If we're entering or exiting a region that's implicitly
5203 extern "C", modify the lang context appropriately. This is
5204 so horrible. Please die. */
5207 {
5211 else
5213 }
5219 {
5220 /* Top-level module declarations are ok, and change the
5221 portion of file we're in. Top-level import declarations
5222 are significant for the import portions. */
5227 {
5230 }
5232 {
5233 mp_state
5236 }
5238 {
5243 }
5244 else
5248 {
5251 {
5254 "global module fragment contents must be"
5256 }
5257 }
5258 }
5260 /* This relies on the ordering of module_parse values. */
5262 /* We're no longer in the import portion of a named module. */
5268 {
5271 /* If the next token is now a `;', consume it. */
5274 }
5275 else
5277 }
5279 /* Get rid of the token array; we don't need it any more. */
5283 /* The EOF should have reset this. */
5286 /* Make sure the declarator obstack was fully cleaned up. */
5289 }
5291 /* Return the appropriate tsubst flags for parsing, possibly in N3276
5292 decltype context. */
5296 {
5301 }
5303 /* We're about to parse a collection of statements. If we're currently
5304 parsing tentatively, set up a firewall so that any nested
5305 cp_parser_commit_to_tentative_parse won't affect the current context. */
5307 static cp_token_position
5309 {
5316 }
5318 /* We've finished parsing the collection of statements. Wrap up the
5319 firewall and replace the relevant tokens with the parsed form. */
5321 static void
5323 tree expr)
5324 {
5328 /* Finish the firewall level. */
5330 /* And remember the result of the parse for when we try again. */
5336 }
5338 /* Like the above functions, but let the user modify the tokens. Used by
5339 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5340 later parses, so it makes sense to localize the effects of
5341 cp_parser_commit_to_tentative_parse. */
5343 struct tentative_firewall
5344 {
5349 {
5350 /* If we're currently parsing tentatively, start a committed level as a
5351 firewall and then an inner tentative parse. */
5353 {
5357 }
5358 }
5361 {
5363 {
5364 /* Finish the inner tentative parse and the firewall, propagating any
5365 uncommitted error state to the outer tentative parse. */
5371 }
5372 }
5373 };
5375 /* Some tokens naturally come in pairs e.g.'(' and ')'.
5376 This class is for tracking such a matching pair of symbols.
5377 In particular, it tracks the location of the first token,
5378 so that if the second token is missing, we can highlight the
5379 location of the first token when notifying the user about the
5380 problem. */
5383 class token_pair
5384 {
5386 /* token_pair's ctor. */
5389 /* If the next token is the opening symbol for this pair, consume it and
5390 return true.
5391 Otherwise, issue an error and return false.
5392 In either case, record the location of the opening token. */
5395 {
5399 }
5401 /* Consume the next token from PARSER, recording its location as
5402 that of the opening token within the pair. */
5405 {
5410 }
5412 /* If the next token is the closing symbol for this pair, consume it
5413 and return it.
5414 Otherwise, issue an error, highlighting the location of the
5415 corresponding opening token, and return NULL. */
5418 {
5421 m_open_loc);
5422 }
5427 location_t m_open_loc;
5428 };
5430 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5432 struct matching_paren_traits
5433 {
5438 };
5440 /* "matching_parens" is a token_pair<T> class for tracking matching
5441 pairs of parentheses. */
5445 /* Traits for token_pair<T> for tracking matching pairs of braces. */
5447 struct matching_brace_traits
5448 {
5453 };
5455 /* "matching_braces" is a token_pair<T> class for tracking matching
5456 pairs of braces. */
5461 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5462 enclosing parentheses. */
5464 static cp_expr
5466 {
5470 /* Consume the '('. */
5472 matching_parens parens;
5474 /* Start the statement-expression. */
5476 /* Parse the compound-statement. */
5478 /* Finish up. */
5480 /* Consume the ')'. */
5488 }
5490 /* Expressions [gram.expr] */
5492 /* Parse a fold-operator.
5494 fold-operator:
5495 - * / % ^ & | = < > << >>
5496 = -= *= /= %= ^= &= |= <<= >>=
5497 == != <= >= && || , .* ->*
5499 This returns the tree code corresponding to the matched operator
5500 as an int. When the current token matches a compound assignment
5501 operator, the resulting tree code is the negative value of the
5502 non-assignment operator. */
5504 static int
5506 {
5508 {
5548 }
5549 }
5551 /* Returns true if CODE indicates a binary expression, which is not allowed in
5552 the LHS of a fold-expression. More codes will need to be added to use this
5553 function in other contexts. */
5555 static bool
5557 {
5559 {
5592 }
5593 }
5595 /* If the next token is a suitable fold operator, consume it and return as
5596 the function above. */
5598 static int
5600 {
5606 }
5608 /* Parse a fold-expression.
5610 fold-expression:
5611 ( ... folding-operator cast-expression)
5612 ( cast-expression folding-operator ... )
5613 ( cast-expression folding operator ... folding-operator cast-expression)
5615 Note that the '(' and ')' are matched in primary expression. */
5617 static cp_expr
5619 {
5620 cp_id_kind pidk;
5624 // Left fold.
5626 {
5633 {
5636 }
5644 }
5649 {
5652 }
5655 {
5658 }
5661 /* The operands of a fold-expression are cast-expressions, so binary or
5662 conditional expressions are not allowed. We check this here to avoid
5663 tentative parsing. */
5675 // Right fold.
5677 {
5680 }
5683 {
5686 }
5689 // Binary left or right fold.
5695 }
5697 /* Parse a primary-expression.
5699 primary-expression:
5700 literal
5701 this
5702 ( expression )
5703 id-expression
5704 lambda-expression (C++11)
5706 GNU Extensions:
5708 primary-expression:
5709 ( compound-statement )
5710 __builtin_va_arg ( assignment-expression , type-id )
5711 __builtin_offsetof ( type-id , offsetof-expression )
5713 C++ Extensions:
5714 __has_nothrow_assign ( type-id )
5715 __has_nothrow_constructor ( type-id )
5716 __has_nothrow_copy ( type-id )
5717 __has_trivial_assign ( type-id )
5718 __has_trivial_constructor ( type-id )
5719 __has_trivial_copy ( type-id )
5720 __has_trivial_destructor ( type-id )
5721 __has_virtual_destructor ( type-id )
5722 __is_abstract ( type-id )
5723 __is_base_of ( type-id , type-id )
5724 __is_class ( type-id )
5725 __is_empty ( type-id )
5726 __is_enum ( type-id )
5727 __is_final ( type-id )
5728 __is_literal_type ( type-id )
5729 __is_pod ( type-id )
5730 __is_polymorphic ( type-id )
5731 __is_std_layout ( type-id )
5732 __is_trivial ( type-id )
5733 __is_union ( type-id )
5735 Objective-C++ Extension:
5737 primary-expression:
5738 objc-expression
5740 literal:
5741 __null
5743 ADDRESS_P is true iff this expression was immediately preceded by
5744 "&" and therefore might denote a pointer-to-member. CAST_P is true
5745 iff this expression is the target of a cast. TEMPLATE_ARG_P is
5746 true iff this expression is a template argument.
5748 Returns a representation of the expression. Upon return, *IDK
5749 indicates what kind of id-expression (if any) was present. */
5751 static cp_expr
5758 {
5761 /* Assume the primary expression is not an id-expression. */
5764 /* Peek at the next token. */
5767 {
5768 /* literal:
5769 integer-literal
5770 character-literal
5771 floating-literal
5772 string-literal
5773 boolean-literal
5774 pointer-literal
5775 user-defined-literal */
5787 {
5791 }
5792 /* Floating-point literals are only allowed in an integral
5793 constant expression if they are cast to an integral or
5794 enumeration type. */
5800 {
5801 /* CAST_P will be set even in invalid code like "int(2.7 +
5802 ...)". Therefore, we have to check that the next token
5803 is sure to end the cast. */
5805 {
5810 enumerator-definition. */
5812 /* The curly brace at the end of an enum-specifier. */
5814 /* The end of a statement. */
5816 /* The end of the cast-expression. */
5818 /* The end of an array bound. */
5820 /* The closing ">" in a template-argument-list. */
5823 /* C++0x only: A ">>" treated like two ">" tokens,
5824 in a template-argument-list. */
5829 }
5831 /* If we are within a cast, then the constraint that the
5832 cast is to an integral or enumeration type will be
5833 checked at that point. If we are not within a cast, then
5834 this code is invalid. */
5837 }
5858 /* ??? Should wide strings be allowed when parser->translate_strings_p
5859 is false (i.e. in attributes)? If not, we can kill the third
5860 argument to cp_parser_string_literal. */
5865 else
5872 /* If we see `( { ' then we are looking at the beginning of
5873 a GNU statement-expression. */
5876 {
5877 /* Statement-expressions are not allowed by the standard. */
5881 /* And they're not allowed outside of a function-body; you
5882 cannot, for example, write:
5884 int i = ({ int j = 3; j + 1; });
5886 at class or namespace scope. */
5889 {
5891 "statement-expressions are not allowed outside "
5897 }
5898 else
5900 }
5901 /* Otherwise it's a normal parenthesized expression. */
5902 {
5903 cp_expr expr;
5908 /* Consume the `('. */
5909 matching_parens parens;
5911 /* Within a parenthesized expression, a `>' token is always
5912 the greater-than operator. */
5913 saved_greater_than_is_operator_p
5918 /* Left fold expression. */
5920 else
5921 /* Parse the parenthesized expression. */
5926 {
5931 "fold-expressions only available with %<-std=c++17%> "
5933 }
5934 else
5935 /* Let the front end know that this expression was
5936 enclosed in parentheses. This matters in case, for
5937 example, the expression is of the form `A::B', since
5938 `&A::B' might be a pointer-to-member, but `&(A::B)' is
5939 not. */
5942 /* DR 705: Wrapping an unqualified name in parentheses
5943 suppresses arg-dependent lookup. We want to pass back
5944 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5945 (c++/37862), but none of the others. */
5949 /* The `>' token might be the end of a template-id or
5950 template-parameter-list now. */
5951 parser->greater_than_is_operator_p
5954 /* Consume the `)'. */
5966 }
5969 {
5971 {
5972 /* We might have an Objective-C++ message. */
5975 /* If that works out, we're done ... */
5978 /* ... else, fall though to see if it's a lambda. */
5979 }
5981 /* Don't warn about a failed tentative parse. */
5986 }
5990 /* We have an Objective-C++ string literal. */
5997 {
5998 /* These two are the boolean literals. */
6006 /* The `__null' literal. */
6011 /* The `nullptr' literal. */
6016 /* Recognize the `this' keyword. */
6020 {
6024 }
6025 /* Pointers cannot appear in constant-expressions. */
6030 /* The `operator' keyword can be the beginning of an
6031 id-expression. */
6038 {
6039 non_integral_constant name;
6041 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
6042 __func__ are the names of variables -- but they are
6043 treated specially. Therefore, they are handled here,
6044 rather than relying on the generic id-expression logic
6045 below. Grammatically, these names are id-expressions.
6047 Consume the token. */
6051 {
6063 }
6068 /* Look up the name. */
6070 }
6073 {
6074 tree expression;
6075 tree type;
6076 location_t type_location;
6077 location_t start_loc
6079 /* The `__builtin_va_arg' construct is used to handle
6080 `va_arg'. Consume the `__builtin_va_arg' token. */
6082 /* Look for the opening `('. */
6083 matching_parens parens;
6085 /* Now, parse the assignment-expression. */
6087 /* Look for the `,'. */
6090 /* Parse the type-id. */
6091 {
6094 }
6095 /* Look for the closing `)'. */
6096 location_t finish_loc
6099 /* Using `va_arg' in a constant-expression is not
6100 allowed. */
6102 NIC_VA_ARG))
6104 /* Construct a location of the form:
6105 __builtin_va_arg (v, int)
6106 ~~~~~~~~~~~~~~~~~~~~~^~~~
6107 with the caret at the type, ranging from the start of the
6108 "__builtin_va_arg" token to the close paren. */
6109 location_t combined_loc
6112 }
6117 // C++ concepts
6121 /* Objective-C++ expressions. */
6131 "%<omp_all_memory%> may only be used in OpenMP "
6139 {
6144 }
6145 /* FALLTHRU */
6149 }
6151 /* An id-expression can start with either an identifier, a
6152 `::' as the beginning of a qualified-id, or the "operator"
6153 keyword. */
6157 /* FALLTHRU */
6161 {
6162 id_expression:
6163 cp_expr id_expression;
6164 cp_expr decl;
6170 /* Parse the id-expression. */
6171 id_expression
6188 /* If we have a template-id, then no further lookup is
6189 required. If the template-id was for a template-class, we
6190 will sometimes have a TYPE_DECL at this point. */
6194 /* Look up the name. */
6195 else
6196 {
6197 tree ambiguous_decls;
6199 /* If we already know that this lookup is ambiguous, then
6200 we've already issued an error message; there's no reason
6201 to check again. */
6204 {
6207 }
6210 none_type,
6211 template_p,
6216 /* If the lookup was ambiguous, an error will already have
6217 been issued. */
6221 /* In Objective-C++, we may have an Objective-C 2.0
6222 dot-syntax for classes here. */
6227 {
6228 tree component;
6235 component);
6236 /* Build a location of the form:
6237 expr.component
6238 ~~~~~^~~~~~~~~
6239 with caret at the start of the component name (at
6240 input_location), ranging from the start of the id_expression
6241 to the end of the component name. */
6242 location_t combined_loc
6247 }
6249 /* In Objective-C++, an instance variable (ivar) may be preferred
6250 to whatever cp_parser_lookup_name() found.
6251 Call objc_lookup_ivar. To avoid exposing cp_expr to the
6252 rest of c-family, we have to do a little extra work to preserve
6253 any location information in cp_expr "decl". Given that
6254 objc_lookup_ivar is implemented in "c-family" and "objc", we
6255 have a trip through the pure "tree" type, rather than cp_expr.
6256 Naively copying it back to "decl" would implicitly give the
6257 new cp_expr value an UNKNOWN_LOCATION for nodes that don't
6258 store an EXPR_LOCATION. Hence we only update "decl" (and
6259 hence its location_t) if we get back a different tree node. */
6261 id_expression);
6265 /* If name lookup gives us a SCOPE_REF, then the
6266 qualifying scope was dependent. */
6268 {
6269 /* At this point, we do not know if DECL is a valid
6270 integral constant expression. We assume that it is
6271 in fact such an expression, so that code like:
6273 template <int N> struct A {
6274 int a[B<N>::i];
6275 };
6277 is accepted. At template-instantiation time, we
6278 will check that B<N>::i is actually a constant. */
6280 }
6281 /* Check to see if DECL is a local variable in a context
6282 where that is forbidden. */
6285 /* DR 2082 permits local variables in unevaluated contexts
6286 within a default argument. */
6288 {
6296 }
6297 }
6299 decl = (finish_id_expression
6301 idk,
6306 template_arg_p,
6311 /* Build a location for an id-expression of the form:
6312 ::ns::id
6313 ~~~~~~^~
6314 or:
6315 id
6316 ^~
6317 i.e. from the start of the first token to the end of the final
6318 token, with the caret at the start of the unqualified-id. */
6322 location_t combined_loc
6327 }
6329 /* Anything else is an error. */
6333 }
6334 }
6342 {
6345 }
6347 /* Complain about missing template keyword when naming a dependent
6348 member template. */
6350 static void
6352 {
6359 "expected %qs keyword before dependent "
6362 }
6364 /* Parse an id-expression.
6366 id-expression:
6367 unqualified-id
6368 qualified-id
6370 qualified-id:
6371 :: [opt] nested-name-specifier template [opt] unqualified-id
6372 :: identifier
6373 :: operator-function-id
6374 :: template-id
6376 Return a representation of the unqualified portion of the
6377 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6378 a `::' or nested-name-specifier.
6380 Often, if the id-expression was a qualified-id, the caller will
6381 want to make a SCOPE_REF to represent the qualified-id. This
6382 function does not do this in order to avoid wastefully creating
6383 SCOPE_REFs when they are not required.
6385 If TEMPLATE_KEYWORD_P is true, then we have just seen the
6386 `template' keyword.
6388 If CHECK_DEPENDENCY_P is false, then names are looked up inside
6389 uninstantiated templates.
6391 If *TEMPLATE_P is non-NULL, it is set to true iff the
6392 `template' keyword is used to explicitly indicate that the entity
6393 named is a template.
6395 If DECLARATOR_P is true, the id-expression is appearing as part of
6396 a declarator, rather than as part of an expression. */
6398 static cp_expr
6405 {
6409 /* Assume the `template' keyword was not used. */
6413 /* Look for the optional `::' operator. */
6414 global_scope_p
6415 = (!template_keyword_p
6420 /* Look for the optional nested-name-specifier. */
6421 nested_name_specifier_p
6424 check_dependency_p,
6426 declarator_p,
6427 template_keyword_p)
6433 /* Peek at the next token. */
6436 /* If there is a nested-name-specifier, then we are looking at
6437 the first qualified-id production. */
6439 {
6440 tree saved_object_scope;
6441 tree saved_qualifying_scope;
6443 /* See if the next token is the `template' keyword. */
6447 /* Name lookup we do during the processing of the
6448 unqualified-id might obliterate SCOPE. */
6451 /* Process the final unqualified-id. */
6453 check_dependency_p,
6454 declarator_p,
6456 /* Restore the SAVED_SCOPE for our caller. */
6460 }
6461 /* Otherwise, if we are in global scope, then we are looking at one
6462 of the other qualified-id productions. */
6464 {
6465 /* If it's an identifier, and the next token is not a "<", then
6466 we can avoid the template-id case. This is an optimization
6467 for this common case. */
6469 && !cp_parser_nth_token_starts_template_argument_list_p
6474 /* Try a template-id. */
6478 declarator_p);
6479 /* If that worked, we're done. */
6483 /* Peek at the next token. (Changes in the token buffer may
6484 have invalidated the pointer obtained above.) */
6488 {
6495 {
6498 }
6499 /* Fall through. */
6504 }
6505 }
6506 else
6507 {
6512 declarator_p,
6513 optional_p);
6514 }
6517 && warn_missing_template_keyword
6518 && !template_keyword_p
6519 /* Don't warn if we're looking inside templates. */
6520 && check_dependency_p
6521 /* In a template argument list a > could be closing
6522 the enclosing targs. */
6525 /* Don't confuse an ill-formed constructor declarator for a missing
6526 template keyword in a return type. */
6530 OPT_Wmissing_template_keyword))
6531 {
6534 /* An operator after the > suggests that the > ends a
6535 template-id; a name or literal suggests that the > is an
6536 operator. */
6540 }
6543 }
6545 /* Parse an unqualified-id.
6547 unqualified-id:
6548 identifier
6549 operator-function-id
6550 conversion-function-id
6551 ~ class-name
6552 template-id
6554 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6555 keyword, in a construct like `A::template ...'.
6557 Returns a representation of unqualified-id. For the `identifier'
6558 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6559 production a BIT_NOT_EXPR is returned; the operand of the
6560 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6561 other productions, see the documentation accompanying the
6562 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6563 names are looked up in uninstantiated templates. If DECLARATOR_P
6564 is true, the unqualified-id is appearing as part of a declarator,
6565 rather than as part of an expression. */
6567 static cp_expr
6573 {
6576 /* Peek at the next token. */
6580 {
6582 {
6583 tree id;
6585 /* We don't know yet whether or not this will be a
6586 template-id. */
6588 /* Try a template-id. */
6590 check_dependency_p,
6591 declarator_p);
6592 /* If it worked, we're done. */
6595 /* Otherwise, it's an ordinary identifier. */
6597 }
6601 check_dependency_p,
6602 declarator_p);
6605 {
6606 tree type_decl;
6607 tree qualifying_scope;
6608 tree object_scope;
6609 tree scope;
6613 /* Consume the `~' token. */
6615 /* Parse the class-name. The standard, as written, seems to
6616 say that:
6618 template <typename T> struct S { ~S (); };
6619 template <typename T> S<T>::~S() {}
6621 is invalid, since `~' must be followed by a class-name, but
6622 `S<T>' is dependent, and so not known to be a class.
6623 That's not right; we need to look in uninstantiated
6624 templates. A further complication arises from:
6626 template <typename T> void f(T t) {
6627 t.T::~T();
6628 }
6630 Here, it is not possible to look up `T' in the scope of `T'
6631 itself. We must look in both the current scope, and the
6632 scope of the containing complete expression.
6634 Yet another issue is:
6636 struct S {
6637 int S;
6638 ~S();
6639 };
6641 S::~S() {}
6643 The standard does not seem to say that the `S' in `~S'
6644 should refer to the type `S' and not the data member
6645 `S::S'. */
6647 /* DR 244 says that we look up the name after the "~" in the
6648 same scope as we looked up the qualifying name. That idea
6649 isn't fully worked out; it's more complicated than that. */
6654 /* Check for invalid scopes. */
6656 {
6660 }
6662 {
6666 scope);
6671 }
6673 {
6679 }
6685 /* Create a location with caret == start at the tilde,
6686 finishing at the end of the peeked token, e.g:
6687 ~token
6688 ^~~~~~. */
6689 location_t loc
6692 /* If the name is of the form "X::~X" it's OK even if X is a
6693 typedef. */
6702 {
6705 }
6707 /* ~auto means the destructor of whatever the object is. */
6709 {
6712 "%<~auto%> only available with "
6716 }
6718 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6719 declarator-id of a constructor or destructor. */
6722 {
6726 }
6728 /* If there was an explicit qualification (S::~T), first look
6729 in the scope given by the qualification (i.e., S).
6731 Note: in the calls to cp_parser_class_name below we pass
6732 typename_type so that lookup finds the injected-class-name
6733 rather than the constructor. */
6737 {
6742 typename_type,
6745 declarator_p);
6748 }
6749 /* In "N::S::~S", look in "N" as well. */
6751 {
6756 type_decl
6760 typename_type,
6763 declarator_p);
6766 }
6767 /* In "p->S::~T", look in the scope given by "*p" as well. */
6769 {
6774 type_decl
6778 typename_type,
6781 declarator_p);
6784 }
6785 /* Look in the surrounding context. */
6787 {
6793 type_decl
6797 typename_type,
6800 declarator_p);
6803 {
6804 /* We couldn't find a type with this name. If we're parsing
6805 tentatively, fail and try something else. */
6807 {
6810 }
6811 /* Otherwise, accept it and check for a match at instantiation
6812 time. */
6817 }
6818 }
6819 /* If an error occurred, assume that the name of the
6820 destructor is the same as the name of the qualifying
6821 class. That allows us to keep parsing after running
6822 into ill-formed destructor names. */
6828 /* Check that destructor name and scope match. */
6830 {
6837 }
6839 /* [class.dtor]
6841 A typedef-name that names a class shall not be used as the
6842 identifier in the declarator for a destructor declaration. */
6849 type_decl);
6852 }
6856 {
6857 cp_expr id;
6859 /* This could be a template-id, so we try that first. */
6861 /* Try a template-id. */
6864 declarator_p);
6865 /* If that worked, we're done. */
6868 /* We still don't know whether we're looking at an
6869 operator-function-id or a conversion-function-id. */
6871 /* Try an operator-function-id. */
6873 /* If that didn't work, try a conversion-function-id. */
6878 }
6879 /* Fall through. */
6886 }
6887 }
6889 /* Check [temp.names]/5: A name prefixed by the keyword template shall
6890 be a template-id or the name shall refer to a class template or an
6891 alias template. */
6893 static void
6895 {
6905 /* Alias templates are also OK. */
6912 name);
6913 }
6915 /* Parse an (optional) nested-name-specifier.
6917 nested-name-specifier: [C++98]
6918 class-or-namespace-name :: nested-name-specifier [opt]
6919 class-or-namespace-name :: template nested-name-specifier [opt]
6921 nested-name-specifier: [C++0x]
6922 type-name ::
6923 namespace-name ::
6924 nested-name-specifier identifier ::
6925 nested-name-specifier template [opt] simple-template-id ::
6927 PARSER->SCOPE should be set appropriately before this function is
6928 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6929 effect. TYPE_P is TRUE if we non-type bindings should be ignored
6930 in name lookups.
6932 Sets PARSER->SCOPE to the class (TYPE) or namespace
6933 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6934 it unchanged if there is no nested-name-specifier. Returns the new
6935 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6937 If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
6939 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6940 part of a declaration and/or decl-specifier. */
6942 static tree
6949 {
6954 /* Remember where the nested-name-specifier starts. */
6957 {
6960 }
6963 {
6964 tree new_scope;
6965 tree old_scope;
6966 tree saved_qualifying_scope;
6968 /* Spot cases that cannot be the beginning of a
6969 nested-name-specifier. */
6972 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
6973 the already parsed nested-name-specifier. */
6975 {
6976 /* Grab the nested-name-specifier and continue the loop. */
6978 /* If we originally encountered this nested-name-specifier
6979 with CHECK_DEPENDENCY_P set to true, we will not have
6980 resolved TYPENAME_TYPEs, so we must do so here. */
6982 && !check_dependency_p
6984 {
6989 }
6992 }
6994 /* Spot cases that cannot be the beginning of a
6995 nested-name-specifier. On the second and subsequent times
6996 through the loop, we look for the `template' keyword. */
6998 ;
6999 /* A template-id can start a nested-name-specifier. */
7001 ;
7002 /* DR 743: decltype can be used in a nested-name-specifier. */
7004 ;
7005 else
7006 {
7007 /* If the next token is not an identifier, then it is
7008 definitely not a type-name or namespace-name. */
7011 /* If the following token is neither a `<' (to begin a
7012 template-id), nor a `::', then we are not looking at a
7013 nested-name-specifier. */
7019 /* name:name is a valid sequence in an Objective C message. */
7021 {
7025 "found %<:%> in nested-name-specifier, "
7028 }
7031 && !cp_parser_nth_token_starts_template_argument_list_p
7034 }
7036 /* The nested-name-specifier is optional, so we parse
7037 tentatively. */
7040 /* Look for the optional `template' keyword, if this isn't the
7041 first time through the loop. */
7043 {
7045 /* DR1710: "In a qualified-id used as the name in
7046 a typename-specifier, elaborated-type-specifier, using-declaration,
7047 or class-or-decltype, an optional keyword template appearing at
7048 the top level is ignored." */
7050 && typename_keyword_p
7053 }
7055 /* Save the old scope since the name lookup we are about to do
7056 might destroy it. */
7059 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
7060 look up names in "X<T>::I" in order to determine that "Y" is
7061 a template. So, if we have a typename at this point, we make
7062 an effort to look through it. */
7064 && !check_dependency_p
7065 && !typename_keyword_p
7070 /* Parse the qualifying entity. */
7071 new_scope
7073 typename_keyword_p,
7074 template_keyword_p,
7075 check_dependency_p,
7076 type_p,
7077 is_declaration);
7078 /* Look for the `::' token. */
7081 /* If we found what we wanted, we keep going; otherwise, we're
7082 done. */
7084 {
7087 /* Restore the OLD_SCOPE since it was valid before the
7088 failed attempt at finding the last
7089 class-or-namespace-name. */
7093 /* If the next token is a decltype, and the one after that is a
7094 `::', then the decltype has failed to resolve to a class or
7095 enumeration type. Give this error even when parsing
7096 tentatively since it can't possibly be valid--and we're going
7097 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
7098 won't get another chance.*/
7102 {
7108 dtype);
7111 /* As below. */
7114 }
7118 {
7119 /* If we have a non-type template-id followed by ::, it can't
7120 possibly be valid. */
7125 {
7128 {
7135 else
7138 }
7139 else
7140 {
7146 else
7147 {
7148 /* Variable template. */
7152 }
7153 }
7160 /* As below. */
7164 }
7165 }
7169 /* If the next token is an identifier, and the one after
7170 that is a `::', then any valid interpretation would have
7171 found a class-or-namespace-name. */
7177 {
7180 {
7182 {
7183 tree decl;
7184 tree ambiguous_decls;
7187 none_type,
7196 decl);
7198 {
7199 // cp_parser_lookup_name has the same diagnostic,
7200 // thus make sure to emit it at most once.
7203 {
7208 }
7210 }
7211 else
7212 {
7214 cp_parser_name_lookup_error
7217 else
7218 cp_parser_name_lookup_error
7221 }
7222 }
7225 /* Treat this as a successful nested-name-specifier
7226 due to:
7228 [basic.lookup.qual]
7230 If the name found is not a class-name (clause
7231 _class_) or namespace-name (_namespace.def_), the
7232 program is ill-formed. */
7234 }
7236 }
7238 }
7239 /* We've found one valid nested-name-specifier. */
7241 /* Name lookup always gives us a DECL. */
7244 /* Uses of "template" must be followed by actual templates. */
7247 /* If it is a class scope, try to complete it; we are about to
7248 be looking up names inside the class. */
7250 /* Since checking types for dependency can be expensive,
7251 avoid doing it if the type is already complete. */
7253 /* Do not try to complete dependent types. */
7255 {
7257 /* If it is a typedef to current class, use the current
7258 class instead, as the typedef won't have any names inside
7259 it yet. */
7263 }
7264 /* Make sure we look in the right scope the next time through
7265 the loop. */
7267 }
7269 /* If parsing tentatively, replace the sequence of tokens that makes
7270 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
7271 token. That way, should we re-parse the token stream, we will
7272 not have to repeat the effort required to do the parse, nor will
7273 we issue duplicate error messages. */
7275 {
7279 /* Reset the contents of the START token. */
7281 /* Retrieve any deferred checks. Do not pop this access checks yet
7282 so the memory will not be reclaimed during token replacing below. */
7291 /* Purge all subsequent tokens. */
7293 }
7299 }
7301 /* Parse a nested-name-specifier. See
7302 cp_parser_nested_name_specifier_opt for details. This function
7303 behaves identically, except that it will an issue an error if no
7304 nested-name-specifier is present. */
7306 static tree
7312 {
7313 tree scope;
7315 /* Look for the nested-name-specifier. */
7317 typename_keyword_p,
7318 check_dependency_p,
7319 type_p,
7320 is_declaration);
7321 /* If it was not present, issue an error message. */
7323 {
7326 }
7329 }
7331 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7332 this is either a class-name or a namespace-name (which corresponds
7333 to the class-or-namespace-name production in the grammar). For
7334 C++0x, it can also be a type-name that refers to an enumeration
7335 type or a simple-template-id.
7337 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7338 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7339 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7340 TYPE_P is TRUE iff the next name should be taken as a class-name,
7341 even the same name is declared to be another entity in the same
7342 scope.
7344 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7345 specified by the class-or-namespace-name. If neither is found the
7346 ERROR_MARK_NODE is returned. */
7348 static tree
7355 {
7356 tree saved_scope;
7357 tree saved_qualifying_scope;
7358 tree saved_object_scope;
7359 tree scope;
7363 /* DR 743: decltype can appear in a nested-name-specifier. */
7365 {
7369 {
7372 }
7376 }
7378 /* Before we try to parse the class-name, we must save away the
7379 current PARSER->SCOPE since cp_parser_class_name will destroy
7380 it. */
7384 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7385 there is no need to look for a namespace-name. */
7386 only_class_p = template_keyword_p
7391 typename_keyword_p,
7392 template_keyword_p,
7394 check_dependency_p,
7396 is_declaration,
7399 /* If that didn't work, try for a namespace-name. */
7401 {
7402 /* Restore the saved scope. */
7406 /* If we are not looking at an identifier followed by the scope
7407 resolution operator, then this is not part of a
7408 nested-name-specifier. (Note that this function is only used
7409 to parse the components of a nested-name-specifier.) */
7414 }
7417 }
7419 /* Return true if we are looking at a compound-literal, false otherwise. */
7421 static bool
7423 {
7426 /* Skip tokens until the next token is a closing parenthesis.
7427 If we find the closing `)', and the next token is a `{', then
7428 we are looking at a compound-literal. */
7429 bool compound_literal_p
7434 /* Roll back the tokens we skipped. */
7438 }
7440 /* Return true if EXPR is the integer constant zero or a complex constant
7441 of zero, without any folding, but ignoring location wrappers. */
7443 bool
7445 {
7448 }
7450 /* Parse a postfix-expression.
7452 postfix-expression:
7453 primary-expression
7454 postfix-expression [ expression ]
7455 postfix-expression ( expression-list [opt] )
7456 simple-type-specifier ( expression-list [opt] )
7457 typename :: [opt] nested-name-specifier identifier
7458 ( expression-list [opt] )
7459 typename :: [opt] nested-name-specifier template [opt] template-id
7460 ( expression-list [opt] )
7461 postfix-expression . template [opt] id-expression
7462 postfix-expression -> template [opt] id-expression
7463 postfix-expression . pseudo-destructor-name
7464 postfix-expression -> pseudo-destructor-name
7465 postfix-expression ++
7466 postfix-expression --
7467 dynamic_cast < type-id > ( expression )
7468 static_cast < type-id > ( expression )
7469 reinterpret_cast < type-id > ( expression )
7470 const_cast < type-id > ( expression )
7471 typeid ( expression )
7472 typeid ( type-id )
7474 GNU Extension:
7476 postfix-expression:
7477 ( type-id ) { initializer-list , [opt] }
7479 This extension is a GNU version of the C99 compound-literal
7480 construct. (The C99 grammar uses `type-name' instead of `type-id',
7481 but they are essentially the same concept.)
7483 If ADDRESS_P is true, the postfix expression is the operand of the
7484 `&' operator. CAST_P is true if this expression is the target of a
7485 cast.
7487 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
7488 class member access expressions [expr.ref].
7490 Returns a representation of the expression. */
7492 static cp_expr
7496 {
7498 location_t loc;
7504 /* Peek at the next token. */
7509 /* Some of the productions are determined by keywords. */
7512 {
7517 {
7518 tree type;
7519 cp_expr expression;
7523 /* All of these can be handled in the same way from the point
7524 of view of parsing. Begin by consuming the token
7525 identifying the cast. */
7528 /* New types cannot be defined in the cast. */
7530 parser->type_definition_forbidden_message
7533 /* Look for the opening `<'. */
7535 /* Parse the type to which we are casting. */
7539 NULL);
7541 /* Look for the closing `>'. */
7543 /* Restore the old message. */
7546 bool saved_greater_than_is_operator_p
7550 /* And the expression which is being cast. */
7551 matching_parens parens;
7555 RT_CLOSE_PAREN);
7559 parser->greater_than_is_operator_p
7562 /* Only type conversions to integral or enumeration types
7563 can be used in constant-expressions. */
7566 {
7569 }
7571 /* Construct a location e.g. :
7572 reinterpret_cast <int *> (expr)
7573 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7574 ranging from the start of the "*_cast" token to the final closing
7575 paren, with the caret at the start. */
7579 {
7581 postfix_expression
7583 tf_warning_or_error);
7586 postfix_expression
7588 tf_warning_or_error);
7591 postfix_expression
7593 tf_warning_or_error);
7596 postfix_expression
7598 tf_warning_or_error);
7602 }
7603 }
7607 {
7608 tree type;
7612 /* Consume the `typeid' token. */
7614 /* Look for the `(' token. */
7615 matching_parens parens;
7617 /* Types cannot be defined in a `typeid' expression. */
7619 parser->type_definition_forbidden_message
7621 /* We can't be sure yet whether we're looking at a type-id or an
7622 expression. */
7624 /* Try a type-id first. */
7629 /* Look for the `)' token. Otherwise, we can't be sure that
7630 we're not looking at an expression: consider `typeid (int
7631 (3))', for example. */
7633 /* If all went well, simply lookup the type-id. */
7636 /* Otherwise, fall back to the expression variant. */
7637 else
7638 {
7639 tree expression;
7641 /* Look for an expression. */
7643 /* Compute its typeid. */
7645 /* Look for the `)' token. */
7647 }
7648 /* Restore the saved message. */
7650 /* `typeid' may not appear in an integral constant expression. */
7654 /* Construct a location e.g. :
7655 typeid (expr)
7656 ^~~~~~~~~~~~~
7657 ranging from the start of the "typeid" token to the final closing
7658 paren, with the caret at the start. */
7660 {
7661 location_t typeid_loc
7665 }
7666 }
7670 {
7671 tree type;
7672 /* The syntax permitted here is the same permitted for an
7673 elaborated-type-specifier. */
7680 }
7688 {
7696 {
7699 }
7705 {
7708 postfix_expression
7710 else
7711 {
7715 }
7721 tf_warning_or_error);
7722 else
7723 {
7727 }
7735 else
7736 {
7740 }
7745 postfix_expression
7749 postfix_expression
7752 else
7753 {
7757 }
7762 {
7766 }
7767 else
7768 {
7769 postfix_expression
7771 }
7776 }
7778 }
7781 {
7782 tree expression;
7783 tree type;
7784 /* Consume the `__builtin_convertvector' token. */
7786 /* Look for the opening `('. */
7787 matching_parens parens;
7789 /* Now, parse the assignment-expression. */
7791 /* Look for the `,'. */
7793 location_t type_location
7795 /* Parse the type-id. */
7796 {
7799 }
7800 /* Look for the closing `)'. */
7802 postfix_expression
7804 tf_warning_or_error);
7806 }
7809 {
7810 tree expression;
7811 tree type;
7812 /* Consume the `__builtin_bit_cast' token. */
7814 /* Look for the opening `('. */
7815 matching_parens parens;
7817 location_t type_location
7819 /* Parse the type-id. */
7820 {
7823 }
7824 /* Look for the `,'. */
7826 /* Now, parse the assignment-expression. */
7828 /* Look for the closing `)'. */
7830 postfix_expression
7832 tf_warning_or_error);
7834 }
7837 {
7838 tree type;
7840 /* If the next thing is a simple-type-specifier, we may be
7841 looking at a functional cast. We could also be looking at
7842 an id-expression. So, we try the functional cast, and if
7843 that doesn't work we fall back to the primary-expression. */
7845 /* Look for the simple-type-specifier. */
7849 CP_PARSER_FLAGS_NONE);
7851 /* Parse the cast itself. */
7853 postfix_expression
7855 /* If that worked, we're done. */
7859 /* If the functional-cast didn't work out, try a
7860 compound-literal. */
7863 {
7868 matching_parens parens;
7871 /* Avoid calling cp_parser_type_id pointlessly, see comment
7872 in cp_parser_cast_expression about c++/29234. */
7875 else
7876 {
7877 /* Parse the type. */
7883 }
7885 /* If things aren't going well, there's no need to
7886 keep going. */
7888 /* Parse the brace-enclosed initializer list. */
7890 /* If that worked, we're definitely looking at a
7891 compound-literal expression. */
7893 {
7894 /* Warn the user that a compound literal is not
7895 allowed in standard C++. */
7898 /* For simplicity, we disallow compound literals in
7899 constant-expressions. We could
7900 allow compound literals of integer type, whose
7901 initializer was a constant, in constant
7902 expressions. Permitting that usage, as a further
7903 extension, would not change the meaning of any
7904 currently accepted programs. (Of course, as
7905 compound literals are not part of ISO C++, the
7906 standard has nothing to say.) */
7908 NIC_NCC))
7909 {
7912 }
7913 /* Form the representation of the compound-literal. */
7914 postfix_expression
7919 }
7920 }
7922 /* It must be a primary-expression. */
7923 postfix_expression
7926 decltype_p,
7928 }
7930 }
7932 /* Note that we don't need to worry about calling build_cplus_new on a
7933 class-valued CALL_EXPR in decltype when it isn't the end of the
7934 postfix-expression; unary_complex_lvalue will take care of that for
7935 all these cases. */
7937 /* Keep looping until the postfix-expression is complete. */
7939 {
7943 /* It is not a Koenig lookup function call. */
7944 postfix_expression
7947 /* Peek at the next token. */
7951 {
7954 {
7956 "two consecutive %<[%> shall "
7959 }
7960 postfix_expression
7962 postfix_expression,
7964 decltype_p);
7973 /* postfix-expression ( expression-list [opt] ) */
7974 {
7986 tree stripped_expression
7988 is_builtin_constant_p
7991 {
7992 /* The whole point of __builtin_constant_p is to allow
7993 non-constant expressions to appear as arguments. */
7994 saved_integral_constant_expression_p
7996 saved_non_integral_constant_expression_p
7999 }
8002 BUILT_IN_CLASSIFY_TYPE))
8003 {
8004 /* __builtin_classify_type (type) */
8011 NULL);
8014 cp_unevaluated uev;
8016 matching_parens parens;
8021 {
8023 {
8031 }
8032 else
8033 {
8034 postfix_expression
8037 }
8039 }
8040 }
8041 args = (cp_parser_parenthesized_expression_list
8048 {
8049 parser->integral_constant_expression_p
8051 parser->non_integral_constant_expression_p
8053 }
8056 {
8059 }
8061 /* Function calls are not permitted in
8062 constant-expressions. */
8065 NIC_FUNC_CALL))
8066 {
8070 }
8075 {
8077 /* In C++20, we may need to perform ADL for a template
8078 name. */
8081 {
8083 {
8086 postfix_expression
8088 complain);
8089 }
8090 else
8091 postfix_expression
8093 }
8094 /* We do not perform argument-dependent lookup if
8095 normal lookup finds a non-function, in accordance
8096 with the expected resolution of DR 218. */
8099 {
8100 /* Do not do argument dependent lookup if regular
8101 lookup finds a member function or a block-scope
8102 function declaration. [basic.lookup.argdep]/3 */
8106 {
8112 {
8115 }
8116 }
8119 {
8122 postfix_expression
8124 complain);
8125 }
8126 }
8127 }
8129 /* Temporarily set input_location to the combined location
8130 with call expression range, as e.g. build_out_target_exprs
8131 called from convert_default_arg relies on input_location,
8132 so updating it only when the call is fully built results
8133 in inconsistencies between location handling in templates
8134 and outside of templates. */
8137 close_paren_loc);
8143 postfix_expression = (build_offset_ref_call_from_tree
8145 complain));
8146 else
8147 /* All other function calls. */
8148 {
8153 {
8157 }
8159 postfix_expression
8161 disallow_virtual,
8162 koenig_p,
8163 complain);
8164 }
8169 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
8173 }
8178 /* postfix-expression . template [opt] id-expression
8179 postfix-expression . pseudo-destructor-name
8180 postfix-expression -> template [opt] id-expression
8181 postfix-expression -> pseudo-destructor-name */
8183 /* Consume the `.' or `->' operator. */
8186 postfix_expression
8188 postfix_expression,
8195 /* postfix-expression ++ */
8196 /* Consume the `++' token. */
8198 /* Generate a representation for the complete expression. */
8199 postfix_expression
8201 POSTINCREMENT_EXPR);
8202 /* Increments may not appear in constant-expressions. */
8210 /* postfix-expression -- */
8211 /* Consume the `--' token. */
8213 /* Generate a representation for the complete expression. */
8214 postfix_expression
8216 POSTDECREMENT_EXPR);
8217 /* Decrements may not appear in constant-expressions. */
8228 return is_member_access
8229 ? postfix_expression
8231 else
8233 }
8234 }
8235 }
8237 /* Helper function for cp_parser_parenthesized_expression_list and
8238 cp_parser_postfix_open_square_expression. Parse a single element
8239 of parenthesized expression list. */
8241 static cp_expr
8245 {
8249 /* Parse the next assignment-expression. */
8251 {
8252 /* A braced-init-list. */
8257 ? &expr_non_constant_p
8261 }
8263 {
8269 }
8270 else
8273 /* If we have an ellipsis, then this is an expression expansion. */
8276 {
8277 /* Consume the `...'. */
8280 /* Build the argument pack. */
8282 }
8284 }
8286 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8287 by cp_parser_builtin_offsetof. We're looking for
8289 postfix-expression [ expression ]
8290 postfix-expression [ braced-init-list ] (C++11)
8291 postfix-expression [ expression-list[opt] ] (C++23)
8293 FOR_OFFSETOF is set if we're being called in that context, which
8294 changes how we deal with integer constant expressions. */
8296 static tree
8298 tree postfix_expression,
8301 {
8308 /* Consume the `[' token. */
8318 /* Parse the index expression. */
8319 /* ??? For offsetof, there is a question of what to allow here. If
8320 offsetof is not being used in an integral constant expression context,
8321 then we *could* get the right answer by computing the value at runtime.
8322 If we are in an integral constant expression context, then we might
8323 could accept any constant expression; hard to say without analysis.
8324 Rather than open the barn door too wide right away, allow only integer
8325 constant expressions here. */
8330 {
8335 {
8337 {
8338 cp_expr expr
8340 /*cast_p=*/
8342 /*allow_exp_p=*/
8344 /*non_cst_p=*/
8345 NULL);
8352 else
8355 /* If the next token isn't a `,', then we are done. */
8360 {
8363 }
8365 /* Otherwise, consume the `,' and keep going. */
8367 }
8370 }
8372 {
8376 }
8377 else
8381 }
8389 {
8393 }
8396 {
8400 {
8402 {
8403 cp_expr expr
8405 /*cast_p=*/
8407 /*allow_exp_p=*/
8409 /*non_cst_p=*/
8410 NULL);
8414 else
8418 {
8422 }
8423 }
8424 else
8425 length
8429 }
8434 {
8437 }
8438 else
8442 length);
8443 }
8447 /* Look for the closing `]'. */
8450 /* Build the ARRAY_REF. */
8453 tf_warning_or_error
8456 /* When not doing offsetof, array references are not permitted in
8457 constant-expressions. */
8463 }
8465 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8466 dereference of incomplete type, returns true if error_mark_node should
8467 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8468 and *DEPENDENT_P. */
8470 bool
8473 {
8474 /* In a template, be permissive by treating an object expression
8475 of incomplete type as dependent (after a pedwarn). */
8476 diagnostic_t kind = (processing_template_decl
8480 {
8492 /* Don't emit any diagnostic for OVERLOADs. */
8496 /* Avoid clobbering e.g. DECLs. */
8500 }
8512 {
8515 }
8517 }
8519 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8520 by cp_parser_builtin_offsetof. We're looking for
8522 postfix-expression . template [opt] id-expression
8523 postfix-expression . pseudo-destructor-name
8524 postfix-expression -> template [opt] id-expression
8525 postfix-expression -> pseudo-destructor-name
8527 FOR_OFFSETOF is set if we're being called in that context. That sorta
8528 limits what of the above we'll actually accept, but nevermind.
8529 TOKEN_TYPE is the "." or "->" token, which will already have been
8530 removed from the stream. */
8532 static tree
8535 cp_expr postfix_expression,
8537 location_t location)
8538 {
8539 tree name;
8545 /* If this is a `->' operator, dereference the pointer. */
8548 tf_warning_or_error);
8549 /* Check to see whether or not the expression is type-dependent and
8550 not the current instantiation. */
8552 /* The identifier following the `->' or `.' is not qualified. */
8558 /* Enter the scope corresponding to the type of the object
8559 given by the POSTFIX_EXPRESSION. */
8561 {
8563 /* According to the standard, no expression should ever have
8564 reference type. Unfortunately, we do not currently match
8565 the standard in this respect in that our internal representation
8566 of an expression may have reference type even when the standard
8567 says it does not. Therefore, we have to manually obtain the
8568 underlying type here. */
8570 /* The type of the POSTFIX_EXPRESSION must be complete. */
8571 /* Unlike the object expression in other contexts, *this is not
8572 required to be of complete type for purposes of class member
8573 access (5.2.5) outside the member function body. */
8577 {
8583 }
8586 {
8587 /* Let the name lookup machinery know that we are processing a
8588 class member access expression. */
8590 /* If something went wrong, we want to be able to discern that case,
8591 as opposed to the case where there was no SCOPE due to the type
8592 of expression being dependent. */
8595 /* If the SCOPE was erroneous, make the various semantic analysis
8596 functions exit quickly -- and without issuing additional error
8597 messages. */
8600 }
8601 }
8604 {
8606 /* If we don't have a (type-dependent) object of class type, use
8607 typeof to figure out the type of the object. */
8611 }
8613 /* Assume this expression is not a pseudo-destructor access. */
8616 /* If the SCOPE is a scalar type, then, if this is a valid program,
8617 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8618 is type dependent, it can be pseudo-destructor-name or something else.
8619 Try to parse it as pseudo-destructor-name first. */
8621 {
8622 tree s;
8623 tree type;
8626 /* Parse the pseudo-destructor-name. */
8635 {
8637 postfix_expression
8640 }
8641 }
8644 {
8645 /* If the SCOPE is not a scalar type, we are looking at an
8646 ordinary class member access expression, rather than a
8647 pseudo-destructor-name. */
8650 /* Parse the id-expression. */
8651 name = (cp_parser_id_expression
8658 /* In general, build a SCOPE_REF if the member name is qualified.
8659 However, if the name was not dependent and has already been
8660 resolved; there is no need to build the SCOPE_REF. For example;
8662 struct X { void f(); };
8663 template <typename T> void f(T* t) { t->X::f(); }
8665 Even though "t" is dependent, "X::f" is not and has been resolved
8666 to a BASELINK; there is no need to include scope information. */
8668 /* But we do need to remember that there was an explicit scope for
8669 virtual function calls. */
8673 /* If the name is a template-id that names a type, we will get a
8674 TYPE_DECL here. That is invalid code. */
8676 {
8679 }
8680 else
8681 {
8683 {
8685 {
8689 }
8690 else
8693 name,
8694 template_p);
8698 }
8700 adjust_result_of_qualified_name_lookup
8702 postfix_expression
8704 template_p,
8705 tf_warning_or_error);
8706 /* Build a location e.g.:
8707 ptr->access_expr
8708 ~~~^~~~~~~~~~~~~
8709 where the caret is at the deref token, ranging from
8710 the start of postfix_expression to the end of the access expr. */
8711 location_t combined_loc
8714 }
8715 }
8717 /* We no longer need to look up names in the scope of the object on
8718 the left-hand side of the `.' or `->' operator. */
8721 /* Outside of offsetof, these operators may not appear in
8722 constant-expressions. */
8724 && (cp_parser_non_integral_constant_expression
8729 }
8731 /* Parse a parenthesized expression-list.
8733 expression-list:
8734 assignment-expression
8735 expression-list, assignment-expression
8737 attribute-list:
8738 expression-list
8739 identifier
8740 identifier, expression-list
8742 CAST_P is true if this expression is the target of a cast.
8744 ALLOW_EXPANSION_P is true if this expression allows expansion of an
8745 argument pack.
8747 WRAP_LOCATIONS_P is true if expressions within this list for which
8748 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8749 their source locations.
8751 Returns a vector of trees. Each element is a representation of an
8752 assignment-expression. NULL is returned if the ( and or ) are
8753 missing. An empty, but allocated, vector is returned on no
8754 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8755 if we are parsing an attribute list for an attribute that wants a
8756 plain identifier argument, normal_attr for an attribute that wants
8757 an expression, or non_attr if we aren't parsing an attribute list. If
8758 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8759 not all of the expressions in the list were constant.
8760 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8761 will be written to with the location of the closing parenthesis. If
8762 an error occurs, it may or may not be written to. */
8772 {
8777 /* Assume all the expressions will be constant. */
8781 matching_parens parens;
8787 /* Within a parenthesized expression, a `>' token is always
8788 the greater-than operator. */
8789 saved_greater_than_is_operator_p
8798 /* Consume expressions until there are no more. */
8801 {
8802 /* At the beginning of attribute lists, check to see if the
8803 next token is an identifier. */
8811 else
8812 expr
8814 allow_expansion_p,
8815 non_constant_p);
8820 /* Add it to the list. We add error_mark_node
8821 expressions to the list, so that we can still tell if
8822 the correct form for a parenthesized expression-list
8823 is found. That gives better errors. */
8829 /* After the first item, attribute lists look the same as
8830 expression lists. */
8833 get_comma:;
8834 /* If the next token isn't a `,', then we are done. */
8838 /* Otherwise, consume the `,' and keep going. */
8840 }
8846 {
8849 skip_comma:;
8850 /* We try and resync to an unnested comma, as that will give the
8851 user better diagnostics. */
8859 {
8860 parser->greater_than_is_operator_p
8864 }
8865 }
8867 parser->greater_than_is_operator_p
8872 }
8874 /* Parse a pseudo-destructor-name.
8876 pseudo-destructor-name:
8877 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
8878 :: [opt] nested-name-specifier template template-id :: ~ type-name
8879 :: [opt] nested-name-specifier [opt] ~ type-name
8881 If either of the first two productions is used, sets *SCOPE to the
8882 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
8883 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
8884 or ERROR_MARK_NODE if the parse fails. */
8886 static void
8888 tree object,
8891 {
8894 /* Handle ~auto. */
8898 {
8901 "%<~auto%> only available with "
8908 }
8910 /* Assume that things will not work out. */
8913 /* Look for the optional `::' operator. */
8915 /* Look for the optional nested-name-specifier. */
8916 nested_name_specifier_p
8923 /* Now, if we saw a nested-name-specifier, we might be doing the
8924 second production. */
8927 {
8928 /* Consume the `template' keyword. */
8930 /* Parse the template-id. */
8934 class_type,
8936 /* Look for the `::' token. */
8938 }
8939 /* If the next token is not a `~', then there might be some
8940 additional qualification. */
8942 {
8943 /* At this point, we're looking for "type-name :: ~". The type-name
8944 must not be a class-name, since this is a pseudo-destructor. So,
8945 it must be either an enum-name, or a typedef-name -- both of which
8946 are just identifiers. So, we peek ahead to check that the "::"
8947 and "~" tokens are present; if they are not, then we can avoid
8948 calling type_name. */
8952 {
8955 }
8957 /* Look for the type-name. */
8962 /* Look for the `::' token. */
8964 }
8965 else
8968 /* Look for the `~'. */
8971 /* Once we see the ~, this has to be a pseudo-destructor. */
8975 /* Look for the type-name again. We are not responsible for
8976 checking that it matches the first type-name. */
8978 }
8980 /* Parse a unary-expression.
8982 unary-expression:
8983 postfix-expression
8984 ++ cast-expression
8985 -- cast-expression
8986 await-expression
8987 unary-operator cast-expression
8988 sizeof unary-expression
8989 sizeof ( type-id )
8990 alignof ( type-id ) [C++0x]
8991 new-expression
8992 delete-expression
8994 GNU Extensions:
8996 unary-expression:
8997 __extension__ cast-expression
8998 __alignof__ unary-expression
8999 __alignof__ ( type-id )
9000 alignof unary-expression [C++0x]
9001 __real__ cast-expression
9002 __imag__ cast-expression
9003 && identifier
9004 sizeof ( type-id ) { initializer-list , [opt] }
9005 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
9006 __alignof__ ( type-id ) { initializer-list , [opt] }
9008 ADDRESS_P is true iff the unary-expression is appearing as the
9009 operand of the `&' operator. CAST_P is true if this expression is
9010 the target of a cast.
9012 Returns a representation of the expression. */
9014 static cp_expr
9017 {
9021 /* Peek at the next token. */
9023 /* Some keywords give away the kind of expression. */
9025 {
9029 {
9032 {
9040 /* Consume the token. */
9042 /* Parse the operand. */
9045 /* Construct a location e.g. :
9046 alignof (expr)
9047 ^~~~~~~~~~~~~~
9048 with start == caret at the start of the "alignof"/"sizeof"
9049 token, with the endpoint at the final closing paren. */
9050 location_t compound_loc
9056 else
9057 {
9058 /* ISO C++ defines alignof only with types, not with
9059 expressions. So pedwarn if alignof is used with a non-
9060 type expression. However, __alignof__ is ok. */
9063 "ISO C++ does not allow %<alignof%> "
9068 }
9069 /* For SIZEOF_EXPR, just issue diagnostics, but keep
9070 SIZEOF_EXPR with the original operand. */
9072 {
9074 {
9076 {
9079 error_mark_node));
9081 }
9082 else
9087 }
9088 }
9093 }
9105 {
9106 /* The saved value of the PEDANTIC flag. */
9108 tree expr;
9110 /* Save away the PEDANTIC flag. */
9112 /* Parse the cast-expression. */
9114 /* Restore the PEDANTIC flag. */
9118 }
9122 {
9123 tree expression;
9125 /* Consume the `__real__' or `__imag__' token. */
9127 /* Parse the cast-expression. */
9129 /* Create the complete representation. */
9134 tf_warning_or_error);
9135 }
9143 {
9144 tree expr;
9153 matching_parens parens;
9157 parser->type_definition_forbidden_message
9160 saved_integral_constant_expression_p
9162 saved_non_integral_constant_expression_p
9166 saved_greater_than_is_operator_p
9178 parser->greater_than_is_operator_p
9181 parser->integral_constant_expression_p
9183 parser->non_integral_constant_expression_p
9190 /* Construct a location of the form:
9191 noexcept (expr)
9192 ^~~~~~~~~~~~~~~
9193 with start == caret, finishing at the close-paren. */
9194 location_t noexcept_loc
9198 noexcept_loc);
9199 }
9202 {
9203 tree expr;
9206 /* Consume the `co_await' token. */
9208 /* Parse its cast-expression. */
9213 /* Handle [expr.await]. */
9215 }
9219 }
9220 }
9222 /* Look for the `:: new' and `:: delete', which also signal the
9223 beginning of a new-expression, or delete-expression,
9224 respectively. If the next token is `::', then it might be one of
9225 these. */
9227 {
9230 /* See if the token after the `::' is one of the keywords in
9231 which we're interested. */
9233 /* If it's `new', we have a new-expression. */
9236 /* Similarly, for `delete'. */
9239 }
9241 /* Look for a unary operator. */
9243 /* The `++' and `--' operators can be handled similarly, even though
9244 they are not technically unary-operators in the grammar. */
9246 {
9251 /* Handle the GNU address-of-label extension. */
9254 {
9255 tree identifier;
9256 tree expression;
9259 /* Consume the '&&' token. */
9261 /* Look for the identifier. */
9263 /* Construct a location of the form:
9264 &&label
9265 ^~~~~~~
9266 with caret==start at the "&&", finish at the end of the label. */
9267 location_t combined_loc
9269 /* Create an expression representing the address. */
9274 NIC_ADDR_LABEL))
9277 }
9278 }
9280 {
9281 cp_expr cast_expression;
9287 /* Consume the operator token. */
9291 /* Parse the cast-expression. */
9292 cast_expression
9297 pidk);
9299 /* Make a location:
9300 OP_TOKEN CAST_EXPRESSION
9301 ^~~~~~~~~~~~~~~~~~~~~~~~~
9302 with start==caret at the operator token, and
9303 extending to the end of the cast_expression. */
9306 /* Now, build an appropriate representation. */
9308 {
9313 complain);
9314 /* TODO: build_x_indirect_ref does not always honor the
9315 location, so ensure it is set. */
9321 /* Fall through. */
9324 cast_expression,
9326 /* TODO: build_x_unary_op does not always honor the location,
9327 so ensure it is set. */
9335 /* Fall through. */
9337 /* Immediately fold negation of a constant, unless the constant is 0
9338 (since -0 == 0) or it would overflow. */
9340 {
9341 tree stripped_expr
9346 {
9349 stripped_expr);
9351 {
9354 }
9355 }
9356 }
9357 /* Fall through. */
9366 }
9370 non_constant_p))
9374 }
9378 decltype_p,
9379 pidk);
9380 }
9382 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
9383 unary-operator, the corresponding tree code is returned. */
9385 static enum tree_code
9387 {
9389 {
9410 }
9411 }
9413 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9414 Returns a representation of the expression. */
9416 static tree
9418 {
9421 /* Consume the __builtin_has_attribute token. */
9424 matching_parens parens;
9428 /* Types cannot be defined in a `sizeof' expression. Save away the
9429 old message. */
9433 parser->type_definition_forbidden_message
9435 parser->type_definition_forbidden_message_arg
9438 /* The restrictions on constant-expressions do not apply inside
9439 sizeof expressions. */
9440 bool saved_integral_constant_expression_p
9442 bool saved_non_integral_constant_expression_p
9446 /* Do not actually evaluate the expression. */
9452 /* We can't be sure yet whether we're looking at a type-id or an
9453 expression. */
9458 /* Look for the type-id. */
9464 /* If the type-id production did not work out, then we must be
9465 looking at an expression. */
9471 /* Go back to evaluating expressions. */
9475 /* And restore the old one. */
9478 parser->integral_constant_expression_p
9480 parser->non_integral_constant_expression_p
9483 /* Consume the comma if it's there. */
9485 {
9489 }
9491 /* Parse the attribute specification. */
9495 {
9501 else
9502 {
9503 /* Fold constant expressions used in attributes first. */
9506 /* Finally, see if OPER has been declared with ATTR. */
9508 }
9511 }
9512 else
9513 {
9516 }
9518 /* Construct a location e.g. :
9519 __builtin_has_attribute (oper, attr)
9520 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9521 with start == caret at the start of the built-in token,
9522 and with the endpoint at the final closing paren. */
9523 location_t compound_loc
9530 }
9532 /* Parse a new-expression.
9534 new-expression:
9535 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9536 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9538 Returns a representation of the expression. */
9540 static tree
9542 {
9545 tree type;
9548 tree ret;
9552 /* Look for the optional `::' operator. */
9553 global_scope_p
9557 /* Look for the `new' operator. */
9559 /* There's no easy way to tell a new-placement from the
9560 `( type-id )' construct. */
9562 /* Look for a new-placement. */
9564 /* If that didn't work out, there's no new-placement. */
9566 {
9570 }
9572 /* If the next token is a `(', then we have a parenthesized
9573 type-id. */
9575 {
9579 /* Consume the `('. */
9580 matching_parens parens;
9583 /* Parse the type-id. */
9584 parser->type_definition_forbidden_message
9586 {
9589 }
9592 /* Look for the closing `)'. */
9595 /* There should not be a direct-new-declarator in this production,
9596 but GCC used to allowed this, so we check and emit a sensible error
9597 message for this case. */
9599 {
9605 }
9606 }
9607 /* Otherwise, there must be a new-type-id. */
9608 else
9611 /* If the next token is a `(' or '{', then we have a new-initializer. */
9616 else
9619 /* A new-expression may not appear in an integral constant
9620 expression. */
9623 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9624 of a new-type-id or type-id of a new-expression, the new-expression shall
9625 contain a new-initializer of the form ( assignment-expression )".
9626 Additionally, consistently with the spirit of DR 1467, we want to accept
9627 'new auto { 2 }' too. */
9633 {
9635 "initialization of new-expression for type %<auto%> "
9638 }
9639 else
9640 {
9641 /* Construct a location e.g.:
9642 ptr = new int[100]
9643 ^~~~~~~~~~~~
9644 with caret == start at the start of the "new" token, and the end
9645 at the end of the final token we consumed. */
9648 /* Create a representation of the new-expression. */
9651 }
9659 }
9661 /* Parse a new-placement.
9663 new-placement:
9664 ( expression-list )
9666 Returns the same representation as for an expression-list. */
9670 {
9673 /* Parse the expression-list. */
9674 expression_list = (cp_parser_parenthesized_expression_list
9683 }
9685 /* Parse a new-type-id.
9687 new-type-id:
9688 type-specifier-seq new-declarator [opt]
9690 Returns the TYPE allocated. If the new-type-id indicates an array
9691 type, *NELTS is set to the number of elements in the last array
9692 bound; the TYPE will not include the last array bound. */
9694 static tree
9696 {
9697 cp_decl_specifier_seq type_specifier_seq;
9703 /* The type-specifier sequence must not contain type definitions.
9704 (It cannot contain declarations of new types either, but if they
9705 are not definitions we will catch that because they are not
9706 complete.) */
9708 parser->type_definition_forbidden_message
9710 /* Parse the type-specifier-seq. */
9715 /* Restore the old message. */
9721 /* Parse the new-declarator. */
9724 /* Determine the number of elements in the last array dimension, if
9725 any. */
9727 /* Skip down to the last array dimension. */
9732 {
9735 }
9740 {
9743 }
9746 {
9755 else
9757 }
9760 }
9762 /* Parse an (optional) new-declarator.
9764 new-declarator:
9765 ptr-operator new-declarator [opt]
9766 direct-new-declarator
9768 Returns the declarator. */
9772 {
9775 cp_cv_quals cv_quals;
9777 /* We don't know if there's a ptr-operator next, or not. */
9779 /* Look for a ptr-operator. */
9781 /* If that worked, look for more new-declarators. */
9783 {
9786 /* Parse another optional declarator. */
9789 declarator = cp_parser_make_indirect_declarator
9793 }
9795 /* If the next token is a `[', there is a direct-new-declarator. */
9800 }
9802 /* Parse a direct-new-declarator.
9804 direct-new-declarator:
9805 [ expression ]
9806 direct-new-declarator [constant-expression]
9808 */
9812 {
9817 {
9818 tree expression;
9821 /* Look for the opening `['. */
9827 else
9829 /* The standard requires that the expression have integral
9830 type. DR 74 adds enumeration types. We believe that the
9831 real intent is that these expressions be handled like the
9832 expression in a `switch' condition, which also allows
9833 classes with a single conversion to integral or
9834 enumeration type. */
9836 {
9837 expression
9839 expression,
9842 {
9844 "expression in new-declarator must have integral "
9847 }
9848 }
9850 /* Look for the closing `]'. */
9853 /* Add this bound to the declarator. */
9856 /* If the next token is not a `[', then there are no more
9857 bounds. */
9861 }
9864 }
9866 /* Parse a new-initializer.
9868 new-initializer:
9869 ( expression-list [opt] )
9870 braced-init-list
9872 Returns a representation of the expression-list. */
9876 {
9880 {
9886 }
9887 else
9888 expression_list = (cp_parser_parenthesized_expression_list
9894 }
9896 /* Parse a delete-expression.
9898 delete-expression:
9899 :: [opt] delete cast-expression
9900 :: [opt] delete [ ] cast-expression
9902 Returns a representation of the expression. */
9904 static tree
9906 {
9909 tree expression;
9912 /* Look for the optional `::' operator. */
9913 global_scope_p
9917 /* Look for the `delete' keyword. */
9919 /* See if the array syntax is in use. */
9921 {
9922 /* Consume the `[' token. */
9924 /* Look for the `]' token. */
9926 /* Remember that this is the `[]' construct. */
9928 }
9929 else
9932 /* Parse the cast-expression. */
9935 /* A delete-expression may not appear in an integral constant
9936 expression. */
9940 /* Construct a location e.g.:
9941 delete [ ] ptr
9942 ^~~~~~~~~~~~~~
9943 with caret == start at the start of the "delete" token, and
9944 the end at the end of the final token we consumed. */
9951 }
9953 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9954 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9955 0 otherwise. */
9957 static int
9959 {
9962 {
10004 /* In ((type ()) () the last () isn't a valid cast-expression,
10005 so the whole must be parsed as postfix-expression. */
10010 /* '[' may start a primary-expression in obj-c++ and in C++11,
10011 as a lambda-expression, eg, '(void)[]{}'. */
10018 /* '++' and '--' may or may not start a cast-expression:
10020 struct T { void operator++(int); };
10021 void f() { (T())++; }
10023 vs
10025 int a;
10026 (int)++a; */
10031 }
10032 }
10034 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
10035 in the order: const_cast, static_cast, reinterpret_cast.
10037 Don't suggest dynamic_cast.
10039 Return the first legal cast kind found, or NULL otherwise. */
10043 {
10044 tree trial;
10046 /* Reuse the parser logic by attempting to build the various kinds of
10047 cast, with "complain" disabled.
10048 Identify the first such cast that is valid. */
10050 /* Don't attempt to run such logic within template processing. */
10054 /* First try const_cast. */
10059 /* If that fails, try static_cast. */
10064 /* Finally, try reinterpret_cast. */
10066 tf_none);
10070 /* No such cast possible. */
10072 }
10074 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
10075 suggesting how to convert a C-style cast of the form:
10077 (DST_TYPE)ORIG_EXPR
10079 to a C++-style cast.
10081 The primary range of RICHLOC is asssumed to be that of the original
10082 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
10083 of the parens in the C-style cast. */
10085 static void
10088 tree dst_type)
10089 {
10090 /* This function is non-trivial, so bail out now if the warning isn't
10091 going to be emitted. */
10095 /* Try to find a legal C++ cast, trying them in order:
10096 const_cast, static_cast, reinterpret_cast. */
10101 /* Replace the open paren with "CAST_SUGGESTION<". */
10102 pretty_printer pp;
10107 /* Replace the close paren with "> (". */
10110 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
10112 }
10115 /* Parse a cast-expression.
10117 cast-expression:
10118 unary-expression
10119 ( type-id ) cast-expression
10121 ADDRESS_P is true iff the unary-expression is appearing as the
10122 operand of the `&' operator. CAST_P is true if this expression is
10123 the target of a cast.
10125 Returns a representation of the expression. */
10127 static cp_expr
10130 {
10131 /* If it's a `(', then we might be looking at a cast. */
10133 {
10139 /* There's no way to know yet whether or not this is a cast.
10140 For example, `(int (3))' is a unary-expression, while `(int)
10141 3' is a cast. So, we resort to parsing tentatively. */
10143 /* Types may not be defined in a cast. */
10145 parser->type_definition_forbidden_message
10147 /* Consume the `('. */
10148 matching_parens parens;
10153 /* A very tricky bit is that `(struct S) { 3 }' is a
10154 compound-literal (which we permit in C++ as an extension).
10155 But, that construct is not a cast-expression -- it is a
10156 postfix-expression. (The reason is that `(struct S) { 3 }.i'
10157 is legal; if the compound-literal were a cast-expression,
10158 you'd need an extra set of parentheses.) But, if we parse
10159 the type-id, and it happens to be a class-specifier, then we
10160 will commit to the parse at that point, because we cannot
10161 undo the action that is done when creating a new class. So,
10162 then we cannot back up and do a postfix-expression.
10164 Another tricky case is the following (c++/29234):
10166 struct S { void operator () (); };
10168 void foo ()
10169 {
10170 ( S()() );
10171 }
10173 As a type-id we parse the parenthesized S()() as a function
10174 returning a function, groktypename complains and we cannot
10175 back up in this case either.
10177 Therefore, we scan ahead to the closing `)', and check to see
10178 if the tokens after the `)' can start a cast-expression. Otherwise
10179 we are dealing with an unary-expression, a postfix-expression
10180 or something else.
10182 Yet another tricky case, in C++11, is the following (c++/54891):
10184 (void)[]{};
10186 The issue is that usually, besides the case of lambda-expressions,
10187 the parenthesized type-id cannot be followed by '[', and, eg, we
10188 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
10189 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
10190 we don't commit, we try a cast-expression, then an unary-expression.
10192 Save tokens so that we can put them back. */
10195 /* We may be looking at a cast-expression. */
10198 cast_expression
10201 /* Roll back the tokens we skipped. */
10203 /* If we aren't looking at a cast-expression, simulate an error so
10204 that the call to cp_parser_error_occurred below returns true. */
10207 else
10208 {
10211 /* Look for the type-id. */
10213 /* Look for the closing `)'. */
10218 }
10220 /* Restore the saved message. */
10223 /* At this point this can only be either a cast or a
10224 parenthesized ctor such as `(T ())' that looks like a cast to
10225 function returning T. */
10227 {
10228 /* Only commit if the cast-expression doesn't start with
10229 '++', '--', or '[' in C++11. */
10237 pidk);
10240 {
10241 /* Warn about old-style casts, if so requested. */
10246 {
10252 }
10254 /* Only type conversions to integral or enumeration types
10255 can be used in constant-expressions. */
10258 NIC_CAST))
10261 /* Perform the cast. */
10262 /* Make a location:
10263 (TYPE) EXPR
10264 ^~~~~~~~~~~
10265 with start==caret at the open paren, extending to the
10266 end of "expr". */
10268 open_paren_loc,
10272 }
10273 }
10274 else
10276 }
10278 /* If we get here, then it's not a cast, so it must be a
10279 unary-expression. */
10282 }
10284 /* Parse a binary expression of the general form:
10286 pm-expression:
10287 cast-expression
10288 pm-expression .* cast-expression
10289 pm-expression ->* cast-expression
10291 multiplicative-expression:
10292 pm-expression
10293 multiplicative-expression * pm-expression
10294 multiplicative-expression / pm-expression
10295 multiplicative-expression % pm-expression
10297 additive-expression:
10298 multiplicative-expression
10299 additive-expression + multiplicative-expression
10300 additive-expression - multiplicative-expression
10302 shift-expression:
10303 additive-expression
10304 shift-expression << additive-expression
10305 shift-expression >> additive-expression
10307 relational-expression:
10308 shift-expression
10309 relational-expression < shift-expression
10310 relational-expression > shift-expression
10311 relational-expression <= shift-expression
10312 relational-expression >= shift-expression
10314 GNU Extension:
10316 relational-expression:
10317 relational-expression <? shift-expression
10318 relational-expression >? shift-expression
10320 equality-expression:
10321 relational-expression
10322 equality-expression == relational-expression
10323 equality-expression != relational-expression
10325 and-expression:
10326 equality-expression
10327 and-expression & equality-expression
10329 exclusive-or-expression:
10330 and-expression
10331 exclusive-or-expression ^ and-expression
10333 inclusive-or-expression:
10334 exclusive-or-expression
10335 inclusive-or-expression | exclusive-or-expression
10337 logical-and-expression:
10338 inclusive-or-expression
10339 logical-and-expression && inclusive-or-expression
10341 logical-or-expression:
10342 logical-and-expression
10343 logical-or-expression || logical-and-expression
10345 All these are implemented with a single function like:
10347 binary-expression:
10348 simple-cast-expression
10349 binary-expression <token> binary-expression
10351 CAST_P is true if this expression is the target of a cast.
10353 The binops_by_token map is used to get the tree codes for each <token> type.
10354 binary-expressions are associated according to a precedence table. */
10356 #define TOKEN_PRECEDENCE(token) \
10357 (((token->type == CPP_GREATER \
10358 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
10359 && !parser->greater_than_is_operator_p) \
10360 ? PREC_NOT_OPERATOR \
10361 : binops_by_token[token->type].prec)
10363 static cp_expr
10369 {
10370 cp_parser_expression_stack stack;
10373 cp_parser_expression_stack_entry current;
10374 cp_expr rhs;
10378 tree overload;
10380 /* Parse the first expression. */
10391 {
10392 /* Get an operator token. */
10398 {
10400 "%<>>%> operator is treated"
10404 }
10409 /* This is a fold-expression; handle it later. */
10412 /* Popping an entry off the stack means we completed a subexpression:
10413 - either we found a token which is not an operator (`>' where it is not
10414 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10415 will happen repeatedly;
10416 - or, we found an operator which has lower priority. This is the case
10417 where the recursive descent *ascends*, as in `3 * 4 + 5' after
10418 parsing `3 * 4'. */
10420 {
10423 else
10425 }
10427 get_rhs:
10432 /* We used the operator token. */
10435 /* For "false && x" or "true || x", x will never be executed;
10436 disable warnings while evaluating it. */
10441 {
10444 }
10446 /* Extract another operand. It may be the RHS of this expression
10447 or the LHS of a new, higher priority expression. */
10452 /* Get another operator token. Look up its precedence to avoid
10453 building a useless (immediately popped) stack entry for common
10454 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10461 {
10462 /* ... and prepare to parse the RHS of the new, higher priority
10463 expression. Since precedence levels on the stack are
10464 monotonically increasing, we do not have to care about
10465 stack overflows. */
10474 pop:
10476 /* If the stack is not empty, we have parsed into LHS the right side
10477 (`4' in the example above) of an expression we had suspended.
10478 We can use the information on the stack to recover the LHS (`3')
10479 from the stack together with the tree code (`MULT_EXPR'), and
10480 the precedence of the higher level subexpression
10481 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10482 which will be used to actually build the additive expression. */
10487 }
10489 /* Undo the disabling of warnings done above. */
10491 {
10494 }
10499 /* Avoid warning for !!x == y. */
10504 /* Avoid warning for !b == y where b is boolean. */
10508 /* Avoid warning for !!b == y where b is boolean. */
10520 /* Don't warn for named "xor" (as opposed to '^'). */
10524 check_for_xor_used_as_pow
10537 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10538 ERROR_MARK for everything that is not a binary expression.
10539 This makes warn_about_parentheses miss some warnings that
10540 involve unary operators. For unary expressions we should
10541 pass the correct tree_code unless the unary expression was
10542 surrounded by parentheses.
10543 */
10547 {
10550 else
10551 {
10554 current.lhs
10557 == tcc_comparison
10561 }
10562 }
10563 else
10564 {
10570 /* TODO: build_x_binary_op doesn't always honor the location. */
10572 }
10575 /* If the binary operator required the use of an overloaded operator,
10576 then this expression cannot be an integral constant-expression.
10577 An overloaded operator can be used even if both operands are
10578 otherwise permissible in an integral constant-expression if at
10579 least one of the operands is of enumeration type. */
10583 NIC_OVERLOADED))
10585 }
10588 }
10590 static cp_expr
10595 {
10598 }
10600 /* Parse the `? expression : assignment-expression' part of a
10601 conditional-expression. The LOGICAL_OR_EXPR is the
10602 logical-or-expression that started the conditional-expression.
10603 Returns a representation of the entire conditional-expression.
10605 This routine is used by cp_parser_assignment_expression
10606 and cp_parser_conditional_expression.
10608 ? expression : assignment-expression
10610 GNU Extensions:
10612 ? : assignment-expression */
10614 static tree
10616 {
10618 cp_expr assignment_expr;
10622 /* Consume the `?' token. */
10627 {
10630 /* Implicit true clause. */
10632 c_inhibit_evaluation_warnings +=
10635 }
10636 else
10637 {
10640 /* Parse the expression. */
10641 c_inhibit_evaluation_warnings +=
10644 c_inhibit_evaluation_warnings +=
10648 }
10650 /* The next token should be a `:'. */
10652 /* Parse the assignment-expression. */
10654 c_inhibit_evaluation_warnings -=
10657 /* Make a location:
10658 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10659 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10660 with the caret at the "?", ranging from the start of
10661 the logical_or_expr to the end of the assignment_expr. */
10666 /* Build the conditional-expression. */
10668 expr,
10669 assignment_expr,
10670 tf_warning_or_error);
10671 }
10673 /* Parse a conditional-expression.
10675 conditional-expression:
10676 logical-or-expression
10677 logical-or-expression ? expression : assignment-expression
10679 GNU Extensions:
10681 logical-or-expression ? : assignment-expression */
10683 static cp_expr
10685 {
10688 /* If the next token is a `?' then we're actually looking at
10689 a conditional-expression; otherwise we're done. */
10693 }
10695 /* Parse an assignment-expression.
10697 assignment-expression:
10698 conditional-expression
10699 logical-or-expression assignment-operator assignment_expression
10700 throw-expression
10701 yield-expression
10703 CAST_P is true if this expression is the target of a cast.
10704 DECLTYPE_P is true if this expression is the operand of decltype.
10706 Returns a representation for the expression. */
10708 static cp_expr
10711 {
10712 cp_expr expr;
10714 /* If the next token is the `throw' keyword, then we're looking at
10715 a throw-expression. */
10718 /* If the next token is the `co_yield' keyword, then we're looking at
10719 a yield-expression. */
10722 /* Otherwise, it must be that we are looking at a
10723 logical-or-expression. */
10724 else
10725 {
10726 /* Parse the binary expressions (logical-or-expression). */
10728 decltype_p,
10730 /* If the next token is a `?' then we're actually looking at a
10731 conditional-expression. */
10734 else
10735 {
10738 /* If it's an assignment-operator, we're using the second
10739 production. */
10740 enum tree_code assignment_operator
10743 {
10744 /* Parse the right-hand side of the assignment. */
10750 /* An assignment may not appear in a
10751 constant-expression. */
10753 NIC_ASSIGNMENT))
10755 /* Build the assignment expression. Its default
10756 location:
10757 LHS = RHS
10758 ~~~~^~~~~
10759 is the location of the '=' token as the
10760 caret, ranging from the start of the lhs to the
10761 end of the rhs. */
10766 assignment_operator,
10769 /* TODO: build_x_modify_expr doesn't honor the location,
10770 so we must set it here. */
10772 }
10773 }
10774 }
10777 }
10779 /* Parse an (optional) assignment-operator.
10781 assignment-operator: one of
10782 = *= /= %= += -= >>= <<= &= ^= |=
10784 GNU Extension:
10786 assignment-operator: one of
10787 <?= >?=
10789 If the next token is an assignment operator, the corresponding tree
10790 code is returned, and the token is consumed. For example, for
10791 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
10792 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
10793 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
10794 operator, ERROR_MARK is returned. */
10796 static enum tree_code
10798 {
10802 /* Peek at the next token. */
10806 {
10852 /* Nothing else is an assignment operator. */
10854 }
10856 /* An operator followed by ... is a fold-expression, handled elsewhere. */
10861 /* If it was an assignment operator, consume it. */
10866 }
10868 /* Parse an expression.
10870 expression:
10871 assignment-expression
10872 expression , assignment-expression
10874 CAST_P is true if this expression is the target of a cast.
10875 DECLTYPE_P is true if this expression is the immediate operand of decltype,
10876 except possibly parenthesized or on the RHS of a comma (N3276).
10877 WARN_COMMA_P is true if a comma should be diagnosed.
10879 Returns a representation of the expression. */
10881 static cp_expr
10884 {
10889 {
10890 cp_expr assignment_expression;
10892 /* Parse the next assignment-expression. */
10893 assignment_expression
10896 /* We don't create a temporary for a call that is the immediate operand
10897 of decltype or on the RHS of a comma. But when we see a comma, we
10898 need to create a temporary for a call on the LHS. */
10903 assignment_expression
10907 /* If this is the first assignment-expression, we can just
10908 save it away. */
10911 else
10912 {
10913 /* Create a location with caret at the comma, ranging
10914 from the start of the LHS to the end of the RHS. */
10922 }
10923 /* If the next token is not a comma, or we're in a fold-expression, then
10924 we are done with the expression. */
10928 /* Consume the `,'. */
10931 {
10932 /* [depr.comma.subscript]: A comma expression appearing as
10933 the expr-or-braced-init-list of a subscripting expression
10934 is deprecated. A parenthesized comma expression is not
10935 deprecated. */
10937 "top-level comma expression in array subscript "
10940 }
10942 /* A comma operator cannot appear in a constant-expression. */
10945 }
10948 }
10950 /* Parse a constant-expression.
10952 constant-expression:
10953 conditional-expression
10955 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
10956 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
10957 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
10958 is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
10959 greater than 1, this isn't really a constant-expression, only a
10960 potentially constant-evaluated expression. If STRICT_P is true,
10961 only parse a conditional-expression, otherwise parse an
10962 assignment-expression. See below for rationale. */
10964 static cp_expr
10969 {
10970 /* It might seem that we could simply parse the
10971 conditional-expression, and then check to see if it were
10972 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
10973 one that the compiler can figure out is constant, possibly after
10974 doing some simplifications or optimizations. The standard has a
10975 precise definition of constant-expression, and we must honor
10976 that, even though it is somewhat more restrictive.
10978 For example:
10980 int i[(2, 3)];
10982 is not a legal declaration, because `(2, 3)' is not a
10983 constant-expression. The `,' operator is forbidden in a
10984 constant-expression. However, GCC's constant-folding machinery
10985 will fold this operation to an INTEGER_CST for `3'. */
10987 /* Save the old settings. */
10988 bool saved_integral_constant_expression_p
10990 bool saved_allow_non_integral_constant_expression_p
10992 bool saved_non_integral_constant_expression_p
10994 /* We are now parsing a constant-expression. */
10996 parser->allow_non_integral_constant_expression_p
11000 /* A manifestly constant-evaluated expression is evaluated even in an
11001 unevaluated operand. */
11004 /* Although the grammar says "conditional-expression", when not STRICT_P,
11005 we parse an "assignment-expression", which also permits
11006 "throw-expression" and the use of assignment operators. In the case
11007 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
11008 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
11009 actually essential that we look for an assignment-expression.
11010 For example, cp_parser_initializer_clauses uses this function to
11011 determine whether a particular assignment-expression is in fact
11012 constant. */
11013 cp_expr expression;
11016 else
11018 /* Restore the old settings. */
11019 parser->integral_constant_expression_p
11021 parser->allow_non_integral_constant_expression_p
11025 {
11026 /* Require an rvalue constant expression here; that's what our
11027 callers expect. Reference constant expressions are handled
11028 separately in e.g. cp_parser_template_argument. */
11037 }
11040 parser->non_integral_constant_expression_p
11044 }
11046 /* Parse __builtin_offsetof.
11048 offsetof-expression:
11049 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
11051 offsetof-member-designator:
11052 id-expression
11053 | offsetof-member-designator "." id-expression
11054 | offsetof-member-designator "[" expression "]"
11055 | offsetof-member-designator "->" id-expression */
11057 static cp_expr
11059 {
11061 tree type;
11062 cp_expr expr;
11063 cp_id_kind dummy;
11065 location_t finish_loc;
11067 /* We're about to accept non-integral-constant things, but will
11068 definitely yield an integral constant expression. Save and
11069 restore these values around our local parsing. */
11075 /* Consume the "__builtin_offsetof" token. */
11077 /* Consume the opening `('. */
11078 matching_parens parens;
11080 /* Parse the type-id. */
11082 {
11084 parser->type_definition_forbidden_message
11088 }
11089 /* Look for the `,'. */
11093 /* Build the (type *)null that begins the traditional offsetof macro. */
11094 tree object_ptr
11098 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
11102 {
11105 {
11107 /* offsetof-member-designator "[" expression "]" */
11113 /* offsetof-member-designator "->" identifier */
11116 /* FALLTHRU */
11119 /* offsetof-member-designator "." identifier */
11127 /* Consume the ")" token. */
11133 /* Error. We know the following require will fail, but
11134 that gives the proper error message. */
11139 }
11140 }
11142 success:
11143 /* Make a location of the form:
11144 __builtin_offsetof (struct s, f)
11145 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
11146 with caret at the type-id, ranging from the start of the
11147 "_builtin_offsetof" token to the close paren. */
11149 /* The result will be an INTEGER_CST, so we need to explicitly
11150 preserve the location. */
11153 failure:
11159 }
11161 /* Parse a builtin trait expression or type. */
11163 static cp_expr
11165 {
11172 /* Get location of initial token. */
11175 /* Consume the token. */
11178 matching_parens parens;
11181 else
11185 {
11194 }
11196 /* __type_pack_element takes an expression as its first argument and uses
11197 template-id syntax instead of function call syntax (for consistency
11198 with Clang). We special case these properties of __type_pack_element
11199 here and elsewhere. */
11201 else
11202 {
11205 }
11211 {
11215 {
11217 {
11219 "trailing argument to %<__type_pack_element%> "
11222 }
11223 }
11225 }
11227 {
11230 {
11233 }
11237 }
11239 {
11242 {
11246 {
11249 }
11253 }
11257 }
11261 /* cp_parser_enclosed_template_argument_list above already took care
11263 else
11266 /* Construct a location of the form:
11267 __is_trivially_copyable(_Tp)
11268 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
11269 with start == caret, finishing at the close-paren. */
11272 /* Complete the trait expression, which may mean either processing
11273 the trait expr now or saving it for template instantiation. */
11275 {
11283 else
11285 }
11286 }
11288 /* Parse a lambda expression.
11290 lambda-expression:
11291 lambda-introducer lambda-declarator [opt] compound-statement
11292 lambda-introducer < template-parameter-list > requires-clause [opt]
11293 lambda-declarator [opt] compound-statement
11295 Returns a representation of the expression. */
11297 static cp_expr
11299 {
11301 tree type;
11309 {
11310 /* C++20 allows lambdas in unevaluated context, but one in the type of a
11311 non-type parameter is nonsensical.
11313 Distinguish a lambda in the parameter type from a lambda in the
11314 default argument by looking at local_variables_forbidden_p, which is
11315 only set in default arguments. */
11317 {
11322 }
11323 }
11325 {
11327 {
11329 "lambda-expression in unevaluated context"
11332 }
11334 }
11336 {
11338 {
11342 }
11344 }
11346 /* We may be in the middle of deferred access check. Disable
11347 it now. */
11361 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11364 /* Now that we've started the type, add the capture fields for any
11365 explicit captures. */
11368 {
11369 /* Inside the class, surrounding template-parameter-lists do not apply. */
11370 unsigned int saved_num_template_parameter_lists
11374 bool fully_implicit_function_template_p
11378 bool auto_is_implicit_function_template_parm_p
11391 /* The body of a lambda in a discarded statement is not discarded. */
11395 /* Similarly the body of a lambda in immediate function context is not
11396 in immediate function context. */
11400 /* By virtue of defining a local class, a lambda expression has access to
11401 the private variables of enclosing classes. */
11414 {
11417 }
11419 /* The capture list was built up in reverse order; fix that now. */
11434 parser->fully_implicit_function_template_p
11438 parser->auto_is_implicit_function_template_parm_p
11441 }
11443 /* This field is only used during parsing of the lambda. */
11446 /* This lambda shouldn't have any proxies left at this point. */
11448 /* And now that we're done, push proxies for an enclosing lambda. */
11451 /* Update the lambda expression to a range. */
11458 else
11466 }
11468 /* Parse the beginning of a lambda expression.
11470 lambda-introducer:
11471 [ lambda-capture [opt] ]
11473 LAMBDA_EXPR is the current representation of the lambda expression. */
11475 static void
11477 {
11478 /* Need commas after the first capture. */
11481 /* Eat the leading `['. */
11484 /* Record default capture mode. "[&" "[=" "[&," "[=," */
11494 {
11500 }
11506 {
11508 tree capture_id;
11509 tree capture_init_expr;
11513 enum capture_kind_type
11514 {
11515 BY_COPY,
11516 BY_REFERENCE
11517 };
11521 {
11524 }
11528 else
11531 /* Possibly capture `this'. */
11533 {
11538 "explicit by-copy capture of %<this%> "
11539 "with by-copy capture default only available with "
11545 this_identifier);
11546 else
11551 }
11553 /* Possibly capture `*this'. */
11556 {
11560 "%<*this%> capture only available with "
11567 this_identifier);
11568 else
11573 }
11575 /* But reject `&this'. */
11578 {
11584 }
11586 /* Remember whether we want to capture as a reference or not. */
11588 {
11591 }
11596 {
11600 "pack init-capture only available with "
11604 }
11606 /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11609 {
11614 }
11616 /* Get the identifier. */
11621 /* Would be nice to have a cp_parser_skip_to_closing_x for general
11622 delimiters, but I modified this to stop on unnested ']' as well. It
11623 was already changed to stop on unnested '}', so the
11624 "closing_parenthesis" name is no more misleading with my change. */
11625 {
11631 }
11633 /* Find the initializer for this capture. */
11637 {
11638 /* An explicit initializer exists. */
11641 "lambda capture initializers "
11649 {
11652 }
11655 }
11656 else
11657 {
11660 /* Turn the identifier into an id-expression. */
11661 capture_init_expr
11666 {
11669 }
11672 {
11675 capture_init_expr);
11680 }
11683 {
11686 capture_init_expr))
11690 }
11692 capture_init_expr
11693 = finish_id_expression
11695 capture_init_expr,
11709 {
11714 {
11715 /* If what follows is an initializer, the second '...' is
11716 invalid. But for cases like [...xs...], the first one
11717 is invalid. */
11724 }
11725 }
11726 }
11730 {
11735 capture_id);
11739 "capture of %qD redundant with by-reference capture "
11741 }
11743 /* Check for duplicates.
11744 Optimize for the zero or one explicit captures cases and only create
11745 the hash_set after adding second capture. */
11753 else
11754 {
11757 }
11763 else
11768 /* If there is any qualification still in effect, clear it
11769 now; we will be starting fresh with the next capture. */
11773 }
11776 }
11778 /* Parse the (optional) middle of a lambda expression.
11780 lambda-declarator:
11781 ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
11782 lambda-specifiers (C++23)
11784 lambda-specifiers:
11785 decl-specifier-seq [opt] noexcept-specifier [opt]
11786 attribute-specifier-seq [opt] trailing-return-type [opt]
11788 LAMBDA_EXPR is the current representation of the lambda expression. */
11790 static bool
11792 {
11793 /* 5.1.1.4 of the standard says:
11794 If a lambda-expression does not include a lambda-declarator, it is as if
11795 the lambda-declarator were ().
11796 This means an empty parameter list, no attributes, and no exception
11797 specification. */
11808 cp_decl_specifier_seq lambda_specs;
11810 /* A lambda op() is const unless explicitly 'mutable'. */
11813 /* The template-parameter-list is optional, but must begin with
11814 an opening angle if present. */
11816 {
11820 "lambda templates are only available with "
11828 /* We may have a constrained generic lambda; parse the requires-clause
11829 immediately after the template-parameter-list and combine with any
11830 shorthand constraints present. */
11833 {
11838 }
11840 /* We just processed one more parameter list. */
11842 }
11844 /* Committee discussion supports allowing attributes here. */
11847 /* The parameter-declaration-clause is optional (unless
11848 template-parameter-list was given), but must begin with an
11849 opening parenthesis if present. */
11851 {
11852 matching_parens parens;
11857 /* Parse parameters. */
11858 param_list
11859 = cp_parser_parameter_declaration_clause
11862 /* Default arguments shall not be specified in the
11863 parameter-declaration-clause of a lambda-declarator. */
11868 OPT_Wc__14_extensions,
11873 }
11877 /* [expr.prim.lambda.general]
11878 lambda-specifier:
11879 consteval, constexpr, mutable, static
11880 [4] A lambda-specifier-seq shall contain at most one of each
11881 lambda-specifier and shall not contain both constexpr and consteval.
11882 The lambda-specifier-seq shall not contain both mutable and static. */
11886 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
11890 {
11892 "parameter declaration before lambda declaration "
11893 "specifiers only optional with %<-std=c++2b%> or "
11896 }
11897 /* Peek at the params, see if we have an xobj parameter. */
11899 {
11901 /* We still need grokdeclarator to see that this is an xobj function
11902 and finish the rest of the work, don't mutate it. */
11905 /* [expr.prim.lambda.closure-5]
11906 Given a lambda with a lambda-capture, the type of the explicit object
11907 parameter, if any, of the lambda's function call operator (possibly
11908 instantiated from a function call operator template) shall be either:
11909 -- the closure type,
11910 -- a class type derived from the closure type, or
11911 -- a reference to a possibly cv-qualified such type. */
11912 bool const unrelated_with_captures
11915 /* Since a lambda's type is anonymous, we can assume an xobj
11916 parameter is unrelated to the closure if it is non-dependent.
11917 If it is dependent we handle it at instantiation time. */
11920 {
11922 "a lambda with captures may not have an explicit object "
11925 }
11927 /* [expr.prim.lambda.general-4]
11928 If the lambda-declarator contains an explicit object parameter
11929 ([dcl.fct]), then no lambda-specifier in the lambda-specifier-seq
11930 shall be mutable or static. */
11932 {
11933 auto_diagnostic_group d;
11935 "%<mutable%> lambda specifier "
11937 /* Tell the user how to do what they probably meant, maybe fixits
11938 would be appropriate later? */
11940 /* The following hints don't make sense when we already have an
11944 "the passed in closure object will not be mutated because "
11948 "declare the explicit object parameter as non-const "
11950 else
11952 "explicit object parameter is already a mutable "
11954 }
11956 {
11957 auto_diagnostic_group d;
11959 "%<static%> lambda specifier "
11963 }
11964 }
11966 {
11968 }
11970 {
11971 /* [expr.prim.lambda.general-4]
11972 If the lambda-specifier-seq contains static, there shall be no
11973 lambda-capture. */
11978 else
11979 {
11982 }
11983 }
11987 {
11989 "parameter declaration before lambda transaction "
11990 "qualifier only optional with %<-std=c++2b%> or "
11993 }
11995 /* Parse optional exception specification. */
11996 exception_spec
12000 {
12002 "parameter declaration before lambda exception "
12003 "specification only optional with %<-std=c++2b%> or "
12006 }
12008 /* GCC 8 accepted attributes here, and this is the place for standard C++11
12009 attributes that appertain to the function type. */
12012 else
12015 /* Parse optional trailing return type. */
12017 {
12020 "parameter declaration before lambda trailing "
12021 "return type only optional with %<-std=c++2b%> or "
12025 }
12027 /* Also allow GNU attributes at the very end of the declaration, the usual
12028 place for GNU attributes. */
12033 {
12034 /* Parse optional trailing requires clause. */
12037 /* The function parameters must be in scope all the way until after the
12038 trailing-return-type in case of decltype. */
12040 }
12042 /* Create the function call operator.
12044 Messing with declarators like this is no uglier than building up the
12045 FUNCTION_DECL by hand, and this is less likely to get out of sync with
12046 other code. */
12047 {
12048 cp_decl_specifier_seq return_type_specs;
12050 tree fco;
12057 {
12061 else
12063 "lambda only available with %<-std=c++17%> or "
12065 }
12070 {
12074 }
12082 VIRT_SPEC_UNSPECIFIED,
12083 REF_QUAL_NONE,
12084 tx_qual,
12085 exception_spec,
12086 return_type,
12087 trailing_requires_clause,
12088 std_attrs,
12089 UNKNOWN_LOCATION);
12092 declarator,
12095 {
12099 /* Give the object parameter a different name. */
12102 }
12104 {
12108 }
12118 }
12119 }
12121 /* Parse the body of a lambda expression, which is simply
12123 compound-statement
12125 but which requires special handling.
12126 LAMBDA_EXPR is the current representation of the lambda expression. */
12128 static void
12130 {
12132 unsigned char local_variables_forbidden_p
12136 /* The body of a lambda-expression is not a subexpression of the enclosing
12137 expression. */
12138 cp_evaluated ev;
12142 else
12143 /* Still increment function_depth so that we don't GC in the
12144 middle of an expression. */
12152 /* Clear this in case we're in the middle of a default argument. */
12156 {
12161 /* Originally C++11 required us to peek for 'return expr'; and
12162 process it specially here to deduce the return type. N3638
12163 removed the need for that. */
12167 }
12174 else
12176 }
12178 /* Statements [gram.stmt.stmt] */
12180 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
12182 static void
12184 {
12188 /* A concept is never expanded normally. */
12194 }
12196 struct cp_omp_attribute_data
12197 {
12200 c_omp_directive_kind kind;
12201 };
12203 /* Handle omp::directive and omp::sequence attributes in ATTRS
12204 (if any) at the start of a statement or in attribute-declaration. */
12206 static tree
12208 {
12219 {
12220 cnt++;
12222 {
12228 {
12230 "mixing OpenMP directives with attribute and pragma "
12234 }
12236 {
12240 }
12243 {
12251 else
12254 }
12260 {
12262 "unknown OpenMP directive name in %qs attribute "
12266 }
12269 {
12270 /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
12271 depend/doacross clause. */
12284 }
12286 {
12287 /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
12291 paren_depth++;
12293 paren_depth--;
12304 {
12307 }
12308 }
12313 }
12314 cp_omp_attribute_data v = {};
12317 }
12318 else
12331 {
12336 }
12337 else
12338 {
12340 {
12343 }
12344 }
12347 {
12349 "OpenMP construct among %<omp::directive%> attributes"
12350 " requires all %<omp::directive%> attributes on the"
12353 }
12355 {
12357 "multiple OpenMP standalone directives among"
12358 " %<omp::directive%> attributes must be all within the"
12361 }
12367 {
12369 "standalone OpenMP directives in %<omp::directive%> attribute"
12372 }
12374 {
12378 {
12380 "mixing OpenMP directives with attribute and pragma "
12383 }
12384 }
12388 tokens++;
12393 {
12400 cp_token tok = {};
12408 tok = {};
12413 }
12414 cp_token tok = {};
12426 /* Move the current source position to that of the first token in the
12427 new lexer. */
12430 }
12432 /* True if and only if the name is one of the contract types. */
12434 static bool
12436 {
12440 }
12442 /* Handle omp::directive and omp::sequence attributes in *PATTRS
12443 (if any) at the start or after declaration-id of a declaration. */
12445 static void
12449 {
12460 {
12462 {
12469 {
12477 else
12480 }
12490 {
12492 {
12495 }
12497 {
12499 "mixing OpenMP directives with attribute and "
12502 }
12503 }
12504 }
12505 }
12508 {
12513 else
12516 }
12521 {
12530 }
12532 }
12534 /* Parse a statement.
12536 statement:
12537 labeled-statement
12538 expression-statement
12539 compound-statement
12540 selection-statement
12541 iteration-statement
12542 jump-statement
12543 declaration-statement
12544 try-block
12546 C++11:
12548 statement:
12549 labeled-statement
12550 attribute-specifier-seq (opt) expression-statement
12551 attribute-specifier-seq (opt) compound-statement
12552 attribute-specifier-seq (opt) selection-statement
12553 attribute-specifier-seq (opt) iteration-statement
12554 attribute-specifier-seq (opt) jump-statement
12555 declaration-statement
12556 attribute-specifier-seq (opt) try-block
12558 init-statement:
12559 expression-statement
12560 simple-declaration
12561 alias-declaration
12563 TM Extension:
12565 statement:
12566 atomic-statement
12568 IN_COMPOUND is true when the statement is nested inside a
12569 cp_parser_compound_statement.
12571 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12572 is a (possibly labeled) if statement which is not enclosed in braces
12573 and has an else clause. This is used to implement -Wparentheses.
12575 CHAIN is a vector of if-else-if conditions.
12577 Note that this version of parsing restricts assertions to be attached to
12578 empty statements. */
12580 static void
12584 {
12590 /* A copy of IN_COMPOUND which is set to false after seeing a label.
12591 This matters for certain pragmas. */
12594 restart:
12597 /* There is no statement yet. */
12604 /* In obj-c++, seeing '[[' might be the either the beginning of
12605 c++11 attributes, or a nested objc-message-expression. So
12606 let's parse the c++11 attributes tentatively. */
12612 {
12615 }
12618 /* Peek at the next token. */
12621 /* If we have contracts, check that they're valid in this context. */
12623 {
12631 /* Check that assertions are null statements. */
12635 }
12641 {
12645 {
12672 }
12678 {
12680 std_attrs);
12682 }
12683 }
12686 /* Remember the location of the first token in the statement. */
12690 /* If this is a keyword, then that will often determine what kind of
12691 statement we have. */
12693 {
12697 {
12700 /* Looks like a labeled-statement with a case label.
12701 Parse the label, and then use tail recursion to parse
12702 the statement. */
12731 /* Objective-C++ exception-handling constructs. */
12747 /* This must be a namespace alias definition. */
12749 {
12750 /* Attributes should be parsed as part of the
12751 declaration, so let's un-parse them. */
12754 }
12772 /* It might be a keyword like `int' that can start a
12773 declaration-statement. */
12775 }
12776 }
12778 {
12779 /* If the next token is a `:', then we are looking at a
12780 labeled-statement. */
12783 {
12784 /* Looks like a labeled-statement with an ordinary label.
12785 Parse the label, and then use tail recursion to parse
12786 the statement. */
12790 /* If there's no statement, it's not a labeled-statement, just
12791 a label. That's allowed in C++23, but only if we're at the
12792 end of a compound-statement. */
12795 {
12799 "label at end of compound statement only available "
12802 }
12806 }
12807 }
12808 /* Anything that starts with a `{' must be a compound-statement. */
12810 {
12813 }
12814 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
12815 a statement all its own. */
12817 {
12818 do_pragma:;
12821 /* Only certain OpenMP pragmas are attached to statements, and thus
12822 are considered statements themselves. All others are not. In
12823 the context of a compound, accept the pragma as a "statement" and
12824 return so that we can check for a close brace. Otherwise we
12825 require a real statement and must go back and read one. */
12827 {
12831 }
12839 {
12841 {
12848 }
12851 }
12859 }
12861 {
12864 }
12866 /* Everything else must be a declaration-statement or an
12867 expression-statement. Try for the declaration-statement
12868 first, unless we are looking at a `;', in which case we know that
12869 we have an expression-statement. */
12871 {
12873 {
12875 /* Attributes should be parsed as part of the declaration,
12876 so let's un-parse them. */
12881 /* Try to parse the declaration-statement. */
12884 /* If that worked, we're done. */
12887 /* It didn't work, restore the post-attribute position. */
12889 {
12892 {
12897 i++;
12899 {
12905 /* Don't handle OpenMP attribs on keywords that
12906 always start a declaration statement but don't
12907 accept attribute before it and therefore
12908 the tentative cp_parser_declaration_statement
12909 fails to parse because of that. */
12914 }
12917 {
12919 std_attrs
12920 = cp_parser_handle_statement_omp_attributes
12926 }
12927 }
12928 }
12929 }
12930 /* All preceding labels have been parsed at this point. */
12936 /* Look for an expression-statement instead. */
12940 attrs_loc);
12942 /* Handle [[fallthrough]];. */
12944 {
12945 /* The next token after the fallthrough attribute is ';'. */
12947 {
12948 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12950 IFN_FALLTHROUGH,
12953 }
12954 else
12958 }
12960 /* Handle [[assert: ...]]; */
12962 {
12963 /* Add the assertion as a statement in the current block. */
12967 }
12968 }
12970 /* Set the line number for the statement. */
12974 /* Allow "[[fallthrough]];" or "[[assume(cond)]];", but warn otherwise. */
12978 }
12980 /* Append ATTR to attribute list ATTRS. */
12982 tree
12984 {
12990 }
12992 /* Parse the label for a labeled-statement, i.e.
12994 label:
12995 attribute-specifier-seq[opt] identifier :
12996 attribute-specifier-seq[opt] case constant-expression :
12997 attribute-specifier-seq[opt] default :
12999 labeled-statement:
13000 label statement
13002 GNU Extension:
13003 case constant-expression ... constant-expression : statement
13005 When a label is parsed without errors, the label is added to the
13006 parse tree by the finish_* functions, so this function doesn't
13007 have to return the label. */
13009 static void
13011 {
13016 /* The next token should be an identifier. */
13020 {
13023 }
13025 /* Remember whether this case or a user-defined label is allowed to fall
13026 through to. */
13031 {
13033 {
13037 /* Consume the `case' token. */
13039 /* Parse the constant-expression. */
13046 {
13047 /* Consume the `...' token. */
13053 /* We don't need to emit warnings here, as the common code
13054 will do this for us. */
13055 }
13056 else
13060 {
13063 {
13066 }
13067 }
13068 else
13071 expr);
13072 }
13076 /* Consume the `default' token. */
13080 {
13083 {
13086 }
13087 }
13088 else
13093 /* Anything else must be an ordinary label. */
13098 }
13100 /* Require the `:' token. */
13103 /* An ordinary label may optionally be followed by attributes.
13104 However, this is only permitted if the attributes are then
13105 followed by a semicolon. This is because, for backward
13106 compatibility, when parsing
13107 lab: __attribute__ ((unused)) int i;
13108 we want the attribute to attach to "i", not "lab". */
13111 {
13112 tree attrs;
13116 /* And fallthrough always binds to the expression-statement. */
13121 ;
13122 else
13124 }
13130 }
13132 /* Parse an expression-statement.
13134 expression-statement:
13135 expression [opt] ;
13137 Returns the new EXPR_STMT -- or NULL_TREE if the expression
13138 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
13139 indicates whether this expression-statement is part of an
13140 expression statement. */
13142 static tree
13144 {
13149 /* There might be attribute fallthrough. */
13152 /* If the next token is a ';', then there is no expression
13153 statement. */
13155 {
13159 {
13160 /* If we ran into a problem, make sure we complained. */
13165 }
13166 }
13170 /* Handle [[fallthrough]];. */
13172 {
13173 /* The next token after the fallthrough attribute is ';'. */
13175 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
13178 else
13182 }
13184 /* Allow "[[fallthrough]];", but warn otherwise. */
13189 /* Give a helpful message for "A<T>::type t;" and the like. */
13192 {
13199 {
13200 /* A::A a; */
13205 }
13206 }
13208 /* Consume the final `;'. */
13213 /* This is the final expression statement of a statement
13214 expression. */
13220 }
13222 /* Parse a compound-statement.
13224 compound-statement:
13225 { statement-seq [opt] label-seq [opt] }
13227 label-seq:
13228 label
13229 label-seq label
13231 GNU extension:
13233 compound-statement:
13234 { label-declaration-seq [opt] statement-seq [opt] }
13236 label-declaration-seq:
13237 label-declaration
13238 label-declaration-seq label-declaration
13240 Returns a tree representing the statement. */
13242 static tree
13245 {
13246 tree compound_stmt;
13247 matching_braces braces;
13249 /* Consume the `{'. */
13256 /* Begin the compound-statement. */
13258 /* If the next keyword is `__label__' we have a label declaration. */
13261 /* Parse an (optional) statement-seq. */
13264 /* Consume the `}'. */
13267 /* Finish the compound-statement. */
13271 }
13273 /* Diagnose errors related to imperfectly nested loops in an OMP
13274 loop construct. This function is called when such code is seen.
13275 Only issue one such diagnostic no matter how much invalid
13276 intervening code there is in the loop.
13277 FIXME: maybe the location associated with the diagnostic should
13278 be the current parser token instead of the location of the outer loop
13279 nest. */
13281 static void
13283 {
13292 /* Only diagnose errors related to perfect nesting once. */
13294 {
13296 {
13298 "inner loops must be perfectly nested in "
13301 }
13303 {
13305 "inner loops must be perfectly nested with "
13308 }
13310 {
13312 "inner loops must be perfectly nested with "
13315 }
13316 /* TODO: Also reject loops with TILE directive. */
13319 }
13320 }
13322 /* Parse an (optional) statement-seq.
13324 statement-seq:
13325 statement
13326 statement-seq [opt] statement */
13328 static void
13330 {
13333 bool in_omp_loop_block
13336 /* Scan statements until there aren't any more. */
13338 {
13341 /* If we are looking at a `}', then we have run out of
13342 statements; the same is true if we have reached the end
13343 of file, or have stumbled upon a stray '@end'. */
13350 /* If we are in a compound statement and find 'else' then
13351 something went wrong. */
13353 {
13356 else
13357 {
13360 }
13361 }
13363 /* Handle special cases for OMP FOR canonical loop syntax. */
13365 {
13369 {
13370 /* Found the nested loop. */
13374 }
13376 {
13377 /* Prior to implementing the OpenMP 5.1 syntax for canonical
13378 loop form, GCC used to accept an empty statements as not
13379 being intervening code. Continue to do that, as an
13380 extension. */
13381 /* FIXME: Maybe issue a warning or something here? */
13383 }
13385 /* The nested compound statement may contain the next loop, or
13386 it might just be intervening code. */
13387 {
13391 }
13392 else
13393 {
13394 /* This must be intervening code. */
13396 /* Defer calling check_omp_intervening_code on pragmas until
13397 cp_parser_statement, because we can't know until we parse
13398 it whether or not the pragma is a statement. */
13403 }
13405 }
13407 /* Parse the statement. */
13409 }
13410 }
13412 /* Return true if this is the C++20 version of range-based-for with
13413 init-statement. */
13415 static bool
13417 {
13420 /* Save tokens so that we can put them back. */
13423 /* There has to be an unnested ; followed by an unnested :. */
13426 CPP_SEMICOLON,
13430 /* We found the semicolon, eat it now. */
13433 /* Now look for ':' that is not nested in () or {}. */
13436 CPP_COLON,
13439 out:
13440 /* Roll back the tokens we skipped. */
13444 }
13446 /* Return true if we're looking at (init; cond), false otherwise. */
13448 static bool
13450 {
13451 /* Save tokens so that we can put them back. */
13454 /* Look for ';' that is not nested in () or {}. */
13457 CPP_SEMICOLON,
13460 /* Roll back the tokens we skipped. */
13464 }
13466 /* Parse a selection-statement.
13468 selection-statement:
13469 if ( init-statement [opt] condition ) statement
13470 if ( init-statement [opt] condition ) statement else statement
13471 switch ( init-statement [opt] condition ) statement
13473 Returns the new IF_STMT or SWITCH_STMT.
13475 If IF_P is not NULL, *IF_P is set to indicate whether the statement
13476 is a (possibly labeled) if statement which is not enclosed in
13477 braces and has an else clause. This is used to implement
13478 -Wparentheses.
13480 CHAIN is a vector of if-else-if conditions. This is used to implement
13481 -Wduplicated-cond. */
13483 static tree
13486 {
13489 token_indent_info guard_tinfo;
13494 /* Peek at the next token. */
13498 /* See what kind of keyword it is. */
13501 {
13504 {
13505 tree statement;
13506 tree condition;
13511 RID_CONSTEXPR))
13512 {
13517 "%<if constexpr%> only available with "
13519 }
13522 {
13524 RID_CONSTEVAL))
13528 RID_CONSTEVAL))
13529 {
13532 }
13533 }
13535 {
13539 "%<if consteval%> only available with "
13550 {
13553 }
13559 {
13560 location_t before_loc
13566 }
13570 /* If the next token is `else', parse the else-clause. */
13572 RID_ELSE))
13573 {
13577 /* Consume the `else' keyword. */
13583 {
13587 }
13591 guard_tinfo);
13594 {
13595 location_t before_loc
13600 }
13603 }
13607 {
13611 }
13615 }
13617 /* Look for the `('. */
13618 matching_parens parens;
13620 {
13623 }
13625 /* Begin the selection-statement. */
13627 {
13630 }
13631 else
13634 /* Parse the optional init-statement. */
13636 {
13637 tree decl;
13640 OPT_Wc__17_extensions,
13641 "init-statement in selection statements only available "
13644 /* A non-empty init-statement can have arbitrary side
13645 effects. */
13648 }
13650 /* Parse the condition. */
13652 /* Look for the `)'. */
13658 {
13662 /* Add the condition. */
13669 /* Parse the then-clause. */
13673 /* Outside a template, the non-selected branch of a constexpr
13674 if is a 'discarded statement', i.e. unevaluated. */
13679 {
13682 }
13685 guard_tinfo);
13692 {
13696 }
13698 /* If the next token is `else', parse the else-clause. */
13700 RID_ELSE))
13701 {
13705 {
13708 }
13710 guard_tinfo
13712 /* Consume the `else' keyword. */
13715 {
13717 RID_IF)
13719 {
13720 /* We've got "if (COND) else if (COND2)". Start
13721 the condition chain and add COND as the first
13722 element. */
13726 {
13727 /* Wrap it in a NOP_EXPR so that we can set the
13728 location of the condition. */
13730 condition);
13733 }
13734 }
13736 RID_IF))
13737 /* This is if-else without subsequent if. Zap the
13738 condition chain; we would have already warned at
13739 this point. */
13741 }
13743 /* Parse the else-clause. */
13749 /* If we are currently parsing a then-clause, then
13750 IF_P will not be NULL. We set it to true to
13751 indicate that this if statement has an else clause.
13752 This may trigger the Wparentheses warning below
13753 when we get back up to the parent if statement. */
13758 {
13762 }
13763 }
13764 else
13765 {
13766 /* This if statement does not have an else clause. If
13767 NESTED_IF is true, then the then-clause has an if
13768 statement which does have an else clause. We warn
13769 about the potential ambiguity. */
13772 "suggest explicit braces to avoid ambiguous"
13775 /* We don't need the condition chain anymore. */
13777 }
13779 /* Now we're all done with the if-statement. */
13781 }
13782 else
13783 {
13787 /* Add the condition. */
13790 /* Parse the body of the switch-statement. */
13796 guard_tinfo);
13800 /* Now we're all done with the switch-statement. */
13802 }
13805 }
13811 }
13812 }
13814 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
13815 If we have seen at least one decl-specifier, and the next token is not
13816 a parenthesis (after "int (" we might be looking at a functional cast)
13817 neither we are dealing with a concept-check expression then we must be
13818 looking at a declaration. */
13820 static void
13823 {
13832 }
13834 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
13835 The declarator shall not specify a function or an array. Returns
13836 TRUE if the declarator is valid, FALSE otherwise. */
13838 static bool
13841 location_t loc)
13842 {
13846 {
13851 else
13859 }
13860 else
13862 }
13864 /* Parse a condition.
13866 condition:
13867 expression
13868 type-specifier-seq declarator = initializer-clause
13869 type-specifier-seq declarator braced-init-list
13871 GNU Extension:
13873 condition:
13874 type-specifier-seq declarator asm-specification [opt]
13875 attributes [opt] = assignment-expression
13877 Returns the expression that should be tested. */
13879 static tree
13881 {
13882 cp_decl_specifier_seq type_specifiers;
13886 /* Try the declaration first. */
13888 /* New types are not allowed in the type-specifier-seq for a
13889 condition. */
13891 parser->type_definition_forbidden_message
13893 /* Parse the type-specifier-seq. */
13895 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
13898 /* Restore the saved message. */
13901 /* Gather the attributes that were provided with the
13902 decl-specifiers. */
13907 /* If all is well, we might be looking at a declaration. */
13909 {
13910 tree decl;
13911 tree asm_specification;
13912 tree attributes;
13917 /* Parse the declarator. */
13919 CP_PARSER_FLAGS_NONE,
13925 /* Parse the attributes. */
13927 /* Parse the asm-specification. */
13929 /* If the next token is not an `=' or '{', then we might still be
13930 looking at an expression. For example:
13932 if (A(a).x)
13934 looks like a decl-specifier-seq and a declarator -- but then
13935 there is no `=', so this is an expression. */
13940 /* If we did see an `=' or '{', then we are looking at a declaration
13941 for sure. */
13943 {
13944 tree pushed_scope;
13951 /* Create the declaration. */
13958 /* Parse the initializer. */
13960 {
13964 }
13966 {
13967 /* Consume the `='. */
13971 }
13972 else
13973 {
13976 }
13980 /* Process the initializer. */
13983 asm_specification,
13984 flags);
13990 }
13991 }
13992 /* If we didn't even get past the declarator successfully, we are
13993 definitely not looking at a declaration. */
13994 else
13997 /* Otherwise, we are looking at an expression. */
13999 }
14001 /* Parses a for-statement or range-for-statement until the closing ')',
14002 not included. */
14004 static tree
14006 {
14010 /* Begin the for-statement. */
14013 /* Maybe parse the optional init-statement in a range-based for loop. */
14015 /* Checked for diagnostic purposes only. */
14017 {
14018 tree dummy;
14021 {
14023 OPT_Wc__20_extensions,
14024 "range-based %<for%> loops with initializer only "
14027 }
14028 }
14030 /* Parse the initialization. */
14036 else
14038 }
14040 static tree
14043 {
14044 /* Normal for loop */
14047 tree stmt;
14050 /* The init-statement has already been parsed in
14051 cp_parser_init_statement, so no work is needed here. */
14054 /* If there's a condition, process it. */
14058 {
14062 }
14064 {
14068 }
14070 /* Look for the `;'. */
14073 /* If there's an expression, process it. */
14079 }
14081 /* Tries to parse a range-based for-statement:
14083 range-based-for:
14084 decl-specifier-seq declarator : expression
14086 The decl-specifier-seq declarator and the `:' are already parsed by
14087 cp_parser_init_statement. If processing_template_decl it returns a
14088 newly created RANGE_FOR_STMT; if not, it is converted to a
14089 regular FOR_STMT. */
14091 static tree
14094 {
14100 /* Get the range declaration momentarily out of the way so that
14101 the range expression doesn't clash with it. */
14103 {
14105 {
14107 /* For decomposition declaration get all of the corresponding
14108 declarations out of the way. */
14112 {
14120 {
14126 }
14127 }
14128 }
14130 {
14135 }
14136 }
14140 else
14143 /* Put the range declaration(s) back into scope. */
14145 {
14149 }
14151 /* finish_omp_for has its own code for the following, so just
14152 return the range_expr instead. */
14156 /* If in template, STMT is converted to a normal for-statement
14157 at instantiation. If not, it is done just ahead. */
14159 {
14171 /* do_auto_deduction doesn't mess with template init-lists. */
14174 }
14175 else
14176 {
14180 }
14182 }
14184 /* Subroutine of cp_convert_range_for: given the initializer expression,
14185 builds up the range temporary. */
14187 static tree
14189 {
14190 /* Find out the type deduced by the declaration
14191 `auto &&__range = range_expr'. */
14196 /* Create the __range variable. */
14203 }
14205 /* Used by cp_parser_range_for in template context: we aren't going to
14206 do a full conversion yet, but we still need to resolve auto in the
14207 type of the for-range-declaration if present. This is basically
14208 a shortcut version of cp_convert_range_for. */
14210 static void
14212 {
14215 {
14218 iter_type = (cp_parser_perform_range_for_lookup
14221 {
14223 iter_type);
14226 tf_warning_or_error);
14229 tf_warning_or_error,
14230 adc_variable_type);
14233 }
14234 }
14235 }
14237 /* Warns when the loop variable should be changed to a reference type to
14238 avoid unnecessary copying. I.e., from
14240 for (const auto x : range)
14242 where range returns a reference, to
14244 for (const auto &x : range)
14246 if this version doesn't make a copy.
14248 This function also warns when the loop variable is initialized with
14249 a value of a different type resulting in a copy:
14251 int arr[10];
14252 for (const double &x : arr)
14254 DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
14255 This function is never called when processing_template_decl is on. */
14257 static void
14259 {
14271 {
14274 {
14275 auto_diagnostic_group d;
14277 "loop variable %qD of type %qT binds to a temporary "
14280 {
14282 TYPE_QUAL_CONST);
14287 }
14288 }
14290 }
14294 /* Since small trivially copyable types are cheap to copy, we suppress the
14295 warning for them. 64B is a common size of a cache line. */
14301 /* If we can initialize a reference directly, suggest that to avoid the
14302 copy. */
14305 {
14306 auto_diagnostic_group d;
14310 {
14314 }
14315 }
14316 }
14318 /* Converts a range-based for-statement into a normal
14319 for-statement, as per the definition.
14321 for (RANGE_DECL : RANGE_EXPR)
14322 BLOCK
14324 should be equivalent to:
14326 {
14327 auto &&__range = RANGE_EXPR;
14328 for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
14329 __begin != __end;
14330 ++__begin)
14331 {
14332 RANGE_DECL = *__begin;
14333 BLOCK
14334 }
14335 }
14337 If RANGE_EXPR is an array:
14338 BEGIN_EXPR = __range
14339 END_EXPR = __range + ARRAY_SIZE(__range)
14340 Else if RANGE_EXPR has a member 'begin' or 'end':
14341 BEGIN_EXPR = __range.begin()
14342 END_EXPR = __range.end()
14343 Else:
14344 BEGIN_EXPR = begin(__range)
14345 END_EXPR = end(__range);
14347 If __range has a member 'begin' but not 'end', or vice versa, we must
14348 still use the second alternative (it will surely fail, however).
14349 When calling begin()/end() in the third alternative we must use
14350 argument dependent lookup, but always considering 'std' as an associated
14351 namespace. */
14353 tree
14357 {
14365 /* If an error happened previously do nothing or else a lot of
14366 unhelpful errors would be issued. */
14368 else
14369 {
14370 tree range_temp;
14374 /* Can't bind a reference to an array of runtime bound. */
14376 else
14377 {
14382 LOOKUP_ONLYCONVERTING);
14384 }
14387 }
14389 /* The new for initialization statement. */
14391 iter_type);
14397 LOOKUP_ONLYCONVERTING);
14407 LOOKUP_ONLYCONVERTING);
14411 /* The new for condition. */
14418 /* The new increment expression. */
14421 tf_warning_or_error);
14424 /* The declaration is initialized with *__begin inside the loop body. */
14436 }
14438 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
14439 We need to solve both at the same time because the method used
14440 depends on the existence of members begin or end.
14441 Returns the type deduced for the iterator expression. */
14443 static tree
14445 {
14447 {
14450 }
14453 {
14458 }
14460 {
14461 /* If RANGE is an array, we will use pointer arithmetic. */
14464 range,
14468 }
14469 else
14470 {
14471 /* If it is not an array, we must do a bit of magic. */
14481 tf_warning_or_error);
14484 tf_warning_or_error);
14487 {
14488 /* Use the member functions. */
14491 }
14492 else
14493 {
14494 /* Use global functions with ADL. */
14495 releasing_vec vec;
14500 tf_warning_or_error);
14502 tf_warning_or_error);
14504 tf_warning_or_error);
14506 tf_warning_or_error);
14507 }
14509 /* Last common checks. */
14511 {
14512 /* If one of the expressions is an error do no more checks. */
14515 }
14518 /* Can happen, when, eg, in a template context, Koenig lookup
14519 can't resolve begin/end (c++/58503). */
14521 else
14522 {
14524 /* The unqualified type of the __begin and __end temporaries should
14525 be the same, as required by the multiple auto declaration. */
14527 {
14534 /* P0184R0 allows __begin and __end to have different types,
14535 but make sure they are comparable so we can give a better
14537 else
14541 }
14543 }
14544 }
14545 }
14547 /* Helper function for cp_parser_perform_range_for_lookup.
14548 Builds a tree for RANGE.IDENTIFIER(). */
14550 static tree
14552 {
14560 releasing_vec vec;
14564 tf_warning_or_error);
14566 }
14568 /* Parse an iteration-statement.
14570 iteration-statement:
14571 while ( condition ) statement
14572 do statement while ( expression ) ;
14573 for ( init-statement condition [opt] ; expression [opt] )
14574 statement
14576 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
14578 static tree
14581 {
14584 tree statement;
14586 token_indent_info guard_tinfo;
14588 /* Peek at the next token. */
14595 /* Remember whether or not we are already within an iteration
14596 statement. */
14599 /* Special case for OMP loop intervening code. Parsing of permitted
14600 collapsed loop nests is handled elsewhere. */
14602 {
14606 }
14608 /* See what kind of keyword it is. */
14611 {
14613 {
14614 tree condition;
14616 /* Begin the while-statement. */
14618 /* Look for the `('. */
14619 matching_parens parens;
14621 /* Parse the condition. */
14624 /* Look for the `)'. */
14626 /* Parse the dependent statement. */
14632 /* We're done with the while-statement. */
14634 }
14638 {
14639 tree expression;
14641 /* Begin the do-statement. */
14643 /* Parse the body of the do-statement. */
14650 /* Look for the `while' keyword. */
14652 /* Look for the `('. */
14653 matching_parens parens;
14655 /* Parse the expression. */
14657 /* We're done with the do-statement. */
14659 /* Look for the `)'. */
14661 /* Look for the `;'. */
14663 }
14667 {
14668 /* Look for the `('. */
14669 matching_parens parens;
14674 /* Look for the `)'. */
14677 /* Parse the body of the for-statement. */
14684 /* We're done with the for-statement. */
14686 }
14693 }
14696 }
14698 /* Parse an init-statement or the declarator of a range-based-for.
14699 Returns true if a range-based-for declaration is seen.
14701 init-statement:
14702 expression-statement
14703 simple-declaration
14704 alias-declaration */
14706 static bool
14708 {
14709 /* If the next token is a `;', then we have an empty
14710 expression-statement. Grammatically, this is also a
14711 simple-declaration, but an invalid one, because it does not
14712 declare anything. Therefore, if we did not handle this case
14713 specially, we would issue an error message about an invalid
14714 declaration. */
14716 {
14720 /* A colon is used in range-based for. */
14723 /* We're going to speculatively look for a declaration, falling back
14724 to an expression, if necessary. */
14728 {
14734 OPT_Wc__23_extensions,
14735 "alias-declaration in init-statement only "
14737 }
14738 else
14739 /* Parse the declaration. */
14742 decl);
14745 {
14746 /* It is a range-for, consume the ':'. */
14751 OPT_Wc__11_extensions,
14752 "range-based %<for%> loops only available with "
14754 }
14756 /* The ';' is not consumed yet because we told
14757 cp_parser_simple_declaration not to. */
14762 /* If the tentative parse failed, then we shall need to look for an
14763 expression-statement. */
14764 }
14765 /* If we are here, it is an expression-statement. */
14768 }
14770 /* Parse a jump-statement.
14772 jump-statement:
14773 break ;
14774 continue ;
14775 return expression [opt] ;
14776 return braced-init-list ;
14777 coroutine-return-statement;
14778 goto identifier ;
14780 GNU extension:
14782 jump-statement:
14783 goto * expression ;
14785 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
14787 static tree
14789 {
14795 /* Peek at the next token. */
14800 /* See what kind of keyword it is. */
14803 {
14807 {
14824 }
14830 {
14834 /* Fall through. */
14844 }
14850 {
14851 tree expr;
14854 {
14858 }
14861 else
14862 /* If the next token is a `;', then there is no
14863 expression. */
14865 /* Build the return-statement, check co-return first, since type
14866 deduction is not valid there. */
14871 else
14873 /* Look for the final `;'. */
14875 }
14882 {
14886 }
14888 /* Create the goto-statement. */
14890 {
14891 /* Issue a warning about this use of a GNU extension. */
14893 /* Consume the '*' token. */
14895 /* Parse the dependent expression. */
14897 }
14898 else
14900 /* Look for the final `;'. */
14907 }
14910 }
14912 /* Parse a declaration-statement.
14914 declaration-statement:
14915 block-declaration */
14917 static void
14919 {
14922 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14925 /* Parse the block-declaration. */
14928 /* Free any declarators allocated. */
14930 }
14932 /* Some dependent statements (like `if (cond) statement'), are
14933 implicitly in their own scope. In other words, if the statement is
14934 a single statement (as opposed to a compound-statement), it is
14935 none-the-less treated as if it were enclosed in braces. Any
14936 declarations appearing in the dependent statement are out of scope
14937 after control passes that point. This function parses a statement,
14938 but ensures that is in its own scope, even if it is not a
14939 compound-statement.
14941 If IF_P is not NULL, *IF_P is set to indicate whether the statement
14942 is a (possibly labeled) if statement which is not enclosed in
14943 braces and has an else clause. This is used to implement
14944 -Wparentheses.
14946 CHAIN is a vector of if-else-if conditions. This is used to implement
14947 -Wduplicated-cond.
14949 Returns the new statement. */
14951 static tree
14955 {
14956 tree statement;
14959 token_indent_info body_tinfo
14965 /* Mark if () ; with a special NOP_EXPR. */
14967 {
14978 }
14979 /* if a compound is opened, we simply parse the statement directly. */
14982 /* If the token is not a `{', then we must take special action. */
14983 else
14984 {
14985 /* Create a compound-statement. */
14987 /* Parse the dependent-statement. */
14990 /* Finish the dummy compound-statement. */
14992 }
14994 token_indent_info next_tinfo
15003 /* Return the statement. */
15005 }
15007 /* For some dependent statements (like `while (cond) statement'), we
15008 have already created a scope. Therefore, even if the dependent
15009 statement is a compound-statement, we do not want to create another
15010 scope. */
15012 static void
15015 {
15016 /* If the token is a `{', then we must take special action. */
15018 {
15019 token_indent_info body_tinfo
15025 token_indent_info next_tinfo
15034 }
15035 else
15036 {
15037 /* Avoid calling cp_parser_compound_statement, so that we
15038 don't create a new scope. Do everything else by hand. */
15039 matching_braces braces;
15041 /* If the next keyword is `__label__' we have a label declaration. */
15044 /* Parse an (optional) statement-seq. */
15047 }
15048 }
15050 /* Modules */
15052 /* Parse a module-name or module-partition.
15054 module-name:
15055 module-name-qualifier [opt] identifier
15057 module-partition:
15058 : module-name-qualifier [opt] identifier
15060 module-name-qualifier:
15061 identifier .
15062 module-name-qualifier identifier .
15064 Returns a pointer to the module object, or NULL on failure.
15065 For PARTITION_P, PARENT is the module this is a partition of. */
15070 {
15076 {
15078 {
15081 else
15084 }
15092 }
15095 }
15097 /* Parse a module-partition. Defers to cp_parser_module_name. */
15101 {
15103 }
15105 /* Named module-declaration
15106 __module ; PRAGMA_EOL
15107 __module : private ; PRAGMA_EOL (unimplemented)
15108 [__export] __module module-name module-partition [opt]
15109 attr-spec-seq-opt ; PRAGMA_EOL
15110 */
15112 static module_parse
15115 {
15116 /* We're a pseudo pragma. */
15121 {
15125 }
15128 {
15129 /* Start global module fragment. */
15134 }
15139 {
15147 {
15150 }
15151 else
15153 "private module fragment only permitted in purview"
15155 }
15157 {
15158 /* Neither the first declaration, nor in a GMF. */
15161 skip_eol:
15163 }
15164 else
15165 {
15178 }
15181 }
15183 /* Import-declaration
15184 __import module-name attr-spec-seq-opt ; PRAGMA_EOL
15185 __import module-partition attr-spec-seq-opt ; PRAGMA_EOL
15186 __import header-name attr-spec-seq-opt ; PRAGMA_EOL
15187 */
15189 static void
15192 {
15193 /* We're a pseudo pragma. */
15198 {
15201 note_lexer:
15203 " disambiguation, to prevent this being considered a"
15205 skip_eol:
15207 }
15209 {
15212 }
15213 else
15214 {
15218 {
15221 }
15223 {
15224 /* An import specifying a module-partition shall only appear after the
15225 module-declaration in a module unit: [module.import]/4. */
15230 else
15233 }
15234 else
15247 {
15248 /* Module-purview imports must not be from source inclusion
15249 [cpp.import]/7 */
15258 }
15261 }
15262 }
15264 /* export-declaration.
15266 export declaration
15267 export { declaration-seq-opt } */
15269 static void
15271 {
15290 {
15297 }
15298 else
15299 {
15300 /* Explicitly check if the next tokens might be a
15301 module-directive line, so we can give a clearer error message
15302 about why the directive will be rejected. */
15309 }
15312 }
15314 /* Declarations [gram.dcl.dcl] */
15316 /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
15317 is the top-level declaration sequence. That affects whether we
15318 deal with module-preamble.
15320 declaration-seq:
15321 declaration
15322 declaration-seq declaration */
15324 static void
15326 {
15328 {
15334 else
15336 }
15337 }
15339 /* Parse a declaration.
15341 declaration:
15342 block-declaration
15343 function-definition
15344 template-declaration
15345 explicit-instantiation
15346 explicit-specialization
15347 linkage-specification
15348 namespace-definition
15350 C++17:
15351 deduction-guide
15353 modules:
15354 (all these are only allowed at the outermost level, check
15355 that semantically, for better diagnostics)
15356 module-declaration
15357 module-export-declaration
15358 module-import-declaration
15359 export-declaration
15361 GNU extension:
15363 declaration:
15364 __extension__ declaration */
15366 static void
15368 {
15371 /* Check for the `__extension__' keyword. */
15373 {
15374 /* Parse the qualified declaration. */
15376 /* Restore the PEDANTIC flag. */
15380 }
15382 /* Try to figure out what kind of declaration is present. */
15388 {
15390 /* A declaration consisting of a single semicolon is invalid
15391 * before C++11. Allow it unless we're being pedantic. */
15395 }
15399 CPP_SEMICOLON))
15400 {
15405 {
15408 std_attrs);
15410 {
15413 {
15415 CPP_PRAGMA));
15417 }
15419 }
15420 }
15428 }
15430 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
15435 /* Conditionally, allow attributes to precede a linkage specification. */
15437 {
15445 {
15447 /* We might have already been here. */
15449 {
15457 }
15460 }
15461 else
15462 {
15465 }
15466 }
15467 /* If we already had some attributes, and we've added more, then prepend.
15468 Otherwise attributes just contains any that we just read. */
15470 {
15474 }
15476 /* If the next token is `extern' and the following token is a string
15477 literal, then we have a linkage specification. */
15481 /* If the next token is `template', then we have either a template
15482 declaration, an explicit instantiation, or an explicit
15483 specialization. */
15485 {
15486 /* `template <>' indicates a template specialization. */
15490 /* `template <' indicates a template declaration. */
15493 /* Anything else must be an explicit instantiation. */
15494 else
15496 }
15497 /* If the next token is `export', it's new-style modules or
15498 old-style template. */
15500 {
15503 else
15505 }
15507 {
15512 // In module purview this will be ill-formed.
15518 else
15520 }
15521 /* If the next token is `extern', 'static' or 'inline' and the one
15522 after that is `template', we have a GNU extended explicit
15523 instantiation directive. */
15530 /* If the next token is `namespace', check for a named or unnamed
15531 namespace definition. */
15540 /* An unnamed namespace definition. */
15544 /* An inline (associated) namespace definition. */
15548 /* Objective-C++ declaration/definition. */
15555 /* At this point we may have a template declared by a concept
15556 introduction. */
15561 else
15562 /* Try to parse a block-declaration, or a function-definition. */
15565 /* Free any declarators allocated. */
15567 }
15569 /* Parse a namespace-scope declaration. */
15571 static void
15573 {
15577 /* A top-level declaration can consist solely of a #pragma. A
15578 nested declaration cannot, so this is done here and not in
15579 cp_parser_declaration. (A #pragma at block scope is
15580 handled in cp_parser_statement.) */
15582 else
15583 /* Parse the declaration itself. */
15585 }
15587 /* Parse a block-declaration.
15589 block-declaration:
15590 simple-declaration
15591 asm-definition
15592 namespace-alias-definition
15593 using-declaration
15594 using-directive
15596 GNU Extension:
15598 block-declaration:
15599 __extension__ block-declaration
15601 C++0x Extension:
15603 block-declaration:
15604 static_assert-declaration
15606 If STATEMENT_P is TRUE, then this block-declaration is occurring as
15607 part of a declaration-statement. */
15609 static void
15612 {
15615 /* Check for the `__extension__' keyword. */
15617 {
15618 /* Parse the qualified declaration. */
15620 /* Restore the PEDANTIC flag. */
15624 }
15626 /* Peek at the next token to figure out which kind of declaration is
15627 present. */
15630 /* If the next keyword is `asm', we have an asm-definition. */
15632 {
15636 }
15637 /* If the next keyword is `namespace', we have a
15638 namespace-alias-definition. */
15641 /* If the next keyword is `using', we have a
15642 using-declaration, a using-directive, or an alias-declaration. */
15644 {
15649 /* If the token after `using' is `namespace', then we have a
15650 using-directive. */
15656 /* If the second token after 'using' is '=', then we have an
15657 alias-declaration. */
15663 /* Otherwise, it's a using-declaration. */
15664 else
15667 }
15668 /* If the next keyword is `__label__' we have a misplaced label
15669 declaration. */
15671 {
15675 /* If the next token is now a `;', consume it. */
15678 }
15679 /* If the next token is `static_assert' we have a static assertion. */
15682 else
15683 {
15688 /* If the next tokens after attributes is `using namespace', then we have
15689 a using-directive. */
15693 RID_NAMESPACE))
15694 {
15698 }
15699 /* If the next token after attributes is `asm', then we have
15700 an asm-definition. */
15702 {
15706 }
15707 /* Anything else must be a simple-declaration. */
15708 else
15711 }
15712 }
15714 /* Parse a simple-declaration.
15716 simple-declaration:
15717 decl-specifier-seq [opt] init-declarator-list [opt] ;
15718 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15719 brace-or-equal-initializer ;
15721 init-declarator-list:
15722 init-declarator
15723 init-declarator-list , init-declarator
15725 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
15726 function-definition as a simple-declaration.
15728 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15729 parsed declaration if it is an uninitialized single declarator not followed
15730 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15731 if present, will not be consumed. */
15733 static void
15737 {
15738 cp_decl_specifier_seq decl_specifiers;
15747 /* Defer access checks until we know what is being declared; the
15748 checks for names appearing in the decl-specifier-seq should be
15749 done as if we were in the scope of the thing being declared. */
15752 /* Parse the decl-specifier-seq. We have to keep track of whether
15753 or not the decl-specifier-seq declares a named class or
15754 enumeration type, since that is the only case in which the
15755 init-declarator-list is allowed to be empty.
15757 [dcl.dcl]
15759 In a simple-declaration, the optional init-declarator-list can be
15760 omitted only when declaring a class or enumeration, that is when
15761 the decl-specifier-seq contains either a class-specifier, an
15762 elaborated-type-specifier, or an enum-specifier. */
15764 CP_PARSER_FLAGS_OPTIONAL,
15767 /* We no longer need to defer access checks. */
15770 cp_omp_declare_simd_data odsd;
15776 /* In a block scope, a valid declaration must always have a
15777 decl-specifier-seq. By not trying to parse declarators, we can
15778 resolve the declaration/expression ambiguity more quickly. */
15781 {
15784 }
15786 /* If the next two tokens are both identifiers, the code is
15787 erroneous. The usual cause of this situation is code like:
15789 T t;
15791 where "T" should name a type -- but does not. */
15794 {
15795 /* If parsing tentatively, we should commit; we really are
15796 looking at a declaration. */
15798 /* Give up. */
15800 }
15804 /* Look for C++17 decomposition declaration. */
15812 {
15813 tree decl
15815 maybe_range_for_decl,
15818 /* The next token should be either a `,' or a `;'. */
15820 /* If it's a `;', we are done. */
15824 {
15828 }
15829 /* Anything else is an error. */
15830 else
15831 {
15832 /* If we have already issued an error message we don't need
15833 to issue another one. */
15838 /* Skip tokens until we reach the end of the statement. */
15840 /* If the next token is now a `;', consume it. */
15844 }
15845 }
15846 else
15849 tree last_type;
15851 /* NULL_TREE if both variable and function declaration are allowed,
15852 error_mark_node if function declaration are not allowed and
15853 a FUNCTION_DECL that should be diagnosed if it is followed by
15854 variable declarations. */
15855 tree auto_function_declaration;
15858 auto_specifier_p
15862 /* Keep going until we hit the `;' at the end of the simple
15863 declaration. */
15866 CPP_SEMICOLON))
15867 {
15870 tree decl;
15874 {
15875 /* If we are processing next declarator, comma is expected */
15880 {
15884 }
15885 }
15886 else
15889 /* Parse the init-declarator. */
15891 CP_PARSER_FLAGS_NONE,
15894 function_definition_allowed_p,
15896 declares_class_or_enum,
15898 maybe_range_for_decl,
15902 /* If an error occurred while parsing tentatively, exit quickly.
15903 (That usually happens when in the body of a function; each
15904 statement is treated as a declaration-statement until proven
15905 otherwise.) */
15910 {
15911 /* If the init-declarator-list contains more than one
15912 init-declarator, they shall all form declarations of
15913 variables. */
15917 {
15919 "non-variable %qD in declaration with more than one "
15923 }
15924 }
15928 {
15932 {
15933 /* If the list of declarators contains more than one declarator,
15934 the type of each declared variable is determined as described
15935 above. If the type deduced for the template parameter U is not
15936 the same in each deduction, the program is ill-formed. */
15941 }
15942 else
15944 }
15946 /* Handle function definitions specially. */
15948 {
15949 /* If the next token is a `,', then we are probably
15950 processing something like:
15952 void f() {}, *p;
15954 which is erroneous. */
15956 {
15959 "mixing"
15961 }
15962 /* Otherwise, we're done with the list of declarators. */
15963 else
15964 {
15968 }
15969 }
15972 /* The next token should be either a `,' or a `;'. */
15974 /* If it's a `,', there are more declarators to come. */
15977 /* If it's a `;', we are done. */
15981 {
15986 }
15987 /* Anything else is an error. */
15988 else
15989 {
15990 /* If we have already issued an error message we don't need
15991 to issue another one. */
15993 /* grokfndecl sets DECL_INITIAL to error_mark_node for
15994 functions. */
15998 /* Skip tokens until we reach the end of the statement. */
16000 /* If the next token is now a `;', consume it. */
16004 }
16005 /* After the first time around, a function-definition is not
16006 allowed -- even if it was OK at first. For example:
16008 int i, f() {}
16010 is not valid. */
16012 }
16014 /* Issue an error message if no declarators are present, and the
16015 decl-specifier-seq does not itself declare a class or
16016 enumeration: [dcl.dcl]/3. */
16018 {
16020 {
16024 /* Ensure an error is issued anyway when finish_decltype_type,
16025 called via cp_parser_decl_specifier_seq, returns a class or
16026 an enumeration (c++/51786). */
16029 }
16030 /* Perform any deferred access checks. */
16032 }
16034 /* Consume the `;'. */
16035 finish:
16039 {
16045 }
16047 done:
16050 }
16052 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
16053 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
16054 initializer ; */
16056 static tree
16061 {
16066 /* Parse the identifier-list. */
16070 {
16078 }
16082 {
16088 else
16089 {
16092 }
16093 }
16097 "structured bindings only available with "
16100 tree pushed_scope;
16107 NULL_TREE);
16114 cp_expr e;
16115 cp_decl_specifier_seq decl_specs;
16122 {
16126 else
16127 {
16130 }
16131 tree elt_pushed_scope;
16137 {
16138 /* Ensure we've diagnosed redeclaration if we aren't creating
16139 a new VAR_DECL. */
16142 }
16143 else
16147 }
16150 {
16153 }
16157 {
16165 || (is_direct_init
16168 {
16172 }
16175 {
16181 }
16182 }
16184 {
16187 /* Ensure DECL_VALUE_EXPR is created for all the decls but
16188 the underlying DECL. */
16190 }
16196 {
16199 }
16202 }
16204 /* Names of storage classes. */
16207 cp_storage_class_name[] = {
16209 };
16211 /* Parse a decl-specifier-seq.
16213 decl-specifier-seq:
16214 decl-specifier-seq [opt] decl-specifier
16215 decl-specifier attribute-specifier-seq [opt] (C++11)
16217 decl-specifier:
16218 storage-class-specifier
16219 type-specifier
16220 function-specifier
16221 friend
16222 typedef
16224 GNU Extension:
16226 decl-specifier:
16227 attributes
16229 Concepts Extension:
16231 decl-specifier:
16232 concept
16234 Set *DECL_SPECS to a representation of the decl-specifier-seq.
16236 The parser flags FLAGS is used to control type-specifier parsing.
16238 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
16239 flags:
16241 1: one of the decl-specifiers is an elaborated-type-specifier
16242 (i.e., a type declaration)
16243 2: one of the decl-specifiers is an enum-specifier or a
16244 class-specifier (i.e., a type definition)
16246 */
16248 static void
16250 cp_parser_flags flags,
16253 {
16257 cp_decl_spec ds;
16259 /* Clear DECL_SPECS. */
16262 /* Assume no class or enumeration type is declared. */
16265 /* Keep a token that additionally will be used for diagnostics. */
16267 /* Keep reading specifiers until there are no more to read. */
16269 {
16274 /* Peek at the next token. */
16277 /* Save the first token of the decl spec list for error
16278 reporting. */
16281 /* Handle attributes. */
16284 {
16285 /* Parse the attributes. */
16288 /* In a sequence of declaration specifiers, c++11 attributes
16289 appertain to the type that precede them. In that case
16290 [dcl.spec]/1 says:
16292 The attribute-specifier-seq affects the type only for
16293 the declaration it appears in, not other declarations
16294 involving the same type.
16296 But for now let's force the user to position the
16297 attribute either at the beginning of the declaration or
16298 after the declarator-id, which would clearly mean that it
16299 applies to the declarator. */
16301 {
16303 /* The c++11 attribute is at the beginning of the
16304 declaration. It appertains to the entity being
16306 else
16307 {
16309 {
16312 }
16314 {
16315 /* This is an attribute following a
16316 class-specifier. */
16321 }
16322 else
16323 {
16324 decl_specs->std_attributes
16328 }
16330 }
16331 }
16333 decl_specs->attributes
16338 }
16339 /* We know by this point that the token is not part of an attribute. */
16342 /* Special case for "this" specifier, indicating a parm is an xobj parm.
16343 The "this" specifier must be the first specifier in the declaration,
16344 after any attributes. */
16346 {
16349 {
16350 /* Don't emit diagnostics if we have already seen "this",
16351 leave it for set_and_check_decl_spec_loc. */
16353 {
16354 auto_diagnostic_group d;
16356 /* Works, need to add tests for it though. */
16361 "%<this%> must be the first specifier "
16363 }
16364 }
16367 }
16369 /* Assume we will find a decl-specifier keyword. */
16371 /* If the next token is an appropriate keyword, we can simply
16372 add it to the list. */
16374 {
16375 /* decl-specifier:
16376 friend
16377 constexpr
16378 constinit */
16381 {
16386 }
16387 else
16388 {
16390 /* Consume the token. */
16392 }
16417 /* Warn for concept as a decl-specifier. We'll rewrite these as
16418 concept declarations later. */
16420 {
16425 else
16428 }
16430 /* In C++20 a concept definition is just 'concept name = expr;'
16431 Support that syntax as a TS extension by pretending we've seen
16432 the 'bool' specifier. */
16436 {
16440 }
16443 /* function-specifier:
16444 inline
16445 virtual
16446 explicit */
16453 /* decl-specifier:
16454 typedef */
16457 /* Consume the token. */
16463 /* A constructor declarator cannot appear in a typedef. */
16465 /* The "typedef" keyword can only occur in a declaration; we
16466 may as well commit at this point. */
16470 {
16480 }
16483 /* storage-class-specifier:
16484 auto
16485 register
16486 static
16487 extern
16488 mutable
16490 GNU Extension:
16491 thread */
16494 {
16495 /* Consume the token. */
16498 /* Complain about `auto' as a storage specifier, if
16499 we're complaining about C++0x compatibility. */
16503 "%<auto%> changes meaning in C++11; "
16506 /* Set the storage class anyway. */
16508 token);
16509 }
16510 else
16511 /* C++0x auto type-specifier. */
16519 /* Consume the token. */
16522 token);
16525 /* Consume the token. */
16531 /* We did not yet find a decl-specifier yet. */
16534 }
16546 {
16552 "%qD only valid in lambda with %<-std=c++23%> or "
16554 }
16559 /* Constructors are a special case. The `S' in `S()' is not a
16560 decl-specifier; it is the beginning of the declarator. */
16561 constructor_p
16562 = (!found_decl_spec
16563 && constructor_possible_p
16564 && (cp_parser_constructor_declarator_p
16566 ds_friend))));
16568 /* If we don't have a DECL_SPEC yet, then we must be looking at
16569 a type-specifier. */
16571 {
16574 tree type_spec;
16579 type_spec
16581 decl_specs,
16587 /* If this type-specifier referenced a user-defined type
16588 (a typedef, class-name, etc.), then we can't allow any
16589 more such type-specifiers henceforth.
16591 [dcl.spec]
16593 The longest sequence of decl-specifiers that could
16594 possibly be a type name is taken as the
16595 decl-specifier-seq of a declaration. The sequence shall
16596 be self-consistent as described below.
16598 [dcl.type]
16600 As a general rule, at most one type-specifier is allowed
16601 in the complete decl-specifier-seq of a declaration. The
16602 only exceptions are the following:
16604 -- const or volatile can be combined with any other
16605 type-specifier.
16607 -- signed or unsigned can be combined with char, long,
16608 short, or int.
16610 -- ..
16612 Example:
16614 typedef char* Pc;
16615 void g (const int Pc);
16617 Here, Pc is *not* part of the decl-specifier seq; it's
16618 the declarator. Therefore, once we see a type-specifier
16619 (other than a cv-qualifier), we forbid any additional
16620 user-defined types. We *do* still allow things like `int
16621 int' to be considered a decl-specifier-seq, and issue the
16622 error message later. */
16625 /* A constructor declarator cannot follow a type-specifier. */
16627 {
16635 }
16636 }
16638 /* If we still do not have a DECL_SPEC, then there are no more
16639 decl-specifiers. */
16644 {
16648 "standard attributes must precede the decl-specifiers to "
16649 "apply to the declaration, or follow them to apply to "
16651 }
16654 /* After we see one decl-specifier, further decl-specifiers are
16655 always optional. */
16657 }
16659 /* Don't allow a friend specifier with a class definition. */
16664 }
16666 /* Parse an (optional) storage-class-specifier.
16668 storage-class-specifier:
16669 auto
16670 register
16671 static
16672 extern
16673 mutable
16675 GNU Extension:
16677 storage-class-specifier:
16678 thread
16680 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
16682 static tree
16684 {
16686 {
16690 /* Fall through for C++98. */
16698 /* Consume the token. */
16703 }
16704 }
16706 /* Parse an (optional) function-specifier.
16708 function-specifier:
16709 inline
16710 virtual
16711 explicit
16713 C++20 Extension:
16714 explicit(constant-expression)
16716 Returns an IDENTIFIER_NODE corresponding to the keyword used.
16717 Updates DECL_SPECS, if it is non-NULL. */
16719 static tree
16722 {
16725 {
16731 /* 14.5.2.3 [temp.mem]
16733 A member function template shall not be virtual. */
16737 else
16742 {
16744 /* If we see '(', it's C++20 explicit(bool). */
16745 tree expr;
16747 {
16748 matching_parens parens;
16751 /* New types are not allowed in an explicit-specifier. */
16754 parser->type_definition_forbidden_message
16759 "%<explicit(bool)%> only available with %<-std=c++20%> "
16762 /* Parse the constant-expression. */
16765 /* Restore the saved message. */
16768 }
16769 else
16770 /* The explicit-specifier explicit without a constant-expression is
16771 equivalent to the explicit-specifier explicit(true). */
16774 /* [dcl.fct.spec]
16775 "the constant-expression, if supplied, shall be a contextually
16776 converted constant expression of type bool." */
16778 /* We could evaluate it -- mark the decl as appropriate. */
16784 /* The expression was value-dependent. Remember it so that we can
16785 substitute it later. */
16788 }
16792 }
16794 /* Consume the token. */
16796 }
16798 /* Parse a linkage-specification.
16800 linkage-specification:
16801 extern string-literal { declaration-seq [opt] }
16802 extern string-literal declaration */
16804 static void
16806 {
16807 /* Look for the `extern' keyword. */
16808 cp_token *extern_token
16811 /* Look for the string-literal. */
16813 tree linkage;
16816 else
16820 /* Transform the literal into an identifier. If the literal is a
16821 wide-character string, or contains embedded NULs, then we can't
16822 handle it as the user wants. */
16826 {
16828 /* Assume C++ linkage. */
16830 }
16831 else
16834 /* We're now using the new linkage. */
16839 /* Preserve the location of the innermost linkage specification,
16840 tracking the locations of nested specifications via a local. */
16841 location_t saved_location
16843 /* Construct a location ranging from the start of the "extern" to
16844 the end of the string-literal, with the caret at the start, e.g.:
16845 extern "C" {
16846 ^~~~~~~~~~
16847 */
16848 parser->innermost_linkage_specification_location
16853 /* If the next token is a `{', then we're using the first
16854 production. */
16856 {
16860 /* Consume the `{' token. */
16861 matching_braces braces;
16863 /* Parse the declarations. */
16865 /* Look for the closing `}'. */
16867 }
16868 /* Otherwise, there's just one declaration. */
16869 else
16870 {
16873 saved_in_unbraced_linkage_specification_p
16877 parser->in_unbraced_linkage_specification_p
16879 }
16881 /* We're done with the linkage-specification. */
16885 /* Restore location of parent linkage specification, if any. */
16887 }
16889 /* Parse a static_assert-declaration.
16891 static_assert-declaration:
16892 static_assert ( constant-expression , string-literal ) ;
16893 static_assert ( constant-expression ) ; (C++17)
16894 static_assert ( constant-expression, conditional-expression ) ; (C++26)
16896 If MEMBER_P, this static_assert is a class member. */
16898 static void
16900 {
16901 cp_expr condition;
16902 location_t token_loc;
16903 tree message;
16905 /* Peek at the `static_assert' token so we can keep track of exactly
16906 where the static assertion started. */
16909 /* Look for the `static_assert' keyword. */
16911 RT_STATIC_ASSERT))
16914 /* We know we are in a static assertion; commit to any tentative
16915 parse. */
16919 /* Parse the `(' starting the static assertion condition. */
16920 matching_parens parens;
16923 /* Parse the constant-expression. Allow a non-constant expression
16924 here in order to give better diagnostics in finish_static_assert. */
16925 condition
16931 {
16934 "%<static_assert%> without a message "
16936 /* Eat the ')' */
16941 }
16942 else
16943 {
16944 /* Parse the separating `,'. */
16947 /* Parse the message expression. */
16950 {
16958 }
16960 {
16964 "%<static_assert%> with non-string message only "
16970 message);
16971 }
16974 else
16978 /* A `)' completes the static assertion. */
16984 }
16986 /* A semicolon terminates the declaration. */
16989 /* Get the location for the static assertion. Use that of the
16990 condition if available, otherwise, use that of the "static_assert"
16991 token. */
16996 /* Complete the static assertion, which may mean either processing
16997 the static assert now or saving it for template instantiation. */
17000 }
17002 /* Parse the expression in decltype ( expression ). */
17004 static tree
17007 {
17009 tree expr;
17011 /* First, try parsing an id-expression. */
17022 {
17025 cp_id_kind idk;
17029 /* Lookup the name we got back from the id-expression. */
17039 {
17040 /* Complete lookup of the id-expression. */
17041 expr = (finish_id_expression
17054 {
17055 /* We found an id-expression, but it was something that we
17056 should not have found. This is an error, not something
17057 we can recover from, so report the error we found and
17058 we'll recover as gracefully as possible. */
17063 }
17064 }
17069 /* We have an id-expression. */
17071 }
17074 {
17075 /* Abort the id-expression parse. */
17078 /* Parsing tentatively, again. */
17081 /* Parse a class member access. */
17089 /* We have an id-expression. */
17091 }
17094 /* We have parsed the complete id-expression or member access. */
17096 else
17097 {
17098 /* Abort our attempt to parse an id-expression or member access
17099 expression. */
17102 /* Parse a full expression. */
17105 }
17108 }
17110 /* Parse a `decltype' type. Returns the type.
17112 decltype-specifier:
17113 decltype ( expression )
17114 C++14:
17115 decltype ( auto ) */
17117 static tree
17119 {
17124 {
17125 /* Already parsed. */
17128 }
17130 /* Look for the `decltype' token. */
17134 /* Parse the opening `('. */
17135 matching_parens parens;
17139 /* Since we're going to preserve any side-effects from this parse, set up a
17140 firewall to protect our callers from cp_parser_commit_to_tentative_parse
17141 in the expression. */
17144 /* If in_declarator_p, a reparse as an expression might succeed (60361).
17145 Otherwise, commit now for better diagnostics. */
17156 {
17157 /* decltype (auto) */
17160 {
17162 "%<decltype(auto)%> type specifier only available with "
17165 }
17166 }
17167 else
17168 {
17169 /* decltype (expression) */
17171 /* Types cannot be defined in a `decltype' expression. Save away the
17172 old message and set the new one. */
17174 parser->type_definition_forbidden_message
17177 /* The restrictions on constant-expressions do not apply inside
17178 decltype expressions. */
17179 bool saved_integral_constant_expression_p
17181 bool saved_non_integral_constant_expression_p
17185 /* Within a parenthesized expression, a `>' token is always
17186 the greater-than operator. */
17187 bool saved_greater_than_is_operator_p
17191 /* Don't synthesize an implicit template type parameter here. This
17192 could happen with C++23 code like
17194 void f(decltype(new auto{0}));
17196 where we want to deduce the auto right away so that the parameter
17197 is of type 'int *'. */
17201 /* Do not actually evaluate the expression. */
17204 /* Do not warn about problems with the expression. */
17210 /* Go back to evaluating expressions. */
17214 /* The `>' token might be the end of a template-id or
17215 template-parameter-list now. */
17216 parser->greater_than_is_operator_p
17219 /* Restore the old message and the integral constant expression
17220 flags. */
17222 parser->integral_constant_expression_p
17224 parser->non_integral_constant_expression_p
17226 }
17228 /* Parse to the closing `)'. */
17230 {
17234 }
17236 /* If we got a parse error while tentative, bail out now. */
17238 {
17241 }
17244 /* Build auto. */
17246 else
17248 tf_warning_or_error);
17250 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
17251 it again. */
17268 }
17270 /* Special member functions [gram.special] */
17272 /* Parse a conversion-function-id.
17274 conversion-function-id:
17275 operator conversion-type-id
17277 Returns an IDENTIFIER_NODE representing the operator. */
17279 static tree
17281 {
17282 tree type;
17283 tree saved_scope;
17284 tree saved_qualifying_scope;
17285 tree saved_object_scope;
17288 /* Look for the `operator' token. */
17291 /* When we parse the conversion-type-id, the current scope will be
17292 reset. However, we need that information in able to look up the
17293 conversion function later, so we save it here. */
17297 /* We must enter the scope of the class so that the names of
17298 entities declared within the class are available in the
17299 conversion-type-id. For example, consider:
17301 struct S {
17302 typedef int I;
17303 operator I();
17304 };
17306 S::operator I() { ... }
17308 In order to see that `I' is a type-name in the definition, we
17309 must be in the scope of `S'. */
17312 /* Parse the conversion-type-id. */
17314 /* Leave the scope of the class, if any. */
17317 /* Restore the saved scope. */
17321 /* If the TYPE is invalid, indicate failure. */
17325 }
17327 /* Parse a conversion-type-id:
17329 conversion-type-id:
17330 type-specifier-seq conversion-declarator [opt]
17332 Returns the TYPE specified. */
17334 static tree
17336 {
17337 tree attributes;
17338 cp_decl_specifier_seq type_specifiers;
17340 tree type_specified;
17343 /* Parse the attributes. */
17347 parser->type_definition_forbidden_message
17350 /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
17351 optional in conversion-type-id. */
17359 /* If that didn't work, stop. */
17362 /* Parse the conversion-declarator. */
17370 /* Don't give this error when parsing tentatively. This happens to
17371 work because we always parse this definitively once. */
17374 {
17376 {
17379 }
17383 }
17386 }
17388 /* Parse an (optional) conversion-declarator.
17390 conversion-declarator:
17391 ptr-operator conversion-declarator [opt]
17393 */
17397 {
17400 cp_cv_quals cv_quals;
17402 /* We don't know if there's a ptr-operator next, or not. */
17404 /* Try the ptr-operator. */
17407 /* If it worked, look for more conversion-declarators. */
17409 {
17412 /* Parse another optional declarator. */
17415 declarator = cp_parser_make_indirect_declarator
17419 }
17422 }
17424 /* Parse an (optional) ctor-initializer.
17426 ctor-initializer:
17427 : mem-initializer-list */
17429 static void
17431 {
17432 /* If the next token is not a `:', then there is no
17433 ctor-initializer. */
17435 {
17436 /* Do default initialization of any bases and members. */
17440 }
17442 /* Consume the `:' token. */
17444 /* And the mem-initializer-list. */
17446 }
17448 /* Parse a mem-initializer-list.
17450 mem-initializer-list:
17451 mem-initializer ... [opt]
17452 mem-initializer ... [opt] , mem-initializer-list */
17454 static void
17456 {
17461 /* Let the semantic analysis code know that we are starting the
17462 mem-initializer-list. */
17467 /* Loop through the list. */
17469 {
17470 tree mem_initializer;
17473 /* Parse the mem-initializer. */
17475 /* If the next token is a `...', we're expanding member initializers. */
17481 {
17482 /* Consume the `...'. */
17486 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
17487 can be expanded but members cannot. */
17490 {
17495 }
17497 /* Construct the pack expansion type. */
17500 }
17503 {
17507 }
17508 /* Look for a target constructor. */
17512 {
17515 {
17519 }
17521 }
17522 /* Add it to the list, unless it was erroneous. */
17524 {
17527 }
17528 /* If the next token is not a `,', we're done. */
17531 /* Consume the `,' token. */
17533 }
17535 /* Perform semantic analysis. */
17538 }
17540 /* Parse a mem-initializer.
17542 mem-initializer:
17543 mem-initializer-id ( expression-list [opt] )
17544 mem-initializer-id braced-init-list
17546 GNU extension:
17548 mem-initializer:
17549 ( expression-list [opt] )
17551 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
17552 class) or FIELD_DECL (for a non-static data member) to initialize;
17553 the TREE_VALUE is the expression-list. An empty initialization
17554 list is represented by void_list_node. */
17556 static tree
17558 {
17559 tree mem_initializer_id;
17560 tree expression_list;
17561 tree member;
17564 /* Find out what is being initialized. */
17566 {
17570 }
17571 else
17572 {
17576 }
17582 {
17588 }
17589 else
17590 {
17602 }
17615 /* We can't attach the source location of this initializer directly to
17616 the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
17617 within the TREE_TYPE of the list node. */
17618 location_t loc
17625 }
17627 /* Parse a mem-initializer-id.
17629 mem-initializer-id:
17630 :: [opt] nested-name-specifier [opt] class-name
17631 decltype-specifier (C++11)
17632 identifier
17634 Returns a TYPE indicating the class to be initialized for the first
17635 production (and the second in C++11). Returns an IDENTIFIER_NODE
17636 indicating the data member to be initialized for the last production. */
17638 static tree
17640 {
17644 tree id;
17648 /* `typename' is not allowed in this context ([temp.res]). */
17650 {
17652 "keyword %<typename%> not allowed in this context (a qualified "
17655 }
17656 /* Look for the optional `::' operator. */
17657 global_scope_p
17661 /* Look for the optional nested-name-specifier. The simplest way to
17662 implement:
17664 [temp.res]
17666 The keyword `typename' is not permitted in a base-specifier or
17667 mem-initializer; in these contexts a qualified name that
17668 depends on a template-parameter is implicitly assumed to be a
17669 type name.
17671 is to assume that we have seen the `typename' keyword at this
17672 point. */
17673 nested_name_specifier_p
17682 /* If there is a `::' operator or a nested-name-specifier, then we
17683 are definitely looking for a class-name. */
17688 typename_type,
17692 /* Otherwise, we could also be looking for an ordinary identifier. */
17695 /* Try a decltype-specifier. */
17697 else
17698 /* Otherwise, try a class-name. */
17702 none_type,
17706 /* If we found one, we're done. */
17709 /* Otherwise, look for an ordinary identifier. */
17711 }
17713 /* Overloading [gram.over] */
17715 /* Parse an operator-function-id.
17717 operator-function-id:
17718 operator operator
17720 Returns an IDENTIFIER_NODE for the operator which is a
17721 human-readable spelling of the identifier, e.g., `operator +'. */
17723 static cp_expr
17725 {
17727 /* Look for the `operator' keyword. */
17730 /* And then the name of the operator itself. */
17732 }
17734 /* Return an identifier node for a user-defined literal operator.
17735 The suffix identifier is chained to the operator name identifier. */
17737 tree
17739 {
17740 tree identifier;
17748 }
17750 /* Parse an operator.
17752 operator:
17753 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
17754 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
17755 || ++ -- , ->* -> () []
17757 GNU Extensions:
17759 operator:
17760 <? >? <?= >?=
17762 Returns an IDENTIFIER_NODE for the operator which is a
17763 human-readable spelling of the identifier, e.g., `operator +'. */
17765 static cp_expr
17767 {
17772 /* Peek at the next token. */
17777 /* Figure out which operator we have. */
17782 {
17784 {
17785 /* The keyword should be either `new', `delete' or `co_await'. */
17792 else
17795 /* Consume the `new', `delete' or co_await token. */
17798 /* Peek at the next token. */
17800 /* If it's a `[' token then this is the array variant of the
17801 operator. */
17804 {
17805 /* Consume the `[' token. */
17807 /* Look for the `]' token. */
17812 }
17815 }
17978 /* Consume the `?'. */
17980 /* Look for the matching `:'. */
17986 {
17987 /* Consume the `('. */
17988 matching_parens parens;
17990 /* Look for the matching `)'. */
17997 }
18000 /* Consume the `['. */
18002 /* Look for the matching `]'. */
18013 /* FALLTHRU */
18022 {
18023 tree string_tree;
18029 /* Consume the string. */
18035 {
18039 }
18040 else
18041 {
18043 /* Look for the suffix identifier. */
18046 {
18049 }
18051 {
18055 }
18056 else
18057 {
18060 }
18061 }
18066 {
18069 }
18072 {
18075 }
18077 {
18080 }
18081 /* Generate a location of the form:
18082 "" _suffix_identifier
18083 ^~~~~~~~~~~~~~~~~~~~~
18084 with caret == start at the start token, finish at the end of the
18085 suffix identifier. */
18086 location_t combined_loc
18089 }
18092 /* Anything else is an error. */
18094 }
18096 /* If we have selected an identifier, we need to consume the
18097 operator token. */
18099 {
18103 }
18104 /* Otherwise, no valid operator name was present. */
18105 else
18106 {
18109 }
18113 }
18115 /* Parse a template-declaration.
18117 template-declaration:
18118 export [opt] template < template-parameter-list > declaration
18120 If MEMBER_P is TRUE, this template-declaration occurs within a
18121 class-specifier.
18123 The grammar rule given by the standard isn't correct. What
18124 is really meant is:
18126 template-declaration:
18127 export [opt] template-parameter-list-seq
18128 decl-specifier-seq [opt] init-declarator [opt] ;
18129 export [opt] template-parameter-list-seq
18130 function-definition
18132 template-parameter-list-seq:
18133 template-parameter-list-seq [opt]
18134 template < template-parameter-list >
18136 Concept Extensions:
18138 template-parameter-list-seq:
18139 template < template-parameter-list > requires-clause [opt]
18141 requires-clause:
18142 requires logical-or-expression */
18144 static void
18146 {
18147 /* Check for `export'. */
18149 {
18150 /* Consume the `export' token. */
18152 /* Warn that this use of export is deprecated. */
18157 else
18159 }
18162 }
18164 /* Parse a template-parameter-list.
18166 template-parameter-list:
18167 template-parameter
18168 template-parameter-list , template-parameter
18170 Returns a TREE_LIST. Each node represents a template parameter.
18171 The nodes are connected via their TREE_CHAINs. */
18173 static tree
18175 {
18178 /* Don't create wrapper nodes within a template-parameter-list,
18179 since we don't want to have different types based on the
18180 spelling location of constants and decls within them. */
18181 auto_suppress_location_wrappers sentinel;
18185 /* The loop below parses the template parms. We first need to know
18186 the total number of template parms to be able to compute proper
18187 canonical types of each dependent type. So after the loop, when
18188 we know the total number of template parms,
18189 end_template_parm_list computes the proper canonical types and
18190 fixes up the dependent types accordingly. */
18192 {
18193 tree parameter;
18196 location_t parm_loc;
18198 /* Parse the template-parameter. */
18203 /* Add it to the list. */
18206 parm_loc,
18207 parameter,
18208 is_non_type,
18209 is_parameter_pack);
18210 else
18211 {
18214 }
18216 /* If the next token is not a `,', we're done. */
18219 /* Otherwise, consume the `,' token. */
18221 }
18224 }
18226 /* Parse a introduction-list.
18228 introduction-list:
18229 introduced-parameter
18230 introduction-list , introduced-parameter
18232 introduced-parameter:
18233 ...[opt] identifier
18235 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
18236 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
18237 WILDCARD_DECL will also have DECL_NAME set and token location in
18238 DECL_SOURCE_LOCATION. */
18240 static tree
18242 {
18246 {
18255 /* Build placeholder. */
18263 /* If the next token is not a `,', we're done. */
18266 /* Otherwise, consume the `,' token. */
18268 }
18270 /* Convert the vec into a TREE_VEC. */
18273 tree parm;
18279 }
18281 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
18282 is an abstract declarator. */
18286 {
18291 }
18293 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
18294 is an abstract declarator. */
18298 {
18302 else
18304 }
18306 /* Returns true if TYPE would declare a constrained constrained-parameter. */
18310 {
18315 }
18317 /* Returns true if PARM declares a constrained-parameter. */
18321 {
18323 }
18325 /* Check that the type parameter is only a declarator-id, and that its
18326 type is not cv-qualified. */
18328 bool
18331 {
18336 {
18339 }
18341 /* Don't allow cv-qualified type parameters. */
18344 {
18347 }
18350 }
18352 /* Finish parsing/processing a template type parameter and checking
18353 various restrictions. */
18357 tree id,
18359 {
18362 else
18364 }
18366 static tree
18368 {
18369 /* FIXME: This should probably be copied, and we may need to adjust
18370 the template parameter depths. */
18380 }
18382 /* Finish parsing/processing a template template parameter by borrowing
18383 the template parameter list from the prototype parameter. */
18385 static tree
18387 tree proto,
18388 tree id,
18390 {
18394 }
18396 /* Create a new non-type template parameter from the given PARM
18397 declarator. */
18399 static tree
18402 {
18408 }
18410 /* Build a constrained template parameter based on the PARMDECL
18411 declarator. The type of PARMDECL is the constrained type, which
18412 refers to the prototype template parameter that ultimately
18413 specifies the type of the declared parameter. */
18415 static tree
18419 {
18425 /* Build the parameter. Return an error if the declarator was invalid. */
18426 tree parm;
18431 parmdecl);
18432 else
18437 /* Finish the parameter decl and create a node attaching the
18438 default argument and constraint. */
18443 }
18445 /* Returns true if the parsed type actually represents the declaration
18446 of a type template-parameter. */
18448 static bool
18450 {
18453 }
18455 /* Returns true if the parsed type actually represents the declaration of
18456 a template template-parameter. */
18458 static bool
18460 {
18463 }
18465 /* Parse a default argument for a type template-parameter.
18466 Note that diagnostics are handled in cp_parser_template_parameter. */
18468 static tree
18470 {
18473 /* Consume the `=' token. */
18478 /* Tell cp_parser_lambda_expression this is a default argument. */
18482 /* Parse the default-argument. */
18485 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18486 NULL);
18490 {
18494 }
18497 }
18499 /* Parse a default argument for a template template-parameter. */
18501 static tree
18503 {
18508 /* Consume the `='. */
18510 /* Parse the id-expression. */
18512 /* save token before parsing the id-expression, for error
18513 reporting */
18515 tree default_argument
18523 /* If the id-expression was a template-id that refers to
18524 a template-class, we already have the declaration here,
18525 so no further lookup is needed. */
18526 ;
18527 else
18528 /* Look up the name. */
18529 default_argument
18531 none_type,
18537 /* See if the default argument is valid. */
18541 }
18543 /* Parse a template-parameter.
18545 template-parameter:
18546 type-parameter
18547 parameter-declaration
18549 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
18550 the parameter. The TREE_PURPOSE is the default value, if any.
18551 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
18552 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
18553 set to true iff this parameter is a parameter pack. */
18555 static tree
18558 {
18561 tree parm;
18563 /* Assume it is a type parameter or a template parameter. */
18565 /* Assume it not a parameter pack. */
18567 /* Peek at the next token. */
18569 /* If it is `template', we have a type-parameter. */
18572 /* If it is `class' or `typename' we do not know yet whether it is a
18573 type parameter or a non-type parameter. Consider:
18575 template <typename T, typename T::X X> ...
18577 or:
18579 template <class C, class D*> ...
18581 Here, the first parameter is a type parameter, and the second is
18582 a non-type parameter. We can tell by looking at the token after
18583 the identifier -- if it is a `,', `=', or `>' then we have a type
18584 parameter. */
18586 {
18587 /* Peek at the token after `class' or `typename'. */
18589 /* If it's an ellipsis, we have a template type parameter
18590 pack. */
18593 /* If it's an identifier, skip it. */
18596 /* Now, see if the token looks like the end of a template
18597 parameter. */
18602 }
18604 /* Otherwise, it is a non-type parameter or a constrained parameter.
18606 [temp.param]
18608 When parsing a default template-argument for a non-type
18609 template-parameter, the first non-nested `>' is taken as the end
18610 of the template parameter-list rather than a greater-than
18611 operator. */
18612 parameter_declarator
18614 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18621 /* If the parameter declaration is marked as a parameter pack, set
18622 *IS_PARAMETER_PACK to notify the caller. */
18627 {
18628 /* Can happen in some cases of erroneous input (c++/34892). */
18630 /* Consume the `...' for better error recovery. */
18632 }
18634 /* The parameter may have been constrained type parameter. */
18637 parameter_declarator,
18638 is_non_type);
18640 // Now we're sure that the parameter is a non-type parameter.
18651 }
18653 /* Parse a type-parameter.
18655 type-parameter:
18656 class identifier [opt]
18657 class identifier [opt] = type-id
18658 typename identifier [opt]
18659 typename identifier [opt] = type-id
18660 template < template-parameter-list > class identifier [opt]
18661 template < template-parameter-list > class identifier [opt]
18662 = id-expression
18664 GNU Extension (variadic templates):
18666 type-parameter:
18667 class ... identifier [opt]
18668 typename ... identifier [opt]
18670 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
18671 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
18672 the declaration of the parameter.
18674 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
18676 static tree
18678 {
18680 tree parameter;
18682 /* Look for a keyword to tell us what kind of parameter this is. */
18688 {
18691 {
18692 tree identifier;
18693 tree default_argument;
18695 /* If the next token is an ellipsis, we have a template
18696 argument pack. */
18698 {
18699 /* Consume the `...' token. */
18704 }
18706 /* If the next token is an identifier, then it names the
18707 parameter. */
18710 else
18713 /* Create the parameter. */
18716 /* If the next token is an `=', we have a default argument. */
18718 {
18719 default_argument
18722 /* Template parameter packs cannot have default
18723 arguments. */
18725 {
18728 "template parameter pack %qD cannot have a "
18730 else
18732 "template parameter packs cannot have "
18735 }
18738 }
18739 else
18742 /* Create the combined representation of the parameter and the
18743 default argument. */
18745 }
18749 {
18750 tree identifier;
18751 tree default_argument;
18753 /* Look for the `<'. */
18755 /* Parse the template-parameter-list. */
18757 /* Look for the `>'. */
18760 /* If template requirements are present, parse them. */
18762 {
18767 }
18769 /* Look for the `class' or 'typename' keywords. */
18771 /* If the next token is an ellipsis, we have a template
18772 argument pack. */
18774 {
18775 /* Consume the `...' token. */
18780 }
18781 /* If the next token is an `=', then there is a
18782 default-argument. If the next token is a `>', we are at
18783 the end of the parameter-list. If the next token is a `,',
18784 then we are at the end of this parameter. */
18788 {
18790 /* Treat invalid names as if the parameter were nameless. */
18793 }
18794 else
18797 /* Create the template parameter. */
18799 identifier);
18801 /* If the next token is an `=', then there is a
18802 default-argument. */
18804 {
18805 default_argument
18808 /* Template parameter packs cannot have default
18809 arguments. */
18811 {
18814 "template parameter pack %qD cannot "
18816 identifier);
18817 else
18821 }
18822 }
18823 else
18826 /* Create the combined representation of the parameter and the
18827 default argument. */
18829 }
18835 }
18838 }
18840 /* Parse a template-id.
18842 template-id:
18843 template-name < template-argument-list [opt] >
18845 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
18846 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
18847 returned. Otherwise, if the template-name names a function, or set
18848 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
18849 names a class, returns a TYPE_DECL for the specialization.
18851 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
18852 uninstantiated templates. */
18854 static tree
18860 {
18861 tree templ;
18862 tree arguments;
18863 tree template_id;
18868 /* If the next token corresponds to a template-id, there is no need
18869 to reparse it. */
18873 {
18876 }
18878 /* Avoid performing name lookup if there is no possibility of
18879 finding a template-id. */
18882 && !cp_parser_nth_token_starts_template_argument_list_p
18884 {
18887 }
18889 /* Remember where the template-id starts. */
18895 /* Parse the template-name. */
18898 check_dependency_p,
18899 is_declaration,
18900 tag_type,
18903 /* Push any access checks inside the firewall we're about to create. */
18909 /* Since we're going to preserve any side-effects from this parse, set up a
18910 firewall to protect our callers from cp_parser_commit_to_tentative_parse
18911 in the template arguments. */
18915 /* If we find the sequence `[:' after a template-name, it's probably
18916 a digraph-typo for `< ::'. Substitute the tokens and check if we can
18917 parse correctly the argument list. */
18924 {
18926 /* Change `:' into `::'. */
18928 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
18929 CPP_LESS. */
18932 /* Parse the arguments. */
18935 {
18936 /* If we couldn't parse an argument list, then we revert our changes
18937 and return simply an error. Maybe this is not a template-id
18938 after all. */
18943 }
18944 /* Otherwise, emit an error about the invalid digraph, but continue
18945 parsing because we got our argument list. */
18948 {
18951 "%<<:%> is an alternate spelling for %<[%>."
18954 {
18956 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
18959 }
18960 }
18961 }
18962 else
18963 {
18964 /* Look for the `<' that starts the template-argument-list. */
18966 {
18969 }
18970 /* Parse the arguments. */
18975 && !template_keyword_p
18978 {
18979 /* This didn't go well. */
18981 {
18982 /* C++20 says that "function-name < a;" is now ill-formed. */
18984 {
18987 "operand of %<<%> is ill-formed in C++20; wrap the "
18989 }
18990 else
18991 /* We expect "f<targs>" to be followed by "(args)". */
18995 /* Purge all subsequent tokens. */
18997 }
18998 else
19002 }
19003 }
19005 /* Set the location to be of the form:
19006 template-name < template-argument-list [opt] >
19007 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19008 with caret == start at the start of the template-name,
19009 ranging until the closing '>'. */
19010 location_t combined_loc
19013 /* Check for concepts autos where they don't belong. We could
19014 identify types in some cases of identifier TEMPL, looking ahead
19015 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
19016 types. We reject them in functions, but if what we have is an
19017 identifier, even with none_type we can't conclude it's NOT a
19018 type, we have to wait for template substitution. */
19021 /* Build a representation of the specialization. */
19024 TEMPLATE_ID_EXPR,
19028 {
19029 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
19030 template (rather than some instantiation thereof) only if
19031 is not nested within some other construct. For example, in
19032 "template <typename T> void f(T) { A<T>::", A<T> is just an
19033 instantiation of A. */
19034 bool entering_scope
19037 template_id
19039 }
19041 {
19042 /* The caller will decide whether this is a concept check or type
19043 constraint. */
19046 }
19048 {
19052 }
19055 {
19056 /* Some type template in dependent scope. */
19059 TEMPLATE_ID_EXPR,
19062 }
19063 else
19064 {
19065 /* If it's not a class-template or a template-template, it should be
19066 a function-template. */
19072 }
19074 /* If parsing tentatively, replace the sequence of tokens that makes
19075 up the template-id with a CPP_TEMPLATE_ID token. That way,
19076 should we re-parse the token stream, we will not have to repeat
19077 the effort required to do the parse, nor will we issue duplicate
19078 error messages about problems during instantiation of the
19079 template. */
19081 /* Don't do this if we had a parse error in a declarator; re-parsing
19082 might succeed if a name changes meaning (60361). */
19086 {
19087 /* Reset the contents of the START_OF_ID token. */
19091 /* Retrieve any deferred checks. Do not pop this access checks yet
19092 so the memory will not be reclaimed during token replacing below. */
19099 /* Purge all subsequent tokens. */
19102 /* ??? Can we actually assume that, if template_id ==
19103 error_mark_node, we will have issued a diagnostic to the
19104 user, as opposed to simply marking the tentative parse as
19105 failed? */
19108 }
19112 }
19114 /* Like cp_parser_template_id, called in non-type context. */
19116 static tree
19121 {
19126 /* We didn't check the arguments in cp_parser_template_id; do that now. */
19129 }
19131 /* Parse a template-name.
19133 template-name:
19134 identifier
19136 The standard should actually say:
19138 template-name:
19139 identifier
19140 operator-function-id
19142 A defect report has been filed about this issue.
19144 A conversion-function-id cannot be a template name because they cannot
19145 be part of a template-id. In fact, looking at this code:
19147 a.operator K<int>()
19149 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
19150 It is impossible to call a templated conversion-function-id with an
19151 explicit argument list, since the only allowed template parameter is
19152 the type to which it is converting.
19154 If TEMPLATE_KEYWORD_P is true, then we have just seen the
19155 `template' keyword, in a construction like:
19157 T::template f<3>()
19159 In that case `f' is taken to be a template-name, even though there
19160 is no way of knowing for sure.
19162 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
19163 name refers to a set of overloaded functions, at least one of which
19164 is a template, or an IDENTIFIER_NODE with the name of the template,
19165 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
19166 names are looked up inside uninstantiated templates. */
19168 static tree
19175 {
19176 tree identifier;
19177 tree decl;
19180 /* If the next token is `operator', then we have either an
19181 operator-function-id or a conversion-function-id. */
19183 {
19184 /* We don't know whether we're looking at an
19185 operator-function-id or a conversion-function-id. */
19187 /* Try an operator-function-id. */
19189 /* If that didn't work, try a conversion-function-id. */
19191 {
19194 }
19195 }
19196 /* Look for the identifier. */
19197 else
19200 /* If we didn't find an identifier, we don't have a template-id. */
19204 /* If the name immediately followed the `template' keyword, then it
19205 is a template-name. However, if the next token is not `<', then
19206 we do not treat it as a template-name, since it is not being used
19207 as part of a template-id. This enables us to handle constructs
19208 like:
19210 template <typename T> struct S { S(); };
19211 template <typename T> S<T>::S();
19213 correctly. We would treat `S' as a template -- if it were `S<T>'
19214 -- but we do not if there is no `<'. */
19218 {
19219 /* In a declaration, in a dependent context, we pretend that the
19220 "template" keyword was present in order to improve error
19221 recovery. For example, given:
19223 template <typename T> void f(T::X<int>);
19225 we want to treat "X<int>" as a template-id. */
19227 && !template_keyword_p
19229 && check_dependency_p
19231 /* Do not do this for dtors (or ctors), since they never
19232 need the template keyword before their name. */
19234 {
19237 /* Explain what went wrong. */
19239 identifier);
19242 /* If parsing tentatively, find the location of the "<" token. */
19245 /* Parse the template arguments so that we can issue error
19246 messages about them. */
19249 /* Skip tokens until we find a good place from which to
19250 continue parsing. */
19255 /* If parsing tentatively, permanently remove the
19256 template argument list. That will prevent duplicate
19257 error messages from being issued about the missing
19258 "template" keyword. */
19265 }
19267 /* If the "template" keyword is present, then there is generally
19268 no point in doing name-lookup, so we just return IDENTIFIER.
19269 But, if the qualifying scope is non-dependent then we can
19270 (and must) do name-lookup normally. */
19272 {
19278 {
19279 /* We're optimizing away the call to cp_parser_lookup_name, but
19280 we still need to do this. */
19284 }
19285 }
19286 }
19288 /* cp_parser_lookup_name clears OBJECT_TYPE. */
19292 /* Look up the name. */
19294 tag_type,
19297 check_dependency_p,
19303 /* 13.3 [temp.names] A < is interpreted as the delimiter of a
19304 template-argument-list if it follows a name that is not a
19305 conversion-function-id and
19306 - that follows the keyword template or a ~ after a nested-name-specifier or
19307 in a class member access expression, or
19308 - for which name lookup finds the injected-class-name of a class template
19309 or finds any declaration of a template, or
19310 - that is an unqualified name for which name lookup either finds one or
19311 more functions or finds nothing, or
19312 - that is a terminal name in a using-declarator (9.9), in a declarator-id
19313 (9.3.4), or in a type-only context other than a nested-name-specifier
19314 (13.8). */
19316 /* Handle injected-class-name. */
19319 /* If DECL is a template, then the name was a template-name. */
19321 {
19324 {
19326 tree attr;
19329 else
19332 {
19335 }
19338 {
19341 }
19342 }
19343 }
19344 else
19345 {
19346 /* Look through an overload set for any templates. */
19354 /* "an unqualified name for which name lookup either finds one or more
19355 functions or finds nothing". */
19358 && !scope
19361 {
19362 /* The "more functions" case. Just use the OVERLOAD as normally.
19363 We don't use is_overloaded_fn here to avoid considering
19364 BASELINKs. */
19366 /* Name lookup found one function. */
19368 /* Name lookup found nothing. */
19371 }
19373 /* "that follows the keyword template"..."in a type-only context" */
19381 {
19382 /* The name does not name a template. */
19385 }
19388 /* cp_parser_template_id can only handle some TYPE_DECLs. */
19391 /* Repeat the lookup at instantiation time. */
19393 }
19396 }
19398 /* Parse a template-argument-list.
19400 template-argument-list:
19401 template-argument ... [opt]
19402 template-argument-list , template-argument ... [opt]
19404 Returns a TREE_VEC containing the arguments. */
19406 static tree
19408 {
19413 /* Don't create location wrapper nodes within a template-argument-list. */
19414 auto_suppress_location_wrappers sentinel;
19418 /* Even if the template-id appears in an integral
19419 constant-expression, the contents of the argument list do
19420 not. */
19426 /* Parse the arguments. */
19428 do
19429 {
19431 /* Consume the comma. */
19434 /* Parse the template-argument. */
19437 /* If the next token is an ellipsis, we're expanding a template
19438 argument pack. */
19440 {
19442 {
19446 }
19447 /* Consume the `...' token. */
19450 /* Make the argument into a TYPE_PACK_EXPANSION or
19451 EXPR_PACK_EXPANSION. */
19453 }
19456 }
19471 }
19473 /* Parse a template-argument.
19475 template-argument:
19476 assignment-expression
19477 type-id
19478 id-expression
19480 The representation is that of an assignment-expression, type-id, or
19481 id-expression -- except that the qualified id-expression is
19482 evaluated, so that the value returned is either a DECL or an
19483 OVERLOAD.
19485 Although the standard says "assignment-expression", it forbids
19486 throw-expressions or assignments in the template argument.
19487 Therefore, we use "conditional-expression" instead. */
19489 static tree
19491 {
19492 tree argument;
19498 cp_id_kind idk;
19500 /* There's really no way to know what we're looking at, so we just
19501 try each alternative in order.
19503 [temp.arg]
19505 In a template-argument, an ambiguity between a type-id and an
19506 expression is resolved to a type-id, regardless of the form of
19507 the corresponding template-parameter.
19509 Therefore, we try a type-id first. */
19512 /* If there was no error parsing the type-id but the next token is a
19513 '>>', our behavior depends on which dialect of C++ we're
19514 parsing. In C++98, we probably found a typo for '> >'. But there
19515 are type-id which are also valid expressions. For instance:
19517 struct X { int operator >> (int); };
19518 template <int V> struct Foo {};
19519 Foo<X () >> 5> r;
19521 Here 'X()' is a valid type-id of a function type, but the user just
19522 wanted to write the expression "X() >> 5". Thus, we remember that we
19523 found a valid type-id, but we still try to parse the argument as an
19524 expression to see what happens.
19526 In C++0x, the '>>' will be considered two separate '>'
19527 tokens. */
19531 /* Similarly for >= which
19532 cp_parser_next_token_ends_template_argument_p treats for
19533 diagnostics purposes as mistyped > =, but can be valid
19534 after a type-id. */
19536 {
19539 }
19540 else
19541 {
19542 /* If the next token isn't a `,' or a `>', then this argument wasn't
19543 really finished. This means that the argument is not a valid
19544 type-id. */
19547 /* If that worked, we're done. */
19550 }
19551 /* We're still not sure what the argument will be. */
19553 /* Try a template. */
19561 /* If the next token isn't a `,' or a `>', then this argument wasn't
19562 really finished. */
19566 {
19567 /* Figure out what is being referred to. If the id-expression
19568 was for a class template specialization, then we will have a
19569 TYPE_DECL at this point. There is no need to do name lookup
19570 at this point in that case. */
19573 none_type,
19582 }
19584 {
19590 }
19591 /* It must be a non-type argument. In C++17 any constant-expression is
19592 allowed. */
19596 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
19598 -- an integral constant-expression of integral or enumeration
19599 type; or
19601 -- the name of a non-type template-parameter; or
19603 -- the name of an object or function with external linkage...
19605 -- the address of an object or function with external linkage...
19607 -- a pointer to member... */
19608 /* Look for a non-type template parameter. */
19610 {
19622 }
19624 /* If the next token is "&", the argument must be the address of an
19625 object or function with external linkage. */
19628 {
19631 }
19632 /* See if we might have an id-expression. */
19639 {
19642 address_p,
19649 else
19650 {
19651 tree probe;
19654 {
19655 /* Strip the dereference temporarily. */
19658 }
19660 /* If we're in a template, we represent a qualified-id referring
19661 to a static data member as a SCOPE_REF even if the scope isn't
19662 dependent so that we can check access control later. */
19667 {
19668 /* A variable without external linkage might still be a
19669 valid constant-expression, so no error is issued here
19670 if the external-linkage check fails. */
19673 }
19675 /* All overloaded functions are allowed; if the external
19676 linkage test does not pass, an error will be issued
19677 later. */
19678 ;
19682 /* A pointer-to-member. */
19683 ;
19685 ;
19686 else
19690 {
19694 else
19697 }
19698 }
19699 }
19700 /* If the argument started with "&", there are no other valid
19701 alternatives at this point. */
19703 {
19706 }
19708 general_expr:
19709 /* If the argument wasn't successfully parsed as a type-id followed
19710 by '>>', the argument can only be a constant expression now.
19711 Otherwise, we try parsing the constant-expression tentatively,
19712 because the argument could really be a type-id. */
19718 else
19719 {
19720 /* In C++20, we can encounter a braced-init-list. */
19725 /* With C++17 generalized non-type template arguments we need to handle
19726 lvalue constant expressions, too. */
19729 }
19737 /* We did our best to parse the argument as a non type-id, but that
19738 was the only alternative that matched (albeit with a '>' after
19739 it). We can assume it's just a typo from the user, and a
19740 diagnostic will then be issued. */
19742 }
19744 /* Parse an explicit-instantiation.
19746 explicit-instantiation:
19747 template declaration
19749 Although the standard says `declaration', what it really means is:
19751 explicit-instantiation:
19752 template decl-specifier-seq [opt] declarator [opt] ;
19754 Things like `template int S<int>::i = 5, int S<double>::j;' are not
19755 supposed to be allowed. A defect report has been filed about this
19756 issue.
19758 GNU Extension:
19760 explicit-instantiation:
19761 storage-class-specifier template
19762 decl-specifier-seq [opt] declarator [opt] ;
19763 function-specifier template
19764 decl-specifier-seq [opt] declarator [opt] ; */
19766 static void
19768 {
19770 cp_decl_specifier_seq decl_specifiers;
19775 /* Look for an (optional) storage-class-specifier or
19776 function-specifier. */
19778 {
19779 extension_specifier
19782 extension_specifier
19785 }
19787 /* Look for the `template' keyword. */
19789 /* Let the front end know that we are processing an explicit
19790 instantiation. */
19792 /* [temp.explicit] says that we are supposed to ignore access
19793 control while processing explicit instantiation directives. */
19795 /* Parse a decl-specifier-seq. */
19797 CP_PARSER_FLAGS_OPTIONAL,
19801 cp_omp_declare_simd_data odsd;
19807 /* If there was exactly one decl-specifier, and it declared a class,
19808 and there's no declarator, then we have an explicit type
19809 instantiation. */
19811 {
19814 /* Turn access control back on for names used during
19815 template instantiation. */
19820 }
19821 else
19822 {
19824 tree decl;
19826 /* Parse the declarator. */
19827 declarator
19829 CP_PARSER_FLAGS_NONE,
19840 {
19843 "explicit instantiation shall not use"
19847 "explicit instantiation shall not use"
19851 "explicit instantiation shall not use"
19856 /* Turn access control back on for names used during
19857 template instantiation. */
19859 /* Do the explicit instantiation. */
19861 }
19862 else
19863 {
19865 /* Skip the body of the explicit instantiation. */
19867 }
19868 }
19869 /* We're done with the instantiation. */
19875 }
19877 /* Parse an explicit-specialization.
19879 explicit-specialization:
19880 template < > declaration
19882 Although the standard says `declaration', what it really means is:
19884 explicit-specialization:
19885 template <> decl-specifier [opt] init-declarator [opt] ;
19886 template <> function-definition
19887 template <> explicit-specialization
19888 template <> template-declaration */
19890 static void
19892 {
19895 /* Look for the `template' keyword. */
19897 /* Look for the `<'. */
19899 /* Look for the `>'. */
19901 /* We have processed another parameter list. */
19904 /* [temp]
19906 A template ... explicit specialization ... shall not have C
19907 linkage. */
19910 {
19914 /* Give it C++ linkage to avoid confusing other parts of the
19915 front end. */
19917 }
19919 /* Let the front end know that we are beginning a specialization. */
19921 {
19922 /* If the next keyword is `template', we need to figure out
19923 whether or not we're looking a template-declaration. */
19925 {
19930 else
19932 }
19933 else
19934 /* Parse the dependent declaration. */
19940 }
19942 /* We're done with the specialization. */
19945 /* For the erroneous case of a template with C linkage, we pushed an
19946 implicit C++ linkage scope; exit that scope now. */
19950 /* We're done with this parameter list. */
19952 }
19954 /* Preserve the attributes across a garbage collect (by making it a GC
19955 root), which can occur when parsing a member function. */
19959 /* Parse a type-specifier.
19961 type-specifier:
19962 simple-type-specifier
19963 class-specifier
19964 enum-specifier
19965 elaborated-type-specifier
19966 cv-qualifier
19968 GNU Extension:
19970 type-specifier:
19971 __complex__
19973 Returns a representation of the type-specifier. For a
19974 class-specifier, enum-specifier, or elaborated-type-specifier, a
19975 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
19977 The parser flags FLAGS is used to control type-specifier parsing.
19979 If IS_DECLARATION is TRUE, then this type-specifier is appearing
19980 in a decl-specifier-seq.
19982 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
19983 class-specifier, enum-specifier, or elaborated-type-specifier, then
19984 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
19985 if a type is declared; 2 if it is defined. Otherwise, it is set to
19986 zero.
19988 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
19989 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
19990 is set to FALSE. */
19992 static tree
19994 cp_parser_flags flags,
19999 {
20005 /* Assume this type-specifier does not declare a new type. */
20008 /* And that it does not specify a cv-qualifier. */
20011 /* Peek at the next token. */
20014 /* If we're looking at a keyword, we can use that to guide the
20015 production we choose. */
20018 {
20023 /* Look for the enum-specifier. */
20025 /* If that worked, we're done. */
20027 {
20032 type_spec,
20033 token,
20036 }
20037 else
20040 /* Any of these indicate either a class-specifier, or an
20041 elaborated-type-specifier. */
20048 /* Parse tentatively so that we can back up if we don't find a
20049 class-specifier. */
20053 /* Look for the class-specifier. */
20058 /* If that worked, we're done. */
20060 {
20065 type_spec,
20066 token,
20069 }
20071 /* Fall through. */
20072 elaborated_type_specifier:
20073 /* We're declaring (not defining) a class or enum. */
20077 /* Fall through. */
20079 /* Look for an elaborated-type-specifier. */
20080 type_spec
20081 = (cp_parser_elaborated_type_specifier
20084 is_declaration));
20087 type_spec,
20088 token,
20111 /* The `__complex__' keyword is a GNU extension. */
20117 }
20119 /* Handle simple keywords. */
20121 {
20123 {
20126 }
20128 }
20130 /* If we do not already have a type-specifier, assume we are looking
20131 at a simple-type-specifier. */
20133 decl_specs,
20134 flags);
20136 /* If we didn't find a type-specifier, and a type-specifier was not
20137 optional in this context, issue an error message. */
20139 {
20142 }
20145 }
20147 /* Parse a simple-type-specifier.
20149 simple-type-specifier:
20150 :: [opt] nested-name-specifier [opt] type-name
20151 :: [opt] nested-name-specifier template template-id
20152 char
20153 wchar_t
20154 bool
20155 short
20156 int
20157 long
20158 signed
20159 unsigned
20160 float
20161 double
20162 void
20164 C++11 Extension:
20166 simple-type-specifier:
20167 auto
20168 decltype ( expression )
20169 char16_t
20170 char32_t
20171 __underlying_type ( type-id )
20173 C++17 extension:
20175 nested-name-specifier(opt) template-name
20177 GNU Extension:
20179 simple-type-specifier:
20180 __int128
20181 __typeof__ unary-expression
20182 __typeof__ ( type-id )
20183 __typeof__ ( type-id ) { initializer-list , [opt] }
20185 Concepts Extension:
20187 simple-type-specifier:
20188 constrained-type-specifier
20190 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
20191 appropriately updated. */
20193 static tree
20196 cp_parser_flags flags)
20197 {
20202 /* Peek at the next token. */
20205 /* If we're looking at a keyword, things are easy. */
20207 {
20245 {
20248 /* Check if the alternate "__intN__" form has been used instead of
20249 "__intN". */
20253 }
20275 CASE_RID_FLOATN_NX:
20290 {
20291 /* The 'auto' might be the placeholder return type for a function decl
20292 with trailing return type. */
20301 {
20303 {
20310 }
20313 {
20316 }
20319 }
20323 {
20326 }
20329 {
20332 }
20333 else
20337 {
20340 "use of %<auto%> in lambda parameter declaration "
20341 "only available with "
20343 }
20346 "use of %<auto%> in template argument "
20350 "use of %<auto%> in parameter declaration "
20354 "use of %<auto%> in parameter declaration "
20355 "only available with "
20357 }
20358 else
20363 /* Since DR 743, decltype can either be a simple-type-specifier by
20364 itself or begin a nested-name-specifier. Parsing it will replace
20365 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
20366 handling below decide what to do. */
20372 /* Consume the `typeof' token. */
20374 /* Parse the operand to `typeof'. */
20376 /* If it is not already a TYPE, take its type. */
20382 token,
20388 /* If token is a type-yielding built-in traits, parse it. */
20391 {
20395 token,
20399 }
20402 }
20404 /* If token is an already-parsed decltype not followed by ::,
20405 it's a simple-type-specifier. */
20408 {
20411 {
20413 token,
20415 /* Remember that we are handling a decltype in order to
20416 implement the resolution of DR 1510 when the argument
20417 isn't instantiation dependent. */
20419 }
20422 }
20424 /* If the type-specifier was for a built-in type, we're done. */
20426 {
20427 /* Record the type. */
20434 type,
20435 token,
20440 /* Consume the token. */
20446 /* There is no valid C++ program where a non-template type is
20447 followed by a "<". That usually indicates that the user thought
20448 that the type was a template. */
20453 }
20455 /* The type-specifier must be a user-defined type. */
20457 {
20463 /* Don't gobble tokens or issue error messages if this is an
20464 optional type-specifier. */
20468 /* Remember current tentative parsing state -- if we know we need
20469 a type, we can give better diagnostics here. */
20474 /* Look for the optional `::' operator. */
20475 global_p
20479 /* Look for the nested-name specifier. */
20480 qualified_p
20487 /* If we have seen a nested-name-specifier, and the next token
20488 is `template', then we are using the template-id production. */
20491 {
20492 /* Look for the template-id. */
20496 none_type,
20498 /* If the template-id did not name a type, we are out of
20499 luck. */
20501 {
20502 /* ...unless we pretend we have seen 'typename'. */
20506 else
20507 {
20510 }
20511 }
20512 }
20513 /* DR 1812: A < following a qualified-id in a typename-specifier
20514 could safely be assumed to begin a template argument list, so
20515 the template keyword should be optional. */
20517 && qualified_p
20518 && typename_p
20520 {
20526 none_type,
20528 /* This is handled below, so back off. */
20539 }
20541 /* Otherwise, look for a type-name. */
20543 {
20552 }
20555 {
20556 /* Try for a type-constraint with template arguments. We check
20557 decl_specs here to avoid trying this for a functional cast. */
20564 none_type,
20567 {
20572 /* Perhaps it's a concept-check expression. */
20574 }
20575 else
20580 }
20583 {
20584 /* Try class template argument deduction or type-constraint without
20585 template arguments. */
20589 {
20590 location_t loc
20593 none_type,
20605 else
20606 {
20611 }
20612 }
20613 else
20615 }
20617 /* If it didn't work out, we don't have a TYPE. */
20622 /* Keep track of all name-lookups performed in class scopes. */
20624 && !global_p
20625 && !qualified_p
20632 token,
20634 }
20636 /* If we didn't get a type-name, issue an error message. */
20638 {
20641 }
20644 {
20645 /* See if TYPE is an Objective-C type, and if so, parse and
20646 accept any protocol references following it. Do this before
20647 the cp_parser_check_for_invalid_template_id() call, because
20648 Objective-C types can be followed by '<...>' which would
20649 enclose protocol names rather than template arguments, and so
20650 everything is fine. */
20653 {
20657 /* Clobber the "unqualified" type previously entered into
20658 DECL_SPECS with the new, improved protocol-qualified version. */
20663 }
20665 /* There is no valid C++ program where a non-template type is
20666 followed by a "<". That usually indicates that the user
20667 thought that the type was a template. */
20669 none_type,
20671 }
20674 }
20676 /* Parse the remainder of a placholder-type-specifier.
20678 placeholder-type-specifier:
20679 type-constraint_opt auto
20680 type-constraint_opt decltype(auto)
20682 The raw form of the constraint is parsed in cp_parser_simple_type_specifier
20683 and passed as TMPL. This function converts TMPL to an actual type-constraint,
20684 parses the placeholder type, and performs some contextual syntactic analysis.
20686 LOC provides the location of the template name.
20688 TENTATIVE is true if the type-specifier parsing is tentative; in that case,
20689 don't give an error if TMPL isn't a valid type-constraint, as the template-id
20690 might actually be a concept-check,
20692 Note that the Concepts TS allows the auto or decltype(auto) to be
20693 omitted in a constrained-type-specifier. */
20695 static tree
20698 {
20704 /* Get the arguments as written for subsequent analysis. */
20707 {
20710 }
20711 else
20712 /* A concept-name with no arguments can't be an expression. */
20717 /* Get the concept and prototype parameter for the constraint. */
20724 /* As per the standard, require auto or decltype(auto), except in some
20725 cases (template parameter lists, -fconcepts-ts enabled). */
20728 {
20732 {
20734 matching_parens parens;
20738 }
20739 }
20741 /* A type constraint constrains a contextually determined type or type
20742 parameter pack. However, the Concepts TS does allow concepts
20743 to introduce non-type and template template parameters. */
20745 {
20748 {
20750 {
20753 }
20755 }
20756 }
20758 /* In a template parameter list, a type-parameter can be introduced
20759 by type-constraints alone. */
20761 {
20762 /* In a default argument we may not be creating new parameters. */
20764 {
20765 /* If this assert turns out to be false, do error() instead. */
20768 }
20770 }
20772 /* Diagnose issues placeholder issues. */
20776 {
20778 /* Perhaps it's a concept-check expression (c++/91073). */
20785 /* Fall through. This is an error of omission. */
20786 }
20788 {
20789 /* A trailing return type only allows type-constraints. */
20792 }
20794 /* In a parameter-declaration-clause, a placeholder-type-specifier
20795 results in an invented template parameter. */
20797 {
20799 {
20805 }
20808 }
20810 /* Determine if the type should be deduced using template argument
20811 deduction or decltype deduction. Note that the latter is always
20812 used for type-constraints in trailing return types. */
20817 /* Otherwise, this is the type of a variable or return type. */
20820 else
20822 }
20824 /* Parse a type-name.
20826 type-name:
20827 class-name
20828 enum-name
20829 typedef-name
20830 simple-template-id [in c++0x]
20832 enum-name:
20833 identifier
20835 typedef-name:
20836 identifier
20838 Concepts:
20840 type-name:
20841 concept-name
20842 partial-concept-id
20844 concept-name:
20845 identifier
20847 Returns a TYPE_DECL for the type. */
20849 static tree
20851 {
20852 tree type_decl;
20854 /* We can't know yet whether it is a class-name or not. */
20856 /* Try a class-name. */
20858 typename_keyword_p,
20860 none_type,
20864 /* If it's not a class-name, keep looking. */
20866 {
20868 /* It must be a typedef-name or an enum-name. */
20872 /* It is either a simple-template-id representing an
20873 instantiation of an alias template... */
20877 none_type,
20879 /* Note that this must be an instantiation of an alias template
20880 because [temp.names]/6 says:
20882 A template-id that names an alias template specialization
20883 is a type-name.
20885 Whereas [temp.names]/7 says:
20887 A simple-template-id that names a class template
20888 specialization is a class-name.
20890 With concepts, this could also be a partial-concept-id that
20891 declares a non-type template parameter. */
20896 else
20900 /* ... Or a typedef-name or an enum-name. */
20902 }
20905 }
20907 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
20908 or a concept-name.
20910 enum-name:
20911 identifier
20913 typedef-name:
20914 identifier
20916 concept-name:
20917 identifier
20919 Returns a TYPE_DECL for the type. */
20921 static tree
20923 {
20924 tree type_decl;
20925 tree identifier;
20932 /* Look up the type-name. */
20939 {
20940 /* See if this is an Objective-C type. */
20945 }
20947 /* Issue an error if we did not find a type-name. */
20949 /* In Objective-C, we have the complication that class names are
20950 normally type names and start declarations (eg, the
20951 "NSObject" in "NSObject *object;"), but can be used in an
20952 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
20953 is an expression. So, a classname followed by a dot is not a
20954 valid type-name. */
20957 {
20962 }
20963 /* Remember that the name was used in the definition of the
20964 current class so that we can check later to see if the
20965 meaning would have been different after the class was
20966 entirely defined. */
20972 }
20974 /* Parse an elaborated-type-specifier. Note that the grammar given
20975 here incorporates the resolution to DR68.
20977 elaborated-type-specifier:
20978 class-key :: [opt] nested-name-specifier [opt] identifier
20979 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
20980 enum-key :: [opt] nested-name-specifier [opt] identifier
20981 typename :: [opt] nested-name-specifier identifier
20982 typename :: [opt] nested-name-specifier template [opt]
20983 template-id
20985 GNU extension:
20987 elaborated-type-specifier:
20988 class-key attributes :: [opt] nested-name-specifier [opt] identifier
20989 class-key attributes :: [opt] nested-name-specifier [opt]
20990 template [opt] template-id
20991 enum attributes :: [opt] nested-name-specifier [opt] identifier
20993 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
20994 declared `friend'. If IS_DECLARATION is TRUE, then this
20995 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
20996 something is being declared.
20998 Returns the TYPE specified. */
21000 static tree
21004 {
21006 tree identifier;
21009 tree globalscope;
21012 /* For class and enum types the location of the class-key or enum-key. */
21014 /* For a scoped enum, the 'class' or 'struct' keyword id. */
21017 /* See if we're looking at the `enum' keyword. */
21019 {
21020 /* Consume the `enum' token. */
21022 /* Remember that it's an enumeration type. */
21024 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
21025 enums) is used here. */
21029 {
21037 /* Consume the `struct' or `class' and parse it anyway. */
21039 /* Create a combined location for the whole scoped-enum-key. */
21041 }
21042 else
21045 /* Parse the attributes. */
21047 }
21048 /* Or, it might be `typename'. */
21050 RID_TYPENAME))
21051 {
21052 /* Consume the `typename' token. */
21054 /* Remember that it's a `typename' type. */
21056 }
21057 /* Otherwise it must be a class-key. */
21058 else
21059 {
21064 /* Parse the attributes. */
21066 }
21068 /* Look for the `::' operator. */
21071 /* Look for the nested-name-specifier. */
21072 tree nested_name_specifier;
21074 {
21075 nested_name_specifier
21080 is_declaration);
21083 }
21084 else
21085 /* Even though `typename' is not present, the proposed resolution
21086 to Core Issue 180 says that in `class A<T>::B', `B' should be
21087 considered a type-name, even if `A<T>' is dependent. */
21088 nested_name_specifier
21093 is_declaration);
21094 /* For everything but enumeration types, consider a template-id.
21095 For an enumeration type, consider only a plain identifier. */
21097 {
21099 tree decl;
21101 /* Allow the `template' keyword. */
21103 /* If we didn't see `template', we don't know if there's a
21104 template-id or not. */
21107 /* The `template' keyword must follow a nested-name-specifier. */
21109 {
21113 }
21115 /* Parse the template-id. */
21119 tag_type,
21120 is_declaration);
21121 /* If we didn't find a template-id, look for an ordinary
21122 identifier. */
21124 ;
21125 /* We can get here when cp_parser_template_id, called by
21126 cp_parser_class_name with tag_type == none_type, succeeds
21127 and caches a BASELINK. Then, when called again here,
21128 instead of failing and returning an error_mark_node
21129 returns it (see template/typename17.C in C++11).
21130 ??? Could we diagnose this earlier? */
21132 {
21135 }
21136 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
21137 in effect, then we must assume that, upon instantiation, the
21138 template will correspond to a class. */
21142 typename_type,
21144 /* If the `typename' keyword is in effect and DECL is not a type
21145 decl, then type is non existent. */
21147 ;
21149 {
21153 /* If the next token is a semicolon, this must be a specialization,
21154 instantiation, or friend declaration. Check the scope while we
21155 still know whether or not we had a nested-name-specifier. */
21160 }
21163 }
21166 {
21171 {
21174 }
21176 /* For a `typename', we needn't call xref_tag. */
21182 /* Template parameter lists apply only if we are not within a
21183 function parameter list. */
21184 bool template_parm_lists_apply
21193 /* Look up a qualified name in the usual way. */
21195 {
21196 tree decl;
21197 tree ambiguous_decls;
21200 tag_type,
21207 /* If the lookup was ambiguous, an error will already have been
21208 issued. */
21212 /* If we are parsing friend declaration, DECL may be a
21213 TEMPLATE_DECL tree node here. However, we need to check
21214 whether this TEMPLATE_DECL results in valid code. Consider
21215 the following example:
21217 namespace N {
21218 template <class T> class C {};
21219 }
21220 class X {
21221 template <class T> friend class N::C; // #1, valid code
21222 };
21223 template <class T> class Y {
21224 friend class N::C; // #2, invalid code
21225 };
21227 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
21228 name lookup of `N::C'. We see that friend declaration must
21229 be template for the code to be valid. Note that
21230 processing_template_decl does not work here since it is
21231 always 1 for the above two cases. */
21233 decl = (cp_parser_maybe_treat_template_as_class
21238 {
21240 identifier,
21243 }
21246 {
21250 allow_template);
21254 }
21256 /* Forward declarations of nested types, such as
21258 class C1::C2;
21259 class C1::C2::C3;
21261 are invalid unless all components preceding the final '::'
21262 are complete. If all enclosing types are complete, these
21263 declarations become merely pointless.
21265 Invalid forward declarations of nested types are errors
21266 caught elsewhere in parsing. Those that are pointless arrive
21267 here. */
21275 }
21276 else
21277 {
21278 /* An elaborated-type-specifier sometimes introduces a new type and
21279 sometimes names an existing type. Normally, the rule is that it
21280 introduces a new type only if there is not an existing type of
21281 the same name already in scope. For example, given:
21283 struct S {};
21284 void f() { struct S s; }
21286 the `struct S' in the body of `f' is the same `struct S' as in
21287 the global scope; the existing definition is used. However, if
21288 there were no global declaration, this would introduce a new
21289 local class named `S'.
21291 An exception to this rule applies to the following code:
21293 namespace N { struct S; }
21295 Here, the elaborated-type-specifier names a new type
21296 unconditionally; even if there is already an `S' in the
21297 containing scope this declaration names a new type.
21298 This exception only applies if the elaborated-type-specifier
21299 forms the complete declaration:
21301 [class.name]
21303 A declaration consisting solely of `class-key identifier ;' is
21304 either a redeclaration of the name in the current scope or a
21305 forward declaration of the identifier as a class name. It
21306 introduces the name into the current scope.
21308 We are in this situation precisely when the next token is a `;'.
21310 An exception to the exception is that a `friend' declaration does
21311 *not* name a new type; i.e., given:
21313 struct S { friend struct T; };
21315 `T' is not a new type in the scope of `S'.
21317 Also, `new struct S' or `sizeof (struct S)' never results in the
21318 definition of a new type; a new type can only be declared in a
21319 declaration context. */
21321 TAG_how how;
21324 /* Friends have special name lookup rules. */
21328 CPP_SEMICOLON))
21329 /* This is a `class-key identifier ;' */
21331 else
21335 (template_parm_lists_apply
21338 /* An unqualified name was used to reference this type, so
21339 there were no qualifying templates. */
21349 }
21350 }
21355 /* Allow attributes on forward declarations of classes. */
21357 {
21368 {
21372 }
21375 else
21377 "attributes ignored on elaborated-type-specifier that is "
21379 }
21383 else
21384 {
21385 /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
21386 for alias definition. */
21390 decl_class);
21392 /* Indicate whether this class was declared as a `class' or as a
21393 `struct'. */
21396 }
21398 /* A "<" cannot follow an elaborated type specifier. If that
21399 happens, the user was probably trying to form a template-id. */
21404 }
21406 /* Parse an enum-specifier.
21408 enum-specifier:
21409 enum-head { enumerator-list [opt] }
21410 enum-head { enumerator-list , } [C++0x]
21412 enum-head:
21413 enum-key identifier [opt] enum-base [opt]
21414 enum-key nested-name-specifier identifier enum-base [opt]
21416 enum-key:
21417 enum
21418 enum class [C++0x]
21419 enum struct [C++0x]
21421 enum-base: [C++0x]
21422 : type-specifier-seq
21424 opaque-enum-specifier:
21425 enum-key identifier enum-base [opt] ;
21427 GNU Extensions:
21428 enum-key attributes[opt] identifier [opt] enum-base [opt]
21429 { enumerator-list [opt] }attributes[opt]
21430 enum-key attributes[opt] identifier [opt] enum-base [opt]
21431 { enumerator-list, }attributes[opt] [C++0x]
21433 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
21434 if the token stream isn't an enum-specifier after all. */
21436 static tree
21438 {
21439 tree identifier;
21441 tree prev_scope;
21443 tree attributes;
21454 /* Parse tentatively so that we can back up if we don't find a
21455 enum-specifier. */
21458 /* Caller guarantees that the current token is 'enum', an identifier
21459 possibly follows, and the token after that is an opening brace.
21460 If we don't have an identifier, fabricate an anonymous name for
21461 the enumeration being defined. */
21464 /* Parse the "class" or "struct", which indicates a scoped
21465 enumeration type in C++0x. */
21468 {
21472 /* Consume the `struct' or `class' token. */
21476 }
21480 /* Clear the qualification. */
21485 /* Figure out in what scope the declaration is being placed. */
21491 nested_name_specifier
21499 {
21500 tree name;
21504 enum_type,
21509 input_location);
21511 {
21514 {
21515 /* Are template enums allowed in ISO? */
21519 /* ignore a typename reference, for it will be solved by name
21520 in start_enum. */
21522 }
21523 }
21526 else
21527 {
21532 }
21533 }
21534 else
21535 {
21538 else
21539 {
21545 }
21546 }
21549 /* Check for the `:' that denotes a specified underlying type in C++0x.
21550 Note that a ':' could also indicate a bitfield width, however. */
21553 {
21554 cp_decl_specifier_seq type_specifiers;
21556 /* Consume the `:'. */
21560 auto tdf
21564 /* Parse the type-specifier-seq. */
21570 /* At this point this is surely not elaborated type specifier. */
21579 /* If that didn't work, stop. */
21581 {
21587 }
21588 }
21590 /* Look for the `{' but don't consume it yet. */
21592 {
21594 {
21600 }
21601 /* An opaque-enum-specifier must have a ';' here. */
21604 {
21607 OPT_Welaborated_enum_base,
21608 "declaration of enumeration with "
21609 "fixed underlying type and no enumerator list is "
21611 else
21613 }
21614 }
21620 {
21622 {
21626 }
21629 }
21631 /* Issue an error message if type-definitions are forbidden here. */
21634 else
21635 /* Create the new type. We do this before consuming the opening
21636 brace so the enum will be recorded as being on the line of its
21637 tag (or the 'enum' keyword, if there is no tag). */
21641 /* If the next token is not '{' it is an opaque-enum-specifier or an
21642 elaborated-type-specifier. */
21644 {
21649 {
21650 /* The following catches invalid code such as:
21651 enum class S<int>::E { A, B, C }; */
21659 {
21663 nested_name_specifier);
21665 }
21668 {
21670 "%qT for enum declaration does not name a class "
21673 }
21674 /* If that scope does not contain the scope in which the
21675 class was originally declared, the program is invalid. */
21677 nested_name_specifier))
21678 {
21681 "declaration of %qD in namespace %qD which does not "
21684 else
21686 "declaration of %qD in %qD which does not "
21690 }
21691 /* If that scope is the scope where the declaration is being placed
21692 the program is invalid. */
21696 {
21700 }
21701 }
21706 /* Consume the opening brace. */
21707 matching_braces braces;
21714 {
21718 }
21719 else
21720 {
21726 }
21730 /* If the next token is not '}', then there are some enumerators. */
21732 {
21734 /* Don't warn for enum {} a; here. */
21738 }
21739 else
21740 {
21741 /* We've seen a '{' so we know we're in an enum-specifier.
21742 Commit to any tentative parse to get syntax errors. */
21745 }
21747 /* Consume the final '}'. */
21752 }
21753 else
21754 {
21755 /* If a ';' follows, then it is an opaque-enum-specifier
21756 and additional restrictions apply. */
21758 {
21765 }
21766 }
21768 /* Look for trailing attributes to apply to this enumeration, and
21769 apply them if appropriate. */
21771 {
21774 trailing_attr,
21776 }
21778 /* Finish up the enumeration. */
21780 {
21785 }
21788 {
21790 {
21793 }
21796 }
21798 }
21800 /* Parse an enumerator-list. The enumerators all have the indicated
21801 TYPE.
21803 enumerator-list:
21804 enumerator-definition
21805 enumerator-list , enumerator-definition */
21807 static void
21809 {
21811 {
21812 /* Parse an enumerator-definition. */
21815 /* If the next token is not a ',', we've reached the end of
21816 the list. */
21819 /* Otherwise, consume the `,' and keep going. */
21821 /* If the next token is a `}', there is a trailing comma. */
21823 {
21828 }
21829 }
21830 }
21832 /* Parse an enumerator-definition. The enumerator has the indicated
21833 TYPE.
21835 enumerator-definition:
21836 enumerator
21837 enumerator = constant-expression
21839 enumerator:
21840 identifier
21842 GNU Extensions:
21844 enumerator-definition:
21845 enumerator attributes [opt]
21846 enumerator attributes [opt] = constant-expression */
21848 static void
21850 {
21851 tree identifier;
21852 tree value;
21853 location_t loc;
21855 /* Save the input location because we are interested in the location
21856 of the identifier and not the location of the explicit value. */
21859 /* Look for the identifier. */
21864 /* Parse any specified attributes. */
21867 /* If the next token is an '=', then there is an explicit value. */
21869 {
21870 /* Consume the `=' token. */
21872 /* Parse the value. */
21874 }
21875 else
21878 /* If we are processing a template, make sure the initializer of the
21879 enumerator doesn't contain any bare template parameter pack. */
21881 {
21882 /* In a lambda it should work, but doesn't currently. */
21884 {
21887 }
21888 }
21892 /* Create the enumerator. */
21894 }
21896 /* Parse a namespace-name.
21898 namespace-name:
21899 original-namespace-name
21900 namespace-alias
21902 Returns the NAMESPACE_DECL for the namespace. */
21904 static tree
21906 {
21907 tree identifier;
21908 tree namespace_decl;
21912 /* Get the name of the namespace. */
21917 /* Look up the identifier in the currently active scope. Look only
21918 for namespaces, due to:
21920 [basic.lookup.udir]
21922 When looking up a namespace-name in a using-directive or alias
21923 definition, only namespace names are considered.
21925 And:
21927 [basic.lookup.qual]
21929 During the lookup of a name preceding the :: scope resolution
21930 operator, object, function, and enumerator names are ignored.
21932 (Note that cp_parser_qualifying_entity only calls this
21933 function if the token after the name is the scope resolution
21934 operator.) */
21936 none_type,
21942 /* If it's not a namespace, issue an error. */
21945 {
21947 {
21948 auto_diagnostic_group d;
21949 name_hint hint;
21953 identifier,
21956 {
21962 }
21963 else
21965 identifier);
21966 }
21967 else
21970 }
21973 }
21975 /* Parse a namespace-definition.
21977 namespace-definition:
21978 named-namespace-definition
21979 unnamed-namespace-definition
21981 named-namespace-definition:
21982 original-namespace-definition
21983 extension-namespace-definition
21985 original-namespace-definition:
21986 namespace identifier { namespace-body }
21988 extension-namespace-definition:
21989 namespace original-namespace-name { namespace-body }
21991 unnamed-namespace-definition:
21992 namespace { namespace-body } */
21994 static void
21996 {
21997 tree identifier;
22007 {
22010 }
22012 /* Look for the `namespace' keyword. */
22013 cp_token* token
22016 /* Parse any specified attributes before the identifier. */
22020 {
22024 RID_INLINE);
22026 {
22030 "definitions only available with %<-std=c++20%> or "
22033 }
22036 {
22041 "standard attributes on namespaces must precede "
22044 /* Parse any attributes specified after the identifier. */
22046 }
22049 {
22050 /* Don't forget that the innermost namespace might have been
22051 marked as inline. Use |= because we cannot overwrite
22052 IS_INLINE in case the outermost namespace is inline, but
22053 there are no nested inlines. */
22056 }
22060 "nested namespace definitions only available with "
22063 /* Nested namespace names can create new namespaces (unlike
22064 other qualified-ids). */
22069 else
22072 }
22084 /* Start the namespace. */
22091 /* Look for the `{' to validate starting the namespace. */
22092 matching_braces braces;
22094 {
22095 /* Parse the body of the namespace. */
22098 /* Look for the final `}'. */
22100 }
22105 /* Pop the nested namespace definitions. */
22108 }
22110 /* Parse a namespace-body.
22112 namespace-body:
22113 declaration-seq [opt] */
22115 static void
22117 {
22119 }
22121 /* Parse a namespace-alias-definition.
22123 namespace-alias-definition:
22124 namespace identifier = qualified-namespace-specifier ; */
22126 static void
22128 {
22129 tree identifier;
22130 tree namespace_specifier;
22134 /* Look for the `namespace' keyword. */
22136 /* Look for the identifier. */
22140 /* Look for the `=' token. */
22143 {
22145 /* Skip the definition. */
22150 }
22152 /* Look for the qualified-namespace-specifier. */
22153 namespace_specifier
22156 /* Look for the `;' token. */
22159 /* Register the alias in the symbol table. */
22161 }
22163 /* Parse a qualified-namespace-specifier.
22165 qualified-namespace-specifier:
22166 :: [opt] nested-name-specifier [opt] namespace-name
22168 Returns a NAMESPACE_DECL corresponding to the specified
22169 namespace. */
22171 static tree
22173 {
22174 /* Look for the optional `::'. */
22178 /* Look for the optional nested-name-specifier. */
22186 }
22188 /* Subroutine of cp_parser_using_declaration. */
22190 static tree
22192 {
22195 {
22196 /* Create the USING_DECL. */
22205 /* Add it to the list of members in this class. */
22207 }
22208 else
22211 }
22213 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
22214 access declaration.
22216 using-declaration:
22217 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
22218 using :: unqualified-id ;
22220 access-declaration:
22221 qualified-id ;
22223 */
22225 static bool
22228 {
22232 tree identifier;
22233 tree qscope;
22238 {
22241 }
22242 else
22243 {
22244 /* Look for the `using' keyword. */
22247 again:
22248 /* Peek at the next token. */
22250 /* See if it's `typename'. */
22252 {
22253 /* Remember that we've seen it. */
22255 /* Consume the `typename' token. */
22257 }
22258 }
22260 /* Look for the optional global scope qualification. */
22261 global_scope_p
22266 /* If we saw `typename', or didn't see `::', then there must be a
22267 nested-name-specifier present. */
22269 {
22275 {
22278 }
22279 }
22280 /* Otherwise, we could be in either of the two productions. In that
22281 case, treat the nested-name-specifier as optional. */
22282 else
22296 /* If the qualifying scope of an access-declaration isn't a class
22297 or enumeration type then it can't be valid. */
22301 /* Something has already gone wrong; there's no need to parse
22302 further. Since an error has occurred, the return value of
22303 cp_parser_parse_definitely will be false, as required. */
22307 /* Parse the unqualified-id. */
22315 {
22320 }
22322 {
22326 "pack expansion in using-declaration only available "
22329 /* A parameter pack can appear in the qualifying scope, and/or in the
22330 terminal name (if naming a conversion function). Logically they're
22331 part of a single pack expansion of the overall USING_DECL, but we
22332 express them as separate pack expansions within the USING_DECL since
22333 we can't create a pack expansion over a USING_DECL. */
22336 {
22339 }
22343 {
22347 }
22349 {
22350 /* Issue an error in terms using a SCOPE_REF that includes both
22351 components. */
22352 tree name
22357 }
22358 }
22360 /* The function we call to handle a using-declaration is different
22361 depending on what scope we are in. */
22363 ;
22366 /* [namespace.udecl]
22368 A using declaration shall not name a template-id. */
22371 else
22372 {
22376 {
22379 }
22380 }
22384 {
22388 "comma-separated list in using-declaration only available "
22391 }
22393 /* Look for the final `;'. */
22398 "access declarations are deprecated "
22399 "in favour of using-declarations; "
22403 }
22405 /* C++20 using enum declaration.
22407 using-enum-declaration :
22408 using elaborated-enum-specifier ; */
22410 static void
22412 {
22415 /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
22416 breaks one of the motivating examples in using-enum-5.C.
22417 cp_parser_simple_type_specifier seems to be closer to what we actually
22418 want, though that hasn't been properly specified yet. */
22420 /* Consume 'enum'. */
22426 tree type = (cp_parser_simple_type_specifier
22433 {
22436 }
22440 /* The elaborated-enum-specifier shall not name a dependent type and the type
22441 shall have a reachable enum-specifier. */
22455 {
22457 auto_diagnostic_group g;
22461 ;
22464 else
22466 }
22468 /* A using-enum-declaration introduces the enumerator names of the named
22469 enumeration as if by a using-declaration for each enumerator. */
22473 }
22475 /* Parse an alias-declaration.
22477 alias-declaration:
22478 using identifier attribute-specifier-seq [opt] = type-id */
22480 static tree
22482 {
22486 cp_decl_specifier_seq decl_specs;
22490 /* Look for the `using' keyword. */
22491 cp_token *using_token
22513 /* Now we are going to parse the type-id of the declaration. */
22515 /*
22516 [dcl.type]/3 says:
22518 "A type-specifier-seq shall not define a class or enumeration
22519 unless it appears in the type-id of an alias-declaration (7.1.3) that
22520 is not the declaration of a template-declaration."
22522 In other words, if we currently are in an alias template, the
22523 type-id should not define a type.
22525 So let's set parser->type_definition_forbidden_message in that
22526 case; cp_parser_check_type_definition (called by
22527 cp_parser_class_specifier) will then emit an error if a type is
22528 defined in the type-id. */
22530 {
22534 }
22539 /* Restore the error message if need be. */
22545 {
22548 }
22550 /* A typedef-name can also be introduced by an alias-declaration. The
22551 identifier following the using keyword becomes a typedef-name. It has
22552 the same semantics as if it were introduced by the typedef
22553 specifier. In particular, it does not define a new type and it shall
22554 not appear in the type-id. */
22559 {
22562 ds_attribute,
22563 attrs_token);
22564 }
22566 ds_typedef,
22567 using_token);
22569 ds_alias,
22570 using_token);
22577 id_location,
22587 else
22598 /* If decl is a template, return its TEMPLATE_DECL so that it gets
22599 added into the symbol table; otherwise, return the TYPE_DECL. */
22603 {
22607 }
22610 }
22612 /* Parse a using-directive.
22614 using-directive:
22615 attribute-specifier-seq [opt] using namespace :: [opt]
22616 nested-name-specifier [opt] namespace-name ; */
22618 static void
22620 {
22621 tree namespace_decl;
22624 {
22625 /* Error during attribute parsing that resulted in skipping
22626 to next semicolon. */
22629 }
22631 /* Look for the `using' keyword. */
22633 /* And the `namespace' keyword. */
22635 /* Look for the optional `::' operator. */
22637 /* And the optional nested-name-specifier. */
22643 /* Get the namespace being used. */
22646 /* And any specified GNU attributes. */
22650 /* Update the symbol table. */
22653 /* Look for the final `;'. */
22655 }
22657 /* Parse an asm-definition.
22659 asm-qualifier:
22660 volatile
22661 inline
22662 goto
22664 asm-qualifier-list:
22665 asm-qualifier
22666 asm-qualifier-list asm-qualifier
22668 asm-definition:
22669 asm ( string-literal ) ;
22671 GNU Extension:
22673 asm-definition:
22674 asm asm-qualifier-list [opt] ( string-literal ) ;
22675 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
22676 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
22677 : asm-operand-list [opt] ) ;
22678 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
22679 : asm-operand-list [opt]
22680 : asm-clobber-list [opt] ) ;
22681 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
22682 : asm-clobber-list [opt]
22683 : asm-goto-list ) ;
22685 The form with asm-goto-list is valid if and only if the asm-qualifier-list
22686 contains goto, and is the only allowed form in that case. No duplicates are
22687 allowed in an asm-qualifier-list. */
22689 static void
22691 {
22696 tree asm_stmt;
22704 /* Look for the `asm' keyword. */
22707 /* In C++20, unevaluated inline assembly is permitted in constexpr
22708 functions. */
22713 "function only available with %<-std=c++20%> or "
22716 /* Handle the asm-qualifier-list. */
22724 {
22728 {
22731 {
22735 }
22736 else
22737 {
22742 }
22748 {
22752 }
22753 else
22762 {
22766 }
22767 else
22782 }
22784 }
22791 {
22794 }
22796 /* Look for the opening `('. */
22799 /* Look for the string. */
22803 {
22807 }
22809 /* If we're allowing GNU extensions, check for the extended assembly
22810 syntax. Unfortunately, the `:' tokens need not be separated by
22811 a space in C, and so, for compatibility, we tolerate that here
22812 too. Doing that means that we have to treat the `::' operator as
22813 two `:' tokens. */
22818 {
22823 /* The extended syntax was used. */
22826 /* Look for outputs. */
22828 {
22829 /* Consume the `:'. */
22831 /* Parse the output-operands. */
22833 CPP_COLON)
22835 CPP_SCOPE)
22837 CPP_CLOSE_PAREN))
22838 {
22842 }
22843 }
22844 /* If the next token is `::', there are no outputs, and the
22845 next token is the beginning of the inputs. */
22847 /* The inputs are coming next. */
22850 /* Look for inputs. */
22853 {
22854 /* Consume the `:' or `::'. */
22856 /* Parse the output-operands. */
22858 CPP_COLON)
22860 CPP_SCOPE)
22862 CPP_CLOSE_PAREN))
22863 {
22867 }
22868 }
22870 /* The clobbers are coming next. */
22873 /* Look for clobbers. */
22876 {
22878 /* Consume the `:' or `::'. */
22880 /* Parse the clobbers. */
22882 CPP_COLON)
22884 CPP_CLOSE_PAREN))
22886 }
22888 /* The labels are coming next. */
22891 /* Look for labels. */
22894 {
22896 /* Consume the `:' or `::'. */
22898 /* Parse the labels. */
22900 }
22904 }
22908 /* Look for the closing `)'. */
22916 {
22917 /* Create the ASM_EXPR. */
22919 {
22922 /* If the extended syntax was not used, mark the ASM_EXPR. */
22924 {
22930 }
22931 }
22932 else
22934 }
22939 }
22941 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
22942 type that comes from the decl-specifier-seq. */
22944 static tree
22946 {
22949 {
22962 }
22965 }
22967 /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
22968 a construct looks like a variable definition but is actually a function
22969 declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
22970 is the declarator for this function declaration. */
22972 static void
22975 {
22976 /* Only warn if we are declaring a function at block scope. */
22980 /* And only if there is no storage class specified. */
22992 /* Don't warn when the whole declarator (not just the declarator-id!)
22993 was parenthesized. That is, don't warn for int(n()) but do warn
22994 for int(f)(). */
22998 tree type;
23000 {
23005 /* If the return type is void there is no ambiguity. */
23008 }
23010 /* Code like long f(); will have null ->type. If we have any
23011 type-specifiers, pretend we've seen int. */
23013 else
23016 auto_diagnostic_group d;
23021 /* The T t() case. */
23023 {
23025 "empty parentheses were disambiguated as a function "
23027 {
23028 /* () means value-initialization (C++03 and up); {} (C++11 and up)
23029 means value-initialization or aggregate-initialization, nothing
23030 means default-initialization. We can only suggest removing the
23031 parentheses/adding {} if T has a default constructor. */
23033 {
23039 {
23043 else
23046 }
23047 }
23048 }
23050 }
23052 /* If we had (...) or the parameter-list wasn't parenthesized,
23053 we're done. */
23057 /* The T t(X()) case. */
23059 {
23061 "parentheses were disambiguated as a function "
23063 {
23065 /* {}-initialization means that we can use an initializer-list
23066 constructor if no default constructor is available, so don't
23067 suggest using {} for classes that have an initializer_list
23068 constructor. */
23070 {
23075 }
23076 else
23077 {
23081 }
23082 }
23083 }
23084 /* The T t(X(), X()) case. */
23086 "parentheses were disambiguated as a function "
23088 {
23091 {
23096 }
23097 }
23098 }
23100 /* If DECLARATOR with DECL_SPECS is a function declarator that has
23101 the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
23102 has the same meaning as in cp_parser_declarator. */
23104 static void
23109 {
23115 {
23123 {
23127 }
23128 }
23129 }
23131 /* Declarators [gram.dcl.decl] */
23133 /* Parse an init-declarator.
23135 init-declarator:
23136 declarator initializer [opt]
23138 GNU Extension:
23140 init-declarator:
23141 declarator asm-specification [opt] attributes [opt] initializer [opt]
23143 function-definition:
23144 decl-specifier-seq [opt] declarator ctor-initializer [opt]
23145 function-body
23146 decl-specifier-seq [opt] declarator function-try-block
23148 GNU Extension:
23150 function-definition:
23151 __extension__ function-definition
23153 TM Extension:
23155 function-definition:
23156 decl-specifier-seq [opt] declarator function-transaction-block
23158 The parser flags FLAGS is used to control type-specifier parsing.
23160 The DECL_SPECIFIERS apply to this declarator. Returns a
23161 representation of the entity declared. If MEMBER_P is TRUE, then
23162 this declarator appears in a class scope. The new DECL created by
23163 this declarator is returned.
23165 The CHECKS are access checks that should be performed once we know
23166 what entity is being declared (and, therefore, what classes have
23167 befriended it).
23169 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
23170 for a function-definition here as well. If the declarator is a
23171 declarator for a function-definition, *FUNCTION_DEFINITION_P will
23172 be TRUE upon return. By that point, the function-definition will
23173 have been completely parsed.
23175 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
23176 is FALSE.
23178 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
23179 parsed declaration if it is an uninitialized single declarator not followed
23180 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
23181 if present, will not be consumed. If returned, this declarator will be
23182 created with SD_INITIALIZED but will not call cp_finish_decl.
23184 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
23185 and there is an initializer, the pointed location_t is set to the
23186 location of the '=' or `(', or '{' in C++11 token introducing the
23187 initializer. */
23189 static tree
23191 cp_parser_flags flags,
23201 {
23205 tree prefix_attributes;
23207 tree asm_specification;
23208 tree initializer;
23210 tree scope;
23212 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
23213 initialized with "= ..", CPP_OPEN_PAREN if initialized with
23214 "(...)". */
23229 /* Assume that this is not the declarator for a function
23230 definition. */
23234 /* Default arguments are only permitted for function parameters. */
23238 /* Defer access checks while parsing the declarator; we cannot know
23239 what names are accessible until we know what is being
23240 declared. */
23245 /* Parse the declarator. */
23246 declarator
23251 /* Gather up the deferred checks. */
23256 /* If the DECLARATOR was erroneous, there's no need to go
23257 further. */
23261 /* Check that the number of template-parameter-lists is OK. */
23271 /* Figure out what scope the entity declared by the DECLARATOR is
23272 located in. `grokdeclarator' sometimes changes the scope, so
23273 we compute it now. */
23276 /* Perform any lookups in the declared type which were thought to be
23277 dependent, but are not in the scope of the declarator. */
23278 decl_specifiers->type
23281 /* If we're allowing GNU extensions, look for an
23282 asm-specification. */
23284 {
23285 /* Look for an asm-specification. */
23288 }
23289 else
23292 /* Gather the attributes that were provided with the
23293 decl-specifiers. */
23296 /* Look for attributes. */
23300 /* Peek at the next token. */
23306 {
23307 /* Handle C++17 deduction guides. Note that class-scope
23308 non-template deduction guides are instead handled in
23309 cp_parser_member_declaration. */
23311 decl_specifiers,
23312 declarator,
23318 /* Check to see if the token indicates the start of a
23319 function-definition. */
23321 {
23323 {
23324 /* If a function-definition should not appear here, issue an
23325 error message. */
23329 }
23331 location_t func_brace_location
23334 /* Neither attributes nor an asm-specification are allowed
23335 on a function-definition. */
23338 "an %<asm%> specification is not allowed "
23342 "attributes are not allowed "
23344 /* This is a function-definition. */
23347 /* Parse the function definition. */
23350 decl_specifiers,
23351 declarator,
23352 prefix_attributes);
23353 else
23354 decl =
23355 (cp_parser_function_definition_from_specifiers_and_declarator
23359 {
23360 /* This is where the prologue starts... */
23363 }
23366 }
23367 }
23369 {
23370 /* A non-template declaration involving a function parameter list
23371 containing an implicit template parameter will be made into a
23372 template. If the resulting declaration is not going to be an
23373 actual function then finish the template scope here to prevent it.
23374 An error message will be issued once we have a decl to talk about.
23376 FIXME probably we should do type deduction rather than create an
23377 implicit template, but the standard currently doesn't allow it. */
23380 }
23382 /* [dcl.dcl]
23384 Only in function declarations for constructors, destructors, type
23385 conversions, and deduction guides can the decl-specifier-seq be omitted.
23387 We explicitly postpone this check past the point where we handle
23388 function-definitions because we tolerate function-definitions
23389 that are missing their return types in some modes. */
23391 {
23395 }
23397 /* An `=' or an '{' in C++11, indicate an initializer. An '(' may indicate
23398 an initializer as well. */
23402 {
23403 /* Don't get fooled into thinking that F(i)(1)(2) is an initializer.
23404 It isn't; it's an expression. (Here '(i)' would have already been
23405 parsed as a declarator.) */
23408 {
23415 /* If this is an initializer, only a ',' or ';' can follow: either
23416 we have another init-declarator, or we're at the end of an
23417 init-declarator-list which can only be followed by a ';'. */
23422 /* Not an init-declarator. */
23424 }
23436 {
23442 }
23443 }
23444 else
23445 {
23446 /* If the init-declarator isn't initialized and isn't followed by a
23447 `,' or `;', it's not a valid init-declarator. */
23450 {
23453 else
23454 {
23458 }
23459 }
23462 }
23464 /* Because start_decl has side-effects, we should only call it if we
23465 know we're going ahead. By this point, we know that we cannot
23466 possibly be looking at any other construct. */
23469 /* Enter the newly declared entry in the symbol table. If we're
23470 processing a declaration in a class-specifier, we wait until
23471 after processing the initializer. */
23473 {
23481 /* Adjust location of decl if declarator->id_loc is more appropriate:
23482 set, and decl wasn't merged with another decl, in which case its
23483 location would be different from input_location, and more accurate. */
23488 }
23490 /* Enter the SCOPE. That way unqualified names appearing in the
23491 initializer will be looked up in SCOPE. */
23494 /* Perform deferred access control checks, now that we know in which
23495 SCOPE the declared entity resides. */
23497 {
23500 /* If the entity being declared is a function, pretend that we
23501 are in its scope. If it is a `friend', it may have access to
23502 things that would not otherwise be accessible. */
23504 {
23507 }
23509 /* Perform access checks for template parameters. */
23512 /* Perform the access control checks for the declarator and the
23513 decl-specifiers. */
23516 /* Restore the saved value. */
23519 }
23521 /* Parse the initializer. */
23526 {
23528 {
23531 else
23532 {
23533 /* If the declaration was erroneous, we don't really
23534 know what the user intended, so just silently
23535 consume the initializer. */
23542 }
23543 }
23544 else
23545 {
23546 /* We want to record the extra mangling scope for in-class
23547 initializers of class members and initializers of static
23548 data member templates and namespace-scope initializers.
23549 The former involves deferring parsing of the initializer
23550 until end of class as with default arguments. So right
23551 here we only handle the latter two. */
23555 && !member_p
23568 }
23569 }
23571 /* The old parser allows attributes to appear after a parenthesized
23572 initializer. Mark Mitchell proposed removing this functionality
23573 on the GCC mailing lists on 2002-08-13. This parser accepts the
23574 attributes -- but ignores them. Made a permerror in GCC 8. */
23580 {
23583 {
23587 }
23588 }
23590 /* And now complain about a non-function implicit template. */
23595 /* For an in-class declaration, use `grokfield' to create the
23596 declaration. */
23598 {
23600 {
23603 }
23612 }
23614 /* Finish processing the declaration. But, skip member
23615 declarations. */
23617 {
23620 asm_specification,
23621 /* If the initializer is in parentheses, then this is
23622 a direct-initialization, which means that an
23623 `explicit' constructor is OK. Otherwise, an
23624 `explicit' constructor cannot be used. */
23627 }
23630 /* Core issue #226 (C++0x only): A default template-argument
23631 shall not be specified in a friend class template
23632 declaration. */
23641 {
23644 else
23646 }
23653 }
23655 /* Parse a declarator.
23657 declarator:
23658 direct-declarator
23659 ptr-operator declarator
23661 abstract-declarator:
23662 ptr-operator abstract-declarator [opt]
23663 direct-abstract-declarator
23665 GNU Extensions:
23667 declarator:
23668 attributes [opt] direct-declarator
23669 attributes [opt] ptr-operator declarator
23671 abstract-declarator:
23672 attributes [opt] ptr-operator abstract-declarator [opt]
23673 attributes [opt] direct-abstract-declarator
23675 The parser flags FLAGS is used to control type-specifier parsing.
23677 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
23678 detect constructors, destructors, deduction guides, or conversion operators.
23679 It is set to -1 if the declarator is a name, and +1 if it is a
23680 function. Otherwise it is set to zero. Usually you just want to
23681 test for >0, but internally the negative value is used.
23683 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
23684 a decl-specifier-seq unless it declares a constructor, destructor,
23685 or conversion. It might seem that we could check this condition in
23686 semantic analysis, rather than parsing, but that makes it difficult
23687 to handle something like `f()'. We want to notice that there are
23688 no decl-specifiers, and therefore realize that this is an
23689 expression, not a declaration.)
23691 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
23692 the declarator is a direct-declarator of the form "(...)".
23694 MEMBER_P is true iff this declarator is a member-declarator.
23696 FRIEND_P is true iff this declarator is a friend.
23698 STATIC_P is true iff the keyword static was seen. */
23702 cp_parser_declarator_kind dcl_kind,
23703 cp_parser_flags flags,
23707 {
23710 cp_cv_quals cv_quals;
23711 tree class_type;
23714 /* Assume this is not a constructor, destructor, or type-conversion
23715 operator. */
23722 /* Check for the ptr-operator production. */
23724 /* Parse the ptr-operator. */
23730 /* If that worked, then we have a ptr-operator. */
23732 {
23733 /* If a ptr-operator was found, then this declarator was not
23734 parenthesized. */
23737 /* The dependent declarator is optional if we are parsing an
23738 abstract-declarator. */
23742 /* Parse the dependent declarator. */
23748 /* If we are parsing an abstract-declarator, we must handle the
23749 case where the dependent declarator is absent. */
23754 declarator = cp_parser_make_indirect_declarator
23756 }
23757 /* Everything else is a direct-declarator. */
23758 else
23759 {
23762 CPP_OPEN_PAREN);
23766 }
23771 }
23773 /* Parse a direct-declarator or direct-abstract-declarator.
23775 direct-declarator:
23776 declarator-id
23777 direct-declarator ( parameter-declaration-clause )
23778 cv-qualifier-seq [opt]
23779 ref-qualifier [opt]
23780 exception-specification [opt]
23781 direct-declarator [ constant-expression [opt] ]
23782 ( declarator )
23784 direct-abstract-declarator:
23785 direct-abstract-declarator [opt]
23786 ( parameter-declaration-clause )
23787 cv-qualifier-seq [opt]
23788 ref-qualifier [opt]
23789 exception-specification [opt]
23790 direct-abstract-declarator [opt] [ constant-expression [opt] ]
23791 ( abstract-declarator )
23793 Returns a representation of the declarator. DCL_KIND is
23794 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
23795 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
23796 we are parsing a direct-declarator. It is
23797 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
23798 of ambiguity we prefer an abstract declarator, as per
23799 [dcl.ambig.res].
23800 The parser flags FLAGS is used to control type-specifier parsing.
23801 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
23802 as for cp_parser_declarator. */
23806 cp_parser_declarator_kind dcl_kind,
23807 cp_parser_flags flags,
23810 {
23821 {
23822 /* Peek at the next token. */
23825 {
23826 /* This is either a parameter-declaration-clause, or a
23827 parenthesized declarator. When we know we are parsing a
23828 named declarator, it must be a parenthesized declarator
23829 if FIRST is true. For instance, `(int)' is a
23830 parameter-declaration-clause, with an omitted
23831 direct-abstract-declarator. But `((*))', is a
23832 parenthesized abstract declarator. Finally, when T is a
23833 template parameter `(T)' is a
23834 parameter-declaration-clause, and not a parenthesized
23835 named declarator.
23837 We first try and parse a parameter-declaration-clause,
23838 and then try a nested declarator (if FIRST is true).
23840 It is not an error for it not to be a
23841 parameter-declaration-clause, even when FIRST is
23842 false. Consider,
23844 int i (int);
23845 int i (3);
23847 The first is the declaration of a function while the
23848 second is the definition of a variable, including its
23849 initializer.
23851 Having seen only the parenthesis, we cannot know which of
23852 these two alternatives should be selected. Even more
23853 complex are examples like:
23855 int i (int (a));
23856 int i (int (3));
23858 The former is a function-declaration; the latter is a
23859 variable initialization.
23861 Thus again, we try a parameter-declaration-clause, and if
23862 that fails, we back out and return. */
23865 {
23866 tree params;
23871 /* In a member-declarator, the only valid interpretation
23872 of a parenthesis is the start of a
23873 parameter-declaration-clause. (It is invalid to
23874 initialize a static data member with a parenthesized
23875 initializer; only the "=" form of initialization is
23876 permitted.) */
23880 /* Consume the `('. */
23882 matching_parens parens;
23885 {
23886 /* If this is going to be an abstract declarator, we're
23887 in a declarator and we can't have default args. */
23890 }
23894 /* Parse the parameter-declaration-clause. */
23895 params
23897 const location_t parens_end
23900 /* Consume the `)'. */
23903 /* For code like
23904 int x(auto(42));
23905 A a(auto(i), 42);
23906 we have synthesized an implicit template parameter and marked
23907 what we thought was a function as an implicit function template.
23908 But now, having seen the whole parameter list, we know it's not
23909 a function declaration, so undo that. */
23912 /* Don't do this for the inner (). */
23916 /* If all went well, parse the cv-qualifier-seq,
23917 ref-qualifier and the exception-specification. */
23919 {
23920 cp_cv_quals cv_quals;
23921 cp_virt_specifiers virt_specifiers;
23922 cp_ref_qualifier ref_qual;
23923 tree exception_specification;
23924 tree late_return;
23925 tree attrs;
23928 unsigned char local_variables_forbidden_p
23930 /* 'this' is not allowed in static member functions. */
23940 /* Parse the cv-qualifier-seq. */
23942 /* Parse the ref-qualifier. */
23944 /* Parse the tx-qualifier. */
23950 /* DR 1207: 'this' is in scope after the cv-quals. */
23953 /* If it turned out that this is e.g. a pointer to a
23954 function, we don't want to delay noexcept parsing. */
23958 /* Parse the exception-specification. */
23959 exception_specification
23961 flags);
23965 cp_omp_declare_simd_data odsd;
23967 && declarator
23970 {
23974 }
23976 /* In here, we handle cases where attribute is used after
23977 the function declaration. For example:
23978 void func (int x) __attribute__((vector(..))); */
23981 late_return
23983 requires_clause);
23987 /* Parse the virt-specifier-seq. */
23991 parens_start,
23992 parens_end);
23993 /* Create the function-declarator. */
23995 params,
23996 cv_quals,
23997 virt_specifiers,
23998 ref_qual,
23999 tx_qual,
24000 exception_specification,
24001 late_return,
24002 requires_clause,
24003 attrs,
24004 parens_loc);
24006 /* Any subsequent parameter lists are to do with
24007 return type, so are not those of the declared
24008 function. */
24014 /* Restore the state of local_variables_forbidden_p. */
24015 parser->local_variables_forbidden_p
24017 }
24019 /* Remove the function parms from scope. */
24023 /* Repeat the main loop. */
24025 }
24027 /* If this is the first, we can try a parenthesized
24028 declarator. */
24030 {
24037 /* Consume the `('. */
24038 matching_parens parens;
24040 /* Parse the nested declarator. */
24043 declarator
24045 ctor_dtor_or_conv_p,
24051 /* Expect a `)'. */
24059 }
24060 /* Otherwise, we must be done. */
24061 else
24063 }
24067 {
24068 /* Parse an array-declarator. */
24078 /* Consume the `['. */
24080 /* Peek at the next token. */
24082 /* If the next token is `]', then there is no
24083 constant-expression. */
24085 {
24087 bounds
24099 {
24100 /* Normally, the array bound must be an integral constant
24101 expression. However, as an extension, we allow VLAs
24102 in function scopes as long as they aren't part of a
24103 parameter declaration. */
24107 }
24110 {
24111 /* Remember this wasn't a constant-expression. */
24114 }
24115 }
24116 else
24118 /* Look for the closing `]'. */
24120 {
24123 }
24128 }
24130 {
24131 {
24132 tree qualifying_scope;
24133 tree unqualified_name;
24134 tree attrs;
24135 special_function_kind sfk;
24140 /* Parse a declarator-id */
24143 {
24146 /* If we see an ellipsis, we should be looking at a
24147 parameter pack. */
24149 {
24150 /* Consume the `...' */
24154 }
24155 }
24158 unqualified_name
24162 {
24166 {
24167 /* Check whether an error occurred. */
24170 /* We already consumed the ellipsis to mark a
24171 parameter pack, but we have no way to report it,
24172 so abort the tentative parse. We will be exiting
24173 immediately anyway. */
24175 }
24176 else
24182 && (qualifying_scope
24184 {
24187 }
24188 }
24193 {
24198 }
24204 {
24205 /* In the declaration of a member of a template class
24206 outside of the class itself, the SCOPE will sometimes
24207 be a TYPENAME_TYPE. For example, given:
24209 template <typename T>
24210 int S<T>::R::i = 3;
24212 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
24213 this context, we must resolve S<T>::R to an ordinary
24214 type, rather than a typename type.
24216 The reason we normally avoid resolving TYPENAME_TYPEs
24217 is that a specialization of `S' might render
24218 `S<T>::R' not a type. However, if `S' is
24219 specialized, then this `i' will not be used, so there
24220 is no harm in resolving the types here. */
24221 tree type;
24223 /* Resolve the TYPENAME_TYPE. */
24226 /* If that failed, the declarator is invalid. */
24228 {
24231 "cannot define member of dependent typedef "
24233 else
24238 }
24240 }
24245 {
24246 tree class_type;
24251 else
24255 {
24259 {
24260 /* We do not attempt to print the declarator
24261 here because we do not have enough
24262 information about its original syntactic
24263 form. */
24267 }
24270 {
24274 "use %<%T::%D%> instead of %<%T::%D%> to "
24276 class_type,
24281 }
24283 }
24286 {
24293 for an unnamed type, even if the type
24294 got a name for linkage purposes. */
24296 /* Handle correctly (c++/19200):
24298 struct S {
24299 struct T{};
24300 friend void S(T);
24301 };
24303 and also:
24305 namespace N {
24306 void S();
24307 }
24309 struct S {
24310 friend void N::S();
24311 }; */
24314 class_type))
24323 }
24324 }
24326 unqualified_name,
24334 /* We're looking for this case in [temp.res]:
24335 A qualified-id is assumed to name a type if [...]
24336 - it is a decl-specifier of the decl-specifier-seq of a
24337 parameter-declaration in a declarator of a function or
24338 function template declaration, ... */
24344 {
24345 /* ...whose declarator-id is qualified. If it isn't, never
24346 assume the parameters to refer to types. */
24349 else
24350 {
24351 /* Now we have something like
24352 template <typename T> int C::x(S::p);
24353 which can be a function template declaration or a
24354 variable template definition. If name lookup for
24355 the declarator-id C::x finds one or more function
24356 templates, assume S::p to name a type. Otherwise,
24357 don't. */
24358 tree decl
24360 none_type,
24368 /* Allow
24369 template<typename T>
24370 A<T>::A(T::type) { } */
24373 qualifying_scope)))
24375 }
24376 }
24377 }
24379 handle_declarator:;
24382 {
24383 /* Any names that appear after the declarator-id for a
24384 member are looked up in the containing scope. */
24386 {
24387 /* But declarations with qualified-ids can't appear in a
24388 function. */
24392 }
24394 }
24398 /* Default args are only allowed on function
24399 declarations. */
24401 else
24405 }
24406 /* We're done. */
24407 else
24409 }
24411 /* For an abstract declarator, we might wind up with nothing at this
24412 point. That's an error; the declarator is not optional. */
24416 {
24417 /* Record overly parenthesized declarator so we can give a
24418 diagnostic about confusing decl/expr disambiguation. */
24420 {
24421 /* If the open and close parens are on different lines, this
24422 is probably a formatting thing, so ignore. */
24427 }
24432 }
24434 /* If we entered a scope, we must exit it now. */
24442 }
24444 /* Parse a ptr-operator.
24446 ptr-operator:
24447 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24448 * cv-qualifier-seq [opt]
24449 &
24450 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
24451 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24453 GNU Extension:
24455 ptr-operator:
24456 & cv-qualifier-seq [opt]
24458 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
24459 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
24460 an rvalue reference. In the case of a pointer-to-member, *TYPE is
24461 filled in with the TYPE containing the member. *CV_QUALS is
24462 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
24463 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
24464 Note that the tree codes returned by this function have nothing
24465 to do with the types of trees that will be eventually be created
24466 to represent the pointer or reference type being parsed. They are
24467 just constants with suggestive names. */
24468 static enum tree_code
24473 {
24478 /* Assume that it's not a pointer-to-member. */
24480 /* And that there are no cv-qualifiers. */
24483 /* Peek at the next token. */
24486 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
24496 {
24497 /* Consume the `*', `&' or `&&'. */
24500 /* A `*' can be followed by a cv-qualifier-seq, and so can a
24501 `&', if we are allowing GNU extensions. (The only qualifier
24502 that can legally appear after `&' is `restrict', but that is
24503 enforced during semantic analysis. */
24511 }
24512 else
24513 {
24514 /* Try the pointer-to-member case. */
24516 /* Look for the optional `::' operator. */
24519 /* Look for the nested-name specifier. */
24526 /* If we found it, and the next token is a `*', then we are
24527 indeed looking at a pointer-to-member operator. */
24530 {
24531 /* Indicate that the `*' operator was used. */
24539 else
24540 {
24541 /* The type of which the member is a member is given by the
24542 current SCOPE. */
24544 /* The next name will not be qualified. */
24548 /* Look for optional c++11 attributes. */
24552 /* Look for the optional cv-qualifier-seq. */
24554 }
24555 }
24556 /* If that didn't work we don't have a ptr-operator. */
24559 }
24562 }
24564 /* Parse an (optional) cv-qualifier-seq.
24566 cv-qualifier-seq:
24567 cv-qualifier cv-qualifier-seq [opt]
24569 cv-qualifier:
24570 const
24571 volatile
24573 GNU Extension:
24575 cv-qualifier:
24576 __restrict__
24578 Returns a bitmask representing the cv-qualifiers. */
24580 static cp_cv_quals
24582 {
24586 {
24588 cp_cv_quals cv_qualifier;
24590 /* Peek at the next token. */
24592 /* See if it's a cv-qualifier. */
24594 {
24610 }
24616 {
24621 }
24622 else
24623 {
24626 }
24627 }
24630 }
24632 /* Parse an (optional) ref-qualifier
24634 ref-qualifier:
24635 &
24636 &&
24638 Returns cp_ref_qualifier representing ref-qualifier. */
24640 static cp_ref_qualifier
24642 {
24645 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
24650 {
24655 {
24667 }
24672 {
24675 }
24676 else
24677 {
24680 }
24681 }
24684 }
24686 /* Parse an optional tx-qualifier.
24688 tx-qualifier:
24689 transaction_safe
24690 transaction_safe_dynamic */
24692 static tree
24694 {
24697 {
24702 {
24706 {
24709 {
24712 }
24713 else
24715 }
24716 }
24717 }
24719 }
24721 /* Parse an (optional) virt-specifier-seq.
24723 virt-specifier-seq:
24724 virt-specifier virt-specifier-seq [opt]
24726 virt-specifier:
24727 override
24728 final
24730 Returns a bitmask representing the virt-specifiers. */
24732 static cp_virt_specifiers
24734 {
24738 {
24740 cp_virt_specifiers virt_specifier;
24742 /* Peek at the next token. */
24744 /* See if it's a virt-specifier-qualifier. */
24748 {
24751 }
24753 {
24756 }
24758 {
24760 }
24761 else
24765 {
24770 }
24771 else
24772 {
24775 }
24776 }
24778 }
24780 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
24781 is in scope even though it isn't real. */
24783 void
24785 {
24786 tree this_parm;
24789 {
24790 /* We don't clear this between NSDMIs. Is it already what we want? */
24797 }
24800 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
24802 current_class_ref
24805 }
24807 /* Return true iff our current scope is a non-static data member
24808 initializer. */
24810 bool
24812 {
24813 /* We recognize NSDMI context by the context-less 'this' pointer set up
24814 by the function above. */
24820 }
24822 /* True if we're parsing a function declarator. */
24824 bool
24826 {
24827 /* this_entity is NULL for a function parameter scope while parsing the
24828 declarator; it is set when parsing the body of the function. */
24831 }
24833 /* Parse a late-specified return type, if any. This is not a separate
24834 non-terminal, but part of a function declarator, which looks like
24836 -> trailing-type-specifier-seq abstract-declarator(opt)
24838 Returns the type indicated by the type-id.
24840 In addition to this, parse any queued up #pragma omp declare simd
24841 clauses, and #pragma acc routine clauses.
24843 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
24844 function. */
24846 static tree
24849 {
24853 && declarator
24857 && declarator
24860 /* Peek at the next token. */
24862 /* A late-specified return type is indicated by an initial '->'. */
24871 {
24872 /* Consume the ->. */
24876 }
24878 /* Function declarations may be followed by a trailing
24879 requires-clause. */
24883 declarator->attributes
24887 declarator->attributes
24892 }
24894 /* Parse a declarator-id.
24896 declarator-id:
24897 id-expression
24898 :: [opt] nested-name-specifier [opt] type-name
24900 In the `id-expression' case, the value returned is as for
24901 cp_parser_id_expression if the id-expression was an unqualified-id.
24902 If the id-expression was a qualified-id, then a SCOPE_REF is
24903 returned. The first operand is the scope (either a NAMESPACE_DECL
24904 or TREE_TYPE), but the second is still just a representation of an
24905 unqualified-id. */
24907 static tree
24909 {
24910 tree id;
24911 /* The expression must be an id-expression. Assume that qualified
24912 names are the names of types so that:
24914 template <class T>
24915 int S<T>::R::i = 3;
24917 will work; we must treat `S<T>::R' as the name of a type.
24918 Similarly, assume that qualified names are templates, where
24919 required, so that:
24921 template <class T>
24922 int S<T>::R<T>::i = 3;
24924 will work, too. */
24930 optional_p);
24934 }
24936 /* Parse a type-id.
24938 type-id:
24939 type-specifier-seq abstract-declarator [opt]
24941 The parser flags FLAGS is used to control type-specifier parsing.
24943 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
24945 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24946 i.e. we've just seen "->".
24948 Returns the TYPE specified. */
24950 static tree
24954 {
24955 cp_decl_specifier_seq type_specifier_seq;
24958 /* Parse the type-specifier-seq. */
24961 is_trailing_return,
24969 /* A bare template name as a template argument is a template template
24970 argument, not a placeholder, so fail parsing it as a type argument. */
24971 {
24975 }
24979 /* There might or might not be an abstract declarator. */
24981 /* Look for the declarator. */
24982 abstract_declarator
24989 /* Check to see if there really was a declarator. */
24994 /* The concepts TS allows 'auto' as a type-id. */
24997 /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
24998 outside the template-argument-list context here only for the sake of
24999 diagnostic: grokdeclarator then can emit a better error message for
25000 e.g. using T = auto. */
25006 && !auto_typeid_ok
25007 /* None of the valid uses of 'auto' in C++14 involve the type-id
25008 nonterminal, but it is valid in a trailing-return-type. */
25011 {
25012 /* A type-id with type 'auto' is only ok if the abstract declarator
25013 is a function declarator with a late-specified return type.
25015 A type-id with 'auto' is also valid in a trailing-return-type
25016 in a compound-requirement. */
25023 else
25024 {
25026 {
25029 {
25030 auto_diagnostic_group g;
25034 tmpl);
25036 tmpl);
25037 }
25040 auto_node);
25041 else
25043 }
25045 }
25046 }
25049 is_template_arg);
25050 }
25052 /* Wrapper for cp_parser_type_id_1. */
25054 static tree
25057 {
25059 }
25061 /* Wrapper for cp_parser_type_id_1. */
25063 static tree
25065 {
25066 tree r;
25068 parser->type_definition_forbidden_message
25073 }
25075 /* Wrapper for cp_parser_type_id_1. */
25077 static tree
25079 {
25082 }
25084 /* Parse a type-specifier-seq.
25086 type-specifier-seq:
25087 type-specifier type-specifier-seq [opt]
25089 GNU extension:
25091 type-specifier-seq:
25092 attributes type-specifier-seq [opt]
25094 The parser flags FLAGS is used to control type-specifier parsing.
25096 If IS_DECLARATION is true, we are at the start of a "condition" or
25097 exception-declaration, so we might be followed by a declarator-id.
25099 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
25100 i.e. we've just seen "->".
25102 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
25104 static void
25106 cp_parser_flags flags,
25110 {
25114 /* Clear the TYPE_SPECIFIER_SEQ. */
25118 /* In the context of a trailing return type, enum E { } is an
25119 elaborated-type-specifier followed by a function-body, not an
25120 enum-specifier. */
25124 /* Parse the type-specifiers and attributes. */
25126 {
25127 tree type_specifier;
25130 /* Check for attributes first. */
25132 {
25133 /* GNU attributes at the end of a declaration apply to the
25134 declaration as a whole, not to the trailing return type. So look
25135 ahead to see if these attributes are at the end. */
25138 {
25144 }
25145 type_specifier_seq->attributes
25149 }
25151 /* record the token of the beginning of the type specifier seq,
25152 for error reporting purposes*/
25156 /* Look for the type-specifier. */
25158 flags,
25159 type_specifier_seq,
25161 NULL,
25164 {
25165 /* If the first type-specifier could not be found, this is not a
25166 type-specifier-seq at all. */
25168 {
25169 /* Set in_declarator_p to avoid skipping to the semicolon. */
25181 }
25182 /* If subsequent type-specifiers could not be found, the
25183 type-specifier-seq is complete. */
25185 }
25188 /* The standard says that a condition can be:
25190 type-specifier-seq declarator = assignment-expression
25192 However, given:
25194 struct S {};
25195 if (int S = ...)
25197 we should treat the "S" as a declarator, not as a
25198 type-specifier. The standard doesn't say that explicitly for
25199 type-specifier-seq, but it does say that for
25200 decl-specifier-seq in an ordinary declaration. Perhaps it
25201 would be clearer just to allow a decl-specifier-seq here, and
25202 then add a semantic restriction that if any decl-specifiers
25203 that are not type-specifiers appear, the program is invalid. */
25206 }
25207 }
25209 /* Return whether the function currently being declared has an associated
25210 template parameter list. */
25212 static bool
25214 {
25227 }
25229 /* Parse a parameter-declaration-clause.
25231 parameter-declaration-clause:
25232 parameter-declaration-list [opt] ... [opt]
25233 parameter-declaration-list , ...
25235 The parser flags FLAGS is used to control type-specifier parsing.
25237 Returns a representation for the parameter declarations. A return
25238 value of NULL indicates a parameter-declaration-clause consisting
25239 only of an ellipsis. */
25241 static tree
25243 cp_parser_flags flags)
25244 {
25245 tree parameters;
25253 && !processing_template_parmlist
25254 && !processing_explicit_instantiation
25255 /* default_arg_ok_p tracks whether this is a parameter-clause for an
25256 actual function or a random abstract declarator. */
25262 /* Peek at the next token. */
25264 /* Check for trivial parameter-declaration-clauses. */
25266 {
25267 /* Consume the `...' token. */
25270 }
25272 /* There are no parameters. */
25274 /* Check for `(void)', too, which is a special case. */
25278 {
25279 /* Consume the `void' token. */
25281 /* There are no parameters. */
25283 }
25285 /* A vector of parameters that haven't been pushed yet. */
25288 /* Parse the parameter-declaration-list. */
25291 /* If a parse error occurred while parsing the
25292 parameter-declaration-list, then the entire
25293 parameter-declaration-clause is erroneous. */
25297 /* Peek at the next token. */
25299 /* If it's a `,', the clause should terminate with an ellipsis. */
25301 {
25302 /* Consume the `,'. */
25304 /* Expect an ellipsis. */
25305 ellipsis_p
25307 }
25308 /* It might also be `...' if the optional trailing `,' was
25309 omitted. */
25311 {
25312 /* Consume the `...' token. */
25314 /* And remember that we saw it. */
25316 }
25317 else
25320 /* A valid parameter-declaration-clause can only be followed by a ')'.
25321 So it's time to push all the parameters we have seen now that we
25322 know we have a valid declaration. Note that here we may not have
25323 committed yet, nor should we. Pushing here will detect the error
25324 of redefining a parameter. */
25326 {
25330 /* Delayed checking of auto parameters. */
25335 {
25339 }
25340 }
25342 /* Finish the parameter list. */
25347 }
25349 /* Parse a parameter-declaration-list.
25351 parameter-declaration-list:
25352 parameter-declaration
25353 parameter-declaration-list , parameter-declaration
25355 The parser flags FLAGS is used to control type-specifier parsing.
25356 PENDING_DECLS is a vector of parameters that haven't been pushed yet.
25358 Returns a representation of the parameter-declaration-list, as for
25359 cp_parser_parameter_declaration_clause. However, the
25360 `void_list_node' is never appended to the list. */
25362 static tree
25364 cp_parser_flags flags,
25366 {
25372 /* The special considerations that apply to a function within an
25373 unbraced linkage specifications do not apply to the parameters
25374 to the function. */
25375 saved_in_unbraced_linkage_specification_p
25379 /* Look for more parameters. */
25381 {
25386 /* Parse the parameter. */
25387 parameter
25392 /* We don't know yet if the enclosing context is unavailable or deprecated,
25393 so wait and deal with it in grokparms if appropriate. */
25397 {
25400 PARM,
25405 }
25409 /* If a parse error occurred parsing the parameter declaration,
25410 then the entire parameter-declaration-list is erroneous. */
25412 {
25415 }
25422 {
25423 /* We cannot always pushdecl while parsing tentatively because
25424 it may have side effects and we can't be sure yet if we're
25425 parsing a declaration, e.g.:
25427 S foo(int(x), int(x), int{x});
25429 where it's not clear if we're dealing with a constructor call
25430 or a function declaration until we've seen the last argument
25431 which breaks it up.
25432 It's safe to pushdecl so long as it doesn't result in a clash
25433 with an already-pushed parameter. But we don't delay pushing
25434 different parameters to handle
25436 S foo(int(i), decltype(i) j = 42);
25438 which is valid. */
25441 /* See if PARAMETERS already contains a parameter with the same
25442 DECL_NAME as DECL. */
25448 }())
25450 else
25452 }
25455 {
25459 }
25461 /* Add the new parameter to the list. */
25465 /* If the parameters were parenthesized, it's the case of
25466 T foo(X(x)) which looks like a variable definition but
25467 is a function declaration. */
25471 /* Peek at the next token. */
25474 /* These are for Objective-C++ */
25477 /* The parameter-declaration-list is complete. */
25480 {
25483 /* Peek at the next token. */
25485 /* If it's an ellipsis, then the list is complete. */
25488 /* Otherwise, there must be more parameters. Consume the
25489 `,'. */
25491 /* When parsing something like:
25493 int i(float f, double d)
25495 we can tell after seeing the declaration for "f" that we
25496 are not looking at an initialization of a variable "i",
25497 but rather at the declaration of a function "i".
25499 Due to the fact that the parsing of template arguments
25500 (as specified to a template-id) requires backtracking we
25501 cannot use this technique when inside a template argument
25502 list. */
25506 /* However, a parameter-declaration of the form
25507 "float(f)" (which is a valid declaration of a
25508 parameter "f") can also be interpreted as an
25509 expression (the conversion of "f" to "float"). */
25512 }
25513 else
25514 {
25522 }
25523 }
25525 parser->in_unbraced_linkage_specification_p
25528 /* Reset implicit_template_scope if we are about to leave the function
25529 parameter list that introduced it. Note that for out-of-line member
25530 definitions, there will be one or more class scopes before we get to
25531 the template parameter scope. */
25535 {
25539 {
25542 }
25543 }
25546 }
25548 /* Parse a parameter declaration.
25550 parameter-declaration:
25551 decl-specifier-seq ... [opt] declarator
25552 decl-specifier-seq declarator = assignment-expression
25553 decl-specifier-seq ... [opt] abstract-declarator [opt]
25554 decl-specifier-seq abstract-declarator [opt] = assignment-expression
25556 The parser flags FLAGS is used to control type-specifier parsing.
25558 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
25559 declares a template parameter. (In that case, a non-nested `>'
25560 token encountered during the parsing of the assignment-expression
25561 is not interpreted as a greater-than operator.)
25563 Returns a representation of the parameter, or NULL if an error
25564 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
25565 true iff the declarator is of the form "(p)". */
25569 cp_parser_flags flags,
25572 {
25574 cp_decl_specifier_seq decl_specifiers;
25576 tree default_argument;
25581 /* In a template parameter, `>' is not an operator.
25583 [temp.param]
25585 When parsing a default template-argument for a non-type
25586 template-parameter, the first non-nested `>' is taken as the end
25587 of the template parameter-list rather than a greater-than
25588 operator. */
25590 /* Type definitions may not appear in parameter types. */
25592 parser->type_definition_forbidden_message
25599 /* Parse the declaration-specifiers. */
25602 flags,
25606 /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form
25607 type-constraint opt auto can be used as a decl-specifier of the
25608 decl-specifier-seq of a parameter-declaration of a function declaration
25609 or lambda-expression..." but we must not synthesize an implicit template
25610 type parameter in its declarator. That is, in "void f(auto[auto{10}]);"
25611 we want to synthesize only the first auto. */
25615 /* Complain about missing 'typename' or other invalid type names. */
25620 /* If an error occurred, there's no reason to attempt to parse the
25621 rest of the declaration. */
25623 {
25626 }
25628 /* Peek at the next token. */
25631 /* If the next token is a `)', `,', `=', `>', or `...', then there
25632 is no declarator. However, when variadic templates are enabled,
25633 there may be a declarator following `...'. */
25638 {
25642 }
25643 /* Otherwise, there should be a declarator. */
25644 else
25645 {
25649 /* After seeing a decl-specifier-seq, if the next token is not a
25650 "(" or "{", there is no possibility that the code is a valid
25651 expression. Therefore, if parsing tentatively, we commit at
25652 this point. */
25654 /* In an expression context, having seen:
25656 (int((char ...
25658 we cannot be sure whether we are looking at a
25659 function-type (taking a "char" as a parameter) or a cast
25660 of some object of type "char" to "int". */
25664 {
25666 {
25669 /* This is a CTAD expression, not a parameter declaration. */
25671 }
25672 else
25674 }
25675 /* Parse the declarator. */
25678 CP_PARSER_DECLARATOR_EITHER,
25679 CP_PARSER_FLAGS_NONE,
25681 parenthesized_p,
25686 /* After the declarator, allow more attributes. */
25687 decl_specifiers.attributes
25691 /* If the declarator is a template parameter pack, remember that and
25692 clear the flag in the declarator itself so we don't get errors
25693 from grokdeclarator. */
25695 {
25698 }
25699 }
25701 /* If the next token is an ellipsis, and we have not seen a declarator
25702 name, and if either the type of the declarator contains parameter
25703 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
25704 for, eg, abbreviated integral type names), then we actually have a
25705 parameter pack expansion expression. Otherwise, leave the ellipsis
25706 for a C-style variadic function. */
25709 /* If a function parameter pack was specified and an implicit template
25710 parameter was introduced during cp_parser_parameter_declaration,
25711 change any implicit parameters introduced into packs. */
25716 {
25724 }
25727 {
25738 {
25739 /* Consume the `...'. */
25743 /* Build a pack expansion type */
25748 else
25750 }
25751 }
25753 /* The restriction on defining new types applies only to the type
25754 of the parameter, not to the default argument. */
25757 /* If the next token is `=', then process a default argument. */
25759 {
25762 /* Used for diagnostics with an xobj parameter. */
25766 /* If we are defining a class, then the tokens that make up the
25767 default argument must be saved and processed later. */
25773 /* A constrained-type-specifier may declare a type
25774 template-parameter. */
25776 default_argument
25779 /* A constrained-type-specifier may declare a
25780 template-template-parameter. */
25782 default_argument
25785 /* Outside of a class definition, we can just parse the
25786 assignment-expression. */
25787 else
25788 default_argument
25792 {
25794 "default arguments are only "
25796 }
25798 || template_parameter_pack_p
25801 {
25802 /* Find the name of the parameter pack. */
25809 template_parm_p
25815 else
25817 template_parm_p
25824 }
25825 }
25826 else
25833 {
25835 {
25836 /* If there is a default_argument, eq_token should always be set. */
25838 location_t param_with_init_loc
25841 input_location);
25843 "an explicit object parameter "
25845 }
25846 /* Xobj parameters can not have default arguments, thus
25847 we can reuse the default argument field to flag the param as such. */
25849 }
25851 /* Generate a location for the parameter, ranging from the start of the
25852 initial token to the end of the final token (using input_location for
25853 the latter, set up by cp_lexer_set_source_position_from_token when
25854 consuming tokens).
25856 If we have a identifier, then use it for the caret location, e.g.
25858 extern int callee (int one, int (*two)(int, int), float three);
25859 ~~~~~~^~~~~~~~~~~~~~
25861 otherwise, reuse the start location for the caret location e.g.:
25863 extern int callee (int one, int (*)(int, int), float three);
25864 ^~~~~~~~~~~~~~~~~
25866 */
25872 input_location);
25875 declarator,
25876 default_argument,
25877 param_loc,
25878 template_parameter_pack_p);
25879 }
25881 /* Parse a default argument and return it.
25883 TEMPLATE_PARM_P is true if this is a default argument for a
25884 non-type template parameter. */
25885 static tree
25887 {
25892 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
25893 set correctly. */
25900 /* Local variable names (and the `this' keyword) may not
25901 appear in a default argument. */
25904 /* Parse the assignment-expression. */
25909 /* The "this" pointer is not valid in a default argument. */
25911 {
25916 }
25918 /* Restore the "this" pointer. */
25920 {
25923 }
25932 }
25934 /* Parse a function-body.
25936 function-body:
25937 compound_statement */
25939 static void
25941 {
25945 }
25947 /* Parse a ctor-initializer-opt followed by a function-body. Return
25948 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
25949 is true we are parsing a function-try-block. */
25951 static void
25954 {
25956 const bool check_body_p
25964 {
25967 "function-try-block body of %<constexpr%> constructor only "
25969 else
25971 "function-try-block body of %<constexpr%> function only "
25973 }
25975 /* Begin the function body. */
25977 /* Parse the optional ctor-initializer. */
25980 /* If we're parsing a constexpr constructor definition, we need
25981 to check that the constructor body is indeed empty. However,
25982 before we get to cp_parser_function_body lot of junk has been
25983 generated, so we can't just check that we have an empty block.
25984 Rather we take a snapshot of the outermost block, and check whether
25985 cp_parser_function_body changed its state. */
25987 {
25991 }
25992 /* Parse the function-body. */
25996 /* Finish the function body. */
25998 }
26000 /* Parse an initializer.
26002 initializer:
26003 = initializer-clause
26004 ( expression-list )
26006 Returns an expression representing the initializer. If no
26007 initializer is present, NULL_TREE is returned.
26009 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
26010 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
26011 set to TRUE if there is no initializer present. If there is an
26012 initializer, and it is not a constant-expression, *NON_CONSTANT_P
26013 is set to true; otherwise it is set to false. */
26015 static tree
26018 {
26020 tree init;
26022 /* Peek at the next token. */
26025 /* Let our caller know whether or not this initializer was
26026 parenthesized. */
26029 /* Assume that the initializer is constant. */
26034 {
26035 /* Consume the `='. */
26037 /* Parse the initializer-clause. */
26039 }
26041 {
26046 non_constant_p);
26051 }
26053 {
26058 }
26059 else
26060 {
26061 /* Anything else is an error. */
26064 }
26070 }
26072 /* Parse an initializer-clause.
26074 initializer-clause:
26075 assignment-expression
26076 braced-init-list
26078 Returns an expression representing the initializer.
26080 If the `assignment-expression' production is used the value
26081 returned is simply a representation for the expression.
26083 Otherwise, calls cp_parser_braced_list. */
26085 static cp_expr
26087 {
26088 cp_expr initializer;
26090 /* Assume the expression is constant. */
26094 /* If it is not a `{', then we are looking at an
26095 assignment-expression. */
26097 {
26098 initializer
26101 non_constant_p);
26102 }
26103 else
26107 }
26109 /* Parse a brace-enclosed initializer list.
26111 braced-init-list:
26112 { initializer-list , [opt] }
26113 { designated-initializer-list , [opt] }
26114 { }
26116 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
26117 the elements of the initializer-list (or NULL, if the last
26118 production is used). The TREE_TYPE for the CONSTRUCTOR will be
26119 NULL_TREE. There is no way to detect whether or not the optional
26120 trailing `,' was provided. NON_CONSTANT_P is as for
26121 cp_parser_initializer. */
26123 static cp_expr
26125 {
26126 tree initializer;
26130 /* Consume the `{' token. */
26131 matching_braces braces;
26133 /* Create a CONSTRUCTOR to represent the braced-initializer. */
26135 /* If it's not a `}', then there is a non-trivial initializer. */
26137 {
26139 /* Parse the initializer list. */
26143 /* A trailing `,' token is allowed. */
26146 }
26149 /* Now, there should be a trailing `}'. */
26156 /* Build a location of the form:
26157 { ... }
26158 ^~~~~~~
26159 with caret==start at the open brace, finish at the close brace. */
26163 }
26165 /* Consume tokens up to, but not including, the next non-nested closing `]'.
26166 Returns true iff we found a closing `]'. */
26168 static bool
26170 {
26174 {
26178 {
26182 /* FALLTHRU */
26185 /* If we've run out of tokens, then there is no closing `]'. */
26199 }
26201 /* Consume the current token, skipping it. */
26203 }
26204 }
26206 /* Consume tokens up to, and including, the next non-nested closing `]'.
26207 Returns true iff we found a closing `]'. */
26209 static bool
26211 {
26216 }
26218 /* Return true if we are looking at an array-designator, false otherwise. */
26220 static bool
26222 {
26223 /* Consume the `['. */
26228 /* Skip tokens until the next token is a closing square bracket.
26229 If we find the closing `]', and the next token is a `=', then
26230 we are looking at an array designator. */
26231 bool array_designator_p
26235 /* Roll back the tokens we skipped. */
26239 }
26241 /* Parse an initializer-list.
26243 initializer-list:
26244 initializer-clause ... [opt]
26245 initializer-list , initializer-clause ... [opt]
26247 C++20 Extension:
26249 designated-initializer-list:
26250 designated-initializer-clause
26251 designated-initializer-list , designated-initializer-clause
26253 designated-initializer-clause:
26254 designator brace-or-equal-initializer
26256 designator:
26257 . identifier
26259 GNU Extension:
26261 initializer-list:
26262 designation initializer-clause ...[opt]
26263 initializer-list , designation initializer-clause ...[opt]
26265 designation:
26266 . identifier =
26267 identifier :
26268 [ constant-expression ] =
26270 Returns a vec of constructor_elt. The VALUE of each elt is an expression
26271 for the initializer. If the INDEX of the elt is non-NULL, it is the
26272 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
26273 as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
26274 are any designators. */
26279 {
26284 /* Assume all of the expressions are constant. */
26291 /* Parse the rest of the list. */
26293 {
26295 tree designator;
26296 tree initializer;
26301 /* Handle the C++20 syntax, '. id ='. */
26309 {
26312 "C++ designated initializers only available with "
26314 /* Consume the `.'. */
26316 /* Consume the identifier. */
26319 /* Consume the `='. */
26321 else
26323 }
26324 /* Also, if the next token is an identifier and the following one is a
26325 colon, we are looking at the GNU designated-initializer
26326 syntax. */
26331 {
26332 /* Warn the user that they are using an extension. */
26335 /* Consume the identifier. */
26337 /* Consume the `:'. */
26339 }
26340 /* Also handle C99 array designators, '[ const ] ='. */
26344 {
26345 /* In C++11, [ could start a lambda-introducer. */
26351 {
26354 }
26355 else
26356 {
26361 }
26366 && (!require_potential_rvalue_constant_expression
26370 /* Warn the user that they are using an extension. */
26373 }
26374 else
26378 {
26381 }
26385 {
26389 }
26393 /* Parse the initializer. */
26396 ? &clause_non_constant_p
26398 /* If any clause is non-constant, so is the entire initializer. */
26403 /* This uses |= rather than = because C_I_D_I could have been set in
26404 cp_parser_functional_cast so we must be careful not to clear the
26405 flag. */
26408 /* If we have an ellipsis, this is an initializer pack
26409 expansion. */
26411 {
26414 /* Consume the `...'. */
26421 /* Turn the initializer into an initializer expansion. */
26423 }
26425 /* Add it to the vector. */
26428 /* If the next token is not a comma, we have reached the end of
26429 the list. */
26433 /* Peek at the next token. */
26435 /* If the next token is a `}', then we're still done. An
26436 initializer-clause can have a trailing `,' after the
26437 initializer-list and before the closing `}'. */
26441 /* Suppress location wrappers in a long initializer to save memory
26442 (14179). The cutoff is chosen arbitrarily. */
26446 /* Look one level down because it's easy. Looking deeper would require
26447 passing down a nelts pointer, and I don't think multi-level massive
26448 initializers are common enough to justify this. */
26454 /* Consume the `,' token. */
26456 }
26458 /* The same identifier shall not appear in multiple designators
26459 of a designated-initializer-list. */
26461 {
26466 {
26468 {
26470 "%<.%s%> designator used multiple times in "
26474 }
26475 else
26477 }
26481 }
26487 }
26489 /* Classes [gram.class] */
26491 /* Parse a class-name.
26493 class-name:
26494 identifier
26495 template-id
26497 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
26498 to indicate that names looked up in dependent types should be
26499 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
26500 keyword has been used to indicate that the name that appears next
26501 is a template. TAG_TYPE indicates the explicit tag given before
26502 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
26503 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
26504 is the class being defined in a class-head. If ENUM_OK is TRUE,
26505 enum-names are also accepted.
26507 Returns the TYPE_DECL representing the class. */
26509 static tree
26518 {
26519 tree decl;
26522 /* All class-names start with an identifier. */
26525 {
26528 }
26530 /* PARSER->SCOPE can be cleared when parsing the template-arguments
26531 to a template-id, so we save it here. Consider object scope too,
26532 so that make_typename_type below can use it (cp_parser_template_name
26533 considers object scope also). This may happen with code like
26535 p->template A<T>::a()
26537 where we first want to look up A<T>::a in the class of the object
26538 expression, as per [basic.lookup.classref]. */
26540 /* This only checks parser->scope to avoid duplicate errors; if
26541 ->object_type is erroneous, go on to give a parse error. */
26545 /* Any name names a type if we're following the `typename' keyword
26546 in a qualified name where the enclosing scope is type-dependent. */
26551 /* Handle the common case (an identifier, but not a template-id)
26552 efficiently. */
26555 {
26559 /* Look for the identifier. */
26563 /* If the next token isn't an identifier, we are certainly not
26564 looking at a class-name. */
26567 /* If we know this is a type-name, there's no need to look it
26568 up. */
26571 else
26572 {
26573 tree ambiguous_decls;
26574 /* If we already know that this lookup is ambiguous, then
26575 we've already issued an error message; there's no reason
26576 to check again. */
26578 {
26581 }
26582 /* If the next token is a `::', then the name must be a type
26583 name.
26585 [basic.lookup.qual]
26587 During the lookup for a name preceding the :: scope
26588 resolution operator, object, function, and enumerator
26589 names are ignored. */
26592 /* Look up the name. */
26594 tag_type,
26597 check_dependency_p,
26601 {
26605 }
26606 }
26607 }
26608 else
26609 {
26610 /* Try a template-id. */
26612 check_dependency_p,
26613 tag_type,
26614 is_declaration);
26617 }
26621 /* If this is a typename, create a TYPENAME_TYPE. */
26623 {
26628 }
26632 /* Check to see that it is really the name of a class. */
26636 /* Situations like this:
26638 template <typename T> struct A {
26639 typename T::template X<int>::I i;
26640 };
26642 are problematic. Is `T::template X<int>' a class-name? The
26643 standard does not seem to be definitive, but there is no other
26644 valid interpretation of the following `::'. Therefore, those
26645 names are considered class-names. */
26646 {
26650 }
26655 /* In Objective-C 2.0, a classname followed by '.' starts a
26656 dot-syntax expression, and it's not a type-name. */
26668 }
26670 /* Make sure that any member-function parameters are in scope.
26671 For instance, a function's noexcept-specifier can use the function's
26672 parameters:
26674 struct S {
26675 void fn (int p) noexcept(noexcept(p));
26676 };
26678 so we need to make sure name lookup can find them. This is used
26679 when we delay parsing of the noexcept-specifier. */
26681 static void
26683 {
26690 {
26694 }
26695 }
26697 /* Undo the effects of inject_parm_decls. */
26699 static void
26701 {
26704 }
26706 /* Parse a class-specifier.
26708 class-specifier:
26709 class-head { member-specification [opt] }
26711 Returns the TREE_TYPE representing the class. */
26713 tree
26715 {
26718 tree type;
26732 /* Parse the class-head. */
26735 /* If the class-head was a semantic disaster, skip the entire body
26736 of the class. */
26738 {
26742 }
26744 /* Look for the `{'. */
26745 matching_braces braces;
26747 {
26750 }
26755 /* Issue an error message if type-definitions are forbidden here. */
26757 /* Remember that we are defining one more class. */
26759 /* Inside the class, surrounding template-parameter-lists do not
26760 apply. */
26761 saved_num_template_parameter_lists
26764 /* We are not in a function body. */
26767 /* Or in a loop. */
26770 /* Or in a switch. */
26773 /* We are not immediately inside an extern "lang" block. */
26774 saved_in_unbraced_linkage_specification_p
26777 /* 'this' from an enclosing non-static member function is unavailable. */
26783 /* Start the class. */
26785 {
26787 /* SCOPE must be a scope nested inside current scope. */
26791 else
26793 }
26797 /* If the type is erroneous, skip the entire body of the class. */
26799 else
26800 /* Parse the member-specification. */
26803 /* Look for the trailing `}'. */
26805 /* Look for trailing attributes to apply to this class. */
26813 /* We've finished a type definition. Check for the common syntax
26814 error of forgetting a semicolon after the definition. We need to
26815 be careful, as we can't just check for not-a-semicolon and be done
26816 with it; the user might have typed:
26818 class X { } c = ...;
26819 class X { } *p = ...;
26821 and so forth. Instead, enumerate all the possible tokens that
26822 might follow this production; if we don't see one of them, then
26823 complain and silently insert the semicolon. */
26824 {
26829 /* Don't try to parse c++11 attributes here. As per the
26830 grammar, that should be a task for
26831 cp_parser_decl_specifier_seq. */
26835 {
26847 /* While it's legal for type qualifiers and storage class
26848 specifiers to follow type definitions in the grammar, only
26849 compiler testsuites contain code like that. Assume that if
26850 we see such code, then what we're really seeing is a case
26851 like:
26853 class X { }
26854 const <type> var = ...;
26856 or
26858 class Y { }
26859 static <type> func (...) ...
26861 i.e. the qualifier or specifier applies to the next
26862 declaration. To do so, however, we need to look ahead one
26863 more token to see if *that* token is a type specifier.
26865 This code could be improved to handle:
26867 class Z { }
26868 static const <type> var = ...; */
26871 {
26874 /* Handling user-defined types here would be nice, but very
26875 tricky. */
26876 want_semicolon
26879 }
26883 }
26885 /* If we don't have a type, then something is very wrong and we
26886 shouldn't try to do anything clever. Likewise for not seeing the
26887 closing brace. */
26889 {
26890 /* Locate the closing brace. */
26891 cp_token_position prev
26896 /* We want to suggest insertion of a ';' immediately *after* the
26897 closing brace, so, if we can, offset the location by 1 column. */
26904 /* If we successfully offset the location, suggest the fix-it. */
26917 else
26920 /* Unget one token and smash it to look as though we encountered
26921 a semicolon in the input stream. */
26926 }
26927 }
26929 /* If this class is not itself within the scope of another class,
26930 then we need to parse the bodies of all of the queued function
26931 definitions. Note that the queued functions defined in a class
26932 are not always processed immediately following the
26933 class-specifier for that class. Consider:
26935 struct A {
26936 struct B { void f() { sizeof (A); } };
26937 };
26939 If `f' were processed before the processing of `A' were
26940 completed, there would be no way to compute the size of `A'.
26941 Note that the nesting we are interested in here is lexical --
26942 not the semantic nesting given by TYPE_CONTEXT. In particular,
26943 for:
26945 struct A { struct B; };
26946 struct A::B { void f() { } };
26948 there is no need to delay the parsing of `A::B::f'. */
26950 {
26951 tree decl;
26958 {
26959 /* Skip default arguments, NSDMIs, etc, in order to improve
26960 error recovery (c++/71169, c++/71832). */
26964 }
26966 /* In a first pass, parse default arguments to the functions.
26967 Then, in a second pass, parse the bodies of the functions.
26968 This two-phased approach handles cases like:
26970 struct S {
26971 void f() { g(); }
26972 void g(int i = 3);
26973 };
26975 */
26977 {
26979 /* If there are default arguments that have not yet been processed,
26980 take care of them now. */
26982 {
26987 }
26988 /* Make sure that any template parameters are in scope. */
26990 /* Parse the default argument expressions. */
26992 /* Remove any template parameters from the symbol table. */
26994 }
26997 /* If there are noexcept-specifiers that have not yet been processed,
26998 take care of them now. Do this before processing NSDMIs as they
26999 may depend on noexcept-specifiers already having been processed. */
27001 {
27004 {
27009 }
27014 /* Make sure that any template parameters are in scope. */
27017 /* Make sure that any member-function parameters are in scope.
27018 This function doesn't expect ccp to be set. */
27022 /* 'this' is not allowed in static member functions. */
27023 unsigned char local_variables_forbidden_p
27028 /* Now we can parse the noexcept-specifier. */
27034 /* Update the fn's type directly -- it might have escaped
27035 beyond this decl :( */
27037 /* Update any instantiations we've already created. We must
27038 keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
27039 so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
27040 in the pattern. */
27045 /* Restore the state of local_variables_forbidden_p. */
27048 /* The finish_struct call above performed various override checking,
27049 but it skipped unparsed noexcept-specifier operands. Now that we
27050 have resolved them, check again. */
27053 /* Remove any member-function parameters from the symbol table. */
27056 /* Remove any template parameters from the symbol table. */
27058 }
27061 /* Now parse any NSDMIs. */
27063 {
27066 {
27071 }
27074 }
27077 /* Now contract attributes. */
27079 {
27082 {
27087 }
27091 /* Make sure that any template parameters are in scope. */
27094 /* Make sure that any member-function parameters are in scope.
27095 This function doesn't expect ccp to be set. */
27099 /* 'this' is not allowed in static member functions. */
27100 unsigned char local_variables_forbidden_p
27105 /* Now we can parse contract conditions. */
27107 {
27110 }
27112 /* Restore the state of local_variables_forbidden_p. */
27115 /* Remove any member-function parameters from the symbol table. */
27118 /* Remove any template parameters from the symbol table. */
27121 /* Perform any deferred contract matching. */
27123 }
27131 /* Now parse the body of the functions. */
27133 {
27134 /* OpenMP UDRs need to be parsed before all other functions. */
27141 }
27142 else
27146 }
27148 /* Put back any saved access checks. */
27151 /* Restore saved state. */
27155 parser->num_template_parameter_lists
27157 parser->in_unbraced_linkage_specification_p
27163 }
27165 /* Parse a class-head.
27167 class-head:
27168 class-key identifier [opt] base-clause [opt]
27169 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
27170 class-key nested-name-specifier [opt] template-id
27171 base-clause [opt]
27173 class-virt-specifier:
27174 final
27176 GNU Extensions:
27177 class-key attributes identifier [opt] base-clause [opt]
27178 class-key attributes nested-name-specifier identifier base-clause [opt]
27179 class-key attributes nested-name-specifier [opt] template-id
27180 base-clause [opt]
27182 Upon return BASES is initialized to the list of base classes (or
27183 NULL, if there are none) in the same form returned by
27184 cp_parser_base_clause.
27186 Returns the TYPE of the indicated class. Sets
27187 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
27188 involving a nested-name-specifier was used, and FALSE otherwise.
27190 Returns error_mark_node if this is not a class-head.
27192 Returns NULL_TREE if the class-head is syntactically valid, but
27193 semantically invalid in a way that means we should skip the entire
27194 body of the class. */
27196 static tree
27199 {
27200 tree nested_name_specifier;
27204 tree attributes;
27205 tree bases;
27215 /* Assume no nested-name-specifier will be present. */
27217 /* Assume no template parameter lists will be used in defining the
27218 type. */
27222 /* Look for the class-key. */
27229 /* Parse the attributes. */
27234 /* If the next token is `::', that is invalid -- but sometimes
27235 people do try to write:
27237 struct ::S {};
27239 Handle this gracefully by accepting the extra qualifier, and then
27240 issuing an error about it later if this really is a
27241 class-head. If it turns out just to be an elaborated type
27242 specifier, remain silent. */
27246 /* It is OK to define an inaccessible class; for example:
27248 class A { class B; };
27249 class A::B {};
27251 So we want to ignore access when parsing the class name.
27252 However, we might be tentatively parsing what is really an
27253 elaborated-type-specifier naming a template-id, e.g.
27255 struct C<&D::m> c;
27257 In this case the tentative parse as a class-head will fail, but not
27258 before cp_parser_template_id splices in a CPP_TEMPLATE_ID token.
27259 Since dk_no_check is sticky, we must instead use dk_deferred so that
27260 any such CPP_TEMPLATE_ID token created during this tentative parse
27261 will correctly capture the access checks imposed by the template-id . */
27264 /* Determine the name of the class. Begin by looking for an
27265 optional nested-name-specifier. */
27267 nested_name_specifier
27273 /* If there was a nested-name-specifier, then there *must* be an
27274 identifier. */
27279 {
27281 /* Although the grammar says `identifier', it really means
27282 `class-name' or `template-name'. You are only allowed to
27283 define a class that has already been declared with this
27284 syntax.
27286 The proposed resolution for Core Issue 180 says that wherever
27287 you see `class T::X' you should treat `X' as a type-name.
27289 We do not know if we will see a class-name, or a
27290 template-name. We look for a class-name first, in case the
27291 class-name is a template-id; if we looked for the
27292 template-name first we would stop after the template-name. */
27299 class_type,
27303 /* If that didn't work, ignore the nested-name-specifier. */
27305 {
27311 }
27312 /* If we could not find a corresponding TYPE, treat this
27313 declaration like an unqualified declaration. */
27316 /* Otherwise, count the number of templates used in TYPE and its
27317 containing scopes. */
27318 else
27320 }
27321 /* Otherwise, the identifier is optional. */
27322 else
27323 {
27324 /* We don't know whether what comes next is a template-id,
27325 an identifier, or nothing at all. */
27327 /* Check for a template-id. */
27332 class_key,
27334 /* If that didn't work, it could still be an identifier. */
27336 {
27338 {
27341 }
27342 else
27344 }
27345 else
27346 {
27349 }
27350 }
27355 {
27357 class_key,
27359 }
27362 /* If it's not a `:' or a `{' then we can't really be looking at a
27363 class-head, since a class-head only appears as part of a
27364 class-specifier. We have to detect this situation before calling
27365 xref_tag, since that has irreversible side-effects. */
27367 {
27371 }
27373 /* At this point, we're going ahead with the class-specifier, even
27374 if some other problem occurs. */
27377 {
27382 }
27383 /* Issue the error about the overly-qualified name now. */
27385 {
27390 }
27392 {
27397 }
27399 {
27400 tree scope;
27403 /* [temp.names]: in a qualified-id formed by a class-head-name, the
27404 keyword template shall not appear at the top level. */
27408 /* Reject typedef-names in class heads. */
27410 {
27413 type);
27416 }
27418 /* Figure out in what scope the declaration is being placed. */
27420 /* If that scope does not contain the scope in which the
27421 class was originally declared, the program is invalid. */
27423 {
27426 "declaration of %qD in namespace %qD which does not "
27429 else
27435 }
27436 /* [dcl.meaning]
27438 A declarator-id shall not be qualified except for the
27439 definition of a ... nested class outside of its class
27440 ... [or] the definition or explicit instantiation of a
27441 class member of a namespace outside of its namespace. */
27445 }
27446 /* An explicit-specialization must be preceded by "template <>". If
27447 it is not, try to recover gracefully. */
27450 && !processing_template_parmlist
27452 {
27453 /* Build a location of this form:
27454 struct typename <ARGS>
27455 ^~~~~~~~~~~~~~~~~~~~~~
27456 with caret==start at the start token, and
27457 finishing at the end of the type. */
27458 location_t reported_loc
27460 class_head_start_location,
27466 "an explicit specialization must be preceded by"
27469 /* Take the same action that would have been taken by
27470 cp_parser_explicit_specialization. */
27473 }
27474 /* There must be no "return" statements between this point and the
27475 end of this function; set "type "to the correct return value and
27476 use "goto done;" to return. */
27477 /* Make sure that the right number of template parameters were
27478 present. */
27480 template_id_p,
27483 {
27484 /* If something went wrong, there is no point in even trying to
27485 process the class-definition. */
27488 }
27490 /* Look up the type. */
27492 {
27496 {
27500 }
27501 else
27502 {
27506 /* Check the scope while we still know whether or not we had a
27507 nested-name-specifier. */
27510 }
27513 }
27515 {
27518 /* Given:
27520 template <typename T> struct S { struct T };
27521 template <typename T> struct S<T>::T { };
27523 we will get a TYPENAME_TYPE when processing the definition of
27524 `S::T'. We need to resolve it to the actual type before we
27525 try to define it. */
27527 {
27530 {
27533 }
27534 }
27538 {
27541 }
27543 /* Enter the scope indicated by the nested-name-specifier. */
27545 /* Get the canonical version of this type. */
27547 /* Call push_template_decl if it seems like we should be defining a
27548 template either from the template headers or the type we're
27549 defining, so that we diagnose both extra and missing headers. */
27553 {
27556 {
27559 }
27560 }
27564 }
27566 {
27567 /* If the class was unnamed, create a dummy name. */
27575 }
27577 /* Diagnose class/struct/union mismatches. */
27581 /* Indicate whether this class was declared as a `class' or as a
27582 `struct'. */
27586 /* If this type was already complete, and we see another definition,
27587 that's an error. Likewise if the type is already being defined:
27588 this can happen, eg, when it's defined from within an expression
27589 (c++/84605). */
27592 {
27594 type);
27596 type);
27599 }
27604 {
27607 {
27608 /* In a lambda this should work, but doesn't currently. */
27611 }
27613 /* Apply attributes now, before any use of the class as a template
27614 argument in its base list. */
27617 }
27619 /* Associate constraints with the type. */
27623 /* We will have entered the scope containing the class; the names of
27624 base classes should be looked up in that context. For example:
27626 struct A { struct B {}; struct C; };
27627 struct A::C : B {};
27629 is valid. */
27631 /* Get the list of base-classes, if there is one. Defer access checking
27632 until the entire list has been seen, as per [class.access.general]. */
27635 {
27641 }
27642 else
27645 /* If we're really defining a class, process the base classes.
27646 If they're invalid, fail. */
27650 /* Now that all bases have been seen and attached to the class, check
27651 accessibility of the types named in the base-clause. This must be
27652 done relative to the class scope, so that we accept e.g.
27654 struct A { protected: struct B {}; };
27655 struct C : A::B, A {}; // OK: A::B is accessible via base A
27657 as per [class.access.general]. */
27664 done:
27665 /* Leave the scope given by the nested-name-specifier. We will
27666 enter the class scope itself while processing the members. */
27671 {
27674 }
27680 out:
27683 }
27685 /* Parse a class-key.
27687 class-key:
27688 class
27689 struct
27690 union
27692 Returns the kind of class-key specified, or none_type to indicate
27693 error. */
27695 static enum tag_types
27697 {
27701 /* Look for the class-key. */
27706 /* Check to see if the TOKEN is a class-key. */
27711 }
27713 /* Parse a type-parameter-key.
27715 type-parameter-key:
27716 class
27717 typename
27718 */
27720 static void
27722 {
27723 /* Look for the type-parameter-key. */
27727 {
27731 /* typename is not allowed in a template template parameter
27732 by the standard until C++17. */
27734 "ISO C++ forbids typename key in template template parameter;"
27736 }
27737 else
27741 }
27743 /* Parse an (optional) member-specification.
27745 member-specification:
27746 member-declaration member-specification [opt]
27747 access-specifier : member-specification [opt] */
27749 static void
27751 {
27753 {
27757 /* Peek at the next token. */
27759 /* If it's a `}', or EOF then we've seen all the members. */
27765 /* See if this token is a keyword. */
27768 {
27772 /* Consume the access-specifier. */
27774 /* Remember which access-specifier is active. */
27776 /* Look for the `:'. */
27781 /* Accept #pragmas at class scope. */
27783 {
27786 }
27788 /* Otherwise, the next construction must be a
27789 member-declaration. */
27791 }
27792 }
27793 }
27795 /* Parse a member-declaration.
27797 member-declaration:
27798 decl-specifier-seq [opt] member-declarator-list [opt] ;
27799 function-definition ; [opt]
27800 :: [opt] nested-name-specifier template [opt] unqualified-id ;
27801 using-declaration
27802 template-declaration
27803 alias-declaration
27805 member-declarator-list:
27806 member-declarator
27807 member-declarator-list , member-declarator
27809 member-declarator:
27810 declarator pure-specifier [opt]
27811 declarator constant-initializer [opt]
27812 identifier [opt] : constant-expression
27814 GNU Extensions:
27816 member-declaration:
27817 __extension__ member-declaration
27819 member-declarator:
27820 declarator attributes [opt] pure-specifier [opt]
27821 declarator attributes [opt] constant-initializer [opt]
27822 identifier [opt] attributes [opt] : constant-expression
27824 C++0x Extensions:
27826 member-declaration:
27827 static_assert-declaration */
27829 static void
27831 {
27832 cp_decl_specifier_seq decl_specifiers;
27833 tree prefix_attributes;
27834 tree decl;
27843 /* Check for the `__extension__' keyword. */
27845 {
27846 /* Recurse. */
27848 /* Restore the old value of the PEDANTIC flag. */
27852 }
27854 /* Check for a template-declaration. */
27856 {
27857 /* An explicit specialization here is an error condition, and we
27858 expect the specialization handler to detect and report this. */
27862 else
27866 }
27867 /* Check for a template introduction. */
27871 /* Check for a using-declaration. */
27873 {
27875 /* Parse the using-declaration. */
27879 else
27880 {
27881 tree decl;
27885 /* Note that if we actually see the '=' token after the
27886 identifier, cp_parser_alias_declaration commits the
27887 tentative parse. In that case, we really expect an
27888 alias-declaration. Otherwise, we expect a using
27889 declaration. */
27890 alias_decl_expected =
27896 else
27899 }
27901 }
27903 /* Check for @defs. */
27905 {
27910 {
27915 }
27917 }
27919 /* If the next token is `static_assert' we have a static assertion. */
27921 {
27924 }
27928 cp_omp_declare_simd_data odsd;
27932 /* Parse the decl-specifier-seq. */
27935 (CP_PARSER_FLAGS_OPTIONAL
27945 /* Check for an invalid type-name. */
27949 /* If there is no declarator, then the decl-specifier-seq should
27950 specify a type. */
27952 {
27953 /* If there was no decl-specifier-seq, and the next token is a
27954 `;', then we have something like:
27956 struct S { ; };
27958 [class.mem]
27960 Each member-declaration shall declare at least one member
27961 name of the class. */
27963 {
27966 {
27970 }
27971 }
27972 else
27973 {
27974 /* See if this declaration is a friend. */
27976 /* If there were decl-specifiers, check to see if there was
27977 a class-declaration. */
27980 /* Nested classes have already been added to the class, but
27981 a `friend' needs to be explicitly registered. */
27983 {
27984 /* If the `friend' keyword was present, the friend must
27985 be introduced with a class-key. */
27988 "in C++03 a class-key must be used "
27990 /* In this case:
27992 template <typename T> struct A {
27993 friend struct A<T>::B;
27994 };
27996 A<T>::B will be represented by a TYPENAME_TYPE, and
27997 therefore not recognized by check_tag_decl. */
27999 {
28003 }
28004 /* Warn if an attribute cannot appear here, as per
28005 [dcl.attr.grammar]/5. But not when declares_class_or_enum:
28006 we ignore attributes in elaborated-type-specifiers. */
28009 {
28014 "that appertains to a friend declaration that "
28016 }
28019 "friend declaration does not name a class or "
28021 else
28024 }
28025 /* If there is no TYPE, an error message will already have
28026 been issued. */
28028 ;
28029 /* An anonymous aggregate has to be handled specially; such
28030 a declaration really declares a data member (with a
28031 particular type), as opposed to a nested class. */
28033 {
28034 /* C++11 9.5/6. */
28037 "a storage class on an anonymous aggregate "
28040 /* Remove constructors and such from TYPE, now that we
28041 know it is an anonymous aggregate. */
28043 /* And make the corresponding data member. */
28046 /* Add it to the class. */
28048 }
28049 else
28050 cp_parser_check_access_in_redeclaration
28053 }
28054 }
28055 else
28056 {
28059 /* Clear attributes from the decl_specifiers but keep them
28060 around as prefix attributes that apply them to the entity
28061 being declared. */
28069 /* See if these declarations will be friends. */
28072 /* Keep going until we hit the `;' at the end of the
28073 declaration. */
28075 {
28077 tree first_attribute;
28078 tree initializer;
28081 /* Peek at the next token. */
28084 /* The following code wants to know early if it is a bit-field
28085 or some other declaration. Attributes can appear before
28086 the `:' token. Skip over them without consuming any tokens
28087 to peek if they are followed by `:'. */
28092 {
28093 size_t n
28096 }
28098 /* Check for a bitfield declaration. */
28104 {
28105 tree identifier;
28106 tree width;
28108 location_t id_location
28113 else
28116 /* Look for attributes that apply to the bitfield. */
28119 /* Consume the `:' token. */
28122 /* Get the width of the bitfield. */
28126 /* In C++20 and as extension for C++11 and above we allow
28127 default member initializers for bit-fields. */
28132 CPP_OPEN_BRACE)))
28133 {
28134 location_t loc
28139 "default member initializers for bit-fields "
28140 "only available with %<-std=c++20%> or "
28145 {
28149 }
28150 }
28151 else
28152 {
28153 /* Look for attributes that apply to the bitfield after
28154 the `:' token and width. This is where GCC used to
28155 parse attributes in the past, pedwarn if there is
28156 a std attribute. */
28159 "ISO C++ allows bit-field attributes only "
28163 }
28167 /* Remember which attributes are prefix attributes and
28168 which are not. */
28170 /* Combine the attributes. */
28173 /* Create the bitfield declaration. */
28176 identifier,
28177 sfk_none,
28178 id_location)
28182 attributes);
28183 }
28184 else
28185 {
28187 tree asm_specification;
28191 /* We can't delay parsing for friends,
28192 alias-declarations, and typedefs, even though the
28193 standard seems to require it. */
28198 /* Parse the declarator. */
28199 declarator
28201 flags,
28207 /* If something went wrong parsing the declarator, make sure
28208 that we at least consume some tokens. */
28210 {
28211 /* Skip to the end of the statement. */
28213 /* If the next token is not a semicolon, that is
28214 probably because we just skipped over the body of
28215 a function. So, we consume a semicolon if
28216 present, but do not issue an error message if it
28217 is not present. */
28219 CPP_SEMICOLON))
28222 }
28224 /* Handle class-scope non-template C++17 deduction guides. */
28227 declarator,
28231 cp_parser_check_for_definition_in_return_type
28235 /* Look for an asm-specification. */
28237 /* Look for attributes that apply to the declaration. */
28239 /* Remember which attributes are prefix attributes and
28240 which are not. */
28242 /* Combine the attributes. */
28245 /* If it's an `=', then we have a constant-initializer or a
28246 pure-specifier. It is not correct to parse the
28247 initializer before registering the member declaration
28248 since the member declaration should be in scope while
28249 its initializer is processed. However, the rest of the
28250 front end does not yet provide an interface that allows
28251 us to handle this correctly. */
28253 {
28254 /* In [class.mem]:
28256 A pure-specifier shall be used only in the declaration of
28257 a virtual function.
28259 A member-declarator can contain a constant-initializer
28260 only if it declares a static member of integral or
28261 enumeration type.
28263 Therefore, if the DECLARATOR is for a function, we look
28264 for a pure-specifier; otherwise, we look for a
28265 constant-initializer. When we call `grokfield', it will
28266 perform more stringent semantics checks. */
28279 {
28280 /* Don't require a constant rvalue in C++11, since we
28281 might want a reference constant. We'll enforce
28282 constancy later. */
28284 /* Parse the initializer. */
28286 }
28287 else
28288 /* Parse the initializer. */
28290 }
28293 {
28294 declarator->init_loc
28298 else
28300 }
28301 /* Detect invalid bit-field cases such as
28303 int *p : 4;
28304 int &&r : 3;
28306 and similar. */
28308 /* If there were no type specifiers, it was a
28309 constructor. */
28311 {
28312 /* This is called for a decent diagnostic only. */
28321 /* Avoid "extra ;" pedwarns. */
28323 CPP_SEMICOLON))
28326 }
28327 /* Otherwise, there is no initializer. */
28328 else
28331 /* See if we are probably looking at a function
28332 definition. We are certainly not looking at a
28333 member-declarator. Calling `grokfield' has
28334 side-effects, so we must not do it unless we are sure
28335 that we are looking at a member-declarator. */
28338 {
28339 /* The grammar does not allow a pure-specifier to be
28340 used when a member function is defined. (It is
28341 possible that this fact is an oversight in the
28342 standard, since a pure function may be defined
28343 outside of the class-specifier. */
28349 declarator,
28350 attributes);
28354 /* If the member was not a friend, declare it here. */
28357 /* Peek at the next token. */
28359 /* If the next token is a semicolon, consume it. */
28361 {
28362 location_t semicolon_loc
28367 "extra %<;%> after in-class "
28369 }
28371 }
28372 else
28376 /* Create the declaration. */
28382 {
28385 else
28387 }
28388 }
28393 /* Reset PREFIX_ATTRIBUTES. */
28395 {
28400 }
28402 /* If there is any qualification still in effect, clear it
28403 now; we will be starting fresh with the next declarator. */
28407 /* If it's a `,', then there are more declarators. */
28409 {
28412 {
28418 }
28419 }
28420 /* If the next token isn't a `;', then we have a parse error. */
28422 CPP_SEMICOLON))
28423 {
28424 /* The next token might be a ways away from where the
28425 actual semicolon is missing. Find the previous token
28426 and use that for our error position. */
28433 /* Assume that the user meant to provide a semicolon. If
28434 we were to cp_parser_skip_to_end_of_statement, we might
28435 skip to a semicolon inside a member function definition
28436 and issue nonsensical error messages. */
28438 }
28441 {
28442 /* Add DECL to the list of members. */
28444 /* Explicitly include, eg, NSDMIs, for better error
28445 recovery (c++/58650). */
28453 /* Add DECL to the queue of NSDMI to be parsed later. */
28455 }
28459 }
28460 }
28463 out:
28466 }
28468 /* Parse a pure-specifier.
28470 pure-specifier:
28471 = 0
28473 Returns INTEGER_ZERO_NODE if a pure specifier is found.
28474 Otherwise, ERROR_MARK_NODE is returned. */
28476 static tree
28478 {
28481 /* Look for the `=' token. */
28484 /* Look for the `0' token. */
28493 /* Accept = default or = delete in c++0x mode. */
28496 {
28499 }
28501 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
28503 {
28508 }
28510 {
28513 }
28516 }
28518 /* Parse a constant-initializer.
28520 constant-initializer:
28521 = constant-expression
28523 Returns a representation of the constant-expression. */
28525 static tree
28527 {
28528 /* Look for the `=' token. */
28532 /* It is invalid to write:
28534 struct S { static const int i = { 7 }; };
28536 */
28538 {
28541 /* Consume the opening brace. */
28542 matching_braces braces;
28544 /* Skip the initializer. */
28546 /* Look for the trailing `}'. */
28550 }
28553 }
28555 /* Derived classes [gram.class.derived] */
28557 /* Parse a base-clause.
28559 base-clause:
28560 : base-specifier-list
28562 base-specifier-list:
28563 base-specifier ... [opt]
28564 base-specifier-list , base-specifier ... [opt]
28566 Returns a TREE_LIST representing the base-classes, in the order in
28567 which they were declared. The representation of each node is as
28568 described by cp_parser_base_specifier.
28570 In the case that no bases are specified, this function will return
28571 NULL_TREE, not ERROR_MARK_NODE. */
28573 static tree
28575 {
28578 /* Look for the `:' that begins the list. */
28581 /* Scan the base-specifier-list. */
28583 {
28585 tree base;
28588 /* Look for the base-specifier. */
28590 /* Look for the (optional) ellipsis. */
28592 {
28593 /* Consume the `...'. */
28597 }
28599 /* Add BASE to the front of the list. */
28601 {
28603 /* Make this a pack expansion type. */
28607 {
28610 }
28611 }
28612 /* Peek at the next token. */
28614 /* If it's not a comma, then the list is complete. */
28617 /* Consume the `,'. */
28619 }
28621 /* PARSER->SCOPE may still be non-NULL at this point, if the last
28622 base class had a qualified name. However, the next name that
28623 appears is certainly not qualified. */
28629 }
28631 /* Parse a base-specifier.
28633 base-specifier:
28634 :: [opt] nested-name-specifier [opt] class-name
28635 virtual access-specifier [opt] :: [opt] nested-name-specifier
28636 [opt] class-name
28637 access-specifier virtual [opt] :: [opt] nested-name-specifier
28638 [opt] class-name
28640 Returns a TREE_LIST. The TREE_PURPOSE will be one of
28641 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
28642 indicate the specifiers provided. The TREE_VALUE will be a TYPE
28643 (or the ERROR_MARK_NODE) indicating the type that was specified. */
28645 static tree
28647 {
28655 tree type;
28657 /* Process the optional `virtual' and `access-specifier'. */
28659 {
28660 /* Peek at the next token. */
28662 /* Process `virtual'. */
28664 {
28666 /* If `virtual' appears more than once, issue an error. */
28668 {
28672 }
28676 /* Consume the `virtual' token. */
28684 /* If more than one access specifier appears, issue an
28685 error. */
28688 {
28692 }
28696 /* Consume the access-specifier. */
28704 }
28705 }
28706 /* It is not uncommon to see programs mechanically, erroneously, use
28707 the 'typename' keyword to denote (dependent) qualified types
28708 as base classes. */
28710 {
28715 else
28717 "keyword %<typename%> not allowed in this context "
28720 }
28722 /* Look for the optional `::' operator. */
28724 /* Look for the nested-name-specifier. The simplest way to
28725 implement:
28727 [temp.res]
28729 The keyword `typename' is not permitted in a base-specifier or
28730 mem-initializer; in these contexts a qualified name that
28731 depends on a template-parameter is implicitly assumed to be a
28732 type name.
28734 is to pretend that we have seen the `typename' keyword at this
28735 point. */
28741 /* If the base class is given by a qualified name, assume that names
28742 we see are type names or templates, as appropriate. */
28748 /* DR 950 allows decltype as a base-specifier. */
28750 else
28751 {
28752 /* Otherwise, look for the class-name. */
28754 class_scope_p,
28755 template_p,
28756 typename_type,
28761 }
28767 }
28769 /* Exception handling [gram.exception] */
28771 /* Save the tokens that make up the noexcept-specifier for a member-function.
28772 Returns a DEFERRED_PARSE. */
28774 static tree
28776 {
28778 /* We want everything up to, including, the final ')'. */
28782 /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
28783 to carry the information we will need. */
28785 /* Save away the noexcept-specifier; we will process it when the
28786 class is complete. */
28791 }
28793 /* Used for late processing of noexcept-specifiers of member-functions.
28794 DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
28795 we saved for later; parse it now. DECL is the declaration of the
28796 member function. */
28798 static tree
28800 {
28801 /* Make sure we've gotten something that hasn't been parsed yet. */
28806 /* Push the saved tokens for the noexcept-specifier onto the parser's
28807 lexer stack. */
28811 /* Parse the cached noexcept-specifier. */
28812 tree parsed_arg
28814 CP_PARSER_FLAGS_NONE,
28819 /* Revert to the main lexer. */
28822 /* Restore the queue. */
28825 /* And we're done. */
28827 }
28829 /* Perform late checking of overriding function with respect to their
28830 noexcept-specifiers. FNDECL is the member function that potentially
28831 overrides some virtual function with the same signature. */
28833 static void
28835 {
28837 tree base_binfo;
28843 {
28852 }
28853 }
28855 /* Parse an (optional) noexcept-specification.
28857 noexcept-specification:
28858 noexcept ( constant-expression ) [opt]
28860 If no noexcept-specification is present, returns NULL_TREE.
28861 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
28862 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
28863 there are no parentheses. CONSUMED_EXPR will be set accordingly.
28864 Otherwise, returns a noexcept specification unless RETURN_COND is true,
28865 in which case a boolean condition is returned instead. The parser flags
28866 FLAGS is used to control parsing. QUALS are qualifiers indicating whether
28867 the (member) function is `const'. */
28869 static tree
28871 cp_parser_flags flags,
28875 {
28879 /* Peek at the next token. */
28882 /* Is it a noexcept-specification? */
28884 {
28885 tree expr;
28887 /* [class.mem]/6 says that a noexcept-specifer (within the
28888 member-specification of the class) is a complete-class context of
28889 a class. So, if the noexcept-specifier has the optional expression,
28890 just save the tokens, and reparse this after we're done with the
28891 class. */
28895 /* No need to delay parsing for a number literal or true/false. */
28907 {
28908 matching_parens parens;
28912 {
28913 /* Types may not be defined in an exception-specification. */
28915 parser->type_definition_forbidden_message
28919 expr
28925 {
28928 }
28930 /* Restore the saved message. */
28932 }
28933 else
28934 {
28937 }
28940 }
28941 else
28942 {
28946 }
28948 /* We cannot build a noexcept-spec right away because this will check
28949 that expr is a constexpr. */
28952 else
28954 }
28955 else
28957 }
28959 /* Parse an (optional) exception-specification.
28961 exception-specification:
28962 throw ( type-id-list [opt] )
28964 Returns a TREE_LIST representing the exception-specification. The
28965 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
28966 control parsing. QUALS are qualifiers indicating whether the (member)
28967 function is `const'. */
28969 static tree
28971 cp_parser_flags flags)
28972 {
28974 tree type_id_list;
28977 /* Peek at the next token. */
28980 /* Is it a noexcept-specification? */
28981 type_id_list
28989 /* If it's not `throw', then there's no exception-specification. */
28995 /* Consume the `throw'. */
28998 /* Look for the `('. */
28999 matching_parens parens;
29002 /* Peek at the next token. */
29004 /* If it's not a `)', then there is a type-id-list. */
29006 {
29007 /* Types may not be defined in an exception-specification. */
29009 parser->type_definition_forbidden_message
29011 /* Parse the type-id-list. */
29013 /* Restore the saved message. */
29017 {
29021 }
29024 "dynamic exception specifications are deprecated in "
29026 }
29027 /* In C++17, throw() is equivalent to noexcept (true). throw()
29028 is deprecated in C++11 and above as well, but is still widely used,
29029 so don't warn about it yet. */
29032 else
29035 /* Look for the `)'. */
29039 }
29041 /* Parse an (optional) type-id-list.
29043 type-id-list:
29044 type-id ... [opt]
29045 type-id-list , type-id ... [opt]
29047 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
29048 in the order that the types were presented. */
29050 static tree
29052 {
29056 {
29058 tree type;
29062 /* Get the next type-id. */
29064 /* Check for invalid 'auto'. */
29066 {
29070 }
29071 /* Parse the optional ellipsis. */
29073 {
29074 /* Consume the `...'. */
29077 /* Turn the type into a pack expansion expression. */
29079 }
29080 /* Add it to the list. */
29082 /* Peek at the next token. */
29084 /* If it is not a `,', we are done. */
29087 /* Consume the `,'. */
29089 }
29092 }
29094 /* Parse a try-block.
29096 try-block:
29097 try compound-statement handler-seq */
29099 static tree
29101 {
29102 tree try_block;
29109 "%<try%> in %<constexpr%> function only "
29119 }
29121 /* Parse a function-try-block.
29123 function-try-block:
29124 try ctor-initializer [opt] function-body handler-seq */
29126 static void
29128 {
29129 tree compound_stmt;
29130 tree try_block;
29132 /* Look for the `try' keyword. */
29135 /* Let the rest of the front end know where we are. */
29137 /* Parse the function-body. */
29138 cp_parser_ctor_initializer_opt_and_function_body
29140 /* We're done with the `try' part. */
29142 /* Parse the handlers. */
29144 /* We're done with the handlers. */
29146 }
29148 /* Parse a handler-seq.
29150 handler-seq:
29151 handler handler-seq [opt] */
29153 static void
29155 {
29157 {
29160 /* Parse the handler. */
29162 /* Peek at the next token. */
29164 /* If it's not `catch' then there are no more handlers. */
29167 }
29168 }
29170 /* Parse a handler.
29172 handler:
29173 catch ( exception-declaration ) compound-statement */
29175 static void
29177 {
29178 tree handler;
29179 tree declaration;
29183 matching_parens parens;
29190 }
29192 /* Parse an exception-declaration.
29194 exception-declaration:
29195 type-specifier-seq declarator
29196 type-specifier-seq abstract-declarator
29197 type-specifier-seq
29198 ...
29200 Returns a VAR_DECL for the declaration, or NULL_TREE if the
29201 ellipsis variant is used. */
29203 static tree
29205 {
29206 cp_decl_specifier_seq type_specifiers;
29210 /* If it's an ellipsis, it's easy to handle. */
29212 {
29213 /* Consume the `...' token. */
29216 }
29218 /* Types may not be defined in exception-declarations. */
29220 parser->type_definition_forbidden_message
29223 /* Parse the type-specifier-seq. */
29228 /* If it's a `)', then there is no declarator. */
29231 else
29233 CP_PARSER_FLAGS_NONE,
29240 /* Restore the saved message. */
29247 }
29249 /* Parse a throw-expression.
29251 throw-expression:
29252 throw assignment-expression [opt]
29254 Returns a THROW_EXPR representing the throw-expression. */
29256 static tree
29258 {
29259 tree expression;
29265 /* Figure out whether or not there is an assignment-expression
29266 following the "throw" keyword. */
29274 else
29277 /* Construct a location e.g.:
29278 throw x
29279 ^~~~~~~
29280 with caret == start at the start of the "throw" token, and
29281 the end at the end of the final token we consumed. */
29287 }
29289 /* Parse a yield-expression.
29291 yield-expression:
29292 co_yield assignment-expression
29293 co_yield braced-init-list
29295 Returns a CO_YIELD_EXPR representing the yield-expression. */
29297 static tree
29299 {
29300 tree expr;
29308 {
29310 /* ??? : probably a moot point? */
29313 }
29314 else
29321 }
29323 /* GNU Extensions */
29325 /* Parse an (optional) asm-specification.
29327 asm-specification:
29328 asm ( string-literal )
29330 If the asm-specification is present, returns a STRING_CST
29331 corresponding to the string-literal. Otherwise, returns
29332 NULL_TREE. */
29334 static tree
29336 {
29337 /* Peek at the next token. */
29339 /* If the next token isn't the `asm' keyword, then there's no
29340 asm-specification. */
29344 /* Consume the `asm' token. */
29346 /* Look for the `('. */
29347 matching_parens parens;
29350 /* Look for the string-literal. */
29355 /* Look for the `)'. */
29359 }
29361 /* Parse an asm-operand-list.
29363 asm-operand-list:
29364 asm-operand
29365 asm-operand-list , asm-operand
29367 asm-operand:
29368 string-literal ( expression )
29369 [ string-literal ] string-literal ( expression )
29371 Returns a TREE_LIST representing the operands. The TREE_VALUE of
29372 each node is the expression. The TREE_PURPOSE is itself a
29373 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
29374 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
29375 is a STRING_CST for the string literal before the parenthesis. Returns
29376 ERROR_MARK_NODE if any of the operands are invalid. */
29378 static tree
29380 {
29385 {
29386 tree name;
29389 {
29390 /* Consume the `[' token. */
29392 /* Read the operand name. */
29397 /* Look for the closing `]'. */
29399 }
29400 else
29402 /* Look for the string-literal. */
29407 /* Look for the `('. */
29408 matching_parens parens;
29410 /* Parse the expression. */
29412 /* Look for the `)'. */
29420 /* Add this operand to the list. */
29422 expression,
29423 asm_operands);
29424 /* If the next token is not a `,', there are no more
29425 operands. */
29428 /* Consume the `,'. */
29430 }
29433 }
29435 /* Parse an asm-clobber-list.
29437 asm-clobber-list:
29438 string-literal
29439 asm-clobber-list , string-literal
29441 Returns a TREE_LIST, indicating the clobbers in the order that they
29442 appeared. The TREE_VALUE of each node is a STRING_CST. */
29444 static tree
29446 {
29450 {
29451 /* Look for the string literal. */
29455 /* Add it to the list. */
29457 /* If the next token is not a `,', then the list is
29458 complete. */
29461 /* Consume the `,' token. */
29463 }
29466 }
29468 /* Parse an asm-label-list.
29470 asm-label-list:
29471 identifier
29472 asm-label-list , identifier
29474 Returns a TREE_LIST, indicating the labels in the order that they
29475 appeared. The TREE_VALUE of each node is a label. */
29477 static tree
29479 {
29483 {
29486 /* Look for the identifier. */
29489 {
29492 {
29498 }
29499 }
29500 /* If the next token is not a `,', then the list is
29501 complete. */
29504 /* Consume the `,' token. */
29506 }
29509 }
29511 /* Return TRUE iff the next tokens in the stream are possibly the
29512 beginning of a GNU extension attribute. */
29514 static bool
29516 {
29518 }
29520 /* Return TRUE iff the next tokens in the stream are possibly the
29521 beginning of a standard C++-11 attribute specifier. */
29523 static bool
29525 {
29527 }
29529 /* Return TRUE iff the next Nth tokens in the stream are possibly the
29530 beginning of a standard C++-11 attribute specifier. */
29532 static bool
29534 {
29542 }
29544 /* Return TRUE iff the next Nth tokens in the stream are possibly the
29545 beginning of a GNU extension attribute. */
29547 static bool
29549 {
29553 }
29555 /* Return true iff the next tokens can be the beginning of either a
29556 GNU attribute list, or a standard C++11 attribute sequence. */
29558 static bool
29560 {
29563 }
29565 /* Return true iff the next Nth tokens can be the beginning of either
29566 a GNU attribute list, or a standard C++11 attribute sequence. */
29568 static bool
29570 {
29573 }
29575 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
29576 of GNU attributes, or return NULL. */
29578 static tree
29580 {
29583 {
29588 else
29590 }
29592 }
29594 /* Parse an (optional) series of attributes.
29596 attributes:
29597 attributes attribute
29599 attribute:
29600 __attribute__ (( attribute-list [opt] ))
29602 The return value is as for cp_parser_gnu_attribute_list. */
29604 static tree
29606 {
29613 {
29615 tree attribute_list;
29618 /* Peek at the next token. */
29620 /* If it's not `__attribute__', then we're done. */
29624 /* Consume the `__attribute__' keyword. */
29626 /* Look for the two `(' tokens. */
29627 matching_parens outer_parens;
29630 matching_parens inner_parens;
29634 /* Peek at the next token. */
29637 /* Parse the attribute-list. */
29639 else
29640 /* If the next token is a `)', then there is no attribute
29641 list. */
29644 /* Look for the two `)' tokens. */
29652 /* Add these new attributes to the list. */
29654 }
29657 }
29659 /* Parse a GNU attribute-list.
29661 attribute-list:
29662 attribute
29663 attribute-list , attribute
29665 attribute:
29666 identifier
29667 identifier ( identifier )
29668 identifier ( identifier , expression-list )
29669 identifier ( expression-list )
29671 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
29672 to an attribute. The TREE_PURPOSE of each node is the identifier
29673 indicating which attribute is in use. The TREE_VALUE represents
29674 the arguments, if any. */
29676 static tree
29678 {
29682 /* Don't create wrapper nodes within attributes: the
29683 handlers don't know how to handle them. */
29684 auto_suppress_location_wrappers sentinel;
29688 {
29690 tree identifier;
29691 tree attribute;
29693 /* Look for the identifier. We also allow keywords here; for
29694 example `__attribute__ ((const))' is legal. */
29698 {
29701 /* Consume the token, but save it since we need it for the
29702 SIMD enabled function parsing. */
29705 /* Save away the identifier that indicates which attribute
29706 this is. */
29708 /* For keywords, use the canonical spelling, not the
29709 parsed identifier. */
29716 /* Peek at the next token. */
29718 /* If it's an `(', then parse the attribute arguments. */
29720 {
29726 vec = cp_parser_parenthesized_expression_list
29732 else
29733 {
29736 }
29737 /* Save the arguments away. */
29739 }
29742 {
29743 /* Add this attribute to the list. */
29746 }
29749 }
29750 /* Unless EXACTLY_ONE is set look for more attributes.
29751 If the next token isn't a `,', we're done. */
29755 /* Consume the comma and keep going. */
29757 }
29760 /* We built up the list in reverse order. */
29762 }
29764 /* Parse arguments of omp::directive attribute.
29766 ( directive-name ,[opt] clause-list[opt] )
29768 For directive just remember the first/last tokens for subsequent
29769 parsing. */
29771 static void
29773 {
29776 {
29782 }
29785 {
29791 }
29802 }
29804 /* Parse arguments of omp::sequence attribute.
29806 ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
29808 static void
29810 {
29811 matching_parens parens;
29813 do
29814 {
29819 {
29823 }
29828 else
29833 {
29842 }
29846 UNKNOWN_LOCATION);
29849 else
29854 }
29859 }
29861 /* Parse a standard C++11 attribute.
29863 The returned representation is a TREE_LIST which TREE_PURPOSE is
29864 the scoped name of the attribute, and the TREE_VALUE is its
29865 arguments list.
29867 Note that the scoped name of the attribute is itself a TREE_LIST
29868 which TREE_PURPOSE is the namespace of the attribute, and
29869 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
29870 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
29871 and which TREE_PURPOSE is directly the attribute name.
29873 Clients of the attribute code should use get_attribute_namespace
29874 and get_attribute_name to get the actual namespace and name of
29875 attributes, regardless of their being GNU or C++11 attributes.
29877 attribute:
29878 attribute-token attribute-argument-clause [opt]
29880 attribute-token:
29881 identifier
29882 attribute-scoped-token
29884 attribute-scoped-token:
29885 attribute-namespace :: identifier
29887 attribute-namespace:
29888 identifier
29890 attribute-argument-clause:
29891 ( balanced-token-seq )
29893 balanced-token-seq:
29894 balanced-token [opt]
29895 balanced-token-seq balanced-token
29897 balanced-token:
29898 ( balanced-token-seq )
29899 [ balanced-token-seq ]
29900 { balanced-token-seq }. */
29902 static tree
29904 {
29911 /* First, parse name of the attribute, a.k.a attribute-token. */
29928 {
29929 /* We are seeing a scoped attribute token. */
29944 else
29945 {
29949 }
29955 NULL_TREE);
29957 }
29959 {
29963 NULL_TREE);
29964 }
29965 else
29966 {
29969 NULL_TREE);
29971 /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
29972 but no longer: we have to be able to tell [[noreturn]] and
29973 __attribute__((noreturn)) apart. */
29974 /* C++14 deprecated attribute is equivalent to GNU's. */
29977 /* C++17 fallthrough attribute is equivalent to GNU's. */
29980 /* C++23 assume attribute is equivalent to GNU's. */
29983 /* Transactional Memory TS optimize_for_synchronized attribute is
29984 equivalent to GNU transaction_callable. */
29988 /* Transactional Memory attributes are GNU attributes. */
29991 }
29993 /* Now parse the optional argument clause of the attribute. */
29996 {
30002 {
30004 attr_id);
30006 }
30008 }
30010 {
30014 /* Maybe we don't expect to see any arguments for this attribute. */
30018 {
30020 attr_id);
30026 }
30030 /* The assume attribute needs special handling of the argument. */
30034 /* A GNU attribute that takes an identifier in parameter. */
30042 /* If this is a fake attribute created to handle -Wno-attributes,
30043 we must skip parsing the arguments. */
30045 {
30047 {
30049 {
30052 }
30054 {
30059 }
30061 {
30067 }
30068 }
30070 /* For unknown attributes, just skip balanced tokens instead of
30071 trying to parse the arguments. Set TREE_VALUE (attribute) to
30072 error_mark_node to distinguish skipped arguments from attributes
30073 with no arguments. */
30078 }
30080 vec = cp_parser_parenthesized_expression_list
30086 else
30087 {
30089 /* e.g. [[attr()]]. */
30092 attr_id);
30095 }
30099 else
30101 }
30104 }
30106 /* Warn if the attribute ATTRIBUTE appears more than once in the
30107 attribute-list ATTRIBUTES. This used to be enforced for certain
30108 attributes, but the restriction was removed in P2156.
30109 LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
30110 found in ATTRIBUTES. */
30112 static bool
30114 {
30123 {
30128 }
30130 }
30132 /* Parse a list of standard C++-11 attributes.
30134 attribute-list:
30135 attribute [opt]
30136 attribute-list , attribute[opt]
30137 attribute ...
30138 attribute-list , attribute ...
30139 */
30141 static tree
30143 {
30148 {
30154 {
30156 {
30159 }
30160 }
30163 {
30169 {
30173 }
30175 {
30180 }
30182 }
30186 }
30189 }
30191 /* Optionally parse a C++20 contract role. A NULL return means that no
30192 contract role was specified.
30194 contract-role:
30195 % default
30196 % identifier
30198 If the identifier does not name a known contract role, it will
30199 be assumed to be default. Returns the identifier for the role
30200 token. */
30202 static tree
30204 {
30214 else
30215 {
30218 }
30221 /* FIXME: Warn about invalid/unknown roles? */
30223 }
30225 /* Parse an optional contract mode.
30227 contract-mode:
30228 contract-semantic
30229 [contract-level] [contract-role]
30231 contract-semantic:
30232 check_never_continue
30233 check_maybe_continue
30234 check_always_continue
30236 contract-level:
30237 default
30238 audit
30239 axiom
30241 contract-role:
30242 default
30243 identifier
30245 This grammar is taken from P1332R0. During parsing, this sets options
30246 on the MODE object to determine the configuration of the contract.
30248 Returns a tree containing the identifiers used in the configuration.
30249 This is either an IDENTIFIER with the literal semantic or a TREE_LIST
30250 whose TREE_VALUE is the contract-level and whose TREE_PURPOSE is the
30251 contract-role, if any. NULL_TREE is returned if no information is
30252 given (i.e., all defaults selected). */
30254 static tree
30257 {
30258 /* The mode is empty; the level and role are default. */
30262 /* There is only a role; the level is default. */
30264 {
30267 }
30269 /* Otherwise, match semantic or level. */
30273 tree config_id;
30275 {
30278 /* Either a named level, a concrete semantic, or an identifier
30279 for a postcondition. */
30284 /* The identifier is the return value for a postcondition. */
30288 }
30290 {
30293 }
30294 else
30295 {
30296 /* We got some other token other than a ':'. */
30299 }
30301 /* Consume the literal semantic or level token. */
30305 {
30307 "expected contract level: "
30310 }
30312 /* We matched an explicit semantic. */
30314 {
30316 {
30320 }
30322 }
30324 /* We matched a level, there may be a role; otherwise this is default. */
30326 {
30329 }
30332 }
30334 static tree
30336 {
30340 }
30342 static bool
30344 {
30346 }
30348 /* Parse a standard C++20 contract attribute specifier.
30350 contract-attribute-specifier:
30351 [ [ assert contract-level [opt] : conditional-expression ] ]
30352 [ [ pre contract-level [opt] : conditional-expression ] ]
30353 [ [ post contract-level [opt] identifier [opt] : conditional-expression ] ]
30355 For free functions, we cannot determine the type of the postcondition
30356 identifier because the we haven't called grokdeclarator yet. In those
30357 cases we parse the postcondition as if the identifier was declared as
30358 'auto <identifier>'. We then instantiate the postcondition once the
30359 return type is known.
30361 For member functions, contracts are in the complete-class context, so the
30362 parse is deferred. We also have the return type avaialable (unless it's
30363 deduced), so we don't need to parse the postcondition in terms of a
30364 placeholder. */
30366 static tree
30368 {
30376 /* Parse the optional mode. */
30379 /* Check for postcondition identifiers. */
30380 cp_expr identifier;
30388 /* Defer the parsing of pre/post contracts inside class definitions. */
30389 tree contract;
30391 current_class_type &&
30393 {
30394 /* Skip until we reach an unenclose ']'. If we ran into an unnested ']'
30395 that doesn't close the attribute, return an error and let the attribute
30396 handling code emit an error for missing ']]'. */
30400 CPP_CLOSE_SQUARE,
30407 /* Build a deferred-parse node. */
30412 /* And its corresponding contract. */
30414 }
30415 else
30416 {
30417 /* Enable location wrappers when parsing contracts. */
30420 /* Build a fake variable for the result identifier. */
30423 {
30427 }
30429 /* Parse the condition, ensuring that parameters or the return variable
30430 aren't flagged for use outside the body of a function. */
30435 /* Try to recover from errors by scanning up to the end of the
30436 attribute. Sometimes we get partially parsed expressions, so
30437 we need to search the condition for errors. */
30441 /* Build the contract. */
30444 /* Leave our temporary scope for the postcondition result. */
30446 {
30449 }
30450 }
30453 {
30456 }
30459 }
30461 /* Parse a contract condition for a deferred contract. */
30464 tree fn,
30465 tree attribute)
30466 {
30469 /* Make sure we've gotten something that hasn't been parsed yet or that
30470 we're not parsing an invalid contract. */
30479 /* Build a fake variable for the result identifier. */
30482 {
30483 /* TODO: Can we guarantee that the identifier has a location? */
30487 {
30490 }
30495 }
30497 /* 'this' is not allowed in preconditions of constructors or in postconditions
30498 of destructors. Note that the previous value of this variable is
30499 established by the calling function, so we need to save it here. */
30504 {
30507 }
30511 /* Push the saved tokens onto the parser's lexer stack. */
30515 /* Parse the condition, ensuring that parameters or the return variable
30516 aren't flagged for use outside the body of a function. */
30521 /* Revert to the main lexer. */
30524 /* Restore the queue. */
30530 /* Commit to changes. */
30533 /* Leave our temporary scope for the postcondition result. */
30535 {
30538 }
30539 }
30541 /* Parse a standard C++-11 attribute specifier.
30543 attribute-specifier:
30544 [ [ attribute-using-prefix [opt] attribute-list ] ]
30545 contract-attribute-specifier
30546 alignment-specifier
30548 attribute-using-prefix:
30549 using attribute-namespace :
30551 alignment-specifier:
30552 alignas ( type-id ... [opt] )
30553 alignas ( alignment-expression ... [opt] ).
30555 Extensions for contracts:
30557 contract-attribute-specifier:
30558 [ [ assert : contract-mode [opt] : conditional-expression ] ]
30559 [ [ pre : contract-mode [opt] : conditional-expression ] ]
30560 [ [ post : contract-mode [opt] identifier [opt] :
30561 conditional-expression ] ]
30563 Return void_list_node if the current token doesn't start an
30564 attribute-specifier to differentiate from NULL_TREE returned e.g.
30565 for [ [ ] ]. */
30567 static tree
30569 {
30575 {
30584 {
30587 }
30589 /* Handle contract-attribute-specs specially. */
30591 {
30596 }
30599 {
30610 {
30613 "attribute using prefix only available "
30619 }
30620 else
30622 }
30626 finish_attrs:
30630 else
30631 /* Warn about parsing c++11 attribute in non-c++11 mode, only
30632 when we are sure that we have actually parsed them. */
30634 }
30635 else
30636 {
30637 tree alignas_expr;
30639 /* Look for an alignment-specifier. */
30650 matching_parens parens;
30658 {
30665 }
30670 /* Handle alignas (pack...). */
30672 {
30675 }
30677 /* Something went wrong, so don't build the attribute. */
30681 /* Missing ')' means the code cannot possibly be valid; go ahead
30682 and commit to make sure we issue a hard error. */
30690 /* Build the C++-11 representation of an 'aligned'
30691 attribute. */
30692 attributes
30695 }
30698 }
30700 /* Parse a standard C++-11 attribute-specifier-seq.
30702 attribute-specifier-seq:
30703 attribute-specifier-seq [opt] attribute-specifier */
30705 static tree
30707 {
30711 /* Don't create wrapper nodes within attributes: the
30712 handlers don't know how to handle them. */
30713 auto_suppress_location_wrappers sentinel;
30716 {
30720 /* Accept [[]][[]]; for which cp_parser_std_attribute_spec
30721 returns NULL_TREE as there are no attributes. */
30729 else
30732 }
30735 }
30737 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
30738 return index of the first token after balanced-token, or N on failure. */
30740 static size_t
30742 {
30745 do
30747 {
30751 /* FALLTHRU */
30753 /* Ran out of tokens. */
30775 }
30778 }
30780 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
30781 return index of the first token after the GNU attribute tokens, or N on
30782 failure. */
30784 static size_t
30786 {
30788 {
30800 }
30802 }
30804 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
30805 next token), return index of the first token after the standard C++11
30806 attribute tokens, or N on failure. */
30808 static size_t
30810 {
30812 {
30815 {
30822 }
30825 {
30830 }
30831 else
30833 }
30835 }
30837 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
30838 as the next token), return index of the first token after the attribute
30839 tokens, or N on failure. */
30841 static size_t
30843 {
30847 }
30849 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
30850 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
30851 current value of the PEDANTIC flag, regardless of whether or not
30852 the `__extension__' keyword is present. The caller is responsible
30853 for restoring the value of the PEDANTIC flag. */
30855 static bool
30857 {
30858 /* Save the old value of the PEDANTIC flag. */
30862 {
30863 /* Consume the `__extension__' token. */
30865 /* We're not being pedantic while the `__extension__' keyword is
30866 in effect. */
30870 }
30873 }
30875 /* Parse a label declaration.
30877 label-declaration:
30878 __label__ label-declarator-seq ;
30880 label-declarator-seq:
30881 identifier , label-declarator-seq
30882 identifier */
30884 static void
30886 {
30887 /* Look for the `__label__' keyword. */
30891 {
30892 tree identifier;
30894 /* Look for an identifier. */
30896 /* If we failed, stop. */
30899 /* Declare it as a label. */
30901 /* If the next token is a `;', stop. */
30904 /* Look for the `,' separating the label declarations. */
30906 }
30908 /* Look for the final `;'. */
30910 }
30912 // -------------------------------------------------------------------------- //
30913 // Concept definitions
30915 static tree
30917 {
30918 /* A concept definition is an unevaluated context. */
30919 cp_unevaluated u;
30926 {
30930 }
30935 {
30939 }
30941 processing_constraint_expression_sentinel parsing_constraint;
30946 /* Consume the trailing ';'. Diagnose the problem if it isn't there,
30947 but continue as if it were. */
30951 }
30953 // -------------------------------------------------------------------------- //
30954 // Requires Clause
30956 /* Diagnose an expression that should appear in ()'s within a requires-clause
30957 and suggest where to place those parentheses. */
30959 static void
30961 {
30963 }
30965 static void
30967 {
30972 }
30974 /* Characterizes the likely kind of expression intended by a mis-written
30975 primary constraint. */
30976 enum primary_constraint_error
30977 {
30978 pce_ok,
30979 pce_maybe_operator,
30980 pce_maybe_postfix
30981 };
30983 /* Returns true if the token(s) following a primary-expression in a
30984 constraint-logical-* expression would require parentheses. */
30986 static primary_constraint_error
30988 {
30991 {
30996 {
30997 /* An equal sign may be part of the definition of a function,
30998 and not an assignment operator, when parsing the expression
30999 for a trailing requires-clause. For example:
31001 template<typename T>
31002 struct S {
31003 S() requires C<T> = default;
31004 };
31006 Don't try to reparse this a binary operator. */
31012 }
31014 /* Arithmetic operators. */
31020 /* Bitwise operators. */
31026 /* Relational operators. */
31034 /* Pointer-to-member. */
31037 /* Assignment operators. */
31048 /* Conditional operator */
31050 /* Unenclosed binary or conditional operator. */
31054 {
31055 /* A primary constraint that precedes the parameter-list of a
31056 lambda expression is followed by an open paren.
31058 []<typename T> requires C (T a, T b) { ... }
31060 Don't try to re-parse this as a postfix expression. */
31065 }
31067 {
31068 /* A primary-constraint-expression followed by a '[[' is not a
31069 postfix expression. */
31074 }
31078 /* Unenclosed postfix operator. */
31082 /* A primary constraint that precedes the lambda-declarator of a
31083 lambda expression is followed by trailing return type.
31085 []<typename T> requires C -> void {}
31087 Don't try to re-parse this as a postfix expression in
31088 C++23 and later. In C++20 ( needs to come in between but we
31089 allow it to be omitted with pedwarn. */
31092 /* Unenclosed postfix operator. */
31094 }
31095 }
31097 /* Returns true if the next token begins a unary expression, preceded by
31098 an operator or keyword. */
31100 static bool
31102 {
31105 {
31116 {
31118 {
31134 }
31135 }
31139 }
31142 }
31144 /* Parse a primary expression within a constraint. */
31146 static cp_expr
31148 {
31149 /* If this looks like a unary expression, parse it as such, but diagnose
31150 it as ill-formed; it requires parens. */
31152 {
31156 }
31159 cp_id_kind idk;
31170 {
31171 /* The primary-expression could be part of an unenclosed non-logical
31172 compound expression. */
31174 }
31176 {
31179 }
31181 /* Retry the parse at a lower precedence. If that succeeds, diagnose the
31182 error, but return the expression as if it were valid. */
31187 else
31190 {
31193 }
31195 /* Otherwise, something has gone very wrong, and we can't generate a more
31196 meaningful diagnostic or recover. */
31199 }
31201 /* Parse a constraint-logical-and-expression.
31203 constraint-logical-and-expression:
31204 primary-expression
31205 constraint-logical-and-expression '&&' primary-expression */
31207 static cp_expr
31209 {
31212 {
31216 }
31218 }
31220 /* Parse a constraint-logical-or-expression.
31222 constraint-logical-or-expression:
31223 constraint-logical-and-expression
31224 constraint-logical-or-expression '||' constraint-logical-and-expression */
31226 static cp_expr
31228 {
31231 {
31235 }
31237 }
31239 /* Parse the expression after a requires-clause. This has a different grammar
31240 than that in the concepts TS. */
31242 static tree
31244 {
31245 processing_constraint_expression_sentinel parsing_constraint;
31252 }
31254 /* Parse a expression after a requires clause.
31256 constraint-expression:
31257 logical-or-expression
31259 The required logical-or-expression must be a constant expression. Note
31260 that we don't check that the expression is constepxr here. We defer until
31261 we analyze constraints and then, we only check atomic constraints. */
31263 static tree
31265 {
31266 processing_constraint_expression_sentinel parsing_constraint;
31275 }
31277 /* Optionally parse a requires clause:
31279 requires-clause:
31280 `requires` constraint-logical-or-expression.
31281 [ConceptsTS]
31282 `requires constraint-expression.
31284 LAMBDA_P is true when the requires-clause is parsed before the
31285 parameter-list of a lambda-declarator. */
31287 static tree
31289 {
31290 /* A requires clause is an unevaluated context. */
31291 cp_unevaluated u;
31295 {
31298 {
31300 "%<requires%> only available with "
31302 /* Parse and discard the requires-clause. */
31305 }
31307 }
31311 {
31312 /* An opening brace following the start of a requires-clause is
31313 ill-formed; the user likely forgot the second `requires' that
31314 would start a requires-expression. */
31319 /* Don't consume the `requires', so that it's reused as the start of a
31320 requires-expression. */
31321 }
31322 else
31327 else
31329 }
31331 /*---------------------------------------------------------------------------
31332 Requires expressions
31333 ---------------------------------------------------------------------------*/
31335 /* Parse a requires expression
31337 requirement-expression:
31338 'requires' requirement-parameter-list [opt] requirement-body */
31340 static tree
31342 {
31346 /* Avoid committing to outer tentative parse. */
31349 /* This is definitely a requires-expression. */
31353 {
31354 /* Local parameters are delared as variables within the scope
31355 of the expression. They are not visible past the end of
31356 the expression. Expressions within the requires-expression
31357 are unevaluated. */
31358 struct scope_sentinel
31359 {
31361 {
31365 }
31368 {
31371 }
31374 /* Parse the optional parameter list. */
31376 {
31380 }
31381 else
31384 /* Parse the requirement body. */
31390 }
31392 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
31393 the parm chain. */
31398 {
31399 /* Perform semantic processing now to diagnose any invalid types and
31400 expressions. */
31405 }
31407 }
31409 /* Parse a parameterized requirement.
31411 requirement-parameter-list:
31412 '(' parameter-declaration-clause ')' */
31414 static tree
31416 {
31417 matching_parens parens;
31421 tree parms = (cp_parser_parameter_declaration_clause
31427 /* Modify the declared parameters by removing their context
31428 so they don't refer to the enclosing scope and explicitly
31429 indicating that they are constraint variables. */
31431 {
31436 {
31439 }
31440 }
31443 }
31445 /* Parse the body of a requirement.
31447 requirement-body:
31448 '{' requirement-list '}' */
31449 static tree
31451 {
31452 matching_braces braces;
31462 }
31464 /* Parse a sequence of requirements.
31466 requirement-seq:
31467 requirement
31468 requirement-seq requirement */
31470 static tree
31472 {
31474 do
31475 {
31479 }
31483 /* If there are no valid requirements, this is not a valid expression. */
31487 /* Reverse the order of requirements so they are analyzed in order. */
31489 }
31491 /* Parse a syntactic requirement or type requirement.
31493 requirement:
31494 simple-requirement
31495 compound-requirement
31496 type-requirement
31497 nested-requirement */
31499 static tree
31501 {
31505 {
31506 /* It's probably a type-requirement. */
31511 /* No, maybe it's something like typename T::type(); */
31516 /* Non-tentative for the error. */
31518 }
31521 else
31523 }
31525 /* Parse a simple requirement.
31527 simple-requirement:
31528 expression ';' */
31530 static tree
31532 {
31543 /* Sometimes we don't get locations, so use the cached token location
31544 as a reasonable approximation. */
31549 {
31552 {
31555 }
31557 {
31561 "if a concept-id is a valid expression; add "
31563 }
31565 }
31568 }
31570 /* Parse a type requirement
31572 type-requirement
31573 nested-name-specifier [opt] required-type-name ';'
31575 required-type-name:
31576 type-name
31577 'template' [opt] simple-template-id */
31579 static tree
31581 {
31585 // Save the scope before parsing name specifiers.
31596 tree type;
31598 {
31607 }
31608 else
31628 }
31630 /* Parse a compound requirement
31632 compound-requirement:
31633 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
31635 static tree
31637 {
31638 /* Parse an expression enclosed in '{ }'s. */
31639 matching_braces braces;
31650 {
31654 }
31656 /* If the expression was invalid, skip the remainder of the requirement. */
31658 {
31662 }
31664 /* Parse the optional noexcept. */
31667 {
31670 }
31672 /* Parse the optional trailing return type. */
31675 {
31681 /* C++20 allows either a type-id or a type-constraint. Parsing
31682 a type-id will subsume the parsing for a type-constraint but
31683 allow for more syntactic forms (e.g., const C<T>*). */
31692 /* Check that we haven't written something like 'const C<T>*'. */
31694 {
31696 {
31701 }
31702 }
31704 /* P1452R2 removed the trailing-return-type option. */
31707 }
31719 }
31721 /* Parse a nested requirement. This is the same as a requires clause.
31723 nested-requirement:
31724 requires-clause */
31726 static tree
31728 {
31740 }
31742 /* Support Functions */
31744 /* Return the appropriate prefer_type argument for lookup_name based on
31745 tag_type. */
31749 {
31751 {
31755 }
31756 }
31758 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
31759 NAME should have one of the representations used for an
31760 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
31761 is returned. If PARSER->SCOPE is a dependent type, then a
31762 SCOPE_REF is returned.
31764 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
31765 returned; the name was already resolved when the TEMPLATE_ID_EXPR
31766 was formed. Abstractly, such entities should not be passed to this
31767 function, because they do not need to be looked up, but it is
31768 simpler to check for this special case here, rather than at the
31769 call-sites.
31771 In cases not explicitly covered above, this function returns a
31772 DECL, OVERLOAD, or baselink representing the result of the lookup.
31773 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
31774 is returned.
31776 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
31777 (e.g., "struct") that was used. In that case bindings that do not
31778 refer to types are ignored.
31780 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
31781 ignored. If IS_TEMPLATE IS 2, the 'template' keyword was specified.
31783 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
31784 are ignored.
31786 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
31787 types.
31789 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
31790 TREE_LIST of candidates if name-lookup results in an ambiguity, and
31791 NULL_TREE otherwise. */
31793 static cp_expr
31800 location_t name_location)
31801 {
31802 tree decl;
31805 /* Assume that the lookup will be unambiguous. */
31809 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
31810 no longer valid. Note that if we are parsing tentatively, and
31811 the parse fails, OBJECT_TYPE will be automatically restored. */
31817 /* A template-id has already been resolved; there is no lookup to
31818 do. */
31822 {
31826 }
31828 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
31829 it should already have been checked to make sure that the name
31830 used matches the type being destroyed. */
31832 {
31833 tree type;
31835 /* Figure out to which type this destructor applies. */
31840 else
31842 /* If that's not a class type, there is no destructor. */
31846 /* In a non-static member function, check implicit this->. */
31849 tf_warning_or_error);
31858 }
31860 /* By this point, the NAME should be an ordinary identifier. If
31861 the id-expression was a qualified name, the qualifying scope is
31862 stored in PARSER->SCOPE at this point. */
31865 /* Perform the lookup. */
31867 {
31873 /* If the SCOPE is dependent, the lookup must be deferred until
31874 the template is instantiated -- unless we are explicitly
31875 looking up names in uninstantiated templates. Even then, we
31876 cannot look up the name if the scope is not a class type; it
31877 might, for example, be a template type parameter. */
31882 /* Defer lookup. */
31884 else
31885 {
31888 /* If PARSER->SCOPE is a dependent type, then it must be a
31889 class type, and we must not be checking dependencies;
31890 otherwise, we would have processed this lookup above. So
31891 that PARSER->SCOPE is not considered a dependent base by
31892 lookup_member, we must enter the scope here. */
31896 /* If the PARSER->SCOPE is a template specialization, it
31897 may be instantiated during name lookup. In that case,
31898 errors may be issued. Even if we rollback the current
31899 tentative parse, those errors are valid. */
31904 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
31905 lookup result and the nested-name-specifier nominates a class C:
31906 * if the name specified after the nested-name-specifier, when
31907 looked up in C, is the injected-class-name of C (Clause 9), or
31908 * if the name specified after the nested-name-specifier is the
31909 same as the identifier or the simple-template-id's template-
31910 name in the last component of the nested-name-specifier,
31911 the name is instead considered to name the constructor of
31912 class C. [ Note: for example, the constructor is not an
31913 acceptable lookup result in an elaborated-type-specifier so
31914 the constructor would not be used in place of the
31915 injected-class-name. --end note ] Such a constructor name
31916 shall be used only in the declarator-id of a declaration that
31917 names a constructor or in a using-declaration. */
31927 }
31929 /* If the scope is a dependent type and either we deferred lookup or
31930 we did lookup but didn't find the name, rememeber the name. */
31933 {
31935 {
31936 tree type;
31938 /* The resolution to Core Issue 180 says that `struct
31939 A::B' should be considered a type-name, even if `A'
31940 is dependent. */
31945 }
31949 CPP_CLOSE_PAREN)))
31953 else
31956 is_template);
31957 }
31960 }
31962 {
31965 /* Look up the name in the scope of the OBJECT_TYPE, unless the
31966 OBJECT_TYPE is not a class. */
31968 /* If the OBJECT_TYPE is a template specialization, it may
31969 be instantiated during name lookup. In that case, errors
31970 may be issued. Even if we rollback the current tentative
31971 parse, those errors are valid. */
31973 name,
31976 tf_warning_or_error);
31977 else
31980 /* If we didn't find a member and have dependent bases, the member lookup
31981 is now dependent. */
31988 /* Look it up in the enclosing context. DR 141: When looking for a
31989 template-name after -> or ., only consider class templates. */
31991 /* DR 141: When looking in the
31992 current enclosing context for a
31993 template-name after -> or ., only
31994 consider class templates. */
31998 /* If we did unqualified lookup of a dependent member-qualified name and
31999 found something, do we want to use it? P1787 clarified that we need
32000 to look in the object scope first even if it's dependent, but for now
32001 let's still use it in some cases.
32002 FIXME remember unqualified lookup result to use if member lookup fails
32003 at instantiation time. */
32005 {
32007 /* Only use the unqualified class template lookup if we're actually
32008 looking at a template arg list. */
32011 }
32013 /* If we know we're looking for a type (e.g. A in p->A::x),
32014 mock up a typename. */
32016 {
32018 typename_type);
32020 }
32024 }
32025 else
32026 {
32031 }
32033 /* If the lookup failed, let our caller know. */
32037 /* If we have resolved the name of a member declaration, check to
32038 see if the declaration is accessible. When the name resolves to
32039 set of overloaded functions, accessibility is checked when
32040 overload resolution is done. If we have a TREE_LIST, then the lookup
32041 is either ambiguous or it found multiple injected-class-names, the
32042 accessibility of which is trivially satisfied.
32044 During an explicit instantiation, access is not checked at all,
32045 as per [temp.explicit]. */
32048 tf_warning_or_error);
32050 /* Pull out the template from an injected-class-name (or multiple). */
32054 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
32056 {
32059 /* The error message we have to print is too complicated for
32060 cp_parser_error, so we incorporate its actions directly. */
32062 {
32064 name);
32066 }
32068 }
32079 }
32081 /* Like cp_parser_lookup_name, but for use in the typical case where
32082 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
32083 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
32085 static tree
32087 {
32089 none_type,
32094 location);
32095 }
32097 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
32098 the current context, return the TYPE_DECL. If TAG_NAME_P is
32099 true, the DECL indicates the class being defined in a class-head,
32100 or declared in an elaborated-type-specifier.
32102 Otherwise, return DECL. */
32104 static tree
32106 {
32107 /* If the TEMPLATE_DECL is being declared as part of a class-head,
32108 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
32110 struct A {
32111 template <typename T> struct B;
32112 };
32114 template <typename T> struct A::B {};
32116 Similarly, in an elaborated-type-specifier:
32118 namespace N { struct X{}; }
32120 struct A {
32121 template <typename T> friend struct N::X;
32122 };
32124 However, if the DECL refers to a class type, and we are in
32125 the scope of the class, then the name lookup automatically
32126 finds the TYPE_DECL created by build_self_reference rather
32127 than a TEMPLATE_DECL. For example, in:
32129 template <class T> struct S {
32130 S s;
32131 };
32133 there is no need to handle such case. */
32139 }
32141 /* If too many, or too few, template-parameter lists apply to the
32142 declarator, issue an error message. Returns TRUE if all went well,
32143 and FALSE otherwise. */
32145 static bool
32148 location_t declarator_location)
32149 {
32151 {
32153 {
32162 {
32163 /* If the DECLARATOR has the form `X<y>' then it uses one
32164 additional level of template parameters. */
32167 }
32169 return cp_parser_check_template_parameters
32171 declarator);
32172 }
32188 }
32190 }
32192 /* NUM_TEMPLATES were used in the current declaration. If that is
32193 invalid, return FALSE and issue an error messages. Otherwise,
32194 return TRUE. If DECLARATOR is non-NULL, then we are checking a
32195 declarator and we can print more accurate diagnostics. */
32197 static bool
32201 location_t location,
32203 {
32204 /* If there are the same number of template classes and parameter
32205 lists, that's OK. */
32208 /* If there are more, but only one more, and the name ends in an identifier,
32209 then we are declaring a primary template. That's OK too. */
32217 /* If there are more template classes than parameter lists, we have
32218 something like:
32220 template <class T> void S<T>::R<T>::f (); */
32222 {
32232 else
32235 }
32236 /* Otherwise, there are too many template parameter lists. We have
32237 something like:
32239 template <class T> template <class U> void S::f(); */
32242 }
32244 /* Parse an optional `::' token indicating that the following name is
32245 from the global namespace. If so, PARSER->SCOPE is set to the
32246 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
32247 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
32248 Returns the new value of PARSER->SCOPE, if the `::' token is
32249 present, and NULL_TREE otherwise. */
32251 static tree
32253 {
32256 /* Peek at the next token. */
32258 /* If we're looking at a `::' token then we're starting from the
32259 global namespace, not our current location. */
32261 {
32262 /* Consume the `::' token. */
32264 /* Set the SCOPE so that we know where to start the lookup. */
32270 }
32272 {
32276 }
32279 }
32281 /* Returns TRUE if the upcoming token sequence is the start of a
32282 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
32283 declarator is preceded by the `friend' specifier. The parser flags FLAGS
32284 is used to control type-specifier parsing. */
32286 static bool
32289 {
32292 tree nested_name_specifier;
32295 /* The common case is that this is not a constructor declarator, so
32296 try to avoid doing lots of work if at all possible. It's not
32297 valid declare a constructor at function scope. */
32300 /* And only certain tokens can begin a constructor declarator. */
32305 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
32306 declarator-id of a constructor or destructor. */
32310 /* Parse tentatively; we are going to roll back all of the tokens
32311 consumed here. */
32313 /* Assume that we are looking at a constructor declarator. */
32316 /* Look for the optional `::' operator. */
32319 /* Look for the nested-name-specifier. */
32320 nested_name_specifier
32327 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
32330 {
32335 }
32341 /* Outside of a class-specifier, there must be a
32342 nested-name-specifier. Except in C++17 mode, where we
32343 might be declaring a guiding declaration. */
32350 /* If we have a class scope, this is easy; DR 147 says that S::S always
32351 names the constructor, and no other qualified name could. */
32354 {
32364 }
32365 /* If we still think that this might be a constructor-declarator,
32366 look for a class-name. */
32368 {
32369 /* If we have:
32371 template <typename T> struct S {
32372 S();
32373 };
32375 we must recognize that the nested `S' names a class. */
32379 tree type_decl;
32383 none_type,
32390 {
32396 none_type,
32401 else
32403 }
32405 /* If there was no class-name, then this is not a constructor.
32406 Otherwise, if we are in a class-specifier and we aren't
32407 handling a friend declaration, check that its type matches
32408 current_class_type (c++/38313). Note: error_mark_node
32409 is left alone for error recovery purposes. */
32411 && (outside_class_specifier_p
32417 /* If we're still considering a constructor, we have to see a `(',
32418 to begin the parameter-declaration-clause, followed by either a
32419 `)', an `...', or a decl-specifier. We need to check for a
32420 type-specifier to avoid being fooled into thinking that:
32422 S (f) (int);
32424 is a constructor. (It is actually a function named `f' that
32425 takes one parameter (of type `int') and returns a value of type
32426 `S'. */
32434 /* A parameter declaration begins with a decl-specifier,
32435 which is either the "attribute" keyword, a storage class
32436 specifier, or (usually) a type-specifier. */
32438 /* GNU attributes can actually appear both at the start of
32439 a parameter and parenthesized declarator.
32440 S (__attribute__((unused)) int);
32441 is a constructor, but
32442 S (__attribute__((unused)) foo) (int);
32443 is a function declaration. [[attribute]] can appear in the
32444 first form too, but not in the second form. */
32446 {
32447 tree type;
32453 {
32457 }
32459 /* Names appearing in the type-specifier should be looked up
32460 in the scope of the class. */
32464 {
32467 {
32471 {
32474 }
32475 }
32477 }
32479 /* Inside the constructor parameter list, surrounding
32480 template-parameter-lists do not apply. */
32481 saved_num_template_parameter_lists
32485 /* Look for the type-specifier. It's not optional, but its typename
32486 might be. Unless this is a friend declaration; we don't want to
32487 treat
32489 friend S (T::fn)(int);
32491 as a constructor, but with P0634, we might assume a type when
32492 looking for the type-specifier. It is actually a function named
32493 `T::fn' that takes one parameter (of type `int') and returns a
32494 value of type `S'. Constructors can be friends, but they must
32495 use a qualified name.
32497 Parse with an empty set of declaration specifiers since we're
32498 trying to match a decl-specifier-seq of the first parameter.
32499 This must be non-null so that cp_parser_simple_type_specifier
32500 will recognize a constrained placeholder type such as:
32501 'C<int> auto' where C is a type concept. */
32502 cp_decl_specifier_seq ctor_specs;
32512 parser->num_template_parameter_lists
32515 /* Leave the scope of the class. */
32520 }
32521 }
32523 /* We did not really want to consume any tokens. */
32527 }
32529 /* Parse the definition of the function given by the DECL_SPECIFIERS,
32530 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
32531 they must be performed once we are in the scope of the function.
32533 Returns the function defined. */
32535 static tree
32536 cp_parser_function_definition_from_specifiers_and_declarator
32539 tree attributes,
32541 {
32542 tree fn;
32545 /* Begin the function-definition. */
32548 /* The things we're about to see are not directly qualified by any
32549 template headers we've seen thus far. */
32552 /* If there were names looked up in the decl-specifier-seq that we
32553 did not check, check them now. We must wait until we are in the
32554 scope of the function to perform the checks, since the function
32555 might be a friend. */
32559 {
32564 }
32567 {
32568 /* Skip the entire function. */
32571 }
32573 {
32574 /* Seen already, skip it. An error message has already been output. */
32578 /* If this is a function from a class, pop the nested class. */
32581 }
32582 else
32583 {
32588 }
32591 }
32593 /* Parse the part of a function-definition that follows the
32594 declarator. INLINE_P is TRUE iff this function is an inline
32595 function defined within a class-specifier.
32597 Returns the function defined. */
32599 static tree
32602 {
32603 tree fn;
32608 bool fully_implicit_function_template_p
32611 tree implicit_template_parms
32614 cp_binding_level* implicit_template_scope
32620 /* If the next token is `return', then the code may be trying to
32621 make use of the "named return value" extension that G++ used to
32622 support. */
32625 {
32626 /* Consume the `return' keyword. */
32628 /* Look for the identifier that indicates what value is to be
32629 returned. */
32631 /* Issue an error message. */
32634 /* Skip tokens until we reach the start of the function body. */
32636 {
32643 }
32644 }
32645 /* The `extern' in `extern "C" void f () { ... }' does not apply to
32646 anything declared inside `f'. */
32647 saved_in_unbraced_linkage_specification_p
32650 /* Inside the function, surrounding template-parameter-lists do not
32651 apply. */
32652 saved_num_template_parameter_lists
32656 /* If the next token is `try', `__transaction_atomic', or
32657 `__transaction_relaxed`, then we are looking at either function-try-block
32658 or function-transaction-block. Note that all of these include the
32659 function-body. */
32663 RID_TRANSACTION_RELAXED))
32667 else
32668 cp_parser_ctor_initializer_opt_and_function_body
32671 /* Finish the function. */
32675 && !inline_p
32681 /* Generate code for it, if necessary. */
32684 /* Restore the saved values. */
32685 parser->in_unbraced_linkage_specification_p
32687 parser->num_template_parameter_lists
32691 parser->fully_implicit_function_template_p
32693 parser->implicit_template_parms
32695 parser->implicit_template_scope
32702 }
32704 /* Parse a template-declaration body (following argument list). */
32706 static void
32708 tree parameter_list,
32710 {
32714 /* We just processed one more parameter list. */
32717 /* Get the deferred access checks from the parameter list. These
32718 will be checked once we know what is being declared, as for a
32719 member template the checks must be performed in the scope of the
32720 class containing the member. */
32723 /* Tentatively parse for a new template parameter list, which can either be
32724 the template keyword or a template introduction. */
32733 /* -fconcept-ts 'concept bool' syntax is handled below, in
32734 cp_parser_single_declaration. */
32736 else
32737 {
32740 checks,
32741 member_p,
32745 /* If this is a member template declaration, let the front
32746 end know. */
32748 {
32753 }
32758 }
32759 /* We are done with the current parameter list. */
32764 /* Finish up. */
32767 /* Check the template arguments for a literal operator template. */
32771 {
32775 else
32776 {
32779 {
32786 /* OK, C++20 string literal operator template. We don't need
32787 to warn in lower dialects here because we will have already
32792 }
32794 {
32803 else
32804 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
32806 "ISO C++ did not adopt string literal operator templa"
32808 }
32809 else
32811 }
32813 {
32816 "template %qD has invalid parameter list; expected "
32817 "non-type template parameter pack %<<char...>%> or "
32819 decl);
32820 else
32822 "template %qD has invalid parameter list; expected "
32824 decl);
32825 }
32826 }
32828 /* Register member declarations. */
32831 /* If DECL is a function template, we must return to parse it later.
32832 (Even though there is no definition, there might be default
32833 arguments that need handling.) */
32837 }
32839 /* Parse a template introduction header for a template-declaration. Returns
32840 false if tentative parse fails. */
32842 static bool
32844 {
32854 /* In classes don't parse valid unnamed bitfields as invalid
32855 template introductions. */
32859 /* Look for the optional `::' operator. */
32862 /* Look for the nested-name-specifier. */
32872 /* Look up the concept for which we will be matching
32873 template parameters. */
32885 /* Look for opening brace for introduction. */
32886 matching_braces braces;
32895 /* Build vector of placeholder parameters and grab
32896 matching identifiers. */
32899 /* Look for closing brace for introduction. */
32903 /* The introduction-list shall not be empty. */
32906 {
32907 /* In cp_parser_introduction_list we have already issued an error. */
32909 }
32912 {
32916 }
32918 /* Build and associate the constraint. */
32923 introduction_list,
32924 introduction_loc);
32926 {
32933 member_p);
32935 }
32941 }
32943 /* Parse a normal template-declaration following the template keyword. */
32945 static void
32947 {
32948 tree parameter_list;
32952 /* Look for the `<' token. */
32956 {
32957 /* 14.5.2.2 [temp.mem]
32959 A local class shall not have member templates. */
32964 }
32965 /* [temp]
32967 A template ... shall not have C linkage. */
32969 {
32972 /* Give it C++ linkage to avoid confusing other parts of the
32973 front end. */
32976 }
32977 else
32980 /* We cannot perform access checks on the template parameter
32981 declarations until we know what is being declared, just as we
32982 cannot check the decl-specifier list. */
32985 /* If the next token is `>', then we have an invalid
32986 specialization. Rather than complain about an invalid template
32987 parameter, issue an error message here. */
32989 {
32993 }
32994 else
32995 {
32996 /* Parse the template parameters. */
32998 }
33000 /* Look for the `>'. */
33003 /* Manage template requirements */
33005 {
33010 }
33013 member_p);
33015 /* For the erroneous case of a template with C linkage, we pushed an
33016 implicit C++ linkage scope; exit that scope now. */
33019 }
33021 /* Parse a template-declaration, assuming that the `export' (and
33022 `extern') keywords, if present, has already been scanned. MEMBER_P
33023 is as for cp_parser_template_declaration. */
33025 static bool
33027 {
33029 {
33033 }
33038 }
33040 /* Perform the deferred access checks from a template-parameter-list.
33041 CHECKS is a TREE_LIST of access checks, as returned by
33042 get_deferred_access_checks. */
33044 static void
33045 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
33046 {
33050 }
33052 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
33053 `function-definition' sequence that follows a template header.
33054 If MEMBER_P is true, this declaration appears in a class scope.
33056 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
33057 *FRIEND_P is set to TRUE iff the declaration is a friend. */
33059 static tree
33065 {
33068 cp_decl_specifier_seq decl_specifiers;
33072 /* This function is only used when processing a template
33073 declaration. */
33077 /* Defer access checks until we know what is being declared. */
33080 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
33081 alternative. */
33084 (CP_PARSER_FLAGS_OPTIONAL
33089 cp_omp_declare_simd_data odsd;
33098 /* There are no template typedefs. */
33100 {
33104 }
33106 /* Gather up the access checks that occurred the
33107 decl-specifier-seq. */
33110 /* Check for the declaration of a template class. */
33112 {
33115 {
33118 /* In this case:
33120 struct C {
33121 friend template <typename T> struct A<T>::B;
33122 };
33124 A<T>::B will be represented by a TYPENAME_TYPE, and
33125 therefore not recognized by shadow_tag. */
33127 && !decl
33134 else
33137 /* If this is a declaration, but not a definition, associate
33138 any constraints with the type declaration. Constraints
33139 are associated with definitions in cp_parser_class_specifier. */
33143 /* Perform access checks for template parameters. */
33146 /* Give a helpful diagnostic for
33147 template <class T> struct A { } a;
33148 if we aren't already recovering from an error. */
33151 {
33153 "a class template declaration must not declare "
33157 }
33158 }
33159 }
33161 /* Complain about missing 'typename' or other invalid type names. */
33164 {
33165 /* cp_parser_parse_and_diagnose_invalid_type_name calls
33166 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
33167 the rest of this declaration. */
33170 }
33172 /* If it's not a template class, try for a template function. If
33173 the next token is a `;', then this declaration does not declare
33174 anything. But, if there were errors in the decl-specifiers, then
33175 the error might well have come from an attempted class-specifier.
33176 In that case, there's no need to warn about a missing declarator. */
33180 {
33182 /* We don't delay parsing for friends, though CWG 2510 may change
33183 that. */
33187 flags,
33189 checks,
33191 member_p,
33192 declares_class_or_enum,
33196 /* 7.1.1-1 [dcl.stc]
33198 A storage-class-specifier shall not be specified in an explicit
33199 specialization... */
33201 && explicit_specialization_p
33203 {
33207 }
33211 }
33213 /* Look for a trailing `;' after the declaration. */
33219 out:
33222 /* Clear any current qualification; whatever comes next is the start
33223 of something new. */
33231 }
33233 /* Parse a cast-expression that is not the operand of a unary "&". */
33235 static cp_expr
33237 {
33240 }
33242 /* Parse a functional cast to TYPE. Returns an expression
33243 representing the cast. */
33245 static cp_expr
33247 {
33249 tree expression_list;
33250 cp_expr cast;
33258 {
33268 /* Create a location of the form:
33269 type_name{i, f}
33270 ^~~~~~~~~~~~~~~
33271 with caret == start at the start of the type name,
33272 finishing at the closing brace. */
33277 }
33286 else
33287 {
33290 }
33292 /* Create a location of the form:
33293 float(i)
33294 ^~~~~~~~
33295 with caret == start at the start of the type name,
33296 finishing at the closing paren. */
33300 tf_warning_or_error);
33302 /* [expr.const]/1: In an integral constant expression "only type
33303 conversions to integral or enumeration type can be used". */
33309 NIC_CONSTRUCTOR))
33313 }
33315 /* Save the tokens that make up the body of a member function defined
33316 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
33317 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
33318 specifiers applied to the declaration. Returns the FUNCTION_DECL
33319 for the member function. */
33321 static tree
33325 tree attributes)
33326 {
33329 tree fn;
33332 /* Create the FUNCTION_DECL. */
33336 /* If something went badly wrong, bail out now. */
33338 {
33339 /* If there's a function-body, skip it. */
33344 }
33346 /* Remember it, if there are default args to post process. */
33349 /* Save away the tokens that make up the body of the
33350 function. */
33356 RID_TRANSACTION_ATOMIC))
33357 {
33359 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
33366 {
33372 }
33373 else
33376 {
33380 }
33381 }
33383 /* Handle function try blocks. */
33385 {
33388 }
33389 /* We can have braced-init-list mem-initializers before the fn body. */
33391 {
33394 {
33395 /* cache_group will stop after an un-nested { } pair, too. */
33399 /* variadic mem-inits have ... after the ')'. */
33402 }
33403 }
33405 /* Handle function try blocks. */
33411 /* Save away the inline definition; we will process it when the
33412 class is complete. */
33416 /* We need to know that this was defined in the class, so that
33417 friend templates are handled correctly. */
33420 /* Add FN to the queue of functions to be parsed later. */
33424 }
33426 /* Save the tokens that make up the in-class initializer for a non-static
33427 data member. Returns a DEFERRED_PARSE. */
33429 static tree
33431 {
33433 }
33435 /* Parse a template-argument-list, as well as the trailing ">" (but
33436 not the opening "<"). See cp_parser_template_argument_list for the
33437 return value. */
33439 static tree
33441 {
33442 tree arguments;
33443 tree saved_scope;
33444 tree saved_qualifying_scope;
33445 tree saved_object_scope;
33448 /* [temp.names]
33450 When parsing a template-id, the first non-nested `>' is taken as
33451 the end of the template-argument-list rather than a greater-than
33452 operator. */
33453 saved_greater_than_is_operator_p
33456 /* Parsing the argument list may modify SCOPE, so we save it
33457 here. */
33461 /* We need to evaluate the template arguments, even though this
33462 template-id may be nested within a "sizeof". */
33463 cp_evaluated ev;
33464 /* Parse the template-argument-list itself. */
33469 {
33472 }
33473 else
33475 /* Look for the `>' that ends the template-argument-list. If we find
33476 a '>>' instead, it's probably just a typo. */
33478 {
33480 {
33481 /* In C++0x, a `>>' in a template argument list or cast
33482 expression is considered to be two separate `>'
33483 tokens. So, change the current token to a `>', but don't
33484 consume it: it will be consumed later when the outer
33485 template argument list (or cast expression) is parsed.
33486 Note that this replacement of `>' for `>>' is necessary
33487 even if we are parsing tentatively: in the tentative
33488 case, after calling
33489 cp_parser_enclosed_template_argument_list we will always
33490 throw away all of the template arguments and the first
33491 closing `>', either because the template argument list
33492 was erroneous or because we are replacing those tokens
33493 with a CPP_TEMPLATE_ID token. The second `>' (which will
33494 not have been thrown away) is needed either to close an
33495 outer template argument list or to complete a new-style
33496 cast. */
33499 }
33501 {
33502 /* If we're in a nested template argument list, the '>>' has
33503 to be a typo for '> >'. We emit the error message, but we
33504 continue parsing and we push a '>' as next token, so that
33505 the argument list will be parsed correctly. Note that the
33506 global source location is still on the token before the
33507 '>>', so we need to say explicitly where we want it. */
33515 }
33516 else
33517 {
33518 /* If this is not a nested template argument list, the '>>'
33519 is a typo for '>'. Emit an error message and continue.
33520 Same deal about the token location, but here we can get it
33521 right by consuming the '>>' before issuing the diagnostic. */
33524 "spurious %<>>%>, use %<>%> to terminate "
33526 }
33527 }
33528 /* Similarly for >>= and >=. */
33531 {
33537 {
33540 }
33542 {
33545 else
33548 }
33549 else
33550 {
33553 }
33559 }
33560 else
33562 /* The `>' token might be a greater-than operator again now. */
33563 parser->greater_than_is_operator_p
33565 /* Restore the SAVED_SCOPE. */
33571 }
33573 /* MEMBER_FUNCTION is a member function, or a friend. If default
33574 arguments, or the body of the function have not yet been parsed,
33575 parse them now. */
33577 static void
33579 {
33582 /* If this member is a template, get the underlying
33583 FUNCTION_DECL. */
33587 /* There should not be any class definitions in progress at this
33588 point; the bodies of members are only parsed outside of all class
33589 definitions. */
33591 /* While we're parsing the member functions we might encounter more
33592 classes. We want to handle them right away, but we don't want
33593 them getting mixed up with functions that are currently in the
33594 queue. */
33597 /* Make sure that any template parameters are in scope. */
33600 /* If the body of the function has not yet been parsed, parse it
33601 now. Except if the tokens have been purged (PR c++/39751). */
33604 {
33605 tree function_scope;
33608 /* The function is no longer pending; we are processing it. */
33613 /* If this is a local class, enter the scope of the containing
33614 function. */
33619 /* Push the body of the function onto the lexer stack. */
33622 /* Let the front end know that we going to be defining this
33623 function. */
33627 /* #pragma omp declare reduction needs special parsing. */
33629 {
33634 }
33635 else
33636 /* Now, parse the body of the function. */
33640 /* Leave the scope of the containing function. */
33644 }
33646 /* Remove any template parameters from the symbol table. */
33649 /* Restore the queue. */
33651 }
33653 /* If DECL contains any default args, remember it on the unparsed
33654 functions queue. */
33656 static void
33658 {
33659 tree probe;
33662 probe;
33665 {
33669 }
33671 /* Remember if there is a noexcept-specifier to post process. */
33676 /* Contracts are deferred. */
33679 {
33682 }
33683 }
33685 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
33686 which is either a FIELD_DECL or PARM_DECL. Parse it and return
33687 the result. For a PARM_DECL, PARMTYPE is the corresponding type
33688 from the parameter-type-list. */
33690 static tree
33693 {
33695 tree parsed_arg;
33700 /* Push the saved tokens for the default argument onto the parser's
33701 lexer stack. */
33707 /* Parse the default argument. */
33718 {
33719 /* In a non-template class, check conversions now. In a template,
33720 we'll wait and instantiate these as needed. */
33723 tf_warning_or_error);
33726 else
33728 }
33730 /* If the token stream has not been completely used up, then
33731 there was extra junk after the end of the default
33732 argument. */
33734 {
33737 else
33739 }
33741 /* Revert to the main lexer. */
33745 }
33747 /* FIELD is a non-static data member with an initializer which we saved for
33748 later; parse it now. */
33750 static void
33752 {
33753 tree def;
33760 NULL_TREE);
33766 }
33768 /* FN is a FUNCTION_DECL which may contains a parameter with an
33769 unparsed DEFERRED_PARSE. Parse the default args now. This function
33770 assumes that the current scope is the scope in which the default
33771 argument should be processed. */
33773 static void
33775 {
33778 /* While we're parsing the default args, we might (due to the
33779 statement expression extension) encounter more classes. We want
33780 to handle them right away, but we don't want them getting mixed
33781 up with default args that are currently in the queue. */
33784 /* Local variable names (and the `this' keyword) may not appear
33785 in a default argument. */
33793 /* Gather the PARM_DECLs into a vec so we can keep track of them when
33794 pushdecl clears DECL_CHAIN. */
33795 releasing_vec parms;
33805 {
33807 tree parsed_arg;
33816 /* This can happen for a friend declaration for a function
33817 already declared with default arguments. */
33820 parsed_arg
33822 default_arg,
33826 /* Update any instantiations we've already created. */
33829 }
33833 /* Restore DECL_CHAINs after clobbering by pushdecl. */
33836 {
33839 }
33843 /* Make sure no default arg is missing. */
33846 /* Restore the state of local_variables_forbidden_p. */
33849 /* Restore the queue. */
33851 }
33853 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
33855 sizeof ... ( identifier )
33857 where the 'sizeof' token has already been consumed. */
33859 static tree
33861 {
33862 /* Consume the `...'. */
33866 matching_parens parens;
33870 else
33878 /* The name is not qualified. */
33898 }
33900 /* Parse the operand of `sizeof' (or a similar operator). Returns
33901 either a TYPE or an expression, depending on the form of the
33902 input. The KEYWORD indicates which kind of expression we have
33903 encountered. */
33905 static tree
33907 {
33914 /* If it's a `...', then we are computing the length of a parameter
33915 pack. */
33920 /* Types cannot be defined in a `sizeof' expression. Save away the
33921 old message. */
33924 parser->type_definition_forbidden_message
33926 parser->type_definition_forbidden_message_arg
33929 /* The restrictions on constant-expressions do not apply inside
33930 sizeof expressions. */
33931 saved_integral_constant_expression_p
33933 saved_non_integral_constant_expression_p
33940 /* Do not actually evaluate the expression. */
33943 /* If it's a `(', then we might be looking at the type-id
33944 construction. */
33946 {
33951 /* We can't be sure yet whether we're looking at a type-id or an
33952 expression. */
33955 matching_parens parens;
33958 /* Note: as a GNU Extension, compound literals are considered
33959 postfix-expressions as they are in C99, so they are valid
33960 arguments to sizeof. See comment in cp_parser_cast_expression
33961 for details. */
33964 else
33965 {
33968 /* Look for the type-id. */
33970 /* Look for the closing `)'. */
33973 }
33975 /* If all went well, then we're done. */
33978 else
33979 {
33980 /* Commit to the tentative_firewall so we get syntax errors. */
33984 }
33985 }
33986 else
33989 /* Go back to evaluating expressions. */
33993 /* And restore the old one. */
33996 parser->integral_constant_expression_p
33998 parser->non_integral_constant_expression_p
34002 }
34004 /* If the current declaration has no declarator, return true. */
34006 static bool
34008 {
34009 /* If the next token is a `;' or a `,' then there is no
34010 declarator. */
34013 }
34015 /* Update the DECL_SPECS to reflect the storage class indicated by
34016 KEYWORD. */
34018 static void
34023 {
34024 cp_storage_class storage_class;
34027 {
34045 }
34048 {
34052 }
34054 {
34061 else
34068 }
34073 {
34076 }
34081 /* A storage class specifier cannot be applied alongside a typedef
34082 specifier. If there is a typedef specifier present then set
34083 conflicting_specifiers_p which will trigger an error later
34084 on in grokdeclarator. */
34087 {
34094 }
34095 }
34097 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
34098 is true, the type is a class or enum definition. */
34100 static void
34102 tree type_spec,
34105 {
34108 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
34109 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
34110 this is what happened. In system headers, we ignore these
34111 declarations so that G++ can work with system headers that are not
34112 C++-safe. */
34114 && !type_definition_p
34127 {
34130 ds_redefined_builtin_type_spec,
34131 token);
34133 {
34137 }
34138 }
34141 else
34142 {
34147 }
34148 }
34150 /* True iff TOKEN is the GNU keyword __thread. */
34152 static bool
34154 {
34157 }
34159 /* Set the location for a declarator specifier and check if it is
34160 duplicated.
34162 DECL_SPECS is the sequence of declarator specifiers onto which to
34163 set the location.
34165 DS is the single declarator specifier to set which location is to
34166 be set onto the existing sequence of declarators.
34168 LOCATION is the location for the declarator specifier to
34169 consider. */
34171 static void
34174 {
34183 {
34187 }
34188 else
34189 {
34191 {
34195 else
34196 {
34199 OPT_Wlong_long,
34201 }
34202 }
34204 {
34208 {
34212 }
34213 else
34214 {
34217 }
34218 }
34219 else
34220 {
34221 /* These correspond to cp-tree.h:cp_decl_spec,
34222 changes here should also be reflected there. */
34241 "this"
34242 };
34246 }
34247 }
34248 }
34250 /* Return true iff the declarator specifier DS is present in the
34251 sequence of declarator specifiers DECL_SPECS. */
34253 bool
34255 cp_decl_spec ds)
34256 {
34263 }
34265 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
34266 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
34268 static bool
34270 {
34272 }
34274 /* Issue an error message indicating that TOKEN_DESC was expected.
34275 If KEYWORD is true, it indicated this function is called by
34276 cp_parser_require_keword and the required token can only be
34277 a indicated keyword.
34279 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34280 within any error as the location of an "opening" token matching
34281 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34282 RT_CLOSE_PAREN). */
34284 static void
34286 required_token token_desc,
34288 location_t matching_location)
34289 {
34295 {
34370 }
34373 {
34375 {
34453 }
34454 }
34458 }
34461 /* If the next token is of the indicated TYPE, consume it. Otherwise,
34462 issue an error message indicating that TOKEN_DESC was expected.
34464 Returns the token consumed, if the token had the appropriate type.
34465 Otherwise, returns NULL.
34467 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34468 within any error as the location of an "opening" token matching
34469 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34470 RT_CLOSE_PAREN). */
34475 required_token token_desc,
34476 location_t matching_location)
34477 {
34480 else
34481 {
34482 /* Output the MESSAGE -- unless we're parsing tentatively. */
34485 matching_location);
34487 }
34488 }
34490 /* Skip an entire parameter list from start to finish. The next token must
34491 be the initial "<" of the parameter list. Returns true on success and
34492 false otherwise. */
34494 static bool
34496 {
34497 /* Consume the "<" because cp_parser_skip_to_end_of_template_parameter_list
34498 requires it. */
34501 }
34503 /* Ensure we are at the end of a template parameter list. If we are, return.
34504 If we are not, something has gone wrong, in which case issue an error and
34505 skip to end of the parameter list. */
34507 static void
34509 {
34510 /* Are we ready, yet? If not, issue error message. */
34515 }
34517 /* You should only call this function from inside a template parameter list
34518 (i.e. the current token should at least be the initial "<" of the
34519 parameter list). If you are skipping the entire list, it may be better to
34520 use cp_parser_skip_entire_template_parameter_list.
34522 Tokens are skipped until the final ">" is found, or if we see
34523 '{', '}', ';', or if we find an unbalanced ')' or ']'.
34525 Returns true if we successfully reached the end, and false if
34526 something unexpected happened (e.g. end of file). */
34528 static bool
34530 {
34531 /* Current level of '< ... >'. */
34533 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
34536 /* Skip tokens until the desired token is found. */
34538 {
34539 /* Peek at the next token. */
34541 {
34549 /* C++0x views the `>>' operator as two `>' tokens, but
34550 C++98 does not. */
34553 {
34554 /* We've hit a `>>' where the first `>' closes the
34555 template argument list, and the second `>' is
34556 spurious. Just consume the `>>' and stop; we've
34557 already produced at least one error. */
34560 }
34561 /* Fall through for C++0x, so we handle the second `>' in
34562 the `>>'. */
34567 {
34568 /* We've reached the token we want, consume it and stop. */
34571 }
34590 /* The '>' was probably forgotten, don't look further. */
34595 }
34597 /* Consume this token. */
34599 }
34600 }
34602 /* If the next token is the indicated keyword, consume it. Otherwise,
34603 issue an error message indicating that TOKEN_DESC was expected.
34605 Returns the token consumed, if the token had the appropriate type.
34606 Otherwise, returns NULL. */
34611 required_token token_desc)
34612 {
34616 {
34618 UNKNOWN_LOCATION);
34620 }
34623 }
34625 /* Returns TRUE iff TOKEN is a token that can begin the body of a
34626 function-definition. */
34628 static bool
34630 {
34633 /* A ctor-initializer begins with a `:'. */
34635 /* A function-try-block begins with `try'. */
34637 /* A function-transaction-block begins with `__transaction_atomic'
34638 or `__transaction_relaxed'. */
34641 /* The named return value extension begins with `return'. */
34643 }
34645 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
34646 definition. */
34648 static bool
34650 {
34657 }
34659 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
34660 C++0x) ending a template-argument. */
34662 static bool
34664 {
34672 /* For better diagnostics, treat >>= like that too, that
34673 shouldn't appear non-nested in template arguments. */
34675 }
34677 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
34678 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
34680 static bool
34683 {
34689 /* Check for the sequence `<::' in the original code. It would be lexed as
34690 `[:', where `[' is a digraph, and there is no whitespace before
34691 `:'. */
34693 {
34698 }
34700 }
34702 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
34703 or none_type otherwise. */
34705 static enum tag_types
34707 {
34709 {
34719 }
34720 }
34722 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
34723 or none_type otherwise or if the token is null. */
34725 static enum tag_types
34727 {
34732 {
34740 }
34741 }
34743 /* Diagnose redundant enum-keys. */
34745 static void
34748 {
34754 /* Look up the NAME to see if it unambiguously refers to the TYPE. */
34759 /* The enum-key is redundant for uses of the TYPE that are not
34760 declarations and for which name lookup returns just the type
34761 itself. */
34769 {
34770 /* Avoid issuing the diagnostic for apparently redundant (unscoped)
34771 enum tag in shared C/C++ code in files (such as headers) included
34772 in the main source file. */
34775 LRK_MACRO_DEFINITION_LOCATION,
34779 }
34787 }
34789 /* Describes the set of declarations of a struct, class, or class template
34790 or its specializations. Used for -Wmismatched-tags. */
34792 class class_decl_loc_t
34793 {
34798 {
34800 }
34802 /* Constructs an object for a single declaration of a class with
34803 CLASS_KEY at the current location in the current function (or
34804 at another scope). KEY_REDUNDANT is true if the class-key may
34805 be omitted in the current context without an ambiguity with
34806 another symbol with the same name.
34807 DEF_P is true for a class declaration that is a definition.
34808 CURLOC is the associated location. */
34812 {
34815 key_redundant);
34817 }
34819 /* Copy, assign, and destroy the object. Necessary because LOCVEC
34820 isn't safely copyable and assignable and doesn't release storage
34821 on its own. */
34825 { }
34828 {
34836 }
34839 {
34841 }
34843 /* Issues -Wmismatched-tags for a single class. */
34846 /* Issues -Wmismatched-tags for all classes. */
34849 /* Adds TYPE_DECL to the collection of class decls and diagnoses
34850 redundant tags (if -Wredundant-tags is enabled). */
34853 /* Either adds this decl to the collection of class decls
34854 or diagnoses it, whichever is appropriate. */
34860 {
34862 }
34865 {
34867 }
34870 {
34872 }
34875 {
34877 }
34879 /* True if a definition for the class has been seen. */
34881 {
34883 }
34885 /* The location of a single mention of a class type with the given
34886 class-key. */
34887 struct class_key_loc_t
34888 {
34891 { }
34893 /* The function the type is mentioned in. */
34894 tree func;
34895 /* The exact location. */
34896 location_t loc;
34897 /* The class-key used in the mention of the type. */
34898 tag_types class_key;
34899 /* True when the class-key could be omitted at this location
34900 without an ambiguity with another symbol of the same name. */
34902 };
34903 /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
34905 /* LOCVEC index of the definition or UINT_MAX if none exists. */
34907 /* The class-key the class was last declared with or none_type when
34908 it has been declared with a mismatched key. */
34909 tag_types def_class_key;
34911 /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
34912 description above. */
34915 };
34919 /* Issue an error message if the CLASS_KEY does not match the TYPE.
34920 DEF_P is expected to be set for a definition of class TYPE. DECL_P
34921 is set for a declaration of class TYPE and clear for a reference to
34922 it that is not a declaration of it. */
34924 static void
34928 {
34934 {
34938 type))
34942 }
34947 /* Only consider the true class-keys below and ignore typename_type,
34948 etc. that are not C++ class-keys. */
34955 }
34957 /* Returns the template or specialization of one to which the RECORD_TYPE
34958 TYPE corresponds. */
34960 static tree
34962 {
34965 /* Determine the template or its partial specialization to which TYPE
34966 corresponds. */
34975 }
34978 /* Adds the class TYPE to the collection of class decls and diagnoses
34979 redundant tags (if -Wredundant-tags is enabled).
34980 DEF_P is expected to be set for a definition of class TYPE. DECL_P
34981 is set for a (likely, based on syntactic context) declaration of class
34982 TYPE and clear for a reference to it that is not a declaration of it. */
34984 void
34987 {
34990 /* Look up the NAME to see if it unambiguously refers to the TYPE
34991 and set KEY_REDUNDANT if so. */
34996 /* The class-key is redundant for uses of the CLASS_TYPE that are
34997 neither definitions of it nor declarations, and for which name
34998 lookup returns just the type itself. */
35009 {
35010 /* Avoid issuing the diagnostic for apparently redundant struct
35011 and union class-keys in shared C/C++ code in files (such as
35012 headers) included in the main source file. */
35015 LRK_MACRO_DEFINITION_LOCATION,
35019 }
35021 /* Set if a declaration of TYPE has previously been seen or if it must
35022 exist in a precompiled header. */
35026 {
35029 {
35030 /* TYPE_DECL is the first declaration or definition of the type
35031 (outside precompiled headers -- see below). Just create
35032 a new entry for it and return unless it's a declaration
35033 involving a template that may need to be diagnosed by
35034 -Wredundant-tags. */
35038 }
35039 else
35040 {
35041 /* TYPE was previously defined in some unknown precompiled header.
35042 Simply add a record of its definition at an unknown location and
35043 proceed below to add a reference to it at the current location.
35044 (Declarations in precompiled headers that are not definitions
35045 are ignored.) */
35046 tag_types def_key
35051 }
35052 }
35054 /* A prior declaration of TYPE_DECL has been seen. */
35057 {
35064 type);
35065 }
35068 /* Do nothing if this is the first declaration of the type. */
35072 /* Do nothing if the class-key in this declaration matches
35073 the definition. */
35077 def_p);
35078 }
35080 /* Either adds this DECL corresponding to the TYPE_DECL to the collection
35081 of class decls or diagnoses it, whichever is appropriate. */
35083 void
35085 tag_types class_key,
35088 {
35089 /* Reset the CLASS_KEY associated with this type on mismatch.
35090 This is an optimization that lets the diagnostic code skip
35091 over classes that use the same class-key in all declarations. */
35095 /* Set IDXDEF to the index of the vector corresponding to
35096 the definition. */
35100 /* Append a record of this declaration to the vector. */
35102 redundant);
35108 /* As a space optimization diagnose declarations of a class
35109 whose definition has been seen and purge the LOCVEC of
35110 all entries except the definition. */
35113 {
35119 }
35120 else
35121 /* Pop the entry pushed above for this declaration. */
35123 }
35125 /* Issues -Wmismatched-tags for a single class. */
35127 void
35129 {
35133 /* Number of uses of the class. */
35136 /* The class (or template) declaration guiding the decisions about
35137 the diagnostic. For ordinary classes it's the same as THIS. For
35138 uses of instantiations of templates other than their declarations
35139 it points to the record for the declaration of the corresponding
35140 primary template or partial specialization. */
35145 {
35146 /* For implicit instantiations of a primary template look up
35147 the primary or partial specialization and use it as
35148 the expected class-key rather than using the class-key of
35149 the first reference to the instantiation. The primary must
35150 be (and inevitably is) at index zero. */
35153 /* It's possible that we didn't find SPEC. Consider:
35155 template<typename T> struct A {
35156 template<typename U> struct W { };
35157 };
35158 struct A<int>::W<int> w; // #1
35160 where while parsing A and #1 we've stashed
35161 A<T>
35162 A<T>::W<U>
35163 A<int>::W<int>
35164 into CLASS2LOC. If TYPE is A<int>::W<int>, specialization_of
35165 will yield A<int>::W<U> which may be in CLASS2LOC if we had
35166 an A<int> class specialization, but otherwise won't be in it.
35167 So try to look up A<T>::W<U>. */
35169 {
35172 }
35173 /* Now we really should have found something. */
35175 }
35176 /* Skip declarations that consistently use the same class-key. */
35180 /* Set if a definition for the class has been seen. */
35183 /* The index of the declaration whose class-key this declaration
35184 is expected to match. It's either the class-key of the class
35185 definition if one exists or the first declaration otherwise. */
35188 /* The class-key the class is expected to be declared with: it's
35189 either the key used in its definition or the first declaration
35190 if no definition has been provided.
35191 For implicit instantiations of a primary template it's
35192 the class-key used to declare the primary with. The primary
35193 must be at index zero. */
35197 /* Advance IDX to the first declaration that either is not
35198 a definition or that doesn't match the first declaration
35199 if no definition is provided. */
35204 /* Save the current function before changing it below. */
35206 /* Set the function declaration to print in diagnostic context. */
35214 auto_diagnostic_group d;
35215 /* Issue a warning for the first mismatched declaration.
35216 Avoid using "%#qT" since the class-key for the same type will
35217 be the same regardless of which one was used in the declaraion. */
35221 {
35222 /* Suggest how to avoid the warning for each instance since
35223 the guidance may be different depending on context. */
35225 (key_redundant_p
35228 xpectkstr);
35230 /* Also point to the first declaration or definition that guided
35231 the decision to issue the warning above. */
35233 (def_p
35237 }
35239 /* Issue warnings for the remaining inconsistent declarations. */
35241 {
35243 /* Skip over the declarations that match either the definition
35244 if one was provided or the first declaration. */
35250 /* Set the function declaration to print in diagnostic context. */
35255 /* Suggest how to avoid the warning for each instance since
35256 the guidance may be different depending on context. */
35258 (key_redundant_p
35261 xpectkstr);
35262 }
35264 /* Restore the current function in case it was replaced above. */
35266 }
35268 /* Issues -Wmismatched-tags for all classes. Called at the end
35269 of processing a translation unit, after declarations of all class
35270 types and their uses have been recorded. */
35272 void
35274 {
35275 /* CLASS2LOC should be empty if both -Wmismatched-tags and
35276 -Wredundant-tags are disabled. */
35278 || warn_redundant_tags
35281 /* Save the current function before changing on return. It should
35282 be null at this point. */
35286 {
35287 /* Iterate over the collected class/struct/template declarations. */
35290 {
35294 }
35295 }
35298 }
35300 /* Issue an error message if DECL is redeclared with different
35301 access than its original declaration [class.access.spec/3].
35302 This applies to nested classes, nested class templates and
35303 enumerations [class.mem/1]. */
35305 static void
35307 {
35318 }
35320 /* Look for the `template' keyword, as a syntactic disambiguator.
35321 Return TRUE iff it is present, in which case it will be
35322 consumed. */
35324 static bool
35326 {
35328 {
35329 /* In C++98 the `template' keyword can only be used within templates;
35330 outside templates the parser can always figure out what is a
35331 template and what is not. In C++11, per the resolution of DR 468,
35332 `template' is allowed in cases where it is not strictly necessary. */
35335 {
35338 "in C++98 %<template%> (as a disambiguator) is only "
35340 /* If this part of the token stream is rescanned, the same
35341 error message would be generated. So, we purge the token
35342 from the stream. */
35345 }
35346 else
35347 {
35348 /* Consume the `template' keyword. */
35351 }
35352 }
35354 }
35356 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
35357 set PARSER->SCOPE, and perform other related actions. */
35359 static void
35361 {
35364 /* Get the stored value. */
35366 /* Set the scope from the stored value. */
35371 }
35373 /* Consume tokens up through a non-nested END token. Returns TRUE if we
35374 encounter the end of a block before what we were looking for. */
35376 static bool
35380 {
35382 {
35385 /* Abort a parenthesized expression if we encounter a semicolon. */
35389 /* If we've reached the end of the file, stop. */
35395 /* We've hit the end of an enclosing block, so there's been some
35396 kind of syntax error. */
35399 /* Consume the token. */
35401 /* See if it starts a new group. */
35403 {
35405 /* In theory this should probably check end == '}', but
35406 cp_parser_save_member_function_body needs it to exit
35407 after either '}' or ')' when called with ')'. */
35410 }
35412 {
35416 }
35421 }
35422 }
35424 /* Like above, for caching a default argument or NSDMI. Both of these are
35425 terminated by a non-nested comma, but it can be unclear whether or not a
35426 comma is nested in a template argument list unless we do more parsing.
35427 In order to handle this ambiguity, when we encounter a ',' after a '<'
35428 we try to parse what follows as a parameter-declaration-list (in the
35429 case of a default argument) or a member-declarator (in the case of an
35430 NSDMI). If that succeeds, then we stop caching. */
35432 static tree
35434 {
35439 tree default_argument;
35441 /* Add tokens until we have processed the entire default
35442 argument. We add the range [first_token, token). */
35445 {
35446 /* For list-initialization, this is straightforward. */
35449 }
35451 {
35454 /* Peek at the next token. */
35456 /* What we do depends on what token we have. */
35458 {
35459 /* In valid code, a default argument must be
35460 immediately followed by a `,' `)', or `...'. */
35463 {
35464 /* If we've seen a '<', we might be in a
35465 template-argument-list. Until Core issue 325 is
35466 resolved, we don't know how this situation ought
35467 to be handled, so try to DTRT. We check whether
35468 what comes after the comma is a valid parameter
35469 declaration list. If it is, then the comma ends
35470 the default argument; otherwise the default
35471 argument continues. */
35475 /* Set ITALP so cp_parser_parameter_declaration_list
35476 doesn't decide to commit to this parse. */
35483 {
35484 /* Parse declarators until we reach a non-comma or
35485 somthing that cannot be an initializer.
35486 Just checking whether we're looking at a single
35487 declarator is insufficient. Consider:
35488 int var = tuple<T,U>::x;
35489 The template parameter 'U' looks exactly like a
35490 declarator. */
35491 do
35492 {
35496 CP_PARSER_FLAGS_NONE,
35505 }
35507 /* If we met an '=' or ';' then the original comma
35508 was the end of the NSDMI. Otherwise assume
35509 we're still in the NSDMI. */
35512 }
35513 else
35514 {
35517 tree t = cp_parser_parameter_declaration_list
35523 }
35530 }
35531 /* FALLTHRU */
35534 /* If we run into a non-nested `;', `}', or `]',
35535 then the code is invalid -- but the default
35536 argument is certainly over. */
35541 /* Handle correctly int n = sizeof ... ( p ); */
35544 /* Update DEPTH, if necessary. */
35559 /* This might be the comparison operator, or it might
35560 start a template argument list. */
35567 /* Fall through for C++0x, which treats the `>>'
35568 operator like two `>' tokens in certain
35569 cases. */
35574 {
35575 /* This might be an operator, or it might close a
35576 template argument list. But if a previous '<'
35577 started a template argument list, this will have
35578 closed it, so we can't be in one anymore. */
35582 }
35585 /* If we run out of tokens, issue an error message. */
35593 /* In these cases, we should look for template-ids.
35594 For example, if the default argument is
35595 `X<int, double>()', we need to do name lookup to
35596 figure out whether or not `X' is a template; if
35597 so, the `,' does not end the default argument.
35599 That is not yet done. */
35604 }
35606 /* If we've reached the end, stop. */
35610 /* Add the token to the token block. */
35612 }
35614 /* Create a DEFERRED_PARSE to represent the unparsed default
35615 argument. */
35622 }
35624 /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
35626 location_t
35628 {
35633 }
35635 /* Begin parsing tentatively. We always save tokens while parsing
35636 tentatively so that if the tentative parsing fails we can restore the
35637 tokens. */
35639 static void
35641 {
35642 /* Enter a new parsing context. */
35644 /* Begin saving tokens. */
35646 /* In order to avoid repetitive access control error messages,
35647 access checks are queued up until we are no longer parsing
35648 tentatively. */
35650 }
35652 /* Commit to the currently active tentative parse. */
35654 static void
35656 {
35660 /* Mark all of the levels as committed. */
35663 {
35670 }
35671 }
35673 /* Commit to the topmost currently active tentative parse.
35675 Note that this function shouldn't be called when there are
35676 irreversible side-effects while in a tentative state. For
35677 example, we shouldn't create a permanent entry in the symbol
35678 table, or issue an error message that might not apply if the
35679 tentative parse is aborted. */
35681 static void
35683 {
35688 {
35696 }
35697 }
35699 /* Abort the currently active tentative parse. All consumed tokens
35700 will be rolled back, and no diagnostics will be issued. */
35702 static void
35704 {
35708 /* Now, pretend that we want to see if the construct was
35709 successfully parsed. */
35711 }
35713 /* Stop parsing tentatively. If a parse error has occurred, restore the
35714 token stream. Otherwise, commit to the tokens we have consumed.
35715 Returns true if no error occurred; false otherwise. */
35717 static bool
35719 {
35723 /* Remember whether or not an error occurred, since we are about to
35724 destroy that information. */
35726 /* Remove the topmost context from the stack. */
35729 /* If no parse errors occurred, commit to the tentative parse. */
35731 {
35732 /* Commit to the tokens read tentatively, unless that was
35733 already done. */
35738 }
35739 /* Otherwise, if errors occurred, roll back our state so that things
35740 are just as they were before we began the tentative parse. */
35741 else
35742 {
35745 }
35746 /* Add the context to the front of the free list. */
35751 }
35753 /* Returns true if we are parsing tentatively and are not committed to
35754 this tentative parse. */
35756 static bool
35758 {
35761 }
35763 /* Returns nonzero iff an error has occurred during the most recent
35764 tentative parse. */
35766 static bool
35768 {
35771 }
35773 /* Returns nonzero if GNU extensions are allowed. */
35775 static bool
35777 {
35779 }
35780 \f
35781 /* Objective-C++ Productions */
35784 /* Parse an Objective-C expression, which feeds into a primary-expression
35785 above.
35787 objc-expression:
35788 objc-message-expression
35789 objc-string-literal
35790 objc-encode-expression
35791 objc-protocol-expression
35792 objc-selector-expression
35794 Returns a tree representation of the expression. */
35796 static cp_expr
35798 {
35799 /* Try to figure out what kind of declaration is present. */
35803 {
35813 {
35825 }
35826 /* FALLTHRU */
35832 }
35835 }
35837 /* Parse an Objective-C message expression.
35839 objc-message-expression:
35840 [ objc-message-receiver objc-message-args ]
35842 Returns a representation of an Objective-C message. */
35844 static tree
35846 {
35859 /* Construct a location e.g.
35860 [self func1:5]
35861 ^~~~~~~~~~~~~~
35862 ranging from the '[' to the ']', with the caret at the start. */
35868 }
35870 /* Parse an objc-message-receiver.
35872 objc-message-receiver:
35873 expression
35874 simple-type-specifier
35876 Returns a representation of the type or expression. */
35878 static tree
35880 {
35881 tree rcv;
35883 /* An Objective-C message receiver may be either (1) a type
35884 or (2) an expression. */
35888 /* If that worked out, fine. */
35895 CP_PARSER_FLAGS_NONE);
35902 }
35904 /* Parse the arguments and selectors comprising an Objective-C message.
35906 objc-message-args:
35907 objc-selector
35908 objc-selector-args
35909 objc-selector-args , objc-comma-args
35911 objc-selector-args:
35912 objc-selector [opt] : assignment-expression
35913 objc-selector-args objc-selector [opt] : assignment-expression
35915 objc-comma-args:
35916 assignment-expression
35917 objc-comma-args , assignment-expression
35919 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
35920 selector arguments and TREE_VALUE containing a list of comma
35921 arguments. */
35923 static tree
35925 {
35931 {
35937 /* Detect if we have a unary selector. */
35946 sel_args
35951 }
35953 /* Handle non-selector arguments, if any. */
35955 {
35956 tree arg;
35961 addl_args
35966 }
35969 {
35972 }
35975 }
35977 /* Parse an Objective-C encode expression.
35979 objc-encode-expression:
35980 @encode objc-typename
35982 Returns an encoded representation of the type argument. */
35984 static cp_expr
35986 {
35987 tree type;
35992 matching_parens parens;
35999 {
36003 }
36005 /* This happens if we find @encode(T) (where T is a template
36006 typename or something dependent on a template typename) when
36007 parsing a template. In that case, we can't compile it
36008 immediately, but we rather create an AT_ENCODE_EXPR which will
36009 need to be instantiated when the template is used.
36010 */
36012 {
36016 }
36019 /* Build a location of the form:
36020 @encode(int)
36021 ^~~~~~~~~~~~
36022 with caret==start at the @ token, finishing at the close paren. */
36026 }
36028 /* Parse an Objective-C @defs expression. */
36030 static tree
36032 {
36033 tree name;
36036 matching_parens parens;
36042 }
36044 /* Parse an Objective-C protocol expression.
36046 objc-protocol-expression:
36047 @protocol ( identifier )
36049 Returns a representation of the protocol expression. */
36051 static tree
36053 {
36054 tree proto;
36058 matching_parens parens;
36063 /* Build a location of the form:
36064 @protocol(prot)
36065 ^~~~~~~~~~~~~~~
36066 with caret==start at the @ token, finishing at the close paren. */
36071 }
36073 /* Parse an Objective-C selector expression.
36075 objc-selector-expression:
36076 @selector ( objc-method-signature )
36078 objc-method-signature:
36079 objc-selector
36080 objc-selector-seq
36082 objc-selector-seq:
36083 objc-selector :
36084 objc-selector-seq objc-selector :
36086 Returns a representation of the method selector. */
36088 static tree
36090 {
36097 matching_parens parens;
36103 {
36112 {
36113 /* Detect if we have a unary selector. */
36115 {
36118 }
36119 else
36120 {
36122 }
36123 }
36128 {
36129 sel_seq
36132 sel_seq
36135 }
36136 else
36137 sel_seq
36142 }
36144 finish_selector:
36148 /* Build a location of the form:
36149 @selector(func)
36150 ^~~~~~~~~~~~~~~
36151 with caret==start at the @ token, finishing at the close paren. */
36154 /* TODO: objc_build_selector_expr doesn't always honor the location. */
36157 }
36159 /* Parse a list of identifiers.
36161 objc-identifier-list:
36162 identifier
36163 objc-identifier-list , identifier
36165 Returns a TREE_LIST of identifier nodes. */
36167 static tree
36169 {
36170 tree identifier;
36171 tree list;
36182 {
36189 identifier));
36191 }
36194 }
36196 /* Parse an Objective-C alias declaration.
36198 objc-alias-declaration:
36199 @compatibility_alias identifier identifier ;
36201 This function registers the alias mapping with the Objective-C front end.
36202 It returns nothing. */
36204 static void
36206 {
36214 }
36216 /* Parse an Objective-C class forward-declaration.
36218 objc-class-declaration:
36219 @class objc-identifier-list ;
36221 The function registers the forward declarations with the Objective-C
36222 front end. It returns nothing. */
36224 static void
36226 {
36229 {
36230 tree id;
36240 else
36242 }
36244 }
36246 /* Parse a list of Objective-C protocol references.
36248 objc-protocol-refs-opt:
36249 objc-protocol-refs [opt]
36251 objc-protocol-refs:
36252 < objc-identifier-list >
36254 Returns a TREE_LIST of identifiers, if any. */
36256 static tree
36258 {
36262 {
36266 }
36269 }
36271 /* Parse a Objective-C visibility specification. */
36273 static void
36275 {
36279 {
36294 }
36296 /* Eat '@private'/'@protected'/'@public'. */
36298 }
36300 /* Parse an Objective-C method type. Return 'true' if it is a class
36301 (+) method, and 'false' if it is an instance (-) method. */
36305 {
36308 else
36310 }
36312 /* Parse an Objective-C protocol qualifier. */
36314 static tree
36316 {
36329 {
36334 }
36337 }
36339 /* Parse an Objective-C typename. */
36341 static tree
36343 {
36347 {
36350 matching_parens parens;
36354 /* An ObjC type name may consist of just protocol qualifiers, in which
36355 case the type shall default to 'id'. */
36357 {
36360 /* If the type could not be parsed, an error has already
36361 been produced. For error recovery, behave as if it had
36362 not been specified, which will use the default type
36363 'id'. */
36365 {
36367 /* We need to skip to the closing parenthesis as
36368 cp_parser_type_id() does not seem to do it for
36369 us. */
36374 }
36375 }
36379 }
36382 }
36384 /* Check to see if TYPE refers to an Objective-C selector name. */
36386 static bool
36388 {
36394 }
36396 /* Parse an Objective-C selector. */
36398 static tree
36400 {
36404 {
36407 }
36409 /* C++ operator names are allowed to appear in ObjC selectors. */
36411 {
36424 }
36425 }
36427 /* Parse an Objective-C params list. */
36429 static tree
36431 {
36437 {
36447 /* Detect if we have a unary selector. */
36450 {
36453 }
36457 {
36458 /* Something went quite wrong. There should be a colon
36459 here, but there is not. Stop parsing parameters. */
36461 }
36463 /* New ObjC allows attributes on parameters too. */
36468 params
36471 type_name,
36472 identifier,
36473 parm_attr));
36476 }
36479 {
36482 }
36484 /* We allow tail attributes for the method. */
36486 {
36494 }
36497 {
36500 }
36502 }
36504 /* Parse the non-keyword Objective-C params. */
36506 static tree
36509 {
36515 {
36517 tree parm;
36523 {
36528 }
36530 /* TODO: parse attributes for tail parameters. */
36540 }
36542 /* We allow tail attributes for the method. */
36544 {
36546 {
36551 }
36552 else
36553 /* We have an error, but parse the attributes, so that we can
36554 carry on. */
36560 }
36563 }
36565 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
36567 static void
36569 {
36572 /* If the next token is `extern' and the following token is a string
36573 literal, then we have a linkage specification. */
36575 && cp_parser_is_pure_string_literal
36578 /* Handle #pragma, if any. */
36581 /* Allow stray semicolons. */
36584 /* Mark methods as optional or required, when building protocols. */
36586 {
36589 }
36591 {
36594 }
36597 /* Other stray characters must generate errors. */
36599 {
36603 }
36604 /* Finally, try to parse a block-declaration, or a function-definition. */
36605 else
36607 }
36609 /* Parse a method signature. */
36611 static tree
36613 {
36629 }
36631 static bool
36633 {
36634 tree tattr;
36639 /* If the attributes are followed by a method introducer, this is not allowed.
36640 Dump the attributes and flag the situation. */
36645 /* Otherwise, the attributes introduce some interstitial code, possibly so
36646 rewind to allow that check. */
36649 }
36651 /* Parse an Objective-C method prototype list. */
36653 static void
36655 {
36659 {
36661 {
36666 else
36670 {
36674 }
36677 }
36683 OPT_Wattributes,
36685 else
36686 /* Allow for interspersed non-ObjC++ code. */
36690 }
36694 else
36698 }
36700 /* Parse an Objective-C method definition list. */
36702 static void
36704 {
36706 {
36710 {
36713 }
36715 {
36718 }
36720 {
36724 tree attribute;
36728 else
36729 {
36733 /* For historical reasons, we accept an optional semicolon. */
36739 tree meth
36743 }
36744 }
36745 /* The following case will be removed once @synthesize is
36746 completely implemented. */
36757 else
36758 /* Allow for interspersed non-ObjC++ code. */
36760 }
36763 }
36765 /* Parse Objective-C ivars. */
36767 static void
36769 {
36780 {
36781 cp_decl_specifier_seq declspecs;
36783 tree prefix_attributes;
36791 CP_PARSER_FLAGS_OPTIONAL,
36795 /* auto, register, static, extern, mutable. */
36797 {
36800 }
36802 /* thread_local. */
36804 {
36807 }
36809 /* typedef. */
36811 {
36814 }
36819 /* Keep going until we hit the `;' at the end of the
36820 declaration. */
36822 {
36827 /* Check for a (possibly unnamed) bitfield declaration. */
36835 {
36836 /* Get the name of the bitfield. */
36841 eat_colon:
36843 /* Get the width of the bitfield. */
36844 width
36846 }
36847 else
36848 {
36849 /* Parse the declarator. */
36850 declarator
36852 CP_PARSER_FLAGS_NONE,
36858 }
36860 /* Look for attributes that apply to the ivar. */
36862 /* Remember which attributes are prefix attributes and
36863 which are not. */
36865 /* Combine the attributes. */
36869 /* Create the bitfield declaration. */
36872 else
36877 /* Add the instance variable. */
36881 /* Reset PREFIX_ATTRIBUTES. */
36883 {
36888 }
36893 {
36896 }
36898 }
36902 }
36907 /* Do not consume the RID_AT_END, so it will be read again as terminating
36908 the @interface of @implementation. */
36912 /* For historical reasons, we accept an optional semicolon. */
36915 }
36917 /* Parse an Objective-C protocol declaration. */
36919 static void
36921 {
36927 {
36932 }
36934 /* See if we have a forward declaration or a definition. */
36937 /* Try a forward declaration first. */
36939 {
36941 {
36942 tree id;
36952 else
36954 }
36956 }
36958 /* Ok, we got a full-fledged definition (or at least should). */
36959 else
36960 {
36965 }
36966 }
36968 /* Parse an Objective-C superclass or category. */
36970 static void
36975 {
36981 {
36984 }
36986 {
36987 matching_parens parens;
36990 /* If there is no category name, and this is an @interface, we
36991 have a class extension. */
36993 {
36996 }
36997 else
37001 }
37002 }
37004 /* Parse an Objective-C class interface. */
37006 static void
37008 {
37016 {
37017 /* It's hard to recover because even if valid @interface stuff
37018 is to follow, we can't compile it (or validate it) if we
37019 don't even know which class it refers to. Let's assume this
37020 was a stray '@interface' token in the stream and skip it.
37021 */
37023 }
37028 /* We have either a class or a category on our hands. */
37031 else
37032 {
37034 /* Handle instance variable declarations, if any. */
37037 }
37040 }
37042 /* Parse an Objective-C class implementation. */
37044 static void
37046 {
37053 {
37054 /* It's hard to recover because even if valid @implementation
37055 stuff is to follow, we can't compile it (or validate it) if
37056 we don't even know which class it refers to. Let's assume
37057 this was a stray '@implementation' token in the stream and
37058 skip it.
37059 */
37061 }
37065 /* We have either a class or a category on our hands. */
37068 else
37069 {
37071 /* Handle instance variable declarations, if any. */
37074 }
37077 }
37079 /* Consume the @end token and finish off the implementation. */
37081 static void
37083 {
37086 }
37088 /* Parse an Objective-C declaration. */
37090 static void
37092 {
37093 /* Try to figure out what kind of declaration is present. */
37098 {
37114 }
37117 {
37140 }
37141 }
37143 /* Parse an Objective-C try-catch-finally statement.
37145 objc-try-catch-finally-stmt:
37146 @try compound-statement objc-catch-clause-seq [opt]
37147 objc-finally-clause [opt]
37149 objc-catch-clause-seq:
37150 objc-catch-clause objc-catch-clause-seq [opt]
37152 objc-catch-clause:
37153 @catch ( objc-exception-declaration ) compound-statement
37155 objc-finally-clause:
37156 @finally compound-statement
37158 objc-exception-declaration:
37159 parameter-declaration
37160 '...'
37162 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
37164 Returns NULL_TREE.
37166 PS: This function is identical to c_parser_objc_try_catch_finally_statement
37167 for C. Keep them in sync. */
37169 static tree
37171 {
37172 location_t location;
37173 tree stmt;
37178 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
37179 node, lest it get absorbed into the surrounding block. */
37185 {
37189 matching_parens parens;
37195 {
37196 /* We have "@catch (...)" (where the '...' are literally
37197 what is in the code). Skip the '...'.
37198 parameter_declaration is set to NULL_TREE, and
37199 objc_being_catch_clauses() knows that that means
37200 '...'. */
37203 }
37204 else
37205 {
37206 /* We have "@catch (NSException *exception)" or something
37207 like that. Parse the parameter declaration. */
37212 else
37217 }
37220 else
37221 {
37222 /* If there was no open parenthesis, we are recovering from
37223 an error, and we are trying to figure out what mistake
37224 the user has made. */
37226 /* If there is an immediate closing parenthesis, the user
37227 probably forgot the opening one (ie, they typed "@catch
37228 NSException *e)". Parse the closing parenthesis and keep
37229 going. */
37233 /* If these is no immediate closing parenthesis, the user
37234 probably doesn't know that parenthesis are required at
37235 all (ie, they typed "@catch NSException *e"). So, just
37236 forget about the closing parenthesis and keep going. */
37237 }
37241 }
37243 {
37246 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
37247 node, lest it get absorbed into the surrounding block. */
37251 }
37254 }
37256 /* Parse an Objective-C synchronized statement.
37258 objc-synchronized-stmt:
37259 @synchronized ( expression ) compound-statement
37261 Returns NULL_TREE. */
37263 static tree
37265 {
37266 location_t location;
37273 matching_parens parens;
37278 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
37279 node, lest it get absorbed into the surrounding block. */
37284 }
37286 /* Parse an Objective-C throw statement.
37288 objc-throw-stmt:
37289 @throw assignment-expression [opt] ;
37291 Returns a constructed '@throw' statement. */
37293 static tree
37295 {
37307 }
37309 /* Parse an Objective-C statement. */
37311 static tree
37313 {
37314 /* Try to figure out what kind of declaration is present. */
37318 {
37329 }
37332 }
37334 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
37335 look ahead to see if an objc keyword follows the attributes. This
37336 is to detect the use of prefix attributes on ObjC @interface and
37337 @protocol. */
37339 static bool
37341 {
37346 {
37350 else
37353 }
37356 }
37358 /* This routine is a minimal replacement for
37359 c_parser_struct_declaration () used when parsing the list of
37360 types/names or ObjC++ properties. For example, when parsing the
37361 code
37363 @property (readonly) int a, b, c;
37365 this function is responsible for parsing "int a, int b, int c" and
37366 returning the declarations as CHAIN of DECLs.
37368 TODO: Share this code with cp_parser_objc_class_ivars. It's very
37369 similar parsing. */
37370 static tree
37372 {
37374 cp_decl_specifier_seq declspecs;
37376 tree prefix_attributes;
37379 CP_PARSER_FLAGS_NONE,
37386 /* auto, register, static, extern, mutable. */
37388 {
37391 }
37393 /* thread_local. */
37395 {
37398 }
37400 /* typedef. */
37402 {
37405 }
37410 /* Keep going until we hit the `;' at the end of the declaration. */
37412 {
37417 /* Parse the declarator. */
37419 CP_PARSER_FLAGS_NONE,
37422 /* Look for attributes that apply to the ivar. */
37424 /* Remember which attributes are prefix attributes and
37425 which are not. */
37427 /* Combine the attributes. */
37437 /* Reset PREFIX_ATTRIBUTES. */
37439 {
37444 }
37451 {
37454 }
37455 else
37457 }
37459 }
37461 /* Parse an Objective-C @property declaration. The syntax is:
37463 objc-property-declaration:
37464 '@property' objc-property-attributes[opt] struct-declaration ;
37466 objc-property-attributes:
37467 '(' objc-property-attribute-list ')'
37469 objc-property-attribute-list:
37470 objc-property-attribute
37471 objc-property-attribute-list, objc-property-attribute
37473 objc-property-attribute
37474 'getter' = identifier
37475 'setter' = identifier
37476 'readonly'
37477 'readwrite'
37478 'assign'
37479 'retain'
37480 'copy'
37481 'nonatomic'
37483 For example:
37484 @property NSString *name;
37485 @property (readonly) id object;
37486 @property (retain, nonatomic, getter=getTheName) id name;
37487 @property int a, b, c;
37489 PS: This function is identical to
37490 c_parser_objc_at_property_declaration for C. Keep them in sync. */
37491 static void
37493 {
37494 /* Parse the optional attribute list.
37496 A list of parsed, but not verified, attributes. */
37502 /* Parse the optional attribute list... */
37504 {
37505 /* Eat the '('. */
37506 matching_parens parens;
37511 /* Allow empty @property attribute lists, but with a warning. */
37513 location_t attr_comb;
37515 {
37519 }
37520 else
37522 {
37529 {
37536 }
37547 /* Account for accepting the 'class' keyword in this context. */
37549 else
37553 enum objc_property_attribute_kind prop_kind
37555 property_attribute_info *prop
37559 tree meth_name;
37561 {
37566 attr_name);
37567 else
37575 {
37578 attr_name);
37581 }
37589 {
37592 attr_name);
37595 }
37597 /* Get the end of the method name, and consume the name. */
37600 /* Because method names may contain C++ keywords, we have a
37601 routine to fetch them (this also consumes the token). */
37605 {
37607 {
37609 attr_end);
37613 }
37614 else
37615 {
37619 }
37621 attr_end);
37622 }
37623 else
37625 attr_end);
37627 /* Updated location including all that was successfully
37628 parsed. */
37631 }
37633 /* If we see a comma here, then keep going - even if we already
37634 saw a syntax error. For simple mistakes e.g. (asign, getter=x)
37635 this makes a more useful output and avoid spurious warnings
37636 about missing attributes that are, in fact, specified after the
37637 one with the syntax error. */
37640 else
37642 }
37648 }
37650 /* 'properties' is the list of properties that we read. Usually a
37651 single one, but maybe more (eg, in "@property int a, b, c;" there
37652 are three).
37653 TODO: Update this parsing so that it accepts (erroneous) bitfields so
37654 that we can issue a meaningful and consistent (between C/C++) error
37655 message from objc_add_property_declaration (). */
37662 else
37663 {
37664 /* Comma-separated properties are chained together in reverse order;
37665 add them one by one. */
37669 prop_attr_list);
37670 }
37673 }
37675 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
37677 objc-synthesize-declaration:
37678 @synthesize objc-synthesize-identifier-list ;
37680 objc-synthesize-identifier-list:
37681 objc-synthesize-identifier
37682 objc-synthesize-identifier-list, objc-synthesize-identifier
37684 objc-synthesize-identifier
37685 identifier
37686 identifier = identifier
37688 For example:
37689 @synthesize MyProperty;
37690 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
37692 PS: This function is identical to c_parser_objc_at_synthesize_declaration
37693 for C. Keep them in sync.
37694 */
37695 static void
37697 {
37699 location_t loc;
37704 {
37708 {
37711 }
37713 {
37717 {
37720 }
37721 }
37722 else
37727 else
37729 }
37732 }
37734 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
37736 objc-dynamic-declaration:
37737 @dynamic identifier-list ;
37739 For example:
37740 @dynamic MyProperty;
37741 @dynamic MyProperty, AnotherProperty;
37743 PS: This function is identical to c_parser_objc_at_dynamic_declaration
37744 for C. Keep them in sync.
37745 */
37746 static void
37748 {
37750 location_t loc;
37755 {
37756 tree property;
37759 {
37762 }
37766 else
37768 }
37771 }
37773 \f
37774 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
37776 /* Returns name of the next clause.
37777 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
37778 the token is not consumed. Otherwise appropriate pragma_omp_clause is
37779 returned and the token is consumed. */
37781 static pragma_omp_clause
37783 {
37799 {
37804 {
38025 }
38026 }
38032 }
38034 /* Validate that a clause of the given type does not already exist. */
38036 static void
38039 {
38042 }
38044 /* OpenMP 2.5:
38045 variable-list:
38046 identifier
38047 variable-list , identifier
38049 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
38050 colon). An opening parenthesis will have been consumed by the caller.
38052 If KIND is nonzero, create the appropriate node and install the decl
38053 in OMP_CLAUSE_DECL and add the node to the head of the list.
38055 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
38056 return the list created.
38058 COLON can be NULL if only closing parenthesis should end the list,
38059 or pointer to bool which will receive false if the list is terminated
38060 by closing parenthesis or true if the list is terminated by colon.
38062 The optional ALLOW_DEREF argument is true if list items can use the deref
38063 (->) operator. */
38065 struct omp_dim
38066 {
38068 location_t loc;
38072 };
38074 static tree
38078 {
38084 {
38087 }
38089 {
38094 /* This condition doesn't include OMP_CLAUSE_DEPEND or
38095 OMP_CLAUSE_AFFINITY since lvalue ("locator list") parsing for those is
38096 handled further down the function. */
38101 {
38107 /* This code rewrites a parsed expression containing various tree
38108 codes used to represent array accesses into a more uniform nest of
38109 OMP_ARRAY_SECTION nodes before it is processed by
38110 semantics.cc:handle_omp_array_sections_1. It might be more
38111 efficient to move this logic to that function instead, analysing
38112 the parsed expression directly rather than this preprocessed
38113 form. */
38116 {
38118 {
38123 }
38128 {
38133 {
38136 }
38138 {
38142 }
38144 {
38149 }
38150 }
38152 /* Bare references have their own special handling, so remove
38153 the explicit dereference added by convert_from_reference. */
38160 }
38162 {
38165 /* If we have "*foo" and
38166 - it's an indirection of a reference, "unconvert" it, i.e.
38167 strip the indirection (to just "foo").
38168 - it's an indirection of a pointer, turn it into
38169 "foo[0:1]". */
38175 integer_one_node);
38176 }
38178 {
38185 }
38191 }
38195 {
38201 }
38205 {
38206 cp_id_kind idk;
38209 }
38214 CPP_CLOSE_PAREN)))
38215 {
38218 }
38219 else
38220 {
38227 {
38232 }
38236 else
38239 {
38245 }
38246 }
38250 ;
38252 {
38254 {
38256 /* The OpenACC cache directive explicitly only allows "array
38257 elements or subarrays". */
38259 {
38263 }
38264 /* FALLTHROUGH. */
38268 start_component_ref:
38271 {
38272 cpp_ttype ttype
38275 location_t loc
38280 decl = (cp_parser_postfix_dot_deref_expression
38283 }
38284 /* FALLTHROUGH. */
38294 {
38302 {
38305 /* Later handling is not prepared to see through these. */
38307 }
38309 parser->colon_corrects_to_scope_p
38312 {
38315 }
38316 else
38317 {
38318 /* Look for `:'. */
38320 {
38325 }
38328 else
38331 CPP_CLOSE_SQUARE))
38332 {
38334 /* Later handling is not prepared to see through these. */
38336 }
38337 }
38338 /* Look for the closing `]'. */
38340 RT_CLOSE_SQUARE))
38341 {
38346 }
38349 }
38354 && !array_section_p
38357 {
38359 {
38363 }
38365 }
38366 else
38374 }
38377 {
38381 {
38382 depend_lvalue:
38386 }
38387 else
38389 }
38391 build_clause:
38396 }
38397 else
38400 get_comma:
38404 }
38410 {
38414 }
38417 {
38420 /* Try to resync to an unnested comma. Copied from
38421 cp_parser_parenthesized_expression_list. */
38422 skip_comma:
38431 }
38434 }
38436 /* Similarly, but expect leading and trailing parenthesis. This is a very
38437 common case for omp clauses. */
38439 static tree
38442 {
38444 {
38446 {
38452 }
38453 else
38455 list);
38456 }
38460 map_lvalue);
38462 }
38464 /* OpenACC 2.0:
38465 copy ( variable-list )
38466 copyin ( variable-list )
38467 copyout ( variable-list )
38468 create ( variable-list )
38469 delete ( variable-list )
38470 present ( variable-list )
38472 OpenACC 2.6:
38473 no_create ( variable-list )
38474 attach ( variable-list )
38475 detach ( variable-list ) */
38477 static tree
38479 tree list)
38480 {
38483 {
38521 /* "The 'host' clause is a synonym for the 'self' clause." */
38527 }
38535 }
38537 /* OpenACC 2.0:
38538 deviceptr ( variable-list ) */
38540 static tree
38542 {
38546 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
38547 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
38548 variable-list must only allow for pointer variables. */
38551 {
38558 }
38561 }
38563 /* OpenACC 2.5:
38564 auto
38565 finalize
38566 independent
38567 nohost
38568 seq */
38570 static tree
38572 tree list)
38573 {
38580 }
38582 /* OpenACC:
38583 num_gangs ( expression )
38584 num_workers ( expression )
38585 vector_length ( expression ) */
38587 static tree
38590 {
38593 matching_parens parens;
38601 {
38606 }
38614 }
38616 /* OpenACC:
38618 gang [( gang-arg-list )]
38619 worker [( [num:] int-expr )]
38620 vector [( [length:] int-expr )]
38622 where gang-arg is one of:
38624 [num:] int-expr
38625 static: size-expr
38627 and size-expr may be:
38629 *
38630 int-expr
38631 */
38633 static tree
38635 omp_clause_code kind,
38637 {
38646 {
38647 matching_parens parens;
38650 do
38651 {
38655 /* Gang static argument. */
38658 {
38666 {
38669 }
38671 /* Check for the '*' argument. */
38675 CPP_CLOSE_PAREN)))
38676 {
38681 {
38684 }
38686 }
38687 }
38688 /* Worker num: argument and vector length: arguments. */
38692 {
38695 }
38697 /* Now collect the actual argument. */
38699 {
38702 }
38714 {
38717 }
38719 }
38724 }
38738 cleanup_error:
38741 }
38743 /* OpenACC 2.0:
38744 tile ( size-expr-list ) */
38746 static tree
38748 {
38752 /* Collapse and tile are mutually exclusive. (The spec doesn't say
38753 so, but the spec authors never considered such a case and have
38754 differing opinions on what it might mean, including 'not
38755 allowed'.) */
38758 clause_loc);
38763 do
38764 {
38771 {
38774 }
38775 else
38779 }
38782 /* Consume the trailing ')'. */
38790 }
38792 /* OpenACC 2.0
38793 Parse wait clause or directive parameters. */
38795 static tree
38797 {
38807 {
38809 {
38812 }
38814 }
38821 {
38825 {
38828 else
38829 {
38836 }
38837 }
38838 }
38841 }
38843 /* OpenACC:
38844 wait [( int-expr-list )] */
38846 static tree
38848 {
38853 else
38854 {
38860 }
38863 }
38865 /* OpenMP 3.0:
38866 collapse ( constant-expression ) */
38868 static tree
38870 {
38872 location_t loc;
38873 HOST_WIDE_INT n;
38876 matching_parens parens;
38894 {
38897 }
38906 }
38908 /* OpenMP 2.5:
38909 default ( none | shared )
38911 OpenMP 5.1:
38912 default ( private | firstprivate )
38914 OpenACC:
38915 default ( none | present ) */
38917 static tree
38920 {
38922 tree c;
38924 matching_parens parens;
38928 {
38931 }
38933 {
38938 {
38965 }
38968 }
38969 else
38970 {
38971 invalid_kind:
38974 else
38977 }
38994 }
38996 /* OpenMP 3.1:
38997 final ( expression ) */
38999 static tree
39001 {
39004 matching_parens parens;
39023 }
39025 /* OpenMP 5.1:
39026 indirect [( expression )]
39027 */
39029 static tree
39031 location_t location)
39032 {
39033 tree t;
39036 {
39037 matching_parens parens;
39052 }
39053 else
39063 }
39065 /* OpenMP 2.5:
39066 if ( expression )
39068 OpenMP 4.5:
39069 if ( directive-name-modifier : expression )
39071 directive-name-modifier:
39072 parallel | task | taskloop | target data | target | target update
39073 | target enter data | target exit data
39075 OpenMP 5.0:
39076 directive-name-modifier:
39077 ... | simd | cancel */
39079 static tree
39082 {
39086 matching_parens parens;
39091 {
39107 {
39110 {
39123 else
39124 {
39125 location_t loc
39130 }
39133 {
39135 {
39140 }
39142 {
39143 location_t loc
39147 }
39148 }
39149 }
39150 }
39152 {
39154 {
39157 }
39158 else
39159 {
39161 {
39162 location_t loc
39165 }
39167 }
39168 }
39169 }
39181 {
39184 {
39187 {
39199 }
39201 p);
39203 }
39205 {
39208 else
39211 }
39214 {
39218 }
39219 }
39227 }
39229 /* OpenMP 3.1:
39230 mergeable */
39232 static tree
39235 {
39236 tree c;
39239 location);
39244 }
39246 /* OpenMP 2.5:
39247 nowait */
39249 static tree
39252 {
39253 tree c;
39260 }
39262 /* OpenMP 2.5:
39263 num_threads ( expression ) */
39265 static tree
39267 location_t location)
39268 {
39271 matching_parens parens;
39291 }
39293 /* OpenMP 4.5:
39294 num_tasks ( expression )
39296 OpenMP 5.1:
39297 num_tasks ( strict : expression ) */
39299 static tree
39301 location_t location)
39302 {
39305 matching_parens parens;
39312 {
39315 {
39319 }
39320 }
39339 }
39341 /* OpenMP 4.5:
39342 grainsize ( expression )
39344 OpenMP 5.1:
39345 grainsize ( strict : expression ) */
39347 static tree
39349 location_t location)
39350 {
39353 matching_parens parens;
39360 {
39363 {
39367 }
39368 }
39387 }
39389 /* OpenMP 4.5:
39390 priority ( expression ) */
39392 static tree
39394 location_t location)
39395 {
39398 matching_parens parens;
39418 }
39420 /* OpenMP 4.5:
39421 hint ( expression ) */
39423 static tree
39425 {
39428 matching_parens parens;
39435 {
39443 }
39456 }
39458 /* OpenMP 5.1:
39459 filter ( integer-expression ) */
39461 static tree
39463 {
39466 matching_parens parens;
39484 }
39486 /* OpenMP 4.5:
39487 defaultmap ( tofrom : scalar )
39489 OpenMP 5.0:
39490 defaultmap ( implicit-behavior [ : variable-category ] ) */
39492 static tree
39494 location_t location)
39495 {
39499 enum omp_clause_defaultmap_kind category
39502 matching_parens parens;
39509 {
39510 invalid_behavior:
39512 "%<tofrom%>, %<firstprivate%>, %<none%> "
39515 }
39516 else
39517 {
39520 }
39523 {
39527 else
39534 else
39543 else
39550 else
39557 else
39566 else
39572 }
39576 {
39581 {
39582 invalid_category:
39586 }
39591 {
39597 else
39604 else
39611 else
39617 }
39620 }
39633 {
39643 {
39661 }
39664 p);
39665 else
39669 }
39676 out_err:
39681 }
39683 /* OpenMP 5.0:
39684 order ( concurrent )
39686 OpenMP 5.1:
39687 order ( order-modifier : concurrent )
39689 order-modifier:
39690 reproducible
39691 unconstrained */
39693 static tree
39695 {
39701 matching_parens parens;
39707 {
39714 else
39715 {
39719 }
39722 }
39724 {
39727 }
39728 else
39729 {
39732 }
39734 {
39737 }
39749 out_err:
39754 }
39756 /* OpenMP 5.0:
39757 bind ( teams | parallel | thread ) */
39759 static tree
39761 location_t location)
39762 {
39763 tree c;
39767 matching_parens parens;
39772 {
39773 invalid:
39777 }
39778 else
39779 {
39782 }
39793 /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
39799 out_err:
39804 }
39806 /* OpenMP 2.5:
39807 ordered
39809 OpenMP 4.5:
39810 ordered ( constant-expression ) */
39812 static tree
39815 {
39817 HOST_WIDE_INT n;
39823 {
39824 matching_parens parens;
39841 {
39843 "ordered argument needs positive constant integer "
39846 }
39847 }
39853 }
39855 /* OpenMP 2.5:
39856 reduction ( reduction-operator : variable-list )
39858 reduction-operator:
39859 One of: + * - & ^ | && ||
39861 OpenMP 3.1:
39863 reduction-operator:
39864 One of: + * - & ^ | && || min max
39866 OpenMP 4.0:
39868 reduction-operator:
39869 One of: + * - & ^ | && ||
39870 id-expression
39872 OpenMP 5.0:
39873 reduction ( reduction-modifier, reduction-operator : variable-list )
39874 in_reduction ( reduction-operator : variable-list )
39875 task_reduction ( reduction-operator : variable-list ) */
39877 static tree
39880 {
39890 {
39893 {
39896 }
39899 {
39907 {
39910 }
39911 }
39912 }
39915 {
39925 }
39929 else
39930 {
39941 {
39971 }
39972 else
39973 {
39975 resync_fail:
39980 }
39981 }
39987 NULL);
39989 {
39996 }
39999 }
40001 /* OpenMP 2.5:
40002 schedule ( schedule-kind )
40003 schedule ( schedule-kind , expression )
40005 schedule-kind:
40006 static | dynamic | guided | runtime | auto
40008 OpenMP 4.5:
40009 schedule ( schedule-modifier : schedule-kind )
40010 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
40012 schedule-modifier:
40013 simd
40014 monotonic
40015 nonmonotonic */
40017 static tree
40019 {
40023 matching_parens parens;
40031 {
40040 else
40046 {
40049 }
40050 else
40051 {
40054 }
40055 }
40060 {
40065 {
40086 }
40087 }
40092 else
40098 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
40100 {
40104 }
40107 {
40122 else
40127 }
40139 invalid_kind:
40141 resync_fail:
40146 }
40148 /* OpenMP 3.0:
40149 untied */
40151 static tree
40154 {
40155 tree c;
40162 }
40164 /* OpenMP 4.0:
40165 inbranch
40166 notinbranch */
40168 static tree
40171 {
40176 }
40178 /* OpenMP 4.0:
40179 parallel
40180 for
40181 sections
40182 taskgroup */
40184 static tree
40188 {
40192 }
40194 /* OpenMP 4.5:
40195 nogroup */
40197 static tree
40200 {
40205 }
40207 /* OpenMP 4.5:
40208 simd
40209 threads */
40211 static tree
40215 {
40220 }
40222 /* OpenMP 4.0:
40223 num_teams ( expression )
40225 OpenMP 5.1:
40226 num_teams ( expression : expression ) */
40228 static tree
40230 location_t location)
40231 {
40234 matching_parens parens;
40245 {
40249 }
40266 }
40268 /* OpenMP 4.0:
40269 thread_limit ( expression ) */
40271 static tree
40273 location_t location)
40274 {
40277 matching_parens parens;
40297 }
40299 /* OpenMP 4.0:
40300 aligned ( variable-list )
40301 aligned ( variable-list : constant-expression ) */
40303 static tree
40305 {
40309 matching_parens parens;
40317 {
40327 }
40333 }
40335 /* OpenMP 5.0:
40336 allocate ( variable-list )
40337 allocate ( expression : variable-list )
40339 OpenMP 5.1:
40340 allocate ( allocator-modifier : variable-list )
40341 allocate ( allocator-modifier , allocator-modifier : variable-list )
40343 allocator-modifier:
40344 allocator ( expression )
40345 align ( expression ) */
40347 static tree
40349 {
40353 matching_parens parens;
40363 {
40369 matching_parens parens2;
40373 {
40377 }
40378 else
40379 {
40383 }
40387 {
40390 }
40394 }
40395 else
40398 {
40404 }
40407 {
40414 }
40415 else
40416 {
40420 }
40427 {
40430 }
40433 }
40435 /* OpenMP 2.5:
40436 lastprivate ( variable-list )
40438 OpenMP 5.0:
40439 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
40441 static tree
40443 {
40451 {
40456 {
40460 }
40461 }
40470 }
40472 /* OpenMP 4.0:
40473 linear ( variable-list )
40474 linear ( variable-list : expression )
40476 OpenMP 4.5:
40477 linear ( modifier ( variable-list ) )
40478 linear ( modifier ( variable-list ) : expression )
40480 modifier:
40481 val
40482 ref
40483 uval
40485 OpenMP 5.2:
40486 linear ( variable-list : modifiers-list )
40488 modifiers:
40489 val
40490 ref
40491 uval
40492 step ( expression ) */
40494 static tree
40497 {
40503 matching_parens parens;
40508 {
40519 {
40522 }
40523 else
40525 }
40530 else
40531 {
40540 }
40543 {
40547 {
40557 {
40561 }
40565 CPP_CLOSE_PAREN)))
40567 }
40571 {
40573 {
40584 {
40590 }
40592 {
40593 location_t step_loc
40596 matching_parens parens2;
40598 {
40604 CPP_CLOSE_PAREN))
40605 {
40606 cp_token *token
40614 tok_loc);
40616 {
40619 }
40622 }
40628 }
40629 else
40631 }
40632 else
40635 {
40638 }
40640 }
40643 }
40647 {
40658 {
40661 }
40664 }
40675 }
40678 {
40682 }
40685 }
40687 /* OpenMP 4.0:
40688 safelen ( constant-expression ) */
40690 static tree
40692 location_t location)
40693 {
40696 matching_parens parens;
40715 }
40717 /* OpenMP 4.0:
40718 simdlen ( constant-expression ) */
40720 static tree
40722 location_t location)
40723 {
40726 matching_parens parens;
40745 }
40747 /* OpenMP 4.5:
40748 vec:
40749 identifier [+/- integer]
40750 vec , identifier [+/- integer]
40751 */
40753 static tree
40756 {
40760 {
40763 }
40766 {
40772 {
40775 {
40783 }
40784 }
40785 }
40788 {
40795 else
40796 {
40797 t = cp_parser_lookup_name_simple
40802 id_loc);
40803 }
40809 {
40812 }
40816 {
40819 }
40823 {
40826 }
40829 add_to_vector:
40831 {
40835 }
40842 }
40845 {
40852 }
40854 }
40856 /* OpenMP 5.0:
40857 detach ( event-handle ) */
40859 static tree
40861 {
40862 matching_parens parens;
40878 else
40879 {
40882 else
40887 }
40900 }
40902 /* OpenMP 5.0:
40903 iterators ( iterators-definition )
40905 iterators-definition:
40906 iterator-specifier
40907 iterator-specifier , iterators-definition
40909 iterator-specifier:
40910 identifier = range-specification
40911 iterator-type identifier = range-specification
40913 range-specification:
40914 begin : end
40915 begin : end : step */
40917 static tree
40919 {
40923 matching_parens parens;
40927 bool saved_colon_corrects_to_scope_p
40929 bool saved_colon_doesnt_start_class_def_p
40932 do
40933 {
40934 tree iter_type;
40938 else
40939 {
40942 parser->type_definition_forbidden_message
40948 }
40952 {
40955 }
40975 {
40978 }
40993 {
40996 }
40998 }
41002 parser->colon_doesnt_start_class_def_p
41012 }
41014 /* OpenMP 5.0:
41015 affinity ( [aff-modifier :] variable-list )
41016 aff-modifier:
41017 iterator ( iterators-definition ) */
41019 static tree
41021 {
41024 matching_parens parens;
41029 {
41034 CPP_OPEN_PAREN)));
41036 {
41039 }
41041 {
41045 {
41053 }
41054 }
41055 }
41059 {
41062 {
41067 }
41068 }
41070 }
41072 /* OpenMP 4.0:
41073 depend ( depend-kind : variable-list )
41075 depend-kind:
41076 in | out | inout
41078 OpenMP 4.5:
41079 depend ( source )
41081 depend ( sink : vec )
41083 OpenMP 5.0:
41084 depend ( depend-modifier , depend-kind: variable-list )
41086 depend-kind:
41087 in | out | inout | mutexinoutset | depobj
41089 depend-modifier:
41090 iterator ( iterators-definition ) */
41092 static tree
41094 {
41099 matching_parens parens;
41103 do
41104 {
41112 {
41117 }
41134 else
41137 }
41145 {
41150 }
41153 {
41164 }
41170 {
41176 }
41177 else
41178 {
41183 {
41187 else
41189 }
41192 {
41197 }
41198 }
41201 invalid_kind:
41203 resync_fail:
41210 }
41212 /* OpenMP 5.2:
41213 doacross ( source : )
41214 doacross ( source : omp_cur_iteration )
41216 doacross ( sink : vec )
41217 doacross ( sink : omp_cur_iteration - logical_iteration ) */
41219 static tree
41221 {
41222 tree nlist;
41225 matching_parens parens;
41230 {
41231 invalid_kind:
41233 resync_fail:
41238 }
41247 else
41256 {
41258 {
41263 }
41268 }
41269 else
41277 }
41279 /* OpenMP 4.0:
41280 from ( variable-list )
41281 to ( variable-list )
41283 OpenMP 5.1:
41284 from ( [present :] variable-list )
41285 to ( [present :] variable-list ) */
41287 static tree
41289 tree list)
41290 {
41300 {
41304 }
41312 }
41314 /* OpenMP 4.0:
41315 map ( map-kind : variable-list )
41316 map ( variable-list )
41318 map-kind:
41319 alloc | to | from | tofrom
41321 OpenMP 4.5:
41322 map-kind:
41323 alloc | to | from | tofrom | release | delete
41325 map ( always [,] map-kind: variable-list )
41327 OpenMP 5.0:
41328 map ( [map-type-modifier[,] ...] map-kind: variable-list )
41330 map-type-modifier:
41331 always | close */
41333 static tree
41335 {
41346 {
41348 {
41351 }
41354 pos++;
41355 pos++;
41356 }
41362 {
41365 {
41368 }
41372 {
41374 {
41381 }
41383 }
41385 {
41387 {
41394 }
41396 }
41398 {
41400 {
41407 }
41409 }
41410 else
41411 {
41419 }
41422 }
41426 {
41450 else
41451 {
41457 }
41460 }
41463 {
41467 }
41469 /* We introduce a scope here so that errors parsing e.g. "always", "close"
41470 tokens do not propagate to later directives that might use them
41471 legally. */
41481 }
41483 /* OpenMP 4.0:
41484 device ( expression )
41486 OpenMP 5.0:
41487 device ( [device-modifier :] integer-expression )
41489 device-modifier:
41490 ancestor | device_num */
41492 static tree
41494 location_t location)
41495 {
41499 matching_parens parens;
41505 {
41509 {
41512 /* A requires directive with the reverse_offload clause must be
41513 specified. */
41515 {
41517 "preceded by %<requires%> directive "
41521 }
41522 }
41524 ;
41525 else
41526 {
41530 }
41533 }
41552 }
41554 /* OpenMP 4.0:
41555 dist_schedule ( static )
41556 dist_schedule ( static , expression ) */
41558 static tree
41560 location_t location)
41561 {
41564 matching_parens parens;
41575 {
41586 }
41590 /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
41591 "dist_schedule", location); */
41597 invalid_kind:
41599 resync_fail:
41604 }
41606 /* OpenMP 4.0:
41607 proc_bind ( proc-bind-kind )
41609 proc-bind-kind:
41610 primary | master | close | spread
41611 where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
41613 static tree
41615 location_t location)
41616 {
41617 tree c;
41624 {
41636 else
41638 }
41639 else
41648 location);
41653 invalid_kind:
41655 resync_fail:
41660 }
41662 /* OpenMP 5.0:
41663 device_type ( host | nohost | any ) */
41665 static tree
41667 location_t location)
41668 {
41669 tree c;
41676 {
41686 else
41688 }
41689 else
41698 location);
41703 invalid_kind:
41705 resync_fail:
41710 }
41712 /* OpenACC:
41713 async [( int-expr )] */
41715 static tree
41717 {
41724 {
41725 matching_parens parens;
41734 }
41744 }
41746 /* OpenACC 2.7:
41747 self [( expression )] */
41749 static tree
41751 {
41752 tree t;
41755 {
41756 matching_parens parens;
41761 {
41766 }
41767 }
41768 else
41773 {
41776 }
41782 }
41784 /* Parse all OpenACC clauses. The set clauses allowed by the directive
41785 is a bitmask in MASK. Return the list of clauses found. */
41787 static tree
41791 {
41795 /* Don't create location wrapper nodes within OpenACC clauses. */
41796 auto_suppress_location_wrappers sentinel;
41799 {
41800 location_t here;
41801 pragma_omp_clause c_kind;
41802 omp_clause_code code;
41813 {
41820 clauses);
41873 clauses);
41878 clauses);
41896 clauses);
41901 clauses);
41914 clauses);
41921 clauses);
41927 clauses);
41935 clauses);
41939 clauses
41946 /* OpenACC compute construct */
41948 else
41949 /* OpenACC 'update' directive */
41955 clauses);
41964 clauses);
41970 OMP_CLAUSE_VECTOR,
41977 clauses);
41986 OMP_CLAUSE_WORKER,
41992 }
41997 {
41998 /* Remove the invalid clause(s) from the list to avoid
41999 confusing the rest of the compiler. */
42002 }
42003 }
42005 saw_error:
42013 }
42015 /* Parse all OpenMP clauses. The set clauses allowed by the directive
42016 is a bitmask in MASK. Return the list of clauses found.
42017 FINISH_P set if finish_omp_clauses should be called.
42018 NESTED non-zero if clauses should be terminated by closing paren instead
42019 of end of pragma. If it is 2, additionally commas are required in between
42020 the clauses. */
42022 static tree
42026 {
42031 /* Don't create location wrapper nodes within OpenMP clauses. */
42032 auto_suppress_location_wrappers sentinel;
42035 {
42036 pragma_omp_clause c_kind;
42044 {
42049 "clauses in %<simd%> trait should be separated "
42051 }
42057 {
42074 clauses);
42093 clauses);
42113 clauses);
42118 clauses);
42123 clauses);
42128 clauses);
42137 clauses
42188 clauses);
42192 clauses
42204 clauses);
42208 clauses
42210 OMP_CLAUSE_TASK_REDUCTION,
42226 clauses);
42231 OMP_CLAUSE_NOTINBRANCH,
42240 {
42241 clause_not_first:
42245 }
42274 {
42276 clauses);
42280 }
42281 else
42283 clauses);
42288 clauses);
42293 clauses);
42315 {
42320 }
42381 clauses
42387 clauses
42394 clauses);
42400 }
42405 {
42406 /* Remove the invalid clause(s) from the list to avoid
42407 confusing the rest of the compiler. */
42410 }
42411 }
42412 saw_error:
42416 {
42419 else
42421 }
42423 }
42425 /* OpenMP 2.5:
42426 structured-block:
42427 statement
42429 In practice, we're also interested in adding the statement to an
42430 outer node. So it is convenient if we work around the fact that
42431 cp_parser_statement calls add_stmt. */
42433 static unsigned
42435 {
42438 /* Only move the values to IN_OMP_BLOCK if they weren't false.
42439 This preserves the "not within loop or switch" style error messages
42440 for nonsense cases like
42441 void foo() {
42442 #pragma omp single
42443 break;
42444 }
42445 */
42450 }
42452 static void
42454 {
42456 }
42458 static tree
42460 {
42469 }
42471 /* OpenMP 5.x:
42472 # pragma omp allocate (list) clauses
42474 OpenMP 5.0 clause:
42475 allocator (omp_allocator_handle_t expression)
42477 OpenMP 5.1 additional clause:
42478 align (constant-expression)] */
42480 static void
42482 {
42488 do
42489 {
42496 matching_parens parens;
42502 {
42505 }
42510 {
42513 }
42515 {
42518 /* FIXME: Remove when adding check to semantics.cc; cf FIXME below. */
42522 {
42524 "positive constant power of two integer "
42527 }
42529 {
42532 {
42537 {
42539 "positive constant power of two integer "
42542 }
42543 }
42544 }
42545 }
42547 {
42550 }
42551 else
42552 {
42555 }
42562 {
42565 }
42567 /* FIXME: When implementing properly, delete the align/allocate expr error
42568 check above and add one in semantics.cc (to properly handle templates).
42569 Base this on the allocator/align modifiers check for the 'allocate' clause
42570 in semantics.cc's finish_omp_clauses. */
42572 }
42574 /* OpenMP 2.5:
42575 # pragma omp atomic new-line
42576 expression-stmt
42578 expression-stmt:
42579 x binop= expr | x++ | ++x | x-- | --x
42580 binop:
42581 +, *, -, /, &, ^, |, <<, >>
42583 where x is an lvalue expression with scalar type.
42585 OpenMP 3.1:
42586 # pragma omp atomic new-line
42587 update-stmt
42589 # pragma omp atomic read new-line
42590 read-stmt
42592 # pragma omp atomic write new-line
42593 write-stmt
42595 # pragma omp atomic update new-line
42596 update-stmt
42598 # pragma omp atomic capture new-line
42599 capture-stmt
42601 # pragma omp atomic capture new-line
42602 capture-block
42604 read-stmt:
42605 v = x
42606 write-stmt:
42607 x = expr
42608 update-stmt:
42609 expression-stmt | x = x binop expr
42610 capture-stmt:
42611 v = expression-stmt
42612 capture-block:
42613 { v = x; update-stmt; } | { update-stmt; v = x; }
42615 OpenMP 4.0:
42616 update-stmt:
42617 expression-stmt | x = x binop expr | x = expr binop x
42618 capture-stmt:
42619 v = update-stmt
42620 capture-block:
42621 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
42623 OpenMP 5.1:
42624 # pragma omp atomic compare new-line
42625 conditional-update-atomic
42627 # pragma omp atomic compare capture new-line
42628 conditional-update-capture-atomic
42630 conditional-update-atomic:
42631 cond-expr-stmt | cond-update-stmt
42632 cond-expr-stmt:
42633 x = expr ordop x ? expr : x;
42634 x = x ordop expr ? expr : x;
42635 x = x == e ? d : x;
42636 cond-update-stmt:
42637 if (expr ordop x) { x = expr; }
42638 if (x ordop expr) { x = expr; }
42639 if (x == e) { x = d; }
42640 ordop:
42641 <, >
42642 conditional-update-capture-atomic:
42643 v = cond-expr-stmt
42644 { v = x; cond-expr-stmt }
42645 { cond-expr-stmt v = x; }
42646 { v = x; cond-update-stmt }
42647 { cond-update-stmt v = x; }
42648 if (x == e) { x = d; } else { v = x; }
42649 { r = x == e; if (r) { x = d; } }
42650 { r = x == e; if (r) { x = d; } else { v = x; } }
42652 where x, r and v are lvalue expressions with scalar type,
42653 expr, e and d are expressions with scalar type and e might be
42654 the same as v. */
42656 static void
42658 {
42674 {
42680 {
42685 enum omp_memory_order new_memory_order
42701 {
42705 }
42713 {
42714 matching_parens parens;
42721 {
42731 }
42734 {
42738 else
42740 }
42741 else
42751 }
42763 {
42767 }
42768 else
42769 {
42772 "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
42773 "%<seq_cst%>, %<acq_rel%>, %<release%>, "
42775 }
42777 {
42779 {
42780 /* OpenACC permits 'update capture'. */
42787 else
42789 }
42791 {
42794 else
42796 }
42798 {
42801 else
42803 }
42805 {
42808 else
42810 }
42812 {
42815 else
42817 }
42820 }
42821 }
42823 }
42829 {
42833 else
42835 }
42837 {
42841 }
42843 {
42846 }
42848 {
42851 }
42855 {
42856 omp_requires_mask
42861 {
42871 {
42873 "%<acquire%> clause implicitly provided by a "
42876 }
42877 else
42882 {
42884 "%<release%> clause implicitly provided by a "
42887 }
42888 else
42893 {
42903 }
42907 }
42908 }
42909 else
42911 {
42914 {
42918 }
42924 {
42928 }
42934 }
42936 memory_order
42941 {
42951 else
42956 {
42957 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
42958 opcode. */
42963 }
42967 {
42970 }
42974 else
42975 {
42983 {
42987 }
42988 }
42991 }
42993 restart:
42995 {
42998 matching_parens parens;
43002 tree cmp_expr;
43005 else
43013 {
43019 }
43021 ;
43023 {
43027 }
43030 {
43032 "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
43035 }
43046 {
43049 }
43054 else
43067 {
43069 {
43072 }
43074 {
43079 }
43080 else
43082 }
43087 {
43092 }
43093 else
43094 {
43095 bad_if:
43099 }
43102 {
43106 {
43110 }
43138 /* Signal to c_finish_omp_atomic that in
43139 if (x == e) { x = d; } else { v = x; }
43140 case the store to v should be conditional. */
43142 }
43144 {
43147 }
43153 }
43157 {
43164 /* FALLTHROUGH */
43176 /* FALLTHROUGH */
43193 /* Undo effects of boolean_increment for post {in,de}crement. */
43195 /* FALLTHRU */
43199 {
43200 /* Undo effects of boolean_increment. */
43202 {
43203 /* This is pre or post increment. */
43208 && !structured_block
43214 }
43215 }
43216 /* FALLTHRU */
43219 {
43222 }
43224 {
43259 {
43263 }
43268 {
43274 {
43279 }
43281 {
43295 {
43297 {
43302 }
43303 else
43305 }
43310 || !structured_block
43311 || v
43317 {
43319 {
43325 }
43326 }
43334 {
43338 cond_expr:
43340 bool saved_colon_corrects_to_scope_p
43344 parser->colon_corrects_to_scope_p
43349 {
43351 {
43353 {
43357 }
43359 {
43360 opcode
43364 }
43365 }
43366 else
43367 {
43370 {
43371 opcode
43376 }
43377 }
43378 }
43380 "invalid form of "
43383 }
43387 }
43392 {
43399 }
43403 }
43407 {
43410 {
43418 }
43420 {
43425 }
43469 }
43472 {
43474 "invalid form of "
43477 }
43488 {
43490 {
43492 "invalid form of "
43495 }
43497 }
43503 }
43510 }
43511 stmt_done:
43513 {
43526 }
43528 {
43532 }
43533 done:
43535 {
43538 }
43546 invalid_compare:
43548 /* FALLTHRU */
43549 saw_error:
43554 {
43558 {
43562 }
43563 }
43564 }
43567 /* OpenMP 2.5:
43568 # pragma omp barrier new-line */
43570 static void
43572 {
43575 }
43577 /* OpenMP 2.5:
43578 # pragma omp critical [(name)] new-line
43579 structured-block
43581 OpenMP 4.5:
43582 # pragma omp critical [(name) [hint(expression)]] new-line
43583 structured-block */
43585 #define OMP_CRITICAL_CLAUSE_MASK \
43586 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
43588 static tree
43590 {
43594 {
43595 matching_parens parens;
43611 }
43618 }
43620 /* OpenMP 5.0:
43621 # pragma omp depobj ( depobj ) depobj-clause new-line
43623 depobj-clause:
43624 depend (dependence-type : locator)
43625 destroy
43626 update (dependence-type)
43628 OpenMP 5.2 additionally:
43629 destroy ( depobj )
43631 dependence-type:
43632 in
43633 out
43634 inout
43635 mutexinout */
43637 static void
43639 {
43641 matching_parens parens;
43643 {
43646 }
43661 {
43667 {
43668 /* Don't create location wrapper nodes within the depend clause. */
43669 auto_suppress_location_wrappers sentinel;
43675 }
43677 {
43679 matching_parens c_parens;
43682 {
43689 "the %<destroy%> expression %qE should be the same "
43696 }
43697 }
43699 {
43700 matching_parens c_parens;
43702 {
43703 location_t c2_loc
43706 {
43721 }
43723 {
43727 }
43733 }
43734 else
43736 }
43737 }
43739 {
43742 }
43746 }
43749 /* OpenMP 2.5:
43750 # pragma omp flush flush-vars[opt] new-line
43752 flush-vars:
43753 ( variable-list )
43755 OpenMP 5.0:
43756 # pragma omp flush memory-order-clause new-line */
43758 static void
43760 {
43766 {
43777 else
43779 "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
43782 }
43784 {
43787 "%<flush%> list specified together with memory order "
43790 }
43794 }
43796 /* Helper function, to parse omp for increment expression. */
43798 static tree
43800 {
43805 {
43808 }
43811 {
43823 }
43825 /* If decl is an iterator, preserve LHS and RHS of the relational
43826 expr until finish_omp_for. */
43837 }
43839 /* Helper function, to parse omp for increment expression. */
43841 static tree
43843 {
43847 cp_id_kind idk;
43851 {
43860 }
43869 {
43874 }
43881 {
43885 }
43898 do
43899 {
43906 {
43908 {
43911 else
43914 }
43915 else
43920 }
43921 }
43925 {
43931 }
43932 else
43936 }
43938 /* Parse the initialization statement of an OpenMP for loop. Range-for
43939 is handled separately in cp_convert_omp_range_for.
43941 On entry SL is the current statement list. Parsing of some forms
43942 of initialization pops this list and stores its contents in either INIT
43943 or THIS_PRE_BODY, and sets SL to null. Initialization for class
43944 iterators is added directly to SL and it is not popped until later.
43946 On return, DECL is set if the initialization is by binding the
43947 iteration variable. If the initialization is by assignment, REAL_DECL
43948 is set to point to a variable in an outer scope. ORIG_INIT is set
43949 if the iteration variable is of class type; this is a copy saved for
43950 error checking in finish_omp_for.
43952 Return true if the resulting construct should have an
43953 OMP_CLAUSE_PRIVATE added to it. */
43955 static tree
43963 {
43969 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
43971 init-expr:
43972 var = lb
43973 integer-type var = lb
43974 random-access-iterator-type var = lb
43975 pointer-type var = lb
43976 */
43977 cp_decl_specifier_seq type_specifiers;
43979 /* First, try to parse as an initialized declaration. See
43980 cp_parser_condition, from whence the bulk of this is copied. */
43988 {
43989 /* If parsing a type specifier seq succeeded, then this
43990 MUST be a initialized declaration. */
43995 CP_PARSER_DECLARATOR_NAMED,
43996 CP_PARSER_FLAGS_NONE,
44008 else
44009 {
44019 {
44021 CPP_OPEN_PAREN))
44024 else
44025 /* Trigger an error. */
44030 }
44034 {
44042 {
44045 auto_node);
44050 }
44053 asm_specification,
44054 LOOKUP_ONLYCONVERTING);
44057 /* In the case of a class iterator, do not pop sl here.
44058 Both class initialization and finalization must happen in
44059 the enclosing init block scope. For now set the init
44060 expression to null; it'll be filled in properly in
44061 finish_omp_for before stuffing it in the OMP_FOR. */
44065 {
44069 {
44071 /* Move lambda DECL_EXPRs to the enclosing block. */
44073 {
44077 {
44081 }
44083 }
44085 {
44090 }
44091 }
44092 }
44093 }
44094 else
44095 /* This is an initialized declaration of non-class,
44096 non-parameterized type iteration variable. */
44097 {
44098 /* Consume '='. */
44102 non_class:
44105 else
44108 asm_specification,
44109 LOOKUP_ONLYCONVERTING);
44112 }
44116 }
44117 }
44118 else
44119 {
44120 cp_id_kind idk;
44121 /* If parsing a type specifier sequence failed, then
44122 this MUST be a simple expression. */
44128 && decl
44131 {
44142 {
44147 }
44152 }
44154 && decl
44157 {
44158 tree rhs;
44167 tf_warning_or_error));
44170 }
44171 else
44172 {
44177 {
44181 }
44182 }
44185 }
44187 }
44189 /* Helper for cp_parser_omp_loop_nest, handle one range-for loop
44190 including introducing new temporaries for the range start and end,
44191 doing auto deduction, and processing decomposition variables.
44193 This function is also called from pt.cc during template instantiation.
44194 In that case SL is NULL_TREE, otherwise it is the current statement
44195 list. */
44196 void
44200 {
44206 {
44210 /* do_auto_deduction doesn't mess with template init-lists. */
44212 {
44216 {
44221 {
44226 }
44227 }
44229 }
44234 {
44237 }
44239 }
44244 /* If an error happened previously do nothing or else a lot of
44245 unhelpful errors would be issued. */
44247 else
44248 {
44249 tree range_temp;
44253 /* Can't bind a reference to an array of runtime bound. */
44255 else
44256 {
44262 LOOKUP_ONLYCONVERTING);
44265 }
44268 }
44279 LOOKUP_ONLYCONVERTING);
44281 /* The new for initialization statement. */
44289 else
44290 {
44293 }
44296 LOOKUP_ONLYCONVERTING);
44298 /* The new for condition. */
44301 else
44307 /* The new increment expression. */
44310 else
44313 tf_warning_or_error);
44317 /* Defer popping sl here. */
44321 {
44326 {
44332 }
44333 }
44337 {
44341 {
44345 {
44351 }
44352 }
44353 }
44355 /* The output ORIG_DECL is not a decl. Instead, it is a tree structure
44356 that holds decls for variables implementing the iterator, represented
44357 as a TREE_LIST whose TREE_CHAIN is a vector. The first two elements
44358 of the vector are decls of scratch variables for the range start and
44359 end that will eventually be bound in the implicit scope surrounding
44360 the whole loop nest. The remaining elements are decls of derived
44361 decomposition variables that are bound inside the loop body. This
44362 structure is further mangled by finish_omp_for into the form required
44363 for the OMP_FOR_ORIG_DECLS field of the OMP_FOR tree node. */\
44372 {
44374 {
44375 /* If cp_finish_decomp was called with processing_template_decl
44376 temporarily set to 1, then decomp names will have deduced
44377 name but the DECL_VALUE_EXPR will be dependent. Hide those
44378 from folding of other loop initializers e.g. for warning
44379 purposes until cp_finish_omp_range_for. */
44384 }
44387 }
44389 }
44391 /* Helper for cp_parser_omp_for_loop, finalize part of range for
44392 inside of the collapsed body. */
44394 void
44396 {
44403 {
44408 {
44409 /* Undo temporary clearing of DECL_HAS_VALUE_EXPR_P done
44410 by cp_convert_omp_range_for above. */
44414 {
44418 }
44419 }
44420 }
44422 /* The declaration is initialized with *__begin inside the loop body. */
44430 }
44432 /* Return true if next tokens contain a standard attribute that contains
44433 omp::directive (DIRECTIVE). */
44435 static bool
44438 {
44446 {
44454 }
44459 location_t last_loc
44468 {
44470 {
44474 cnt++;
44478 {
44482 }
44483 }
44484 }
44486 {
44489 }
44491 {
44493 "%<[[omp::directive(%s)]]%> must be the only specified "
44497 }
44502 }
44504 /* Parse an OpenMP structured block sequence. KIND is the corresponding
44505 separating directive. */
44507 static tree
44510 {
44516 {
44529 kind == PRAGMA_OMP_SCAN
44534 }
44538 }
44541 /* OpenMP 5.0:
44543 scan-loop-body:
44544 { structured-block scan-directive structured-block } */
44546 static void
44548 {
44552 matching_braces braces;
44559 else
44560 {
44562 "%<#pragma omp scan%> with zero preceding executable "
44565 }
44571 {
44581 {
44588 }
44590 {
44593 }
44594 else
44599 }
44600 else
44606 else
44607 {
44610 "%<#pragma omp scan%> with zero succeeding executable "
44613 }
44615 clauses);
44619 }
44622 /* This function parses a single level of a loop nest, invoking itself
44623 recursively if necessary.
44625 loop-nest :: for (...) loop-body
44626 loop-body :: loop-nest
44627 | { [intervening-code] loop-body [intervening-code] }
44628 | final-loop-body
44629 intervening-code :: structured-block-sequence
44630 final-loop-body :: structured-block
44632 For a collapsed loop nest, only a single OMP_FOR is built, pulling out
44633 all the iterator information from the inner loops into vectors in the
44634 parser->omp_for_parse_state structure.
44636 In the "range for" case, it is transformed into a regular "for" iterator
44637 by introducing some temporary variables for the begin/end,
44638 as well as bindings of the actual iteration variables which are
44639 injected into the body of the loop.
44641 Initialization code for iterator variables may end up either in the
44642 init vector (simple assignments), in omp_for_parse_state->pre_body
44643 (decl_exprs for iterators bound in the for statement), or in the
44644 scope surrounding this level of loop initialization.
44646 The scopes of class iterator variables and their finalizers need to
44647 be adjusted after parsing so that all of the initialization happens
44648 in a scope surrounding all of the intervening and body code. For
44649 this reason we separately store the initialization and body blocks
44650 for each level of loops in the omp_for_parse_state structure and
44651 reassemble/reorder them in cp_parser_omp_for. See additional
44652 comments there about the use of placeholders, etc. */
44654 static tree
44656 {
44661 tree init_scope;
44666 location_t loc;
44674 /* We have already matched the FOR token but not consumed it yet. */
44678 /* Forbid break/continue in the loop initializer, condition, and
44679 increment expressions. */
44683 /* We are not in intervening code now. */
44686 /* Don't create location wrapper nodes within an OpenMP "for"
44687 statement. */
44688 auto_suppress_location_wrappers sentinel;
44690 matching_parens parens;
44697 integer_zero_node);
44700 /* The init_block acts as a container for this level of loop goo. */
44704 /* Wrap a scope around this entire level of loop to hold bindings
44705 of loop iteration variables. We can't insert them directly
44706 in the containing scope because that would cause their visibility to
44707 be incorrect with respect to intervening code after this loop.
44708 We will combine the nested init_scopes in postprocessing after the
44709 entire loop is parsed. */
44712 /* Now we need another level of statement list container to capture the
44713 initialization (and possible finalization) bits. In some cases this
44714 container may be popped off during initializer parsing to store code in
44715 INIT or THIS_PRE_BODY, depending on the form of initialization. If
44716 we have a class iterator we will pop it at the end of parsing this
44717 level, so the cleanups are handled correctly. */
44721 {
44722 /* Save tokens so that we can put them back. */
44725 /* Look for ':' that is not nested in () or {}. */
44726 is_range_for
44729 CPP_COLON,
44730 /*consume_paren=*/
44733 /* Roll back the tokens we skipped. */
44737 {
44738 bool saved_colon_corrects_to_scope_p
44741 /* A colon is used in range-based for. */
44744 /* Parse the declaration. */
44746 /*function_definition_allowed_p=*/
44748 parser->colon_corrects_to_scope_p
44762 "%<ordered%> clause with parameter on "
44766 }
44767 }
44769 add_private_clause
44775 /* If the iteration variable was introduced via a declaration in the
44776 for statement, DECL points at it. Otherwise DECL is null and
44777 REAL_DECL is a variable previously declared in an outer scope.
44778 Make REAL_DECL point at the iteration variable no matter where it
44779 was introduced. */
44783 /* Some clauses treat iterator variables specially. */
44788 {
44794 {
44798 }
44801 {
44802 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
44806 {
44810 }
44811 else
44812 {
44815 }
44817 }
44818 else
44819 {
44824 }
44825 }
44828 {
44829 tree c;
44831 {
44840 decl);
44845 decl);
44846 }
44848 {
44855 else
44860 {
44863 /* For linear, signal that we need to fill up
44864 the so far unknown linear step. */
44867 }
44868 }
44869 }
44878 {
44879 /* If decl is an iterator, preserve the operator on decl
44880 until finish_omp_for. */
44882 && ((processing_template_decl
44887 else
44890 }
44892 parse_close_paren:
44898 /* We've parsed all the for (...) stuff now. Store the bits. */
44904 {
44907 }
44909 {
44911 omp_for_parse_state->orig_declv
44914 }
44921 /* Start a nested block for the loop body. */
44923 integer_zero_node);
44931 {
44935 }
44938 {
44939 /* This is the open brace in the loop-body grammar production. Rather
44940 than trying to special-case braces, just parse it as a compound
44941 statement and handle the nested loop-body case there. Note that
44942 when we see a further open brace inside the compound statement
44943 loop-body, we don't know whether it is the start of intervening
44944 code that is a compound statement, or a level of braces
44945 surrounding a nested loop-body. Use the WANT_NESTED_LOOP state
44946 bit to ensure we have only one nested loop at each level. */
44953 {
44954 /* We have already parsed the whole loop body and not found a
44955 nested loop. */
44959 }
44961 }
44962 else
44963 {
44964 /* This is the final-loop-body case in the grammar: we have something
44965 that is not a FOR and not an open brace. */
44967 {
44968 /* If we were expecting a nested loop, give an error and mark
44969 that parsing has failed, and try to recover by parsing the
44970 body as regular code without further collapsing. */
44974 }
44977 /* Generate the parts of range for that belong in the loop body,
44978 to be executed on every iteration. This includes setting the
44979 user-declared decomposition variables from the compiler-generated
44980 temporaries that are the real iteration variables for OMP_FOR.
44981 FIXME: Not sure if this is correct with respect to visibility
44982 of the variables from intervening code. However, putting this
44983 code in each level of loop instead of all around the innermost
44984 body also makes the decomposition variables visible to the
44985 inner for init/bound/step exressions, which is not supposed to
44986 happen and causes test failures. */
44989 {
44994 }
44996 /* Now parse the final-loop-body for the innermost loop. */
45000 else
45003 }
45008 /* Pop and remember the body block. Add the body placeholder
45009 to the surrounding statement list instead. This is just a unique
45010 token that will be replaced when we reassemble the generated
45011 code for the entire omp for statement. */
45016 /* Pop and remember the init block. */
45023 /* Return the init placeholder rather than the remembered init block.
45024 Again, this is just a unique cookie that will be used to reassemble
45025 code pieces when the entire omp for statement has been parsed. */
45027 }
45029 /* Worker for find_structured_blocks. *TP points to a STATEMENT_LIST
45030 and ITER is the element that is or contains a nested loop. This
45031 function moves the statements before and after ITER into
45032 OMP_STRUCTURED_BLOCKs and modifies *TP. */
45033 static void
45035 {
45039 {
45044 TSI_SAME_STMT);
45045 i++;
45047 }
45048 else
45049 {
45053 }
45058 TSI_SAME_STMT);
45059 }
45061 /* Helper to find and mark structured blocks in intervening code for a
45062 single loop level with markers for later error checking. *TP is the
45063 piece of code to be marked and INNER is the inner loop placeholder.
45064 Returns true if INNER was found (recursively) in *TP. */
45065 static bool
45067 {
45073 {
45075 {
45077 /* The normal case is that there is no intervening code and we
45078 do not have to insert any OMP_STRUCTURED_BLOCK markers. */
45080 {
45084 }
45085 }
45087 }
45092 else
45094 }
45096 /* Helpers used for relinking tree structures: In tree rooted at
45097 CONTEXT, replace ORIG with REPLACEMENT. If FLATTEN is true, try to combine
45098 nested BIND_EXPRs. Gives an assertion if it fails to find ORIG. */
45101 tree orig;
45102 tree repl;
45104 };
45106 static tree
45109 {
45112 {
45115 }
45116 /* Remove redundant BIND_EXPRs with no bindings even when not specifically
45117 trying to flatten. */
45122 {
45125 }
45129 {
45131 {
45132 /* Merge binding lists for two directly nested BIND_EXPRs,
45133 keeping the outer one. */
45138 }
45140 /* There might be a statement list containing cleanup_points
45141 etc between the two levels of BIND_EXPR. We can still merge
45142 them, again keeping the outer BIND_EXPR. */
45145 {
45148 {
45153 }
45154 }
45155 }
45157 }
45159 static void
45161 {
45174 }
45176 /* Walker to patch up the BLOCK_NODE hierarchy after the above surgery.
45177 *DP is is the parent block. */
45179 static tree
45181 {
45184 /* BIND_EXPR_BLOCK may be null if the expression is not a
45185 full-expression; if there's no block, no patching is necessary
45186 for this node. */
45188 {
45191 {
45195 }
45200 }
45203 }
45205 /* Parse the restricted form of the for statement allowed by OpenMP. */
45207 static tree
45210 {
45211 tree ret;
45219 tree result;
45226 {
45229 }
45232 {
45235 }
45242 {
45248 }
45254 {
45257 }
45259 /* Initialize parse state for recursive descent. */
45284 /* Bomb out early if there was an error (not enough loops, etc). */
45286 {
45289 }
45291 /* Relink the init and body blocks that were built during parsing. At
45292 this point we have a structure nested like
45293 init 0
45294 body 0
45295 init 1
45296 body 1
45297 init 2
45298 body 2
45299 and we want to turn it into
45300 init 0
45301 init 1
45302 init 2
45303 omp_for
45304 body 0
45305 body 1
45306 body 2
45307 We also need to flatten the init blocks, as some code for later
45308 processing of combined directives gets confused otherwise. */
45315 /* First insert markers for structured blocks for intervening code in
45316 the loop bodies. */
45318 {
45322 }
45324 /* Do the substitution from the inside out. */
45326 {
45333 }
45335 /* Generate the OMP_FOR. Note finish_omp_for adds the OMP_FOR
45336 (and possibly other stuff) to the current statement list but
45337 returns a pointer to the OMP_FOR itself, or null in case of error. */
45345 /* Check for errors involving lb/ub/incr expressions referencing
45346 variables declared in intervening code. */
45352 {
45353 /* Splice the omp_for into the nest of init blocks. */
45358 /* Some later processing for combined directives assumes
45359 that the BIND_EXPR containing range for variables appears
45360 at top level in the OMP_FOR body. Fix that up if it's
45361 not the case, e.g. because there is intervening code. */
45365 /* Clean up the block subblock/superblock links. Per comment in
45366 begin_compound_stmt, "we don't build BLOCK nodes when processing
45367 templates", so skip this step in that case. */
45369 {
45373 }
45375 /* Finally record the result. */
45377 }
45381 }
45383 /* Helper function for OpenMP parsing, split clauses and call
45384 finish_omp_clauses on each of the set of clauses afterwards. */
45386 static void
45389 {
45395 i == C_OMP_CLAUSE_SPLIT_TARGET
45397 }
45399 /* OpenMP 5.0:
45400 #pragma omp loop loop-clause[optseq] new-line
45401 for-loop */
45403 #define OMP_LOOP_CLAUSE_MASK \
45404 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45405 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45406 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45407 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45408 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
45409 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45411 static tree
45415 {
45426 {
45429 }
45441 }
45443 /* OpenMP 4.0:
45444 #pragma omp simd simd-clause[optseq] new-line
45445 for-loop */
45447 #define OMP_SIMD_CLAUSE_MASK \
45448 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
45449 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
45450 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45451 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
45452 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45453 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45454 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45455 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45456 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
45457 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
45458 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45460 static tree
45464 {
45475 {
45478 }
45490 }
45492 /* OpenMP 2.5:
45493 #pragma omp for for-clause[optseq] new-line
45494 for-loop
45496 OpenMP 4.0:
45497 #pragma omp for simd for-simd-clause[optseq] new-line
45498 for-loop */
45500 #define OMP_FOR_CLAUSE_MASK \
45501 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45502 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45503 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45504 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45505 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45506 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
45507 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
45508 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
45509 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45510 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45511 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45513 static tree
45517 {
45524 /* parallel for{, simd} disallows nowait clause, but for
45525 target {teams distribute ,}parallel for{, simd} it should be accepted. */
45528 /* Composite distribute parallel for{, simd} disallows ordered clause. */
45533 {
45538 {
45562 }
45563 }
45565 {
45568 }
45570 /* Composite distribute parallel for disallows linear clause. */
45577 {
45580 }
45592 }
45597 /* OpenMP 2.5:
45598 # pragma omp master new-line
45599 structured-block */
45601 static tree
45605 {
45613 {
45618 {
45638 }
45639 }
45641 {
45644 }
45647 {
45651 }
45652 else
45657 }
45659 /* OpenMP 5.1:
45660 # pragma omp masked masked-clauses new-line
45661 structured-block */
45663 #define OMP_MASKED_CLAUSE_MASK \
45664 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
45666 static tree
45670 {
45679 {
45684 {
45705 }
45706 }
45708 {
45711 }
45716 {
45719 }
45723 clauses);
45724 }
45726 /* OpenMP 2.5:
45727 # pragma omp ordered new-line
45728 structured-block
45730 OpenMP 4.5:
45731 # pragma omp ordered ordered-clauses new-line
45732 structured-block */
45734 #define OMP_ORDERED_CLAUSE_MASK \
45735 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
45736 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
45738 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
45739 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
45740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DOACROSS))
45742 static bool
45745 {
45753 {
45758 {
45760 {
45763 }
45765 {
45767 "%qs clause may only be used in compound "
45771 }
45772 tree clauses
45774 OMP_ORDERED_DEPEND_CLAUSE_MASK,
45778 }
45779 }
45781 tree clauses
45792 }
45794 /* OpenMP 2.5:
45796 section-scope:
45797 { section-sequence }
45799 section-sequence:
45800 section-directive[opt] structured-block
45801 section-sequence section-directive structured-block */
45803 static tree
45805 {
45810 matching_braces braces;
45817 != PRAGMA_OMP_SECTION
45819 {
45821 PRAGMA_OMP_SECTION);
45824 }
45827 {
45837 {
45841 }
45843 {
45846 }
45849 PRAGMA_OMP_SECTION);
45852 }
45863 }
45865 /* OpenMP 2.5:
45866 # pragma omp sections sections-clause[optseq] newline
45867 sections-scope */
45869 #define OMP_SECTIONS_CLAUSE_MASK \
45870 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45871 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45872 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45873 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45874 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45875 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
45877 static tree
45880 {
45892 {
45895 }
45902 }
45904 /* OpenMP 2.5:
45905 # pragma omp parallel parallel-clause[optseq] new-line
45906 structured-block
45907 # pragma omp parallel for parallel-for-clause[optseq] new-line
45908 structured-block
45909 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
45910 structured-block
45912 OpenMP 4.0:
45913 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
45914 structured-block */
45916 #define OMP_PARALLEL_CLAUSE_MASK \
45917 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
45918 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45919 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45920 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
45921 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
45922 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
45923 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45924 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
45925 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
45928 static tree
45932 {
45939 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
45945 {
45953 if_p);
45957 if_p);
45960 block);
45965 }
45966 /* When combined with distribute, parallel has to be followed by for.
45967 #pragma omp target parallel is allowed though. */
45971 {
45975 }
45977 {
45981 {
45995 block);
45998 /* masked does have just filter clause, but during gimplification
45999 isn't represented by a gimplification omp context, so for
46000 #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
46001 so that
46002 #pragma omp parallel masked
46003 #pragma omp taskloop simd lastprivate (x)
46004 isn't confused with
46005 #pragma omp parallel masked taskloop simd lastprivate (x) */
46009 }
46011 {
46025 block);
46028 /* master doesn't have any clauses and during gimplification
46029 isn't represented by a gimplification omp context, so for
46030 #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
46031 so that
46032 #pragma omp parallel master
46033 #pragma omp taskloop simd lastprivate (x)
46034 isn't confused with
46035 #pragma omp parallel master taskloop simd lastprivate (x) */
46039 }
46041 {
46056 block);
46061 }
46063 {
46066 }
46068 {
46078 block);
46081 }
46082 }
46084 {
46087 }
46092 {
46095 }
46104 }
46106 /* OpenMP 2.5:
46107 # pragma omp single single-clause[optseq] new-line
46108 structured-block */
46110 #define OMP_SINGLE_CLAUSE_MASK \
46111 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46112 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46113 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
46114 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46115 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46117 static tree
46119 {
46130 }
46132 /* OpenMP 5.1:
46133 # pragma omp scope scope-clause[optseq] new-line
46134 structured-block */
46136 #define OMP_SCOPE_CLAUSE_MASK \
46137 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46138 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46139 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46140 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46141 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46143 static tree
46145 {
46156 }
46158 /* OpenMP 3.0:
46159 # pragma omp task task-clause[optseq] new-line
46160 structured-block */
46162 #define OMP_TASK_CLAUSE_MASK \
46163 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46164 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
46165 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
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_SHARED) \
46169 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
46170 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
46171 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46172 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
46173 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46174 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
46175 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
46176 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
46178 static tree
46180 {
46192 }
46194 /* OpenMP 3.0:
46195 # pragma omp taskwait new-line
46197 OpenMP 5.0:
46198 # pragma omp taskwait taskwait-clause[opt] new-line */
46200 #define OMP_TASKWAIT_CLAUSE_MASK \
46201 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46202 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46204 static void
46206 {
46207 tree clauses
46212 {
46219 }
46220 else
46222 }
46224 /* OpenMP 3.1:
46225 # pragma omp taskyield new-line */
46227 static void
46229 {
46232 }
46234 /* OpenMP 4.0:
46235 # pragma omp taskgroup new-line
46236 structured-block
46238 OpenMP 5.0:
46239 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
46241 #define OMP_TASKGROUP_CLAUSE_MASK \
46242 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46243 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
46245 static tree
46247 {
46248 tree clauses
46253 if_p),
46254 clauses);
46255 }
46258 /* OpenMP 2.5:
46259 # pragma omp threadprivate (variable-list) */
46261 static void
46263 {
46264 tree vars;
46270 }
46272 /* OpenMP 4.0:
46273 # pragma omp cancel cancel-clause[optseq] new-line */
46275 #define OMP_CANCEL_CLAUSE_MASK \
46276 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
46277 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
46278 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
46279 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
46280 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
46282 static void
46284 {
46288 }
46290 /* OpenMP 4.0:
46291 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
46293 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
46294 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
46295 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
46296 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
46297 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
46299 static bool
46302 {
46303 tree clauses;
46307 {
46312 {
46315 }
46316 }
46318 {
46322 }
46325 {
46330 else
46334 }
46337 OMP_CANCELLATION_POINT_CLAUSE_MASK,
46339 pragma_tok);
46342 }
46344 /* OpenMP 4.0:
46345 #pragma omp distribute distribute-clause[optseq] new-line
46346 for-loop */
46348 #define OMP_DISTRIBUTE_CLAUSE_MASK \
46349 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
46353 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46354 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46355 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
46357 static tree
46361 {
46370 {
46378 else
46381 {
46387 {
46391 else
46394 }
46400 else
46414 }
46415 }
46417 {
46420 }
46425 {
46428 }
46440 }
46442 /* OpenMP 4.0:
46443 # pragma omp teams teams-clause[optseq] new-line
46444 structured-block */
46446 #define OMP_TEAMS_CLAUSE_MASK \
46447 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46448 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46449 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46450 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46451 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
46452 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
46453 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46454 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
46456 static tree
46460 {
46469 {
46473 {
46499 }
46501 {
46527 }
46528 }
46530 {
46533 }
46538 {
46541 }
46551 }
46553 /* OpenMP 4.0:
46554 # pragma omp target data target-data-clause[optseq] new-line
46555 structured-block */
46557 #define OMP_TARGET_DATA_CLAUSE_MASK \
46558 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46559 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46560 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46561 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
46562 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
46564 static tree
46566 {
46568 omp_requires_mask
46571 tree clauses
46577 {
46580 {
46606 "%<#pragma omp target data%> with map-type other "
46607 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
46611 }
46616 }
46619 {
46622 "%<#pragma omp target data%> must contain at least "
46623 "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
46626 }
46637 }
46639 /* OpenMP 4.5:
46640 # pragma omp target enter data target-enter-data-clause[optseq] new-line
46641 structured-block */
46643 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
46644 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46645 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46646 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46647 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46648 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46650 static bool
46653 {
46656 {
46661 {
46664 }
46665 }
46667 {
46671 }
46674 {
46680 }
46683 omp_requires_mask
46686 tree clauses
46692 {
46695 {
46729 "%<#pragma omp target enter data%> with map-type other "
46733 }
46735 }
46738 {
46741 "%<#pragma omp target enter data%> must contain at least "
46744 }
46752 }
46754 /* OpenMP 4.5:
46755 # pragma omp target exit data target-enter-data-clause[optseq] new-line
46756 structured-block */
46758 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
46759 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46760 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46761 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46762 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46763 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46765 static bool
46768 {
46771 {
46776 {
46779 }
46780 }
46782 {
46786 }
46789 {
46795 }
46798 omp_requires_mask
46801 tree clauses
46809 {
46812 {
46846 "%<#pragma omp target exit data%> with map-type other "
46847 "than %<from%>, %<tofrom%>, %<release%> or %<delete%> "
46851 }
46853 }
46856 {
46859 "%<#pragma omp target exit data%> must contain at least "
46862 }
46870 }
46872 /* OpenMP 4.0:
46873 # pragma omp target update target-update-clause[optseq] new-line */
46875 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
46876 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
46877 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
46878 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46879 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46880 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46881 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46883 static bool
46886 {
46888 {
46894 }
46896 tree clauses
46901 {
46903 "%<#pragma omp target update%> must contain at least one "
46906 }
46909 omp_requires_mask
46918 }
46920 /* OpenMP 4.0:
46921 # pragma omp target target-clause[optseq] new-line
46922 structured-block */
46924 #define OMP_TARGET_CLAUSE_MASK \
46925 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46929 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
46930 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46931 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46932 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
46933 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46934 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
46935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
46936 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR)\
46937 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR))
46939 static bool
46942 {
46944 omp_requires_mask
46948 {
46960 {
46968 {
46969 tree stmt;
46971 {
46974 OMP_TARGET_CLAUSE_MASK,
46979 OMP_TARGET_CLAUSE_MASK,
46984 OMP_TARGET_CLAUSE_MASK,
46989 }
46991 }
46996 {
47000 if_p);
47005 if_p);
47010 if_p);
47014 }
47020 /* For combined target teams, ensure the num_teams and
47021 thread_limit clause expressions are evaluated on the host,
47022 before entering the target construct. */
47031 {
47034 tf_none);
47041 OMP_CLAUSE_FIRSTPRIVATE);
47046 }
47051 }
47053 {
47056 }
47058 {
47062 }
47064 {
47067 }
47069 {
47072 }
47074 {
47077 }
47078 }
47080 {
47083 }
47090 {
47096 }
47105 }
47107 /* OpenACC 2.0:
47108 # pragma acc cache (variable-list) new-line
47109 */
47111 static tree
47113 {
47114 /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
47115 clauses. */
47116 auto_suppress_location_wrappers sentinel;
47132 }
47134 /* OpenACC 2.0:
47135 # pragma acc data oacc-data-clause[optseq] new-line
47136 structured-block */
47138 #define OACC_DATA_CLAUSE_MASK \
47139 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47140 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47141 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47142 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47143 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47144 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47145 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
47146 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47147 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47148 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47149 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
47151 static tree
47153 {
47166 }
47168 /* OpenACC 2.0:
47169 # pragma acc host_data <clauses> new-line
47170 structured-block */
47172 #define OACC_HOST_DATA_CLAUSE_MASK \
47173 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
47174 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47175 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
47177 static tree
47179 {
47187 {
47191 }
47199 }
47201 /* OpenACC 2.0:
47202 # pragma acc declare oacc-data-clause[optseq] new-line
47203 */
47205 #define OACC_DECLARE_CLAUSE_MASK \
47206 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47207 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47208 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47209 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47210 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47211 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
47212 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
47213 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
47215 static tree
47217 {
47227 {
47231 }
47234 {
47238 {
47242 }
47245 {
47257 {
47259 "%qD must be a global variable in "
47261 decl);
47264 }
47269 {
47273 }
47275 {
47277 "invalid use of %<extern%> variable %qD "
47281 }
47283 {
47285 "invalid use of %<global%> variable %qD "
47289 }
47291 }
47294 /* This seems to ignore the existence of cleanup scopes?
47295 What is the meaning for local extern decls? The local
47296 extern is in this scope, but it is referring to a decl that
47297 is namespace scope. */
47300 {
47303 }
47305 {
47307 "%qD must be a variable declared in the same scope as "
47311 }
47314 {
47316 /* We need to mark the aliased decl, as that is the entity
47317 that is being referred to. This won't work for
47318 dependent variables, but it didn't work for them before
47319 DECL_LOCAL_DECL_P was a thing either. But then
47320 dependent local extern variable decls are as rare as
47321 hen's teeth. */
47329 {
47334 }
47336 tree id;
47339 else
47345 {
47348 {
47351 {
47355 }
47356 }
47357 }
47358 }
47359 }
47372 }
47374 /* OpenACC 2.0:
47375 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
47377 or
47379 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
47381 LOC is the location of the #pragma token.
47382 */
47384 #define OACC_ENTER_DATA_CLAUSE_MASK \
47385 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47386 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47387 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47388 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47389 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47390 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47392 #define OACC_EXIT_DATA_CLAUSE_MASK \
47393 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47394 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47395 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47396 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
47397 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
47398 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
47399 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47401 static tree
47404 {
47413 {
47418 }
47425 else
47430 {
47434 }
47442 }
47444 /* OpenACC 2.0:
47445 # pragma acc loop oacc-loop-clause[optseq] new-line
47446 structured-block */
47448 #define OACC_LOOP_CLAUSE_MASK \
47449 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
47450 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47451 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47452 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
47453 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
47454 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
47455 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
47456 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
47457 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
47458 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
47460 static tree
47463 {
47473 {
47479 }
47486 /* Later processing of combined acc loop constructs gets confused
47487 by an extra level of empty nested BIND_EXPRs, so flatten them. */
47496 }
47498 /* OpenACC 2.0:
47499 # pragma acc kernels oacc-kernels-clause[optseq] new-line
47500 structured-block
47502 or
47504 # pragma acc parallel oacc-parallel-clause[optseq] new-line
47505 structured-block
47507 OpenACC 2.6:
47509 # pragma acc serial oacc-serial-clause[optseq] new-line
47510 */
47512 #define OACC_KERNELS_CLAUSE_MASK \
47513 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47514 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47515 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47516 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47517 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47518 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47519 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47520 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47521 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47522 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47523 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
47524 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
47525 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47526 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47527 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
47528 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47530 #define OACC_PARALLEL_CLAUSE_MASK \
47531 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47532 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47533 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47534 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47535 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47536 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47537 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47538 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47539 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
47540 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47541 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47542 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
47543 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
47544 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47545 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47546 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47547 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47548 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
47549 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47551 #define OACC_SERIAL_CLAUSE_MASK \
47552 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47553 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47554 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47555 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47556 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47557 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47558 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47559 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47560 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47561 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47562 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47563 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
47564 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47565 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47566 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47567 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47569 static tree
47572 {
47573 omp_clause_mask mask;
47576 {
47594 }
47597 {
47601 {
47604 tree clauses;
47609 }
47610 }
47621 }
47623 /* OpenACC 2.0:
47624 # pragma acc update oacc-update-clause[optseq] new-line
47625 */
47627 #define OACC_UPDATE_CLAUSE_MASK \
47628 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47629 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
47630 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
47631 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47632 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
47633 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47634 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
47636 static tree
47638 {
47645 {
47647 "%<#pragma acc update%> must contain at least one "
47650 }
47658 }
47660 /* OpenACC 2.0:
47661 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
47663 LOC is the location of the #pragma token.
47664 */
47666 #define OACC_WAIT_CLAUSE_MASK \
47667 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
47669 static tree
47671 {
47685 }
47687 /* OpenMP 4.0:
47688 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
47690 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
47691 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
47692 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
47693 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
47694 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
47695 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
47696 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
47698 static void
47702 {
47704 cp_omp_declare_simd_data data;
47706 {
47714 /* It is safe to take the address of a local variable; it will only be
47715 used while this scope is live. */
47717 }
47719 {
47721 "%<#pragma omp declare %s%> followed by "
47726 }
47728 /* Store away all pragma tokens. */
47737 {
47741 {
47754 }
47759 "%<#pragma omp declare %s%> not immediately followed by "
47764 }
47765 }
47767 /* OpenMP 5.0:
47769 trait-selector:
47770 trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
47772 trait-score:
47773 score(score-expression)
47775 Note that this function returns a list of trait selectors for the
47776 trait-selector-set SET. */
47778 static tree
47781 {
47783 do
47784 {
47785 tree selector;
47789 else
47790 {
47793 }
47795 enum omp_ts_code sel
47799 {
47800 /* Per the spec, "Implementations can ignore specified selectors
47801 that are not those described in this section"; however, we
47802 must record such selectors because they cause match failures. */
47804 OPT_Wopenmp,
47814 {
47817 }
47818 else
47820 }
47828 tree t;
47831 {
47833 {
47837 }
47839 matching_parens parens;
47846 {
47853 {
47857 matching_parens parens2;
47866 "%<score%> cannot be specified in traits "
47870 {
47881 else
47883 }
47884 }
47885 else
47889 }
47892 {
47896 {
47900 properties);
47901 }
47902 else
47903 {
47906 }
47909 do
47910 {
47915 {
47918 }
47923 else
47924 {
47928 }
47934 else
47936 }
47940 /* FIXME: this is bogus, the expression need
47941 not be constant. */
47944 {
47951 else
47953 properties);
47954 }
47955 else
47960 {
47962 {
47964 "selector may not be specified in "
47967 }
47968 properties
47970 OMP_DECLARE_SIMD_CLAUSE_MASK,
47972 }
47974 {
47975 /* FIXME: The "requires" selector was added in OpenMP 5.1.
47976 Currently only the now-deprecated syntax
47977 from OpenMP 5.0 is supported. */
47981 }
47982 else
47987 }
47993 }
47997 {
48000 }
48006 else
48008 }
48012 }
48014 /* OpenMP 5.0:
48016 trait-set-selector[,trait-set-selector[,...]]
48018 trait-set-selector:
48019 trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
48021 trait-set-selector-name:
48022 constructor
48023 device
48024 implementation
48025 user */
48027 static tree
48030 {
48032 do
48033 {
48036 setp
48041 {
48044 }
48051 matching_braces braces;
48055 tree selectors
48058 {
48061 }
48069 else
48071 }
48077 }
48079 /* Assumption clauses:
48080 OpenMP 5.1
48081 absent (directive-name-list)
48082 contains (directive-name-list)
48083 holds (expression)
48084 no_openmp
48085 no_openmp_routines
48086 no_parallelism */
48088 static void
48091 {
48106 {
48119 {
48124 }
48126 {
48131 }
48133 {
48138 }
48140 {
48142 matching_parens parens;
48144 {
48156 }
48157 }
48159 {
48161 matching_parens parens;
48163 {
48164 do
48165 {
48168 location_t dloc
48171 {
48172 tree id;
48177 CPP_KEYWORD))
48178 {
48179 enum rid rid
48183 }
48184 else
48187 }
48190 else
48191 {
48204 else
48205 {
48210 "mentioned in both %<absent%> and "
48218 ? &absent_head
48221 "mentioned multiple times in %qs "
48228 }
48231 }
48234 else
48236 }
48243 }
48244 }
48246 {
48253 }
48254 else
48255 {
48259 }
48260 }
48262 }
48264 /* OpenMP 5.1
48265 # pragma omp assume clauses[optseq] new-line */
48267 static void
48269 {
48272 }
48274 /* OpenMP 5.1
48275 # pragma omp assumes clauses[optseq] new-line */
48277 static bool
48279 {
48282 }
48284 /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
48285 that into "omp declare variant base" attribute. */
48287 static tree
48289 tree attrs)
48290 {
48291 matching_parens parens;
48293 {
48294 fail:
48297 }
48302 cp_expr varid
48310 tree variant;
48317 else
48318 {
48319 tree ambiguous_decls;
48327 }
48331 {
48333 variant
48341 }
48356 {
48359 }
48371 {
48373 match_loc);
48382 }
48387 }
48390 /* Finalize #pragma omp declare simd clauses after direct declarator has
48391 been parsed, and put that into "omp declare simd" attribute. */
48393 static tree
48395 {
48401 {
48406 }
48411 {
48422 {
48425 pragma_tok);
48433 }
48434 else
48435 {
48437 attrs
48439 }
48441 }
48445 {
48451 {
48453 {
48460 {
48468 else
48471 }
48477 {
48479 "unknown OpenMP directive name in "
48484 }
48488 {
48490 "OpenMP directive other than %<declare simd%> "
48491 "or %<declare variant%> appertains to a "
48494 }
48497 {
48499 "mixing OpenMP directives with attribute and "
48502 }
48507 {
48510 }
48512 cp_token tok = {};
48520 tok = {};
48525 tok = {};
48537 /* Move the current source position to that of the first token
48538 in the new lexer. */
48548 {
48556 pragma_tok);
48560 cl);
48565 }
48566 else
48567 {
48569 attrs
48571 attrs);
48572 }
48575 }
48577 }
48578 else
48580 }
48586 }
48588 /* D should be DEFERRED_PARSE from omp::decl attribute. If it contains
48589 a threadprivate, groupprivate, allocate or declare target directive,
48590 return true and parse it for DECL. */
48592 bool
48594 {
48600 {
48608 else
48611 }
48617 {
48619 "unknown OpenMP directive name in "
48622 }
48624 /* && dir->id != PRAGMA_OMP_GROUPPRIVATE */
48638 cp_token tok = {};
48646 tok = {};
48651 tok = {};
48663 /* Move the current source position to that of the first token in the
48664 new lexer. */
48669 }
48671 /* Helper for cp_parser_omp_declare_target, handle one to or link clause
48672 on #pragma omp declare target. Return false if errors were reported. */
48674 static bool
48677 {
48680 tree id;
48682 {
48685 }
48686 else
48689 {
48692 "%qD specified both in declare target %<link%> and %qs"
48694 else
48696 "%qD specified both in declare target %<link%> and "
48699 }
48701 {
48708 {
48711 {
48715 }
48716 }
48717 }
48721 {
48725 {
48728 }
48729 }
48731 {
48735 {
48738 }
48739 }
48741 {
48745 {
48749 }
48750 }
48752 }
48754 /* OpenMP 4.0:
48755 # pragma omp declare target new-line
48756 declarations and definitions
48757 # pragma omp end declare target new-line
48759 OpenMP 4.5:
48760 # pragma omp declare target ( extended-list ) new-line
48762 # pragma omp declare target declare-target-clauses[seq] new-line */
48764 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
48765 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
48766 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \
48767 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
48768 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
48769 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
48771 static void
48773 {
48781 clauses
48786 {
48788 clauses);
48791 }
48792 else
48793 {
48794 cp_omp_declare_target_attr a
48799 }
48801 {
48806 }
48808 {
48823 }
48829 "%<device_type%> clause must specify 'any' when used with "
48831 }
48833 /* OpenMP 5.1
48834 # pragma omp begin assumes clauses[optseq] new-line
48836 # pragma omp begin declare target clauses[optseq] new-line */
48838 #define OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK \
48839 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
48840 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
48842 static void
48844 {
48848 {
48851 }
48853 {
48857 {
48860 }
48862 {
48864 tree clauses
48866 OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK,
48868 pragma_tok);
48872 {
48877 }
48878 cp_omp_declare_target_attr a
48881 }
48882 else
48883 {
48886 }
48887 }
48889 {
48894 }
48895 else
48896 {
48899 }
48900 }
48902 /* OpenMP 4.0:
48903 # pragma omp end declare target new-line
48905 OpenMP 5.1:
48906 # pragma omp end assumes new-line */
48908 static void
48910 {
48914 {
48917 }
48919 {
48923 {
48926 }
48929 else
48930 {
48934 }
48938 "%<#pragma omp end declare target%> without corresponding "
48939 "%<#pragma omp declare target%> or "
48941 else
48942 {
48943 cp_omp_declare_target_attr
48946 {
48949 "%qs in attribute syntax terminated "
48954 else
48956 "%qs in pragma syntax terminated "
48961 }
48962 }
48963 }
48965 {
48972 else
48973 {
48974 cp_omp_begin_assumes_data
48977 {
48980 "%qs in attribute syntax terminated "
48983 else
48985 "%qs in pragma syntax terminated "
48988 }
48989 }
48990 }
48991 else
48992 {
48996 }
48997 }
48999 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
49000 expression and optional initializer clause of
49001 #pragma omp declare reduction. We store the expression(s) as
49002 either 3, 6 or 7 special statements inside of the artificial function's
49003 body. The first two statements are DECL_EXPRs for the artificial
49004 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
49005 expression that uses those variables.
49006 If there was any INITIALIZER clause, this is followed by further statements,
49007 the fourth and fifth statements are DECL_EXPRs for the artificial
49008 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
49009 constructor variant (first token after open paren is not omp_priv),
49010 then the sixth statement is a statement with the function call expression
49011 that uses the OMP_PRIV and optionally OMP_ORIG variable.
49012 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
49013 to initialize the OMP_PRIV artificial variable and there is seventh
49014 statement, a DECL_EXPR of the OMP_PRIV statement again. */
49016 static bool
49018 {
49030 tree combiner;
49051 {
49054 }
49057 {
49059 matching_parens parens;
49065 {
49068 }
49084 {
49088 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
49092 == CPP_CLOSE_PAREN
49095 {
49099 }
49105 }
49106 else
49107 {
49109 /* Don't create location wrapper nodes here. */
49110 auto_suppress_location_wrappers sentinel;
49125 {
49130 }
49132 tree arg;
49145 }
49158 }
49162 UNKNOWN_LOCATION);
49165 }
49167 /* OpenMP 4.0
49168 #pragma omp declare reduction (reduction-id : typename-list : expression) \
49169 initializer-clause[opt] new-line
49171 initializer-clause:
49172 initializer (omp_priv initializer)
49173 initializer (function-name (argument-list)) */
49175 static void
49178 {
49188 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
49195 {
49227 }
49239 /* Types may not be defined in declare reduction type list. */
49242 parser->type_definition_forbidden_message
49248 saved_colon_doesnt_start_class_def_p
49253 {
49257 ;
49275 else
49280 else
49282 }
49284 /* Restore the saved message. */
49287 parser->colon_doesnt_start_class_def_p
49292 {
49293 fail:
49296 }
49302 {
49303 tree fntype
49306 NULL_TREE);
49323 {
49327 }
49333 {
49336 }
49338 {
49340 {
49346 }
49353 }
49354 else
49355 {
49358 /* We should never meet a matched duplicate decl. */
49360 }
49365 else
49368 {
49371 }
49379 else
49380 {
49384 }
49389 {
49397 }
49405 }
49409 done:
49410 /* Free any declarators allocated. */
49412 }
49414 /* OpenMP 4.0
49415 #pragma omp declare simd declare-simd-clauses[optseq] new-line
49416 #pragma omp declare reduction (reduction-id : typename-list : expression) \
49417 initializer-clause[opt] new-line
49418 #pragma omp declare target new-line
49420 OpenMP 5.0
49421 #pragma omp declare variant (identifier) match (context-selector) */
49423 static bool
49426 {
49428 {
49433 {
49438 }
49440 {
49445 }
49448 {
49451 context);
49453 }
49455 {
49458 }
49460 {
49464 }
49465 }
49470 }
49472 /* OpenMP 5.0
49473 #pragma omp requires clauses[optseq] new-line */
49475 static bool
49477 {
49482 {
49488 {
49503 {
49506 matching_parens parens;
49508 {
49510 {
49515 this_req
49518 this_req
49521 this_req
49524 this_req
49527 this_req
49529 }
49531 {
49533 "expected %<acq_rel%>, %<acquire%>, "
49536 {
49543 CPP_CLOSE_PAREN))
49546 }
49547 }
49548 else
49555 /*consume_paren=*/
49559 {
49562 }
49563 }
49565 }
49566 else
49567 {
49569 "%<unified_shared_memory%>, "
49570 "%<dynamic_allocators%>, "
49571 "%<reverse_offload%> "
49575 }
49579 {
49581 {
49588 }
49590 {
49594 }
49597 {
49600 this_req
49602 (omp_requires_mask
49604 }
49608 "lexically after first %<atomic%> construct "
49611 omp_requires_mask
49614 }
49615 }
49617 }
49623 }
49626 /* OpenMP 5.1:
49627 #pragma omp nothing new-line */
49629 static void
49631 {
49633 }
49636 /* OpenMP 5.1
49637 #pragma omp error clauses[optseq] new-line */
49639 static bool
49642 {
49650 {
49663 };
49671 {
49674 }
49676 {
49681 }
49685 matching_parens parens;
49687 {
49689 {
49693 else
49695 tf_warning_or_error,
49696 LOOKUP_NORMAL);
49697 }
49698 else
49699 {
49701 {
49709 }
49711 {
49716 {
49723 CPP_CLOSE_PAREN))
49726 }
49727 }
49728 else
49730 }
49736 /*consume_paren=*/
49740 {
49742 {
49745 }
49746 else
49748 }
49750 {
49752 {
49755 }
49756 else
49758 }
49759 }
49760 else
49762 }
49772 {
49774 {
49778 }
49779 tree fndecl
49788 }
49795 {
49799 }
49803 else
49807 }
49809 /* OpenMP 4.5:
49810 #pragma omp taskloop taskloop-clause[optseq] new-line
49811 for-loop
49813 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
49814 for-loop */
49816 #define OMP_TASKLOOP_CLAUSE_MASK \
49817 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
49818 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
49819 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
49820 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
49821 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
49822 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
49823 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
49824 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
49825 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
49826 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
49827 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
49828 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
49829 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
49830 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
49831 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
49832 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
49833 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
49835 static tree
49839 {
49846 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
49847 clause. */
49852 {
49857 {
49881 }
49882 }
49884 {
49887 }
49892 {
49895 }
49902 if_p);
49908 }
49911 /* OpenACC 2.0:
49912 # pragma acc routine oacc-routine-clause[optseq] new-line
49913 function-definition
49915 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
49916 */
49918 #define OACC_ROUTINE_CLAUSE_MASK \
49919 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
49920 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
49921 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
49922 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
49923 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
49925 /* Parse the OpenACC routine pragma. This has an optional '( name )'
49926 component, which must resolve to a declared namespace-scope
49927 function. The clauses are either processed directly (for a named
49928 function), or defered until the immediatley following declaration
49929 is parsed. */
49931 static void
49934 {
49936 /* The checking for "another pragma following this one" in the "no optional
49937 '( name )'" case makes sure that we dont re-enter. */
49940 cp_oacc_routine_data data;
49946 /* It is safe to take the address of a local variable; it will only be
49947 used while this scope is live. */
49950 /* Look for optional '( name )'. */
49952 {
49953 matching_parens parens;
49956 /* We parse the name as an id-expression. If it resolves to
49957 anything other than a non-overloaded function at namespace
49958 scope, it's an error. */
49974 {
49978 }
49980 data.clauses
49984 /* The clauses are in reverse order; fix that to make later diagnostic
49985 emission easier. */
49991 {
49996 }
49998 /* Perhaps we should use the same rule as declarations in different
49999 namespaces? */
50001 {
50006 }
50009 {
50013 }
50017 }
50019 {
50020 /* Store away all pragma tokens. */
50028 /* Emit a helpful diagnostic if there's another pragma following this
50029 one. */
50031 {
50034 /* ..., and then just keep going. */
50036 }
50038 /* We only have to consider the pragma_external case here. */
50043 else
50046 }
50047 }
50049 /* Finalize #pragma acc routine clauses after direct declarator has
50050 been parsed. */
50052 static tree
50054 {
50059 {
50061 "%<#pragma acc routine%> not immediately followed by "
50064 }
50080 /* The clauses are in reverse order; fix that to make later diagnostic
50081 emission easier. */
50084 /* Later, cp_finalize_oacc_routine will process the clauses. */
50088 }
50090 /* Apply any saved OpenACC routine clauses to a just-parsed
50091 declaration. */
50093 static void
50095 {
50097 {
50098 /* Keep going if we're in error reporting mode. */
50104 {
50106 {
50108 "%<#pragma acc routine%> not immediately followed by"
50112 }
50116 }
50118 int compatible
50123 {
50126 }
50128 {
50129 }
50130 else
50131 {
50133 {
50142 }
50144 /* Set the routine's level of parallelism. */
50148 /* Add an "omp declare target" attribute. */
50153 }
50154 }
50155 }
50157 /* Main entry point to OpenMP statement pragmas. */
50159 static void
50161 {
50162 tree stmt;
50167 {
50195 if_p);
50215 if_p);
50220 if_p);
50225 if_p);
50230 if_p);
50235 if_p);
50240 if_p);
50252 if_p);
50266 if_p);
50271 if_p);
50278 }
50281 }
50282 \f
50283 /* Transactional Memory parsing routines. */
50285 /* Parse a transaction attribute.
50287 txn-attribute:
50288 attribute
50289 [ [ identifier ] ]
50291 We use this instead of cp_parser_attributes_opt for transactions to avoid
50292 the pedwarn in C++98 mode. */
50294 static tree
50296 {
50311 {
50315 /* For keywords, use the canonical spelling,
50316 not the parsed identifier. */
50320 }
50321 else
50325 error1:
50328 }
50330 /* Parse a __transaction_atomic or __transaction_relaxed statement.
50332 transaction-statement:
50333 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
50334 compound-statement
50335 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
50336 */
50338 static tree
50340 {
50351 else
50352 {
50356 }
50358 /* Parse a noexcept specification. */
50362 {
50363 /* cancel-and-throw is unimplemented. */
50366 }
50367 else
50369 CP_PARSER_FLAGS_NONE,
50374 /* Keep track if we're in the lexical scope of an outer transaction. */
50386 }
50388 /* Parse a __transaction_atomic or __transaction_relaxed expression.
50390 transaction-expression:
50391 __transaction_atomic txn-noexcept-spec[opt] ( expression )
50392 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
50393 */
50395 static tree
50397 {
50410 keyword == RID_TRANSACTION_RELAXED
50424 /* Set this early. This might mean that we allow transaction_cancel in
50425 an expression that we find out later actually has to be a constexpr.
50426 However, we expect that cxx_constant_value will be able to deal with
50427 this; also, if the noexcept has no constexpr, then what we parse next
50428 really is a transaction's body. */
50431 /* Parse a noexcept specification. */
50433 CP_PARSER_FLAGS_NONE,
50440 {
50441 matching_parens parens;
50448 }
50449 else
50450 {
50451 /* The only expression that is available got parsed for the noexcept
50452 already. noexcept is true then. */
50455 }
50464 }
50466 /* Parse a function-transaction-block.
50468 function-transaction-block:
50469 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
50470 function-body
50471 __transaction_atomic txn-attribute[opt] function-try-block
50472 __transaction_relaxed ctor-initializer[opt] function-body
50473 __transaction_relaxed function-try-block
50474 */
50476 static void
50478 {
50493 else
50494 {
50498 }
50506 else
50507 cp_parser_ctor_initializer_opt_and_function_body
50513 }
50515 /* Parse a __transaction_cancel statement.
50517 cancel-statement:
50518 __transaction_cancel txn-attribute[opt] ;
50519 __transaction_cancel txn-attribute[opt] throw-expression ;
50521 ??? Cancel and throw is not yet implemented. */
50523 static tree
50525 {
50531 RT_TRANSACTION_CANCEL);
50538 /* ??? Parse cancel-and-throw here. */
50543 {
50547 }
50549 {
50553 }
50555 {
50558 {
50564 }
50565 }
50567 {
50571 }
50577 }
50578 \f
50580 /* Special handling for the first token or line in the file. The first
50581 thing in the file might be #pragma GCC pch_preprocess, which loads a
50582 PCH file, which is a GC collection point. So we need to handle this
50583 first pragma without benefit of an existing lexer structure.
50585 Always returns one token to the caller in *FIRST_TOKEN. This is
50586 either the true first token of the file, or the first token after
50587 the initial pragma. */
50589 static void
50591 {
50599 {
50603 }
50605 /* Skip to the end of the pragma. */
50607 {
50610 do
50613 }
50615 /* Now actually load the PCH file. */
50619 /* Read one more token to return to our caller. We have to do this
50620 after reading the PCH file in, since its pointers have to be
50621 live. */
50623 }
50625 /* Parse a pragma GCC ivdep. */
50627 static bool
50629 {
50632 }
50634 /* Parse a pragma GCC unroll. */
50636 static tree
50638 {
50644 }
50646 /* Parse a pragma GCC novector. */
50648 static bool
50650 {
50653 }
50655 /* Normal parsing of a pragma token. Here we can (and must) use the
50656 regular lexer. */
50658 static bool
50660 {
50663 tree stmt;
50675 {
50681 }
50685 {
50693 {
50704 }
50709 {
50720 }
50725 {
50736 }
50741 {
50753 }
50758 {
50770 }
50775 {
50787 }
50806 {
50812 }
50820 {
50826 }
50834 {
50839 }
50845 {
50851 }
50859 {
50865 }
50907 {
50909 "%<#pragma omp requires%> may only be used at file or "
50913 }
50918 {
50920 "%<#pragma omp assumes%> may only be used at file or "
50924 }
50960 "%<#pragma omp scan%> may only be used in "
50966 "%<#pragma omp section%> may only be used in "
50973 {
50980 {
50992 }
50995 {
50998 pragma_str);
51000 }
51004 do
51005 {
51007 {
51009 {
51014 }
51016 {
51021 }
51023 {
51028 }
51032 }
51035 }
51042 {
51045 }
51048 }
51055 bad_stmt:
51058 }
51062 }
51064 /* Helper for pragma_lex in preprocess-only mode; in this mode, we have not
51065 populated the lexer with any tokens (the tokens rather being read by
51066 c-ppoutput.c's machinery), so we need to read enough tokens now to handle
51067 a pragma. */
51068 static void
51070 {
51075 /* Read the rest of the tokens comprising the pragma line. */
51077 do
51078 {
51085 }
51087 /* The interface the pragma parsers have to the lexer. */
51089 enum cpp_ttype
51091 {
51107 else
51108 {
51112 }
51115 }
51117 void
51119 {
51120 /* We have already read all the tokens, so we just need to discard
51121 them here. */
51125 }
51127 \f
51128 /* External interface. */
51130 /* Parse one entire translation unit. */
51132 void
51134 {
51142 /* cp_lexer_new_main is called before doing any GC allocation
51143 because tokenization might load a PCH file. */
51152 }
51154 /* Create an identifier for a generic parameter type (a synthesized
51155 template parameter implied by `auto' or a concept identifier). */
51158 static tree
51160 {
51164 }
51166 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
51167 (creating a new template parameter list if necessary). Returns the newly
51168 created template type parm. */
51170 static tree
51172 {
51173 /* A requires-clause is not a function and cannot have placeholders. */
51175 {
51178 }
51182 /* We are either continuing a function template that already contains implicit
51183 template parameters, creating a new fully-implicit function template, or
51184 extending an existing explicit function template with implicit template
51185 parameters. */
51193 {
51197 }
51198 else
51199 {
51200 /* Roll back to the existing template parameter scope (in the case of
51201 extending an explicit function template) or introduce a new template
51202 parameter scope ahead of the function parameter scope (or class scope
51203 in the case of out-of-line member definitions). The function scope is
51204 added back after template parameter synthesis below. */
51209 {
51212 }
51214 {
51215 /* If not defining a class, then any class scope is a scope level in
51216 an out-of-line member definition. In this case simply wind back
51217 beyond the first such scope to inject the template parameter list.
51218 Otherwise wind back to the class being defined. The latter can
51219 occur in class member friend declarations such as:
51221 class A {
51222 void foo (auto);
51223 };
51224 class B {
51225 friend void A::foo (auto);
51226 };
51228 The template parameter list synthesized for the friend declaration
51229 must be injected in the scope of 'B'. This can also occur in
51230 erroneous cases such as:
51232 struct A {
51233 struct B {
51234 void foo (auto);
51235 };
51236 void B::foo (auto) {}
51237 };
51239 Here the attempted definition of 'B::foo' within 'A' is ill-formed
51240 but, nevertheless, the template parameter list synthesized for the
51241 declarator should be injected into the scope of 'A' as if the
51242 ill-formed template was specified explicitly. */
51245 {
51248 }
51249 }
51255 {
51256 /* Introduce a new template parameter list for implicit template
51257 parameters. */
51261 parser->implicit_template_scope
51268 }
51269 else
51270 {
51271 /* Synthesize implicit template parameters at the end of the explicit
51272 template parameter list. */
51279 parser->implicit_template_parms
51281 }
51282 }
51284 /* Synthesize a new template parameter and track the current template
51285 parameter chain with implicit_template_parms. */
51291 /* Synthesize the type template parameter. */
51299 /* Attach the constraint to the parm before processing. */
51302 tree new_parm
51304 input_location,
51305 node,
51308 // Process_template_parm returns the list of parms, and
51309 // parser->implicit_template_parms holds the final node of the parm
51310 // list. We really want to manipulate the newly appended element.
51317 // Record the last implicit parm node
51320 /* Mark the synthetic declaration "virtual". This is used when
51321 comparing template-heads to determine if whether an abbreviated
51322 function template is equivalent to an explicit template.
51324 Note that DECL_ARTIFICIAL is used elsewhere for template
51325 parameters. */
51331 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
51334 /* If creating a fully implicit function template, start the new implicit
51335 template parameter list with this synthesized type, otherwise grow the
51336 current template parameter list. */
51339 {
51345 }
51346 else
51347 {
51352 }
51354 /* If the new parameter was constrained, we need to add that to the
51355 constraints in the template parameter list. */
51357 {
51361 }
51366 }
51368 /* Finish the declaration of a fully implicit function template. Such a
51369 template has no explicit template parameter list so has not been through the
51370 normal template head and tail processing. synthesize_implicit_template_parm
51371 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
51372 provided if the declaration is a class member such that its template
51373 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
51374 form is returned. Otherwise NULL_TREE is returned. */
51376 static tree
51378 {
51383 {
51387 }
51399 }
51401 /* Like finish_fully_implicit_template, but to be used in error
51402 recovery, rearranging scopes so that we restore the state we had
51403 before synthesize_implicit_template_parm inserted the implement
51404 template parms scope. */
51406 static void
51408 {
51413 {
51422 }
51423 else
51429 }
51431 /* Helper function for diagnostics that have complained about things
51432 being used with 'extern "C"' linkage.
51434 Attempt to issue a note showing where the 'extern "C"' linkage began. */
51436 void
51438 {
51442 }