| blob | a2bc6f69000cef65231779ea4327a3be5e86173d |
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;
595 parser->type_definition_forbidden_message_arg
611 }
613 DEBUG_FUNCTION void
615 {
617 }
619 DEBUG_FUNCTION void
621 {
624 else
626 }
628 /* Allocate memory for a new lexer object and return it. */
632 {
633 /* Allocate the memory. */
636 /* Initially we are not debugging. */
641 /* Create the buffer. */
645 }
647 /* Return TRUE if token is the start of a module declaration that will be
648 terminated by a CPP_PRAGMA_EOL token. */
651 {
655 }
657 /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
658 PRAGMA_NONE. */
660 static enum pragma_kind
662 {
665 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
667 }
669 /* Handle early pragmas such as #pragma GCC diagnostic, which needs to be done
670 during preprocessing for the case of preprocessing-related diagnostics. This
671 is called immediately after pushing the CPP_PRAGMA_EOL token onto
672 lexer->buffer. */
674 static void
676 {
680 /* Back up to the start of the pragma so pragma_lex () can parse it when
681 c-pragma lib asks it to. */
685 {
690 }
696 /* Dispatch it. */
697 const unsigned int id
702 /* Reset to normal state. */
704 }
706 /* The parser. */
710 /* Create a new main C++ lexer, the lexer that gets tokens from the
711 preprocessor, and also create the main parser. */
715 {
716 cp_token token;
718 /* It's possible that parsing the first pragma will load a PCH file,
719 which is a GC collection point. So we have to do that before
720 allocating any memory. */
726 /* Put the first token in the buffer. */
733 /* Create the parser now, so we can use it to handle early pragmas. */
737 /* Get the remaining tokens from the preprocessor. */
739 {
741 /* Process the previous token. */
745 /* Check for early pragmas that need to be handled now. */
751 }
759 {
760 /* Set the EOF token's location to be the just after the previous
761 token's range. That way 'at-eof' diagnostics point at something
762 meaninful. */
766 }
771 /* Subsequent preprocessor diagnostics should use compiler
772 diagnostic functions to get the compiler source location. */
777 /* If we processed any #pragma GCC target directives, we handled them early so
778 any macros they defined would be effective during preprocessing. Now, we
779 need to reset to the default state to begin compilation, and we will
780 process them again at the correct time as needed. */
785 }
787 /* Create a lexer and parser to be used during preprocess-only mode.
788 This will be filled with tokens to parse when needed by pragma_lex (). */
789 void
791 {
794 }
796 /* Create a new lexer whose token stream is primed with the tokens in
797 CACHE. When these tokens are exhausted, no new tokens will be read. */
801 {
806 /* We do not own the buffer. */
809 /* Insert an EOF token. */
820 /* Initially we are not debugging. */
826 }
828 /* Frees all resources associated with LEXER. */
830 static void
832 {
835 else
836 {
837 /* Restore the token we overwrite with EOF. */
840 }
843 }
845 /* This needs to be set to TRUE before the lexer-debugging infrastructure can
846 be used. The point of this flag is to help the compiler to fold away calls
847 to cp_lexer_debugging_p within this source file at compile time, when the
848 lexer is not being debugged. */
850 #define LEXER_DEBUGGING_ENABLED_P false
852 /* Returns nonzero if debugging information should be output. */
856 {
861 }
866 {
868 }
872 {
874 }
878 {
880 }
884 {
886 }
890 {
893 /* Skip past purged tokens. */
895 {
897 tp--;
898 }
901 }
903 /* Same as above, but return NULL when the lexer doesn't own the token
904 buffer or if the next_token is at the start of the token
905 vector or if all previous tokens are purged. */
909 {
912 {
915 /* Skip past purged tokens. */
917 {
920 tp--;
921 }
923 }
926 }
928 /* Overload for make_location, taking the lexer to mean the location of the
929 previous token. */
933 {
936 }
938 /* Overload for make_location taking tokens instead of locations. */
942 {
944 }
946 /* nonzero if we are presently saving tokens. */
950 {
952 }
954 /* Store the next token from the preprocessor in *TOKEN. Return true
955 if we reach EOF. If LEXER is NULL, assume we are handling an
956 initial #pragma pch_preprocess, and thus want the lexer to return
957 processed strings.
959 Diagnostics issued from this function must have their controlling option (if
960 any) in c.opt annotated as a libcpp option via the CppReason property. */
962 static void
964 {
967 /* Get a new token from the preprocessor. */
968 token->type
970 flags);
975 /* Usually never see a zero, but just in case ... */
978 /* On some systems, some header files are surrounded by an
979 implicit extern "C" block. Set a flag in the token if it
980 comes from such a header. */
985 /* Check to see if this token is a keyword. */
987 {
989 {
990 /* Mark this token as a keyword. */
992 /* Record which keyword. */
994 }
995 else
996 {
1000 /* These are outside the CXX11 range. */
1004 {
1005 /* Warn about the C++11 keyword (but still treat it as
1006 an identifier). */
1011 /* Clear out the C_RID_CODE so we don't warn about this
1012 particular identifier-turned-keyword again. */
1014 }
1018 {
1019 /* Warn about the C++20 keyword (but still treat it as
1020 an identifier). */
1025 /* Clear out the C_RID_CODE so we don't warn about this
1026 particular identifier-turned-keyword again. */
1028 }
1031 }
1032 }
1034 {
1035 /* This only happens in Objective-C++; it must be a keyword. */
1038 {
1039 /* Replace 'class' with '@class', 'private' with '@private',
1040 etc. This prevents confusion with the C++ keyword
1041 'class', and makes the tokens consistent with other
1042 Objective-C 'AT' keywords. For example '@class' is
1043 reported as RID_AT_CLASS which is consistent with
1044 '@synchronized', which is reported as
1045 RID_AT_SYNCHRONIZED.
1046 */
1056 }
1057 }
1058 }
1060 /* Update the globals input_location and the input file stack from TOKEN. */
1063 {
1065 }
1067 /* Update the globals input_location and the input file stack from LEXER. */
1070 {
1073 }
1075 /* Return a pointer to the next token in the token stream, but do not
1076 consume it. */
1080 {
1082 {
1086 }
1088 }
1090 /* Return true if the next token has the indicated TYPE. */
1094 {
1096 }
1098 /* Return true if the next token does not have the indicated TYPE. */
1102 {
1104 }
1106 /* Return true if the next token is the indicated KEYWORD. */
1110 {
1112 }
1116 {
1118 }
1122 {
1124 }
1126 /* Return true if KEYWORD can start a decl-specifier. */
1128 bool
1130 {
1132 {
1133 /* auto specifier: storage-class-specifier in C++,
1134 simple-type-specifier in C++0x. */
1136 /* Storage classes. */
1142 /* Elaborated type specifiers. */
1148 /* Simple type specifiers. */
1162 CASE_RID_FLOATN_NX:
1164 /* CV qualifiers. */
1167 /* Function specifiers. */
1170 /* friend/typdef/inline specifiers. */
1174 /* GNU extensions. */
1176 /* C++11 extensions. */
1179 /* C++20 extensions. */
1190 }
1191 }
1193 /* Peeks the corresponding built-in trait if the first token is
1194 a built-in trait and the second token is either `(' or `<' depending
1195 on the trait. Otherwise, returns nullptr. */
1199 {
1202 {
1206 /* Check if the subsequent token is a `<' token to
1207 __type_pack_element or is a `(' token to everything else. */
1215 }
1217 }
1219 /* Similarly, but only if the token is an expression-yielding
1220 built-in trait. */
1224 {
1230 }
1232 /* Similarly, but only if the token is a type-yielding
1233 built-in trait. */
1237 {
1243 }
1245 /* Return true if the next token is a keyword for a decl-specifier. */
1247 static bool
1249 {
1257 }
1259 /* Returns TRUE iff the token T begins a decltype type. */
1261 static bool
1263 {
1266 }
1268 /* Returns TRUE iff the next token begins a decltype type. */
1270 static bool
1272 {
1275 }
1277 /* Called when processing a token with tree_check_value; perform or defer the
1278 associated checks and return the value. */
1280 static tree
1282 {
1283 /* Perform any access checks that were deferred. */
1288 {
1294 }
1295 /* Return the stored value. */
1297 }
1299 /* Return a pointer to the Nth token in the token stream. If N is 1,
1300 then this is precisely equivalent to cp_lexer_peek_token (except
1301 that it is not inline). One would like to disallow that case, but
1302 there is one case (cp_parser_nth_token_starts_template_id) where
1303 the caller passes a variable for N and it might be 1. */
1307 {
1310 /* N is 1-based, not zero-based. */
1321 {
1325 }
1328 {
1331 }
1334 }
1336 /* Return the next token, and advance the lexer's next_token pointer
1337 to point to the next non-purged token. */
1341 {
1344 do
1345 {
1348 }
1353 /* Provide debugging output. */
1355 {
1359 }
1362 }
1364 /* Permanently remove the next token from the token stream, and
1365 advance the next_token pointer to refer to the next non-purged
1366 token. */
1368 static void
1370 {
1379 do
1380 tok++;
1383 }
1385 /* Permanently remove all tokens after TOK, up to, but not
1386 including, the token that will be returned next by
1387 cp_lexer_peek_token. */
1389 static void
1391 {
1397 {
1402 }
1403 }
1405 /* Begin saving tokens. All tokens consumed after this point will be
1406 preserved. */
1408 static void
1410 {
1411 /* Provide debugging output. */
1416 }
1418 /* Commit to the portion of the token stream most recently saved. */
1420 static void
1422 {
1423 /* Provide debugging output. */
1428 }
1430 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1431 to the token stream. Stop saving tokens. */
1433 static void
1435 {
1436 /* Provide debugging output. */
1441 }
1443 /* Determines what saved_token_sentinel does when going out of scope. */
1446 STS_COMMIT,
1447 STS_ROLLBACK,
1448 STS_DONOTHING
1449 };
1451 /* RAII wrapper around the above functions, with sanity checking (the token
1452 stream should be the same at the point of instantiation as it is at the
1453 point of destruction).
1455 Creating a variable saves tokens. MODE determines what happens when the
1456 object is destroyed. STS_COMMIT commits tokens (default),
1457 STS_ROLLBACK rolls-back and STS_DONOTHING does nothing. Calling
1458 rollback() will immediately roll-back tokens and set MODE to
1459 STS_DONOTHING. */
1461 struct saved_token_sentinel
1462 {
1465 saved_token_sentinel_mode mode;
1469 {
1472 }
1474 {
1476 cp_lexer_set_source_position_from_token
1479 }
1481 {
1488 }
1489 };
1491 /* Print a representation of the TOKEN on the STREAM. */
1493 static void
1495 {
1496 /* We don't use cpp_type2name here because the parser defines
1497 a few tokens of its own. */
1499 /* cpplib-defined token types */
1500 #define OP(e, s) #e,
1501 #define TK(e, s) #e,
1502 TTYPE_TABLE
1503 #undef OP
1504 #undef TK
1505 /* C++ parser token types - see "Manifest constants", above. */
1509 };
1511 /* For some tokens, print the associated data. */
1513 {
1515 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1516 For example, `struct' is mapped to an INTEGER_CST. */
1519 /* fall through */
1537 /* If we have a name for the token, print it out. Otherwise, we
1538 simply give the numeric code. */
1541 else
1544 }
1545 }
1547 DEBUG_FUNCTION void
1549 {
1552 }
1554 DEBUG_FUNCTION void
1556 {
1559 else
1561 }
1564 /* Start emitting debugging information. */
1566 static void
1568 {
1575 }
1577 /* Stop emitting debugging information. */
1579 static void
1581 {
1588 }
1590 /* Create a new cp_token_cache, representing a range of tokens. */
1594 {
1599 }
1601 /* Diagnose if #pragma omp declare simd isn't followed immediately
1602 by function declaration or definition. */
1606 {
1608 {
1613 }
1614 }
1616 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1617 and put that into "omp declare simd" attribute. */
1621 {
1623 {
1625 {
1628 }
1630 {
1633 }
1634 }
1635 }
1637 /* Similarly, but for use in declaration parsing functions
1638 which call cp_parser_handle_directive_omp_attributes. */
1642 {
1649 "%<declare %s%> directive not immediately followed by "
1653 }
1655 /* Diagnose if #pragma acc routine isn't followed immediately by function
1656 declaration or definition. */
1660 {
1662 {
1664 "%<#pragma acc routine%> not immediately followed by "
1667 }
1668 }
1669 \f
1670 /* Decl-specifiers. */
1672 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1674 static void
1676 {
1678 }
1680 /* Declarators. */
1682 /* Nothing other than the parser should be creating declarators;
1683 declarators are a semi-syntactic representation of C++ entities.
1684 Other parts of the front end that need to create entities (like
1685 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1699 /* An erroneous declarator. */
1702 /* The obstack on which declarators and related data structures are
1703 allocated. */
1706 /* Alloc BYTES from the declarator memory pool. */
1710 {
1712 }
1714 /* Allocate a declarator of the indicated KIND. Clear fields that are
1715 common to all declarators. */
1719 {
1733 }
1735 /* Make a declarator for a generalized identifier. If
1736 QUALIFYING_SCOPE is non-NULL, the identifier is
1737 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1738 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1739 is, if any. */
1744 {
1747 /* It is valid to write:
1749 class C { void f(); };
1750 typedef C D;
1751 void D::f();
1753 The standard is not clear about whether `typedef const C D' is
1754 legal; as of 2002-09-15 the committee is considering that
1755 question. EDG 3.0 allows that syntax. Therefore, we do as
1756 well. */
1771 }
1773 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1774 of modifiers such as const or volatile to apply to the pointer
1775 type, represented as identifiers. ATTRIBUTES represent the attributes that
1776 appertain to the pointer or reference. */
1778 cp_declarator *
1780 tree attributes)
1781 {
1789 {
1793 }
1794 else
1800 }
1802 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1803 represent the attributes that appertain to the pointer or
1804 reference. */
1806 cp_declarator *
1809 {
1817 {
1821 }
1822 else
1828 }
1830 /* Like make_pointer_declarator -- but for a pointer to a non-static
1831 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1832 appertain to the pointer or reference. */
1834 cp_declarator *
1837 tree attributes)
1838 {
1847 {
1850 }
1851 else
1857 }
1859 /* Make a declarator for the function given by TARGET, with the
1860 indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1861 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1862 indicates what exceptions can be thrown. STD_ATTRS contains
1863 attributes that appertain to the function type. */
1865 cp_declarator *
1867 tree parms,
1868 cp_cv_quals cv_qualifiers,
1869 cp_virt_specifiers virt_specifiers,
1870 cp_ref_qualifier ref_qualifier,
1871 tree tx_qualifier,
1872 tree exception_specification,
1873 tree late_return_type,
1874 tree requires_clause,
1875 tree std_attrs,
1876 location_t parens_loc)
1877 {
1892 {
1896 }
1897 else
1903 }
1905 /* Make a declarator for an array of BOUNDS elements, each of which is
1906 defined by ELEMENT. */
1908 cp_declarator *
1910 {
1917 {
1921 }
1922 else
1926 }
1928 /* Determine whether the declarator we've seen so far can be a
1929 parameter pack, when followed by an ellipsis. */
1930 static bool
1932 {
1934 /* We already saw an ellipsis. */
1937 /* Search for a declarator name, or any other declarator that goes
1938 after the point where the ellipsis could appear in a parameter
1939 pack. If we find any of these, then this declarator cannot be
1940 made into a parameter pack. */
1943 {
1945 {
1958 }
1959 }
1962 }
1966 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1967 DECLARATOR and DEFAULT_ARGUMENT. */
1969 cp_parameter_declarator *
1972 tree default_argument,
1973 location_t loc,
1975 {
1983 else
1991 }
1993 /* Returns true iff DECLARATOR is a declaration for a function. */
1995 static bool
1997 {
1999 {
2008 }
2010 }
2012 /* The parser. */
2014 /* Overview
2015 --------
2017 A cp_parser parses the token stream as specified by the C++
2018 grammar. Its job is purely parsing, not semantic analysis. For
2019 example, the parser breaks the token stream into declarators,
2020 expressions, statements, and other similar syntactic constructs.
2021 It does not check that the types of the expressions on either side
2022 of an assignment-statement are compatible, or that a function is
2023 not declared with a parameter of type `void'.
2025 The parser invokes routines elsewhere in the compiler to perform
2026 semantic analysis and to build up the abstract syntax tree for the
2027 code processed.
2029 The parser (and the template instantiation code, which is, in a
2030 way, a close relative of parsing) are the only parts of the
2031 compiler that should be calling push_scope and pop_scope, or
2032 related functions. The parser (and template instantiation code)
2033 keeps track of what scope is presently active; everything else
2034 should simply honor that. (The code that generates static
2035 initializers may also need to set the scope, in order to check
2036 access control correctly when emitting the initializers.)
2038 Methodology
2039 -----------
2041 The parser is of the standard recursive-descent variety. Upcoming
2042 tokens in the token stream are examined in order to determine which
2043 production to use when parsing a non-terminal. Some C++ constructs
2044 require arbitrary look ahead to disambiguate. For example, it is
2045 impossible, in the general case, to tell whether a statement is an
2046 expression or declaration without scanning the entire statement.
2047 Therefore, the parser is capable of "parsing tentatively." When the
2048 parser is not sure what construct comes next, it enters this mode.
2049 Then, while we attempt to parse the construct, the parser queues up
2050 error messages, rather than issuing them immediately, and saves the
2051 tokens it consumes. If the construct is parsed successfully, the
2052 parser "commits", i.e., it issues any queued error messages and
2053 the tokens that were being preserved are permanently discarded.
2054 If, however, the construct is not parsed successfully, the parser
2055 rolls back its state completely so that it can resume parsing using
2056 a different alternative.
2058 Future Improvements
2059 -------------------
2061 The performance of the parser could probably be improved substantially.
2062 We could often eliminate the need to parse tentatively by looking ahead
2063 a little bit. In some places, this approach might not entirely eliminate
2064 the need to parse tentatively, but it might still speed up the average
2065 case. */
2067 /* Flags that are passed to some parsing functions. These values can
2068 be bitwise-ored together. */
2070 enum
2071 {
2072 /* No flags. */
2074 /* The construct is optional. If it is not present, then no error
2075 should be issued. */
2077 /* When parsing a type-specifier, treat user-defined type-names
2078 as non-type identifiers. */
2080 /* When parsing a type-specifier, do not try to parse a class-specifier
2081 or enum-specifier. */
2083 /* When parsing a decl-specifier-seq, only allow type-specifier or
2084 constexpr. */
2086 /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
2087 for C++20 consteval or for C++23 static. */
2089 /* When parsing a decl-specifier-seq, allow missing typename. */
2091 /* When parsing of the noexcept-specifier should be delayed. */
2093 /* When parsing a consteval declarator. */
2095 /* When parsing a parameter declaration. */
2097 };
2099 /* This type is used for parameters and variables which hold
2100 combinations of the above flags. */
2103 /* The different kinds of declarators we want to parse. */
2105 enum cp_parser_declarator_kind
2106 {
2107 /* We want an abstract declarator. */
2108 CP_PARSER_DECLARATOR_ABSTRACT,
2109 /* We want a named declarator. */
2110 CP_PARSER_DECLARATOR_NAMED,
2111 /* We don't mind, but the name must be an unqualified-id. */
2112 CP_PARSER_DECLARATOR_EITHER
2113 };
2115 /* The precedence values used to parse binary expressions. The minimum value
2116 of PREC must be 1, because zero is reserved to quickly discriminate
2117 binary operators from other tokens. */
2119 enum cp_parser_prec
2120 {
2121 PREC_NOT_OPERATOR,
2122 PREC_LOGICAL_OR_EXPRESSION,
2123 PREC_LOGICAL_AND_EXPRESSION,
2124 PREC_INCLUSIVE_OR_EXPRESSION,
2125 PREC_EXCLUSIVE_OR_EXPRESSION,
2126 PREC_AND_EXPRESSION,
2127 PREC_EQUALITY_EXPRESSION,
2128 PREC_RELATIONAL_EXPRESSION,
2129 PREC_SPACESHIP_EXPRESSION,
2130 PREC_SHIFT_EXPRESSION,
2131 PREC_ADDITIVE_EXPRESSION,
2132 PREC_MULTIPLICATIVE_EXPRESSION,
2133 PREC_PM_EXPRESSION,
2134 NUM_PREC_VALUES = PREC_PM_EXPRESSION
2135 };
2137 /* A mapping from a token type to a corresponding tree node type, with a
2138 precedence value. */
2140 struct cp_parser_binary_operations_map_node
2141 {
2142 /* The token type. */
2144 /* The corresponding tree code. */
2146 /* The precedence of this operator. */
2148 };
2150 struct cp_parser_expression_stack_entry
2151 {
2152 /* Left hand side of the binary operation we are currently
2153 parsing. */
2154 cp_expr lhs;
2155 /* Original tree code for left hand side, if it was a binary
2156 expression itself (used for -Wparentheses). */
2158 /* Tree code for the binary operation we are parsing. */
2160 /* Precedence of the binary operation we are parsing. */
2162 /* Location of the binary operation we are parsing. */
2163 location_t loc;
2164 /* Flags from the operator token. */
2166 };
2168 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
2169 entries because precedence levels on the stack are monotonically
2170 increasing. */
2174 /* Used for parsing OMP for loops.
2176 Some notes on flags used for context:
2177 parser->omp_for_parse_state is non-null anywhere inside the OMP FOR
2178 construct, except for the final-loop-body.
2179 The want_nested_loop flag is true if inside a {} sequence where
2180 a loop-nest (or another {} sequence containing a loop-nest) is expected,
2181 but has not yet been seen. It's false when parsing intervening code
2182 statements or their substatements that cannot contain a loop-nest.
2183 The in_intervening_code flag is true when parsing any intervening code,
2184 including substatements, and whether or not want_nested_loop is true.
2186 And, about error handling:
2187 The saw_intervening_code flag is set if the loop is not perfectly
2188 nested, even in the usual case where this is not an error.
2189 perfect_nesting_fail is set if an error has been diagnosed because an
2190 imperfectly-nested loop was found where a perfectly-nested one is
2191 required (we diagnose this only once).
2192 fail is set if any kind of structural error in the loop nest
2193 has been found and diagnosed.
2194 */
2198 tree pre_body;
2199 tree orig_declv;
2203 location_t for_loc;
2204 releasing_vec init_blockv;
2205 releasing_vec body_blockv;
2206 releasing_vec init_placeholderv;
2207 releasing_vec body_placeholderv;
2215 tree clauses;
2217 tree ordered_cl;
2218 };
2220 /* Prototypes. */
2222 /* Constructors and destructors. */
2227 /* Class variables. */
2231 /* The operator-precedence table used by cp_parser_binary_expression.
2232 Transformed into an associative array (binops_by_token) by
2233 cp_parser_new. */
2268 };
2270 /* The same as binops, but initialized by cp_parser_new so that
2271 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2272 for speed. */
2275 /* Constructors and destructors. */
2277 /* Construct a new context. The context below this one on the stack
2278 is given by NEXT. */
2282 {
2285 /* Allocate the storage. */
2287 {
2288 /* Pull the first entry from the free list. */
2292 }
2293 else
2296 /* No errors have occurred yet in this context. */
2298 /* If this is not the bottommost context, copy information that we
2299 need from the previous context. */
2301 {
2302 /* If, in the NEXT context, we are parsing an `x->' or `x.'
2303 expression, then we are parsing one in this context, too. */
2305 /* Thread the stack. */
2307 }
2310 }
2312 /* Managing the unparsed function queues. */
2314 #define unparsed_funs_with_default_args \
2315 parser->unparsed_queues->last ().funs_with_default_args
2316 #define unparsed_funs_with_definitions \
2317 parser->unparsed_queues->last ().funs_with_definitions
2318 #define unparsed_nsdmis \
2319 parser->unparsed_queues->last ().nsdmis
2320 #define unparsed_noexcepts \
2321 parser->unparsed_queues->last ().noexcepts
2322 #define unparsed_contracts \
2323 parser->unparsed_queues->last ().contracts
2325 static void
2327 {
2328 cp_unparsed_functions_entry e
2331 }
2333 static void
2335 {
2338 }
2340 /* Prototypes. */
2342 /* Routines to parse various constructs.
2344 Those that return `tree' will return the error_mark_node (rather
2345 than NULL_TREE) if a parse error occurs, unless otherwise noted.
2346 Sometimes, they will return an ordinary node if error-recovery was
2347 attempted, even though a parse error occurred. So, to check
2348 whether or not a parse error occurred, you should always use
2349 cp_parser_error_occurred. If the construct is optional (indicated
2350 either by an `_opt' in the name of the function that does the
2351 parsing or via a FLAGS parameter), then NULL_TREE is returned if
2352 the construct is not present. */
2354 /* Lexical conventions [gram.lex] */
2356 static tree finish_userdef_string_literal
2359 /* Basic concepts [gram.basic] */
2363 /* Expressions [gram.expr] */
2365 static cp_expr cp_parser_primary_expression
2367 static cp_expr cp_parser_id_expression
2369 static cp_expr cp_parser_unqualified_id
2371 static tree cp_parser_nested_name_specifier_opt
2373 static tree cp_parser_nested_name_specifier
2375 static tree cp_parser_qualifying_entity
2377 static cp_expr cp_parser_postfix_expression
2379 static tree cp_parser_postfix_open_square_expression
2381 static tree cp_parser_postfix_dot_deref_expression
2386 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2389 static void cp_parser_pseudo_destructor_name
2391 static cp_expr cp_parser_unary_expression
2393 static enum tree_code cp_parser_unary_operator
2395 static tree cp_parser_has_attribute_expression
2397 static tree cp_parser_new_expression
2401 static tree cp_parser_new_type_id
2409 static tree cp_parser_delete_expression
2411 static cp_expr cp_parser_cast_expression
2413 static cp_expr cp_parser_binary_expression
2415 static tree cp_parser_question_colon_clause
2418 static cp_expr cp_parser_assignment_expression
2420 static enum tree_code cp_parser_assignment_operator_opt
2422 static cp_expr cp_parser_expression
2424 static cp_expr cp_parser_constant_expression
2426 static cp_expr cp_parser_builtin_offsetof
2428 static cp_expr cp_parser_lambda_expression
2430 static void cp_parser_lambda_introducer
2432 static bool cp_parser_lambda_declarator_opt
2434 static void cp_parser_lambda_body
2437 /* Statements [gram.stmt.stmt] */
2439 static void cp_parser_statement
2441 static void cp_parser_label_for_labeled_statement
2443 static tree cp_parser_expression_statement
2445 static tree cp_parser_compound_statement
2447 static void cp_parser_statement_seq_opt
2449 static tree cp_parser_selection_statement
2451 static tree cp_parser_condition
2453 static tree cp_parser_iteration_statement
2455 static bool cp_parser_init_statement
2457 static tree cp_parser_for
2459 static tree cp_parser_c_for
2461 static tree cp_parser_range_for
2463 static void do_range_for_auto_deduction
2465 static tree cp_parser_perform_range_for_lookup
2467 static tree cp_parser_range_for_member_function
2469 static tree cp_parser_jump_statement
2471 static void cp_parser_declaration_statement
2474 static tree cp_parser_implicitly_scoped_statement
2476 static void cp_parser_already_scoped_statement
2479 /* State of module-declaration parsing. */
2480 enum module_parse
2481 {
2484 _MP_UNUSED,
2494 };
2496 static module_parse cp_parser_module_declaration
2498 static void cp_parser_import_declaration
2501 /* Declarations [gram.dcl.dcl] */
2503 static void cp_parser_declaration_seq_opt
2505 static void cp_parser_declaration
2507 static void cp_parser_toplevel_declaration
2509 static void cp_parser_block_declaration
2511 static void cp_parser_simple_declaration
2513 static void cp_parser_decl_specifier_seq
2515 static tree cp_parser_storage_class_specifier_opt
2517 static tree cp_parser_function_specifier_opt
2519 static tree cp_parser_type_specifier
2522 static tree cp_parser_simple_type_specifier
2524 static tree cp_parser_placeholder_type_specifier
2526 static tree cp_parser_type_name
2528 static tree cp_parser_nonclass_name
2530 static tree cp_parser_elaborated_type_specifier
2532 static tree cp_parser_enum_specifier
2534 static void cp_parser_enumerator_list
2536 static void cp_parser_enumerator_definition
2538 static tree cp_parser_namespace_name
2540 static void cp_parser_namespace_definition
2542 static void cp_parser_namespace_body
2544 static tree cp_parser_qualified_namespace_specifier
2546 static void cp_parser_namespace_alias_definition
2548 static bool cp_parser_using_declaration
2550 static void cp_parser_using_directive
2552 static void cp_parser_using_enum
2554 static tree cp_parser_alias_declaration
2556 static void cp_parser_asm_definition
2558 static void cp_parser_linkage_specification
2560 static void cp_parser_static_assert
2562 static tree cp_parser_decltype
2564 static tree cp_parser_decomposition_declaration
2567 /* Declarators [gram.dcl.decl] */
2569 static tree cp_parser_init_declarator
2579 static enum tree_code cp_parser_ptr_operator
2581 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2583 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2585 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2587 static tree cp_parser_tx_qualifier_opt
2589 static tree cp_parser_late_return_type_opt
2591 static tree cp_parser_declarator_id
2593 static tree cp_parser_type_id
2595 static tree cp_parser_template_type_arg
2598 static tree cp_parser_type_id_1
2600 static void cp_parser_type_specifier_seq
2602 static tree cp_parser_parameter_declaration_clause
2604 static tree cp_parser_parameter_declaration_list
2608 static tree cp_parser_default_argument
2610 static void cp_parser_function_body
2612 static tree cp_parser_initializer
2614 static cp_expr cp_parser_initializer_clause
2616 static cp_expr cp_parser_braced_list
2621 static void cp_parser_ctor_initializer_opt_and_function_body
2624 static tree cp_parser_late_parsing_omp_declare_simd
2627 static tree cp_parser_late_parsing_oacc_routine
2630 static tree synthesize_implicit_template_parm
2632 static tree finish_fully_implicit_template
2634 static void abort_fully_implicit_template
2637 /* Classes [gram.class] */
2639 static tree cp_parser_class_name
2641 static tree cp_parser_class_specifier
2643 static tree cp_parser_class_head
2645 static enum tag_types cp_parser_class_key
2647 static void cp_parser_type_parameter_key
2649 static void cp_parser_member_specification_opt
2651 static void cp_parser_member_declaration
2653 static tree cp_parser_pure_specifier
2655 static tree cp_parser_constant_initializer
2658 /* Derived classes [gram.class.derived] */
2660 static tree cp_parser_base_clause
2662 static tree cp_parser_base_specifier
2665 /* Special member functions [gram.special] */
2667 static tree cp_parser_conversion_function_id
2669 static tree cp_parser_conversion_type_id
2673 static void cp_parser_ctor_initializer_opt
2675 static void cp_parser_mem_initializer_list
2677 static tree cp_parser_mem_initializer
2679 static tree cp_parser_mem_initializer_id
2682 /* Overloading [gram.over] */
2684 static cp_expr cp_parser_operator_function_id
2686 static cp_expr cp_parser_operator
2689 /* Templates [gram.temp] */
2691 static void cp_parser_template_declaration
2693 static tree cp_parser_template_parameter_list
2695 static tree cp_parser_template_parameter
2697 static tree cp_parser_type_parameter
2699 static tree cp_parser_template_id
2701 static tree cp_parser_template_id_expr
2703 static tree cp_parser_template_name
2705 static tree cp_parser_template_argument_list
2707 static tree cp_parser_template_argument
2709 static void cp_parser_explicit_instantiation
2711 static void cp_parser_explicit_specialization
2714 /* Exception handling [gram.except] */
2716 static tree cp_parser_try_block
2718 static void cp_parser_function_try_block
2720 static void cp_parser_handler_seq
2722 static void cp_parser_handler
2724 static tree cp_parser_exception_declaration
2726 static tree cp_parser_throw_expression
2728 static tree cp_parser_exception_specification_opt
2730 static tree cp_parser_type_id_list
2732 static tree cp_parser_noexcept_specification_opt
2735 /* GNU Extensions */
2737 static tree cp_parser_asm_specification_opt
2739 static tree cp_parser_asm_operand_list
2741 static tree cp_parser_asm_clobber_list
2743 static tree cp_parser_asm_label_list
2745 static bool cp_next_tokens_can_be_attribute_p
2747 static bool cp_next_tokens_can_be_gnu_attribute_p
2749 static bool cp_next_tokens_can_be_std_attribute_p
2751 static bool cp_nth_tokens_can_be_std_attribute_p
2753 static bool cp_nth_tokens_can_be_gnu_attribute_p
2755 static bool cp_nth_tokens_can_be_attribute_p
2757 static tree cp_parser_attributes_opt
2759 static tree cp_parser_gnu_attributes_opt
2761 static tree cp_parser_gnu_attribute_list
2763 static tree cp_parser_std_attribute
2765 static tree cp_parser_std_attribute_spec
2767 static tree cp_parser_std_attribute_spec_seq
2769 static size_t cp_parser_skip_std_attribute_spec_seq
2771 static size_t cp_parser_skip_attributes_opt
2773 static bool cp_parser_extension_opt
2775 static void cp_parser_label_declaration
2778 /* Concept Extensions */
2780 static tree cp_parser_concept_definition
2782 static tree cp_parser_constraint_expression
2784 static tree cp_parser_requires_clause_opt
2786 static tree cp_parser_requires_expression
2788 static tree cp_parser_requirement_parameter_list
2790 static tree cp_parser_requirement_body
2792 static tree cp_parser_requirement_seq
2794 static tree cp_parser_requirement
2796 static tree cp_parser_simple_requirement
2798 static tree cp_parser_compound_requirement
2800 static tree cp_parser_type_requirement
2802 static tree cp_parser_nested_requirement
2805 /* Transactional Memory Extensions */
2807 static tree cp_parser_transaction
2809 static tree cp_parser_transaction_expression
2811 static void cp_parser_function_transaction
2813 static tree cp_parser_transaction_cancel
2816 /* Coroutine extensions. */
2818 static tree cp_parser_yield_expression
2821 /* Contracts */
2823 static void cp_parser_late_contract_condition
2827 pragma_external,
2828 pragma_member,
2829 pragma_objc_icode,
2830 pragma_stmt,
2831 pragma_compound
2832 };
2833 static bool cp_parser_pragma
2836 /* Objective-C++ Productions */
2838 static tree cp_parser_objc_message_receiver
2840 static tree cp_parser_objc_message_args
2842 static tree cp_parser_objc_message_expression
2844 static cp_expr cp_parser_objc_encode_expression
2846 static tree cp_parser_objc_defs_expression
2848 static tree cp_parser_objc_protocol_expression
2850 static tree cp_parser_objc_selector_expression
2852 static cp_expr cp_parser_objc_expression
2854 static bool cp_parser_objc_selector_p
2856 static tree cp_parser_objc_selector
2858 static tree cp_parser_objc_protocol_refs_opt
2860 static void cp_parser_objc_declaration
2862 static tree cp_parser_objc_statement
2864 static bool cp_parser_objc_valid_prefix_attributes
2866 static void cp_parser_objc_at_property_declaration
2868 static void cp_parser_objc_at_synthesize_declaration
2870 static void cp_parser_objc_at_dynamic_declaration
2872 static tree cp_parser_objc_struct_declaration
2875 /* Utility Routines */
2877 static cp_expr cp_parser_lookup_name
2879 static tree cp_parser_lookup_name_simple
2881 static tree cp_parser_maybe_treat_template_as_class
2883 static bool cp_parser_check_declarator_template_parameters
2885 static bool cp_parser_check_template_parameters
2887 static cp_expr cp_parser_simple_cast_expression
2889 static tree cp_parser_global_scope_opt
2891 static bool cp_parser_constructor_declarator_p
2893 static tree cp_parser_function_definition_from_specifiers_and_declarator
2895 static tree cp_parser_function_definition_after_declarator
2897 static bool cp_parser_template_declaration_after_export
2899 static void cp_parser_perform_template_parameter_access_checks
2901 static tree cp_parser_single_declaration
2903 static cp_expr cp_parser_functional_cast
2905 static tree cp_parser_save_member_function_body
2907 static tree cp_parser_save_nsdmi
2909 static tree cp_parser_enclosed_template_argument_list
2911 static void cp_parser_save_default_args
2913 static void cp_parser_late_parsing_for_member
2915 static tree cp_parser_late_parse_one_default_arg
2917 static void cp_parser_late_parsing_nsdmi
2919 static void cp_parser_late_parsing_default_args
2921 static tree cp_parser_sizeof_operand
2923 static cp_expr cp_parser_trait
2925 static bool cp_parser_declares_only_class_p
2927 static void cp_parser_set_storage_class
2929 static void cp_parser_set_decl_spec_type
2931 static void set_and_check_decl_spec_loc
2934 static bool cp_parser_friend_p
2936 static void cp_parser_required_error
2942 static bool cp_parser_token_starts_function_definition_p
2944 static bool cp_parser_next_token_starts_class_definition_p
2946 static bool cp_parser_next_token_ends_template_argument_p
2948 static bool cp_parser_nth_token_starts_template_argument_list_p
2950 static enum tag_types cp_parser_token_is_class_key
2952 static enum tag_types cp_parser_token_is_type_parameter_key
2955 static void cp_parser_check_class_key
2957 static void cp_parser_check_access_in_redeclaration
2959 static bool cp_parser_optional_template_keyword
2961 static void cp_parser_pre_parsed_nested_name_specifier
2963 static bool cp_parser_cache_group
2965 static tree cp_parser_cache_defarg
2967 static void cp_parser_parse_tentatively
2969 static void cp_parser_commit_to_tentative_parse
2971 static void cp_parser_commit_to_topmost_tentative_parse
2973 static void cp_parser_abort_tentative_parse
2975 static bool cp_parser_parse_definitely
2979 static bool cp_parser_uncommitted_to_tentative_parse_p
2981 static void cp_parser_error
2983 static void cp_parser_name_lookup_error
2985 static bool cp_parser_simulate_error
2987 static bool cp_parser_check_type_definition
2989 static void cp_parser_check_for_definition_in_return_type
2991 static void cp_parser_check_for_invalid_template_id
2993 static bool cp_parser_non_integral_constant_expression
2995 static void cp_parser_diagnose_invalid_type_name
2997 static bool cp_parser_parse_and_diagnose_invalid_type_name
2999 static int cp_parser_skip_to_closing_parenthesis
3001 static void cp_parser_skip_to_end_of_statement
3003 static void cp_parser_consume_semicolon_at_end_of_statement
3005 static void cp_parser_skip_to_end_of_block_or_statement
3007 static bool cp_parser_skip_to_closing_brace
3009 static bool cp_parser_skip_entire_template_parameter_list
3011 static void cp_parser_require_end_of_template_parameter_list
3013 static bool cp_parser_skip_to_end_of_template_parameter_list
3015 static void cp_parser_skip_to_pragma_eol
3017 static bool cp_parser_error_occurred
3019 static bool cp_parser_allow_gnu_extensions_p
3021 static bool cp_parser_is_pure_string_literal
3023 static bool cp_parser_is_string_literal
3025 static bool cp_parser_is_keyword
3027 static tree cp_parser_make_typename_type
3031 static bool cp_parser_compound_literal_p
3033 static bool cp_parser_array_designator_p
3035 static bool cp_parser_init_statement_p
3037 static bool cp_parser_skip_up_to_closing_square_bracket
3039 static bool cp_parser_skip_to_closing_square_bracket
3044 // -------------------------------------------------------------------------- //
3045 // Unevaluated Operand Guard
3046 //
3047 // Implementation of an RAII helper for unevaluated operand parsing.
3049 {
3052 }
3055 {
3058 }
3060 // -------------------------------------------------------------------------- //
3061 // Tentative Parsing
3063 /* Returns nonzero if we are parsing tentatively. */
3067 {
3069 }
3071 /* Returns nonzero if TOKEN is a string literal. */
3073 static bool
3075 {
3081 }
3083 /* Returns nonzero if TOKEN is a string literal
3084 of a user-defined string literal. */
3086 static bool
3088 {
3095 }
3097 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
3099 static bool
3101 {
3103 }
3105 /* Helper function for cp_parser_error.
3106 Having peeked a token of kind TOK1_KIND that might signify
3107 a conflict marker, peek successor tokens to determine
3108 if we actually do have a conflict marker.
3109 Specifically, we consider a run of 7 '<', '=' or '>' characters
3110 at the start of a line as a conflict marker.
3111 These come through the lexer as three pairs and a single,
3112 e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
3113 If it returns true, *OUT_LOC is written to with the location/range
3114 of the marker. */
3116 static bool
3119 {
3130 /* It must be at the start of the line. */
3135 /* We have a conflict marker. Construct a location of the form:
3136 <<<<<<<
3137 ^~~~~~~
3138 with start == caret, finishing at the end of the marker. */
3143 }
3145 /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
3146 RT_CLOSE_PAREN. */
3150 {
3152 {
3160 }
3161 }
3163 /* Attempt to convert TOKEN_DESC from a required_token to an
3164 enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
3166 static enum cpp_ttype
3168 {
3170 {
3191 /* Use CPP_EOF as a "no completions possible" code. */
3193 }
3194 }
3197 /* Subroutine of cp_parser_error and cp_parser_required_error.
3199 Issue a diagnostic of the form
3200 FILE:LINE: MESSAGE before TOKEN
3201 where TOKEN is the next token in the input stream. MESSAGE
3202 (specified by the caller) is usually of the form "expected
3203 OTHER-TOKEN".
3205 This bypasses the check for tentative passing, and potentially
3206 adds material needed by cp_parser_required_error.
3208 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
3209 suggesting insertion of the missing token.
3211 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
3212 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
3213 location. */
3215 static void
3217 required_token missing_token_desc,
3218 location_t matching_location)
3219 {
3221 /* This diagnostic makes more sense if it is tagged to the line
3222 of the token we just peeked at. */
3226 {
3231 }
3233 /* If this is actually a conflict marker, report it as such. */
3237 {
3238 location_t loc;
3240 {
3243 /* Consume tokens until the end of the source line. */
3245 {
3259 }
3261 }
3262 }
3264 auto_diagnostic_group d;
3271 {
3272 /* Potentially supply a fix-it hint, suggesting to add the
3273 missing token immediately after the *previous* token.
3274 This may move the primary location within richloc. */
3278 prev_token_loc);
3280 /* If matching_location != UNKNOWN_LOCATION, highlight it.
3281 Attempt to consolidate diagnostics by printing it as a
3282 secondary range within the main diagnostic. */
3284 added_matching_location
3286 }
3288 /* If we were parsing a string-literal and there is an unknown name
3289 token right after, then check to see if that could also have been
3290 a literal string by checking the name against a list of known
3291 standard string literal constants defined in header files. If
3292 there is one, then add that as an hint to the error message. */
3293 name_hint h;
3297 {
3304 token_name,
3305 header_hint));
3306 }
3308 /* Actually emit the error. */
3310 /* Because c_parser_error does not understand
3311 CPP_KEYWORD, keywords are treated like
3312 identifiers. */
3317 {
3318 /* If we weren't able to consolidate matching_location, then
3319 print it as a secondary diagnostic. */
3324 }
3325 }
3327 /* If not parsing tentatively, issue a diagnostic of the form
3328 FILE:LINE: MESSAGE before TOKEN
3329 where TOKEN is the next token in the input stream. MESSAGE
3330 (specified by the caller) is usually of the form "expected
3331 OTHER-TOKEN". */
3333 static void
3335 {
3338 }
3340 /* Issue an error about name-lookup failing. NAME is the
3341 IDENTIFIER_NODE DECL is the result of
3342 the lookup (as returned from cp_parser_lookup_name). DESIRED is
3343 the thing that we hoped to find. */
3345 static void
3347 tree name,
3348 tree decl,
3349 name_lookup_error desired,
3350 location_t location)
3351 {
3352 /* If name lookup completely failed, tell the user that NAME was not
3353 declared. */
3355 {
3368 else
3370 }
3372 {
3374 {
3391 }
3392 }
3394 {
3396 {
3406 name);
3410 }
3411 }
3412 else
3413 {
3415 {
3428 }
3429 }
3430 }
3432 /* If we are parsing tentatively, remember that an error has occurred
3433 during this tentative parse. Returns true if the error was
3434 simulated; false if a message should be issued by the caller. */
3436 static bool
3438 {
3440 {
3443 }
3445 }
3447 /* This function is called when a type is defined. If type
3448 definitions are forbidden at this point, an error message is
3449 issued. */
3451 static bool
3453 {
3454 /* If types are forbidden here, issue a message. */
3456 {
3457 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3458 or %qs in the message need to be interpreted. */
3462 }
3464 }
3466 /* This function is called when the DECLARATOR is processed. The TYPE
3467 was a type defined in the decl-specifiers. If it is invalid to
3468 define a type in the decl-specifiers for DECLARATOR, an error is
3469 issued. TYPE_LOCATION is the location of TYPE and is used
3470 for error reporting. */
3472 static void
3475 {
3476 /* [dcl.fct] forbids type definitions in return types.
3477 Unfortunately, it's not easy to know whether or not we are
3478 processing a return type until after the fact. */
3486 {
3491 type);
3492 }
3493 }
3495 /* A type-specifier (TYPE) has been parsed which cannot be followed by
3496 "<" in any valid C++ program. If the next token is indeed "<",
3497 issue a message warning the user about what appears to be an
3498 invalid attempt to form a template-id. LOCATION is the location
3499 of the type-specifier (TYPE) */
3501 static void
3503 tree type,
3505 location_t location)
3506 {
3510 {
3516 {
3519 else
3521 }
3522 else
3524 /* Remember the location of the invalid "<". */
3527 /* Consume the "<". */
3529 /* Parse the template arguments. */
3531 /* Permanently remove the invalid template arguments so that
3532 this error message is not issued again. */
3535 }
3536 }
3538 /* If parsing an integral constant-expression, issue an error message
3539 about the fact that THING appeared and return true. Otherwise,
3540 return false. In either case, set
3541 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3543 static bool
3545 non_integral_constant thing)
3546 {
3549 {
3551 {
3554 {
3557 "ISO C++ forbids using a floating-point literal "
3562 "enumeration type cannot appear in a "
3653 }
3657 }
3658 }
3660 }
3662 /* Emit a diagnostic for an invalid type name. This function commits
3663 to the current active tentative parse, if any. (Otherwise, the
3664 problematic construct might be encountered again later, resulting
3665 in duplicate error messages.) LOCATION is the location of ID. */
3667 static void
3669 location_t location)
3670 {
3673 /* Try to lookup the identifier. */
3680 /* If the lookup was ambiguous, an error will already have
3681 been issued. */
3683 /* If the lookup found a template-name, it means that the user forgot
3684 to specify an argument list. Emit a useful error message. */
3686 {
3687 auto_diagnostic_group d;
3690 decl);
3695 }
3699 /* Something like 'unsigned A a;' */
3702 {
3703 /* Issue an error message. */
3704 auto_diagnostic_group d;
3705 name_hint hint;
3709 {
3715 }
3716 else
3718 /* If we're in a template class, it's possible that the user was
3719 referring to a type from a base class. For example:
3721 template <typename T> struct A { typedef T X; };
3722 template <typename T> struct B : public A<T> { X x; };
3724 The user should have said "typename A<T>::X". */
3733 {
3736 id);
3739 id);
3740 else
3743 }
3760 {
3763 {
3767 {
3768 /* Go from a particular instantiation of the
3769 template (which will have an empty TYPE_FIELDs),
3770 to the main version. */
3776 {
3781 }
3782 }
3783 }
3784 found:;
3785 }
3786 }
3787 /* Here we diagnose qualified-ids where the scope is actually correct,
3788 but the identifier does not resolve to a valid type name. */
3790 {
3792 {
3793 auto_diagnostic_group d;
3794 name_hint hint;
3803 {
3806 "%qE in namespace %qE does not name a template"
3809 else
3813 }
3815 {
3818 "%qE in namespace %qE does not name a template"
3821 else
3823 "%qE in namespace %qE does not name a template"
3826 }
3827 else
3828 {
3831 "%qE in namespace %qE does not name a type"
3834 else
3838 }
3841 }
3844 {
3845 /* A<T>::A<T>() */
3846 auto_diagnostic_group d;
3852 }
3855 {
3860 "need %<typename%> before %<%T::%D::%E%> because "
3864 id,
3867 else
3871 }
3873 {
3874 auto_diagnostic_group d;
3886 else
3892 }
3893 else
3895 }
3896 }
3898 /* Check for a common situation where a type-name should be present,
3899 but is not, and issue a sensible error message. Returns true if an
3900 invalid type-name was detected.
3902 The situation handled by this function are variable declarations of the
3903 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3904 Usually, `ID' should name a type, but if we got here it means that it
3905 does not. We try to emit the best possible error message depending on
3906 how exactly the id-expression looks like. */
3908 static bool
3910 {
3911 tree id;
3914 /* Avoid duplicate error about ambiguous lookup. */
3916 {
3920 }
3929 /* If the next token is a (, this is a function with no explicit return
3930 type, i.e. constructor, destructor or conversion op. */
3933 {
3936 }
3940 /* Emit a diagnostic for the invalid type. */
3942 out:
3943 /* If we aren't in the middle of a declarator (i.e. in a
3944 parameter-declaration-clause), skip to the end of the declaration;
3945 there's no point in trying to process it. */
3949 }
3951 /* Consume tokens up to, and including, the next non-nested closing `)'.
3952 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3953 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3954 found an unnested token of that type. */
3956 static int
3959 cpp_ttype or_ttype,
3961 {
3972 {
3975 /* Have we found what we're looking for before the closing paren? */
3981 {
3985 /* FALLTHRU */
3987 /* If we've run out of tokens, then there is no closing `)'. */
3990 /* This is good for lambda expression capture-lists. */
4000 /* This matches the processing in skip_to_end_of_statement. */
4020 {
4024 }
4034 condop_depth--;
4040 /* FALLTHROUGH */
4043 /* We fell into a pragma. Skip it, and continue. */
4049 }
4051 /* Consume the token. */
4053 }
4054 }
4056 /* Consume tokens up to, and including, the next non-nested closing `)'.
4057 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
4058 are doing error recovery. Returns -1 if OR_COMMA is true and we
4059 found an unnested token of that type. */
4061 static int
4066 {
4070 }
4072 /* Consume tokens until we reach the end of the current statement.
4073 Normally, that will be just before consuming a `;'. However, if a
4074 non-nested `}' comes first, then we stop before consuming that. */
4076 static void
4078 {
4081 /* Unwind generic function template scope if necessary. */
4086 {
4090 {
4094 /* FALLTHRU */
4096 /* If we've run out of tokens, stop. */
4100 /* If the next token is a `;', we have reached the end of the
4101 statement. */
4107 /* If this is a non-nested '}', stop before consuming it.
4108 That way, when confronted with something like:
4110 { 3 + }
4112 we stop before consuming the closing '}', even though we
4113 have not yet reached a `;'. */
4117 /* If it is the closing '}' for a block that we have
4118 scanned, stop -- but only after consuming the token.
4119 That way given:
4121 void f g () { ... }
4122 typedef int I;
4124 we will stop after the body of the erroneously declared
4125 function, but before consuming the following `typedef'
4126 declaration. */
4128 {
4131 }
4141 /* FALLTHROUGH */
4144 /* We fell into a pragma. Skip it, and continue or return. */
4152 }
4154 /* Consume the token. */
4156 }
4157 }
4159 /* This function is called at the end of a statement or declaration.
4160 If the next token is a semicolon, it is consumed; otherwise, error
4161 recovery is attempted. */
4163 static void
4165 {
4166 /* Look for the trailing `;'. */
4168 {
4169 /* If there is additional (erroneous) input, skip to the end of
4170 the statement. */
4172 /* If the next token is now a `;', consume it. */
4175 }
4176 }
4178 /* Skip tokens until we have consumed an entire block, or until we
4179 have consumed a non-nested `;'. */
4181 static void
4183 {
4186 /* Unwind generic function template scope if necessary. */
4191 {
4195 {
4199 /* FALLTHRU */
4201 /* If we've run out of tokens, stop. */
4205 /* Stop if this is an unnested ';'. */
4211 /* Stop if this is an unnested '}', or closes the outermost
4212 nesting level. */
4213 nesting_depth--;
4221 /* Nest. */
4222 nesting_depth++;
4228 /* FALLTHROUGH */
4231 /* Skip it, and continue or return. */
4239 }
4241 /* Consume the token. */
4243 }
4244 }
4246 /* Skip tokens until a non-nested closing curly brace is the next
4247 token, or there are no more tokens. Return true in the first case,
4248 false otherwise. */
4250 static bool
4252 {
4256 {
4260 {
4264 /* FALLTHRU */
4266 /* If we've run out of tokens, stop. */
4270 /* If the next token is a non-nested `}', then we have reached
4271 the end of the current block. */
4277 /* If it the next token is a `{', then we are entering a new
4278 block. Consume the entire block. */
4284 }
4286 /* Consume the token. */
4288 }
4289 }
4291 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4292 parameter is the PRAGMA token, allowing us to purge the entire pragma
4293 sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4294 forwards (not error recovery). */
4296 static void
4298 {
4301 do
4302 {
4303 /* The preprocessor makes sure that a PRAGMA_EOL token appears
4304 before an EOF token, even when the EOF is on the pragma line.
4305 We should never get here without being inside a deferred
4306 pragma. */
4309 }
4313 {
4317 {
4319 /* Put the current source position back where it was before this
4320 lexer was pushed. */
4322 }
4323 }
4324 }
4326 /* Require pragma end of line, resyncing with it as necessary. The
4327 arguments are as for cp_parser_skip_to_pragma_eol. */
4329 static void
4331 {
4337 {
4339 /* Put the current source position back where it was before this
4340 lexer was pushed. */
4342 }
4343 }
4345 /* This is a simple wrapper around make_typename_type. When the id is
4346 an unresolved identifier node, we can provide a superior diagnostic
4347 using cp_parser_diagnose_invalid_type_name. */
4349 static tree
4351 location_t id_location)
4352 {
4353 tree result;
4355 {
4361 }
4363 }
4365 /* This is a wrapper around the
4366 make_{pointer,ptrmem,reference}_declarator functions that decides
4367 which one to call based on the CODE and CLASS_TYPE arguments. The
4368 CODE argument should be one of the values returned by
4369 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4370 appertain to the pointer or reference. */
4374 cp_cv_quals cv_qualifiers,
4376 tree attributes)
4377 {
4384 else
4394 }
4396 /* Create a new C++ parser. */
4400 {
4401 /* Initialize the binops_by_token so that we can get the tree
4402 directly from the token. */
4410 /* For now, we always accept GNU extensions. */
4413 /* The `>' token is a greater-than operator, not the end of a
4414 template-id. */
4419 /* We are not parsing a constant-expression. */
4424 /* Local variable names are not forbidden. */
4427 /* We are not processing an `extern "C"' declaration. */
4430 /* We aren't parsing an export-declaration. */
4433 /* We are not processing a declarator. */
4436 /* We are not processing a template-argument-list. */
4439 /* We are not in an iteration statement. */
4442 /* We are not in a switch statement. */
4445 /* We are not parsing a type-id inside an expression. */
4448 /* String literals should be translated to the execution character set. */
4451 /* We are not parsing a function body. */
4454 /* We can correct until told otherwise. */
4457 /* The unparsed function queue is empty. */
4460 /* There are no classes being defined. */
4463 /* No template parameters apply. */
4466 /* Special parsing data structures. */
4470 /* Disallow OpenMP array sections in expressions. */
4473 /* Not declaring an implicit function template. */
4479 /* Allow constrained-type-specifiers. */
4482 /* We haven't yet seen an 'extern "C"'. */
4486 }
4488 /* Create a cp_lexer structure which will emit the tokens in CACHE
4489 and push it onto the parser's lexer stack. This is used for delayed
4490 parsing of in-class method bodies and default arguments, and should
4491 not be confused with tentative parsing. */
4492 static void
4494 {
4499 /* Move the current source position to that of the first token in the
4500 new lexer. */
4502 }
4504 /* Pop the top lexer off the parser stack. This is never used for the
4505 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4506 static void
4508 {
4513 /* Put the current source position back where it was before this
4514 lexer was pushed. */
4516 }
4518 /* Lexical conventions [gram.lex] */
4520 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4521 identifier. */
4523 static cp_expr
4525 {
4528 /* Look for the identifier. */
4530 /* Return the value. */
4533 else
4535 }
4537 /* Worker for cp_parser_string_literal, cp_parser_userdef_string_literal
4538 and cp_parser_unevaluated_string_literal.
4539 Do not call this directly; use either of the above.
4541 Parse a sequence of adjacent string constants. Return a
4542 TREE_STRING representing the combined, nul-terminated string
4543 constant. If TRANSLATE is true, translate the string to the
4544 execution character set. If WIDE_OK is true, a wide string is
4545 valid here. If UDL_OK is true, a string literal with user-defined
4546 suffix can be used in this context. If UNEVAL is true, diagnose
4547 numeric and conditional escape sequences in it if pedantic.
4549 C++98 [lex.string] says that if a narrow string literal token is
4550 adjacent to a wide string literal token, the behavior is undefined.
4551 However, C99 6.4.5p4 says that this results in a wide string literal.
4552 We follow C99 here, for consistency with the C front end.
4554 This code is largely lifted from lex_string() in c-lex.cc.
4556 FUTURE: ObjC++ will need to handle @-strings here. */
4558 static cp_expr
4562 {
4563 tree value;
4571 tree string_tree;
4577 {
4580 }
4585 {
4587 {
4591 }
4595 }
4596 else
4597 {
4600 }
4603 /* Try to avoid the overhead of creating and destroying an obstack
4604 for the common case of just one string. */
4607 {
4615 {
4619 }
4620 else
4624 }
4625 else
4626 {
4632 do
4633 {
4635 count++;
4640 {
4643 {
4646 }
4649 {
4654 }
4656 }
4657 else
4661 {
4665 {
4669 "concatenation of string literals with "
4671 }
4672 }
4681 {
4683 {
4687 }
4691 }
4692 else
4693 {
4697 }
4698 }
4701 /* A string literal built by concatenation has its caret=start at
4702 the start of the initial string, and its finish at the finish of
4703 the final string literal. */
4707 }
4710 {
4713 }
4719 {
4723 {
4727 }
4730 {
4738 else
4750 }
4755 {
4760 else
4762 }
4763 }
4764 else
4765 /* cpp_interpret_string has issued an error. */
4769 {
4772 }
4775 }
4777 /* Parse a sequence of adjacent string constants. Return a TREE_STRING
4778 representing the combined, nul-terminated string constant. If
4779 TRANSLATE is true, translate the string to the execution character set.
4780 If WIDE_OK is true, a wide string is valid here.
4782 This function issues an error if a user defined string literal is
4783 encountered; use cp_parser_userdef_string_literal if UDLs are allowed. */
4787 {
4792 }
4794 /* Parse a string literal or user defined string literal.
4796 user-defined-string-literal :
4797 string-literal ud-suffix
4799 If LOOKUP_UDLIT, perform a lookup for a suitable template function. */
4803 {
4807 }
4809 /* Parse an unevaluated string literal.
4811 unevaluated-string:
4812 string-literal */
4816 {
4821 }
4823 /* Look up a literal operator with the name and the exact arguments. */
4825 static tree
4827 {
4833 {
4837 {
4844 {
4854 }
4858 /* May be this should be sufficient_parms_p instead,
4859 depending on how exactly should user-defined literals
4860 work in presence of default arguments on the literal
4861 operator parameters. */
4864 }
4865 }
4868 }
4870 /* Parse a user-defined char constant. Returns a call to a user-defined
4871 literal operator taking the character as an argument. */
4873 static cp_expr
4875 {
4883 /* Build up a call to the user-defined operator */
4884 /* Lookup the name we got back from the id-expression. */
4885 releasing_vec args;
4889 {
4893 }
4896 }
4898 /* A subroutine of cp_parser_userdef_numeric_literal to
4899 create a char... template parameter pack from a string node. */
4901 static tree
4903 {
4904 tree charvec;
4911 /* Fill in CHARVEC with all of the parameters. */
4914 {
4923 }
4925 /* Build the argument packs. */
4931 }
4933 /* A subroutine of cp_parser_userdef_numeric_literal to
4934 create a char... template parameter pack from a string node. */
4936 static tree
4938 {
4939 tree charvec;
4950 /* First template parm is character type. */
4953 /* Fill in CHARVEC with all of the parameters. */
4960 /* Build the argument packs. */
4966 }
4968 /* Parse a user-defined numeric constant. returns a call to a user-defined
4969 literal operator. */
4971 static cp_expr
4973 {
4983 /* Look for a literal operator taking the exact type of numeric argument
4984 as the literal value. */
4985 releasing_vec args;
4989 {
4991 tf_warning_or_error);
4994 {
4997 long_long_unsigned_type_node);
4998 }
4999 else
5000 {
5004 long_double_type_node);
5008 }
5011 }
5013 /* If the numeric argument didn't work, look for a raw literal
5014 operator taking a const char* argument consisting of the number
5015 in string format. */
5020 {
5022 tf_warning_or_error);
5024 }
5026 /* If the raw literal didn't work, look for a non-type template
5027 function with parameter pack char.... Call the function with
5028 template parameter characters representing the number. */
5032 {
5035 {
5037 num_string);
5039 }
5042 tf_warning_or_error);
5044 }
5046 /* In C++14 the standard library defines complex number suffixes that
5047 conflict with GNU extensions. Prefer them if <complex> is #included. */
5057 {
5061 {
5062 /* No <complex>, so pedwarn and use GNU semantics. */
5065 }
5066 }
5068 bool complained
5075 {
5077 "(from %<<complex>%>) to enable the C++14 user-defined literal "
5082 }
5089 else
5090 {
5091 /* Use the built-in semantics. */
5092 tree type;
5094 {
5097 else
5099 }
5107 }
5110 /* Avoid repeated diagnostics. */
5113 }
5115 /* Parse a user-defined string constant. Returns a call to a user-defined
5116 literal operator taking a character pointer and the length of the string
5117 as arguments. */
5119 static tree
5121 {
5127 tree decl;
5129 /* Build up a call to the user-defined operator. */
5130 /* Lookup the name we got back from the id-expression. */
5131 releasing_vec args;
5138 tf_warning_or_error);
5140 /* Look for a suitable template function, either (C++20) with a single
5141 parameter of class type, or (N3599) with typename parameter CharT and
5142 parameter pack CharT... */
5146 {
5147 /* Use resolve_nondeduced_context to try to choose one form of template
5148 or the other. */
5155 else
5156 {
5161 }
5165 tf_warning_or_error);
5166 }
5171 }
5174 /* Basic concepts [gram.basic] */
5176 /* Parse a translation-unit.
5178 translation-unit:
5179 declaration-seq [opt] */
5181 static void
5183 {
5186 /* Create the declarator obstack. */
5188 /* Create the error declarator. */
5190 /* Create the empty parameter list. */
5192 UNKNOWN_LOCATION);
5193 /* Remember where the base of the declarator obstack lies. */
5205 /* Parse until EOF. */
5207 {
5210 /* If we're entering or exiting a region that's implicitly
5211 extern "C", modify the lang context appropriately. This is
5212 so horrible. Please die. */
5215 {
5219 else
5221 }
5227 {
5228 /* Top-level module declarations are ok, and change the
5229 portion of file we're in. Top-level import declarations
5230 are significant for the import portions. */
5235 {
5238 }
5240 {
5241 mp_state
5244 }
5246 {
5251 }
5252 else
5256 {
5259 {
5262 "global module fragment contents must be"
5264 }
5265 }
5266 }
5268 /* This relies on the ordering of module_parse values. */
5270 /* We're no longer in the import portion of a named module. */
5276 {
5279 /* If the next token is now a `;', consume it. */
5282 }
5283 else
5285 }
5287 /* Get rid of the token array; we don't need it any more. */
5291 /* The EOF should have reset this. */
5294 /* Make sure the declarator obstack was fully cleaned up. */
5297 }
5299 /* Return the appropriate tsubst flags for parsing, possibly in N3276
5300 decltype context. */
5304 {
5309 }
5311 /* We're about to parse a collection of statements. If we're currently
5312 parsing tentatively, set up a firewall so that any nested
5313 cp_parser_commit_to_tentative_parse won't affect the current context. */
5315 static cp_token_position
5317 {
5324 }
5326 /* We've finished parsing the collection of statements. Wrap up the
5327 firewall and replace the relevant tokens with the parsed form. */
5329 static void
5331 tree expr)
5332 {
5336 /* Finish the firewall level. */
5338 /* And remember the result of the parse for when we try again. */
5344 }
5346 /* Like the above functions, but let the user modify the tokens. Used by
5347 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5348 later parses, so it makes sense to localize the effects of
5349 cp_parser_commit_to_tentative_parse. */
5351 struct tentative_firewall
5352 {
5357 {
5358 /* If we're currently parsing tentatively, start a committed level as a
5359 firewall and then an inner tentative parse. */
5361 {
5365 }
5366 }
5369 {
5371 {
5372 /* Finish the inner tentative parse and the firewall, propagating any
5373 uncommitted error state to the outer tentative parse. */
5379 }
5380 }
5381 };
5383 /* Some tokens naturally come in pairs e.g.'(' and ')'.
5384 This class is for tracking such a matching pair of symbols.
5385 In particular, it tracks the location of the first token,
5386 so that if the second token is missing, we can highlight the
5387 location of the first token when notifying the user about the
5388 problem. */
5391 class token_pair
5392 {
5394 /* token_pair's ctor. */
5397 /* If the next token is the opening symbol for this pair, consume it and
5398 return true.
5399 Otherwise, issue an error and return false.
5400 In either case, record the location of the opening token. */
5403 {
5407 }
5409 /* Consume the next token from PARSER, recording its location as
5410 that of the opening token within the pair. */
5413 {
5418 }
5420 /* If the next token is the closing symbol for this pair, consume it
5421 and return it.
5422 Otherwise, issue an error, highlighting the location of the
5423 corresponding opening token, and return NULL. */
5426 {
5429 m_open_loc);
5430 }
5435 location_t m_open_loc;
5436 };
5438 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5440 struct matching_paren_traits
5441 {
5446 };
5448 /* "matching_parens" is a token_pair<T> class for tracking matching
5449 pairs of parentheses. */
5453 /* Traits for token_pair<T> for tracking matching pairs of braces. */
5455 struct matching_brace_traits
5456 {
5461 };
5463 /* "matching_braces" is a token_pair<T> class for tracking matching
5464 pairs of braces. */
5469 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5470 enclosing parentheses. */
5472 static cp_expr
5474 {
5478 /* Consume the '('. */
5480 matching_parens parens;
5482 /* Start the statement-expression. */
5484 /* Parse the compound-statement. */
5486 /* Finish up. */
5488 /* Consume the ')'. */
5496 }
5498 /* Expressions [gram.expr] */
5500 /* Parse a fold-operator.
5502 fold-operator:
5503 - * / % ^ & | = < > << >>
5504 = -= *= /= %= ^= &= |= <<= >>=
5505 == != <= >= && || , .* ->*
5507 This returns the tree code corresponding to the matched operator
5508 as an int. When the current token matches a compound assignment
5509 operator, the resulting tree code is the negative value of the
5510 non-assignment operator. */
5512 static int
5514 {
5516 {
5556 }
5557 }
5559 /* Returns true if CODE indicates a binary expression, which is not allowed in
5560 the LHS of a fold-expression. More codes will need to be added to use this
5561 function in other contexts. */
5563 static bool
5565 {
5567 {
5600 }
5601 }
5603 /* If the next token is a suitable fold operator, consume it and return as
5604 the function above. */
5606 static int
5608 {
5614 }
5616 /* Parse a fold-expression.
5618 fold-expression:
5619 ( ... folding-operator cast-expression)
5620 ( cast-expression folding-operator ... )
5621 ( cast-expression folding operator ... folding-operator cast-expression)
5623 Note that the '(' and ')' are matched in primary expression. */
5625 static cp_expr
5627 {
5628 cp_id_kind pidk;
5632 // Left fold.
5634 {
5641 {
5644 }
5652 }
5657 {
5660 }
5663 {
5666 }
5669 /* The operands of a fold-expression are cast-expressions, so binary or
5670 conditional expressions are not allowed. We check this here to avoid
5671 tentative parsing. */
5683 // Right fold.
5685 {
5688 }
5691 {
5694 }
5697 // Binary left or right fold.
5703 }
5705 /* Parse a primary-expression.
5707 primary-expression:
5708 literal
5709 this
5710 ( expression )
5711 id-expression
5712 lambda-expression (C++11)
5714 GNU Extensions:
5716 primary-expression:
5717 ( compound-statement )
5718 __builtin_va_arg ( assignment-expression , type-id )
5719 __builtin_offsetof ( type-id , offsetof-expression )
5721 C++ Extensions:
5722 __has_nothrow_assign ( type-id )
5723 __has_nothrow_constructor ( type-id )
5724 __has_nothrow_copy ( type-id )
5725 __has_trivial_assign ( type-id )
5726 __has_trivial_constructor ( type-id )
5727 __has_trivial_copy ( type-id )
5728 __has_trivial_destructor ( type-id )
5729 __has_virtual_destructor ( type-id )
5730 __is_abstract ( type-id )
5731 __is_base_of ( type-id , type-id )
5732 __is_class ( type-id )
5733 __is_empty ( type-id )
5734 __is_enum ( type-id )
5735 __is_final ( type-id )
5736 __is_literal_type ( type-id )
5737 __is_pod ( type-id )
5738 __is_polymorphic ( type-id )
5739 __is_std_layout ( type-id )
5740 __is_trivial ( type-id )
5741 __is_union ( type-id )
5743 Objective-C++ Extension:
5745 primary-expression:
5746 objc-expression
5748 literal:
5749 __null
5751 ADDRESS_P is true iff this expression was immediately preceded by
5752 "&" and therefore might denote a pointer-to-member. CAST_P is true
5753 iff this expression is the target of a cast. TEMPLATE_ARG_P is
5754 true iff this expression is a template argument.
5756 Returns a representation of the expression. Upon return, *IDK
5757 indicates what kind of id-expression (if any) was present. */
5759 static cp_expr
5766 {
5769 /* Assume the primary expression is not an id-expression. */
5772 /* Peek at the next token. */
5775 {
5776 /* literal:
5777 integer-literal
5778 character-literal
5779 floating-literal
5780 string-literal
5781 boolean-literal
5782 pointer-literal
5783 user-defined-literal */
5795 {
5799 }
5800 /* Floating-point literals are only allowed in an integral
5801 constant expression if they are cast to an integral or
5802 enumeration type. */
5808 {
5809 /* CAST_P will be set even in invalid code like "int(2.7 +
5810 ...)". Therefore, we have to check that the next token
5811 is sure to end the cast. */
5813 {
5818 enumerator-definition. */
5820 /* The curly brace at the end of an enum-specifier. */
5822 /* The end of a statement. */
5824 /* The end of the cast-expression. */
5826 /* The end of an array bound. */
5828 /* The closing ">" in a template-argument-list. */
5831 /* C++0x only: A ">>" treated like two ">" tokens,
5832 in a template-argument-list. */
5837 }
5839 /* If we are within a cast, then the constraint that the
5840 cast is to an integral or enumeration type will be
5841 checked at that point. If we are not within a cast, then
5842 this code is invalid. */
5845 }
5866 /* ??? Should wide strings be allowed when parser->translate_strings_p
5867 is false (i.e. in attributes)? If not, we can kill the third
5868 argument to cp_parser_string_literal. */
5873 else
5880 /* If we see `( { ' then we are looking at the beginning of
5881 a GNU statement-expression. */
5884 {
5885 /* Statement-expressions are not allowed by the standard. */
5889 /* And they're not allowed outside of a function-body; you
5890 cannot, for example, write:
5892 int i = ({ int j = 3; j + 1; });
5894 at class or namespace scope. */
5897 {
5899 "statement-expressions are not allowed outside "
5905 }
5906 else
5908 }
5909 /* Otherwise it's a normal parenthesized expression. */
5910 {
5911 cp_expr expr;
5916 /* Consume the `('. */
5917 matching_parens parens;
5919 /* Within a parenthesized expression, a `>' token is always
5920 the greater-than operator. */
5921 saved_greater_than_is_operator_p
5926 /* Left fold expression. */
5928 else
5929 /* Parse the parenthesized expression. */
5934 {
5939 "fold-expressions only available with %<-std=c++17%> "
5941 }
5942 else
5943 /* Let the front end know that this expression was
5944 enclosed in parentheses. This matters in case, for
5945 example, the expression is of the form `A::B', since
5946 `&A::B' might be a pointer-to-member, but `&(A::B)' is
5947 not. */
5950 /* DR 705: Wrapping an unqualified name in parentheses
5951 suppresses arg-dependent lookup. We want to pass back
5952 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5953 (c++/37862), but none of the others. */
5957 /* The `>' token might be the end of a template-id or
5958 template-parameter-list now. */
5959 parser->greater_than_is_operator_p
5962 /* Consume the `)'. */
5974 }
5977 {
5979 {
5980 /* We might have an Objective-C++ message. */
5983 /* If that works out, we're done ... */
5986 /* ... else, fall though to see if it's a lambda. */
5987 }
5989 /* Don't warn about a failed tentative parse. */
5994 }
5998 /* We have an Objective-C++ string literal. */
6005 {
6006 /* These two are the boolean literals. */
6014 /* The `__null' literal. */
6019 /* The `nullptr' literal. */
6024 /* Recognize the `this' keyword. */
6028 {
6032 }
6033 /* Pointers cannot appear in constant-expressions. */
6038 /* The `operator' keyword can be the beginning of an
6039 id-expression. */
6046 {
6047 non_integral_constant name;
6049 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
6050 __func__ are the names of variables -- but they are
6051 treated specially. Therefore, they are handled here,
6052 rather than relying on the generic id-expression logic
6053 below. Grammatically, these names are id-expressions.
6055 Consume the token. */
6059 {
6071 }
6076 /* Look up the name. */
6078 }
6081 {
6082 tree expression;
6083 tree type;
6084 location_t type_location;
6085 location_t start_loc
6087 /* The `__builtin_va_arg' construct is used to handle
6088 `va_arg'. Consume the `__builtin_va_arg' token. */
6090 /* Look for the opening `('. */
6091 matching_parens parens;
6093 /* Now, parse the assignment-expression. */
6095 /* Look for the `,'. */
6098 /* Parse the type-id. */
6099 {
6102 }
6103 /* Look for the closing `)'. */
6104 location_t finish_loc
6107 /* Using `va_arg' in a constant-expression is not
6108 allowed. */
6110 NIC_VA_ARG))
6112 /* Construct a location of the form:
6113 __builtin_va_arg (v, int)
6114 ~~~~~~~~~~~~~~~~~~~~~^~~~
6115 with the caret at the type, ranging from the start of the
6116 "__builtin_va_arg" token to the close paren. */
6117 location_t combined_loc
6120 }
6125 // C++ concepts
6129 /* Objective-C++ expressions. */
6139 "%<omp_all_memory%> may only be used in OpenMP "
6147 {
6152 }
6153 /* FALLTHRU */
6157 }
6159 /* An id-expression can start with either an identifier, a
6160 `::' as the beginning of a qualified-id, or the "operator"
6161 keyword. */
6165 /* FALLTHRU */
6169 {
6170 id_expression:
6171 cp_expr id_expression;
6172 cp_expr decl;
6178 /* Parse the id-expression. */
6179 id_expression
6196 /* If we have a template-id, then no further lookup is
6197 required. If the template-id was for a template-class, we
6198 will sometimes have a TYPE_DECL at this point. */
6202 /* Look up the name. */
6203 else
6204 {
6205 tree ambiguous_decls;
6207 /* If we already know that this lookup is ambiguous, then
6208 we've already issued an error message; there's no reason
6209 to check again. */
6212 {
6215 }
6218 none_type,
6219 template_p,
6224 /* If the lookup was ambiguous, an error will already have
6225 been issued. */
6229 /* In Objective-C++, we may have an Objective-C 2.0
6230 dot-syntax for classes here. */
6235 {
6236 tree component;
6243 component);
6244 /* Build a location of the form:
6245 expr.component
6246 ~~~~~^~~~~~~~~
6247 with caret at the start of the component name (at
6248 input_location), ranging from the start of the id_expression
6249 to the end of the component name. */
6250 location_t combined_loc
6255 }
6257 /* In Objective-C++, an instance variable (ivar) may be preferred
6258 to whatever cp_parser_lookup_name() found.
6259 Call objc_lookup_ivar. To avoid exposing cp_expr to the
6260 rest of c-family, we have to do a little extra work to preserve
6261 any location information in cp_expr "decl". Given that
6262 objc_lookup_ivar is implemented in "c-family" and "objc", we
6263 have a trip through the pure "tree" type, rather than cp_expr.
6264 Naively copying it back to "decl" would implicitly give the
6265 new cp_expr value an UNKNOWN_LOCATION for nodes that don't
6266 store an EXPR_LOCATION. Hence we only update "decl" (and
6267 hence its location_t) if we get back a different tree node. */
6269 id_expression);
6273 /* If name lookup gives us a SCOPE_REF, then the
6274 qualifying scope was dependent. */
6276 {
6277 /* At this point, we do not know if DECL is a valid
6278 integral constant expression. We assume that it is
6279 in fact such an expression, so that code like:
6281 template <int N> struct A {
6282 int a[B<N>::i];
6283 };
6285 is accepted. At template-instantiation time, we
6286 will check that B<N>::i is actually a constant. */
6288 }
6289 /* Check to see if DECL is a local variable in a context
6290 where that is forbidden. */
6293 /* DR 2082 permits local variables in unevaluated contexts
6294 within a default argument. */
6296 {
6304 }
6305 }
6307 decl = (finish_id_expression
6309 idk,
6314 template_arg_p,
6319 /* Build a location for an id-expression of the form:
6320 ::ns::id
6321 ~~~~~~^~
6322 or:
6323 id
6324 ^~
6325 i.e. from the start of the first token to the end of the final
6326 token, with the caret at the start of the unqualified-id. */
6330 location_t combined_loc
6335 }
6337 /* Anything else is an error. */
6341 }
6342 }
6350 {
6353 }
6355 /* Complain about missing template keyword when naming a dependent
6356 member template. */
6358 static void
6360 {
6367 "expected %qs keyword before dependent "
6370 }
6372 /* Parse an id-expression.
6374 id-expression:
6375 unqualified-id
6376 qualified-id
6378 qualified-id:
6379 :: [opt] nested-name-specifier template [opt] unqualified-id
6380 :: identifier
6381 :: operator-function-id
6382 :: template-id
6384 Return a representation of the unqualified portion of the
6385 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6386 a `::' or nested-name-specifier.
6388 Often, if the id-expression was a qualified-id, the caller will
6389 want to make a SCOPE_REF to represent the qualified-id. This
6390 function does not do this in order to avoid wastefully creating
6391 SCOPE_REFs when they are not required.
6393 If TEMPLATE_KEYWORD_P is true, then we have just seen the
6394 `template' keyword.
6396 If CHECK_DEPENDENCY_P is false, then names are looked up inside
6397 uninstantiated templates.
6399 If *TEMPLATE_P is non-NULL, it is set to true iff the
6400 `template' keyword is used to explicitly indicate that the entity
6401 named is a template.
6403 If DECLARATOR_P is true, the id-expression is appearing as part of
6404 a declarator, rather than as part of an expression. */
6406 static cp_expr
6413 {
6417 /* Assume the `template' keyword was not used. */
6421 /* Look for the optional `::' operator. */
6422 global_scope_p
6423 = (!template_keyword_p
6428 /* Look for the optional nested-name-specifier. */
6429 nested_name_specifier_p
6432 check_dependency_p,
6434 declarator_p,
6435 template_keyword_p)
6441 /* Peek at the next token. */
6444 /* If there is a nested-name-specifier, then we are looking at
6445 the first qualified-id production. */
6447 {
6448 tree saved_object_scope;
6449 tree saved_qualifying_scope;
6451 /* See if the next token is the `template' keyword. */
6455 /* Name lookup we do during the processing of the
6456 unqualified-id might obliterate SCOPE. */
6459 /* Process the final unqualified-id. */
6461 check_dependency_p,
6462 declarator_p,
6464 /* Restore the SAVED_SCOPE for our caller. */
6468 }
6469 /* Otherwise, if we are in global scope, then we are looking at one
6470 of the other qualified-id productions. */
6472 {
6473 /* If it's an identifier, and the next token is not a "<", then
6474 we can avoid the template-id case. This is an optimization
6475 for this common case. */
6477 && !cp_parser_nth_token_starts_template_argument_list_p
6482 /* Try a template-id. */
6486 declarator_p);
6487 /* If that worked, we're done. */
6491 /* Peek at the next token. (Changes in the token buffer may
6492 have invalidated the pointer obtained above.) */
6496 {
6503 {
6506 }
6507 /* Fall through. */
6512 }
6513 }
6514 else
6515 {
6520 declarator_p,
6521 optional_p);
6522 }
6525 && warn_missing_template_keyword
6526 && !template_keyword_p
6527 /* Don't warn if we're looking inside templates. */
6528 && check_dependency_p
6529 /* In a template argument list a > could be closing
6530 the enclosing targs. */
6533 /* Don't confuse an ill-formed constructor declarator for a missing
6534 template keyword in a return type. */
6538 OPT_Wmissing_template_keyword))
6539 {
6542 /* An operator after the > suggests that the > ends a
6543 template-id; a name or literal suggests that the > is an
6544 operator. */
6548 }
6551 }
6553 /* Parse an unqualified-id.
6555 unqualified-id:
6556 identifier
6557 operator-function-id
6558 conversion-function-id
6559 ~ class-name
6560 template-id
6562 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6563 keyword, in a construct like `A::template ...'.
6565 Returns a representation of unqualified-id. For the `identifier'
6566 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6567 production a BIT_NOT_EXPR is returned; the operand of the
6568 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6569 other productions, see the documentation accompanying the
6570 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6571 names are looked up in uninstantiated templates. If DECLARATOR_P
6572 is true, the unqualified-id is appearing as part of a declarator,
6573 rather than as part of an expression. */
6575 static cp_expr
6581 {
6584 /* Peek at the next token. */
6588 {
6590 {
6591 tree id;
6593 /* We don't know yet whether or not this will be a
6594 template-id. */
6596 /* Try a template-id. */
6598 check_dependency_p,
6599 declarator_p);
6600 /* If it worked, we're done. */
6603 /* Otherwise, it's an ordinary identifier. */
6605 }
6609 check_dependency_p,
6610 declarator_p);
6613 {
6614 tree type_decl;
6615 tree qualifying_scope;
6616 tree object_scope;
6617 tree scope;
6621 /* Consume the `~' token. */
6623 /* Parse the class-name. The standard, as written, seems to
6624 say that:
6626 template <typename T> struct S { ~S (); };
6627 template <typename T> S<T>::~S() {}
6629 is invalid, since `~' must be followed by a class-name, but
6630 `S<T>' is dependent, and so not known to be a class.
6631 That's not right; we need to look in uninstantiated
6632 templates. A further complication arises from:
6634 template <typename T> void f(T t) {
6635 t.T::~T();
6636 }
6638 Here, it is not possible to look up `T' in the scope of `T'
6639 itself. We must look in both the current scope, and the
6640 scope of the containing complete expression.
6642 Yet another issue is:
6644 struct S {
6645 int S;
6646 ~S();
6647 };
6649 S::~S() {}
6651 The standard does not seem to say that the `S' in `~S'
6652 should refer to the type `S' and not the data member
6653 `S::S'. */
6655 /* DR 244 says that we look up the name after the "~" in the
6656 same scope as we looked up the qualifying name. That idea
6657 isn't fully worked out; it's more complicated than that. */
6662 /* Check for invalid scopes. */
6664 {
6668 }
6670 {
6674 scope);
6679 }
6681 {
6687 }
6693 /* Create a location with caret == start at the tilde,
6694 finishing at the end of the peeked token, e.g:
6695 ~token
6696 ^~~~~~. */
6697 location_t loc
6700 /* If the name is of the form "X::~X" it's OK even if X is a
6701 typedef. */
6710 {
6713 }
6715 /* ~auto means the destructor of whatever the object is. */
6717 {
6720 "%<~auto%> only available with "
6724 }
6726 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6727 declarator-id of a constructor or destructor. */
6729 {
6730 auto_diagnostic_group d;
6741 }
6743 /* If there was an explicit qualification (S::~T), first look
6744 in the scope given by the qualification (i.e., S).
6746 Note: in the calls to cp_parser_class_name below we pass
6747 typename_type so that lookup finds the injected-class-name
6748 rather than the constructor. */
6752 {
6757 typename_type,
6760 declarator_p);
6763 }
6764 /* In "N::S::~S", look in "N" as well. */
6766 {
6771 type_decl
6775 typename_type,
6778 declarator_p);
6781 }
6782 /* In "p->S::~T", look in the scope given by "*p" as well. */
6784 {
6789 type_decl
6793 typename_type,
6796 declarator_p);
6799 }
6800 /* Look in the surrounding context. */
6802 {
6808 type_decl
6812 typename_type,
6815 declarator_p);
6818 {
6819 /* We couldn't find a type with this name. If we're parsing
6820 tentatively, fail and try something else. */
6822 {
6825 }
6826 /* Otherwise, accept it and check for a match at instantiation
6827 time. */
6832 }
6833 }
6834 /* If an error occurred, assume that the name of the
6835 destructor is the same as the name of the qualifying
6836 class. That allows us to keep parsing after running
6837 into ill-formed destructor names. */
6843 /* Check that destructor name and scope match. */
6845 {
6852 }
6854 /* [class.dtor]
6856 A typedef-name that names a class shall not be used as the
6857 identifier in the declarator for a destructor declaration. */
6864 type_decl);
6867 }
6871 {
6872 cp_expr id;
6874 /* This could be a template-id, so we try that first. */
6876 /* Try a template-id. */
6879 declarator_p);
6880 /* If that worked, we're done. */
6883 /* We still don't know whether we're looking at an
6884 operator-function-id or a conversion-function-id. */
6886 /* Try an operator-function-id. */
6888 /* If that didn't work, try a conversion-function-id. */
6893 }
6894 /* Fall through. */
6901 }
6902 }
6904 /* Check [temp.names]/5: A name prefixed by the keyword template shall
6905 be a template-id or the name shall refer to a class template or an
6906 alias template. */
6908 static void
6910 {
6920 /* Alias templates are also OK. */
6927 name);
6928 }
6930 /* Parse an (optional) nested-name-specifier.
6932 nested-name-specifier: [C++98]
6933 class-or-namespace-name :: nested-name-specifier [opt]
6934 class-or-namespace-name :: template nested-name-specifier [opt]
6936 nested-name-specifier: [C++0x]
6937 type-name ::
6938 namespace-name ::
6939 nested-name-specifier identifier ::
6940 nested-name-specifier template [opt] simple-template-id ::
6942 PARSER->SCOPE should be set appropriately before this function is
6943 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6944 effect. TYPE_P is TRUE if we non-type bindings should be ignored
6945 in name lookups.
6947 Sets PARSER->SCOPE to the class (TYPE) or namespace
6948 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6949 it unchanged if there is no nested-name-specifier. Returns the new
6950 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6952 If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
6954 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6955 part of a declaration and/or decl-specifier. */
6957 static tree
6964 {
6969 /* Remember where the nested-name-specifier starts. */
6972 {
6975 }
6978 {
6979 tree new_scope;
6980 tree old_scope;
6981 tree saved_qualifying_scope;
6983 /* Spot cases that cannot be the beginning of a
6984 nested-name-specifier. */
6987 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
6988 the already parsed nested-name-specifier. */
6990 {
6991 /* Grab the nested-name-specifier and continue the loop. */
6993 /* If we originally encountered this nested-name-specifier
6994 with CHECK_DEPENDENCY_P set to true, we will not have
6995 resolved TYPENAME_TYPEs, so we must do so here. */
6997 && !check_dependency_p
6999 {
7004 }
7007 }
7009 /* Spot cases that cannot be the beginning of a
7010 nested-name-specifier. On the second and subsequent times
7011 through the loop, we look for the `template' keyword. */
7013 ;
7014 /* A template-id can start a nested-name-specifier. */
7016 ;
7017 /* DR 743: decltype can be used in a nested-name-specifier. */
7019 ;
7020 else
7021 {
7022 /* If the next token is not an identifier, then it is
7023 definitely not a type-name or namespace-name. */
7026 /* If the following token is neither a `<' (to begin a
7027 template-id), nor a `::', then we are not looking at a
7028 nested-name-specifier. */
7034 /* name:name is a valid sequence in an Objective C message. */
7036 {
7040 "found %<:%> in nested-name-specifier, "
7043 }
7046 && !cp_parser_nth_token_starts_template_argument_list_p
7049 }
7051 /* The nested-name-specifier is optional, so we parse
7052 tentatively. */
7055 /* Look for the optional `template' keyword, if this isn't the
7056 first time through the loop. */
7058 {
7060 /* DR1710: "In a qualified-id used as the name in
7061 a typename-specifier, elaborated-type-specifier, using-declaration,
7062 or class-or-decltype, an optional keyword template appearing at
7063 the top level is ignored." */
7065 && typename_keyword_p
7068 }
7070 /* Save the old scope since the name lookup we are about to do
7071 might destroy it. */
7074 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
7075 look up names in "X<T>::I" in order to determine that "Y" is
7076 a template. So, if we have a typename at this point, we make
7077 an effort to look through it. */
7079 && !check_dependency_p
7080 && !typename_keyword_p
7085 /* Parse the qualifying entity. */
7086 new_scope
7088 typename_keyword_p,
7089 template_keyword_p,
7090 check_dependency_p,
7091 type_p,
7092 is_declaration);
7093 /* Look for the `::' token. */
7096 /* If we found what we wanted, we keep going; otherwise, we're
7097 done. */
7099 {
7102 /* Restore the OLD_SCOPE since it was valid before the
7103 failed attempt at finding the last
7104 class-or-namespace-name. */
7108 /* If the next token is a decltype, and the one after that is a
7109 `::', then the decltype has failed to resolve to a class or
7110 enumeration type. Give this error even when parsing
7111 tentatively since it can't possibly be valid--and we're going
7112 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
7113 won't get another chance.*/
7117 {
7123 dtype);
7126 /* As below. */
7129 }
7133 {
7134 /* If we have a non-type template-id followed by ::, it can't
7135 possibly be valid. */
7140 {
7143 {
7150 else
7153 }
7154 else
7155 {
7161 else
7162 {
7163 /* Variable template. */
7167 }
7168 }
7175 /* As below. */
7179 }
7180 }
7184 /* If the next token is an identifier, and the one after
7185 that is a `::', then any valid interpretation would have
7186 found a class-or-namespace-name. */
7192 {
7195 {
7197 {
7198 tree decl;
7199 tree ambiguous_decls;
7202 none_type,
7211 decl);
7213 {
7214 // cp_parser_lookup_name has the same diagnostic,
7215 // thus make sure to emit it at most once.
7218 {
7223 }
7225 }
7226 else
7227 {
7229 cp_parser_name_lookup_error
7232 else
7233 cp_parser_name_lookup_error
7236 }
7237 }
7240 /* Treat this as a successful nested-name-specifier
7241 due to:
7243 [basic.lookup.qual]
7245 If the name found is not a class-name (clause
7246 _class_) or namespace-name (_namespace.def_), the
7247 program is ill-formed. */
7249 }
7251 }
7253 }
7254 /* We've found one valid nested-name-specifier. */
7256 /* Name lookup always gives us a DECL. */
7259 /* Uses of "template" must be followed by actual templates. */
7262 /* If it is a class scope, try to complete it; we are about to
7263 be looking up names inside the class. */
7265 /* Since checking types for dependency can be expensive,
7266 avoid doing it if the type is already complete. */
7268 /* Do not try to complete dependent types. */
7270 {
7272 /* If it is a typedef to current class, use the current
7273 class instead, as the typedef won't have any names inside
7274 it yet. */
7278 }
7279 /* Make sure we look in the right scope the next time through
7280 the loop. */
7282 }
7284 /* If parsing tentatively, replace the sequence of tokens that makes
7285 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
7286 token. That way, should we re-parse the token stream, we will
7287 not have to repeat the effort required to do the parse, nor will
7288 we issue duplicate error messages. */
7290 {
7294 /* Reset the contents of the START token. */
7296 /* Retrieve any deferred checks. Do not pop this access checks yet
7297 so the memory will not be reclaimed during token replacing below. */
7306 /* Purge all subsequent tokens. */
7308 }
7314 }
7316 /* Parse a nested-name-specifier. See
7317 cp_parser_nested_name_specifier_opt for details. This function
7318 behaves identically, except that it will an issue an error if no
7319 nested-name-specifier is present. */
7321 static tree
7327 {
7328 tree scope;
7330 /* Look for the nested-name-specifier. */
7332 typename_keyword_p,
7333 check_dependency_p,
7334 type_p,
7335 is_declaration);
7336 /* If it was not present, issue an error message. */
7338 {
7341 }
7344 }
7346 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7347 this is either a class-name or a namespace-name (which corresponds
7348 to the class-or-namespace-name production in the grammar). For
7349 C++0x, it can also be a type-name that refers to an enumeration
7350 type or a simple-template-id.
7352 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7353 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7354 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7355 TYPE_P is TRUE iff the next name should be taken as a class-name,
7356 even the same name is declared to be another entity in the same
7357 scope.
7359 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7360 specified by the class-or-namespace-name. If neither is found the
7361 ERROR_MARK_NODE is returned. */
7363 static tree
7370 {
7371 tree saved_scope;
7372 tree saved_qualifying_scope;
7373 tree saved_object_scope;
7374 tree scope;
7378 /* DR 743: decltype can appear in a nested-name-specifier. */
7380 {
7384 {
7387 }
7391 }
7393 /* Before we try to parse the class-name, we must save away the
7394 current PARSER->SCOPE since cp_parser_class_name will destroy
7395 it. */
7399 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7400 there is no need to look for a namespace-name. */
7401 only_class_p = template_keyword_p
7406 typename_keyword_p,
7407 template_keyword_p,
7409 check_dependency_p,
7411 is_declaration,
7414 /* If that didn't work, try for a namespace-name. */
7416 {
7417 /* Restore the saved scope. */
7421 /* If we are not looking at an identifier followed by the scope
7422 resolution operator, then this is not part of a
7423 nested-name-specifier. (Note that this function is only used
7424 to parse the components of a nested-name-specifier.) */
7429 }
7432 }
7434 /* Return true if we are looking at a compound-literal, false otherwise. */
7436 static bool
7438 {
7441 /* Skip tokens until the next token is a closing parenthesis.
7442 If we find the closing `)', and the next token is a `{', then
7443 we are looking at a compound-literal. */
7444 bool compound_literal_p
7449 /* Roll back the tokens we skipped. */
7453 }
7455 /* Return true if EXPR is the integer constant zero or a complex constant
7456 of zero, without any folding, but ignoring location wrappers. */
7458 bool
7460 {
7463 }
7465 /* Parse a postfix-expression.
7467 postfix-expression:
7468 primary-expression
7469 postfix-expression [ expression ]
7470 postfix-expression ( expression-list [opt] )
7471 simple-type-specifier ( expression-list [opt] )
7472 typename :: [opt] nested-name-specifier identifier
7473 ( expression-list [opt] )
7474 typename :: [opt] nested-name-specifier template [opt] template-id
7475 ( expression-list [opt] )
7476 postfix-expression . template [opt] id-expression
7477 postfix-expression -> template [opt] id-expression
7478 postfix-expression . pseudo-destructor-name
7479 postfix-expression -> pseudo-destructor-name
7480 postfix-expression ++
7481 postfix-expression --
7482 dynamic_cast < type-id > ( expression )
7483 static_cast < type-id > ( expression )
7484 reinterpret_cast < type-id > ( expression )
7485 const_cast < type-id > ( expression )
7486 typeid ( expression )
7487 typeid ( type-id )
7489 GNU Extension:
7491 postfix-expression:
7492 ( type-id ) { initializer-list , [opt] }
7494 This extension is a GNU version of the C99 compound-literal
7495 construct. (The C99 grammar uses `type-name' instead of `type-id',
7496 but they are essentially the same concept.)
7498 If ADDRESS_P is true, the postfix expression is the operand of the
7499 `&' operator. CAST_P is true if this expression is the target of a
7500 cast.
7502 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
7503 class member access expressions [expr.ref].
7505 Returns a representation of the expression. */
7507 static cp_expr
7511 {
7513 location_t loc;
7519 /* Peek at the next token. */
7524 /* Some of the productions are determined by keywords. */
7527 {
7532 {
7533 tree type;
7534 cp_expr expression;
7538 /* All of these can be handled in the same way from the point
7539 of view of parsing. Begin by consuming the token
7540 identifying the cast. */
7543 /* New types cannot be defined in the cast. */
7545 parser->type_definition_forbidden_message
7548 /* Look for the opening `<'. */
7550 /* Parse the type to which we are casting. */
7554 NULL);
7556 /* Look for the closing `>'. */
7558 /* Restore the old message. */
7561 bool saved_greater_than_is_operator_p
7565 /* And the expression which is being cast. */
7566 matching_parens parens;
7570 RT_CLOSE_PAREN);
7574 parser->greater_than_is_operator_p
7577 /* Only type conversions to integral or enumeration types
7578 can be used in constant-expressions. */
7581 {
7584 }
7586 /* Construct a location e.g. :
7587 reinterpret_cast <int *> (expr)
7588 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7589 ranging from the start of the "*_cast" token to the final closing
7590 paren, with the caret at the start. */
7594 {
7596 postfix_expression
7598 tf_warning_or_error);
7601 postfix_expression
7603 tf_warning_or_error);
7606 postfix_expression
7608 tf_warning_or_error);
7611 postfix_expression
7613 tf_warning_or_error);
7617 }
7618 }
7622 {
7623 tree type;
7627 /* Consume the `typeid' token. */
7629 /* Look for the `(' token. */
7630 matching_parens parens;
7632 /* Types cannot be defined in a `typeid' expression. */
7634 parser->type_definition_forbidden_message
7636 /* We can't be sure yet whether we're looking at a type-id or an
7637 expression. */
7639 /* Try a type-id first. */
7644 /* Look for the `)' token. Otherwise, we can't be sure that
7645 we're not looking at an expression: consider `typeid (int
7646 (3))', for example. */
7648 /* If all went well, simply lookup the type-id. */
7651 /* Otherwise, fall back to the expression variant. */
7652 else
7653 {
7654 tree expression;
7656 /* Look for an expression. */
7658 /* Compute its typeid. */
7660 /* Look for the `)' token. */
7662 }
7663 /* Restore the saved message. */
7665 /* `typeid' may not appear in an integral constant expression. */
7669 /* Construct a location e.g. :
7670 typeid (expr)
7671 ^~~~~~~~~~~~~
7672 ranging from the start of the "typeid" token to the final closing
7673 paren, with the caret at the start. */
7675 {
7676 location_t typeid_loc
7680 }
7681 }
7685 {
7686 tree type;
7687 /* The syntax permitted here is the same permitted for an
7688 elaborated-type-specifier. */
7695 }
7703 {
7711 {
7714 }
7720 {
7723 postfix_expression
7725 else
7726 {
7730 }
7736 tf_warning_or_error);
7737 else
7738 {
7742 }
7750 else
7751 {
7755 }
7760 postfix_expression
7764 postfix_expression
7767 else
7768 {
7772 }
7777 {
7781 }
7782 else
7783 {
7784 postfix_expression
7786 }
7791 }
7793 }
7796 {
7797 tree expression;
7798 tree type;
7799 /* Consume the `__builtin_convertvector' token. */
7801 /* Look for the opening `('. */
7802 matching_parens parens;
7804 /* Now, parse the assignment-expression. */
7806 /* Look for the `,'. */
7808 location_t type_location
7810 /* Parse the type-id. */
7811 {
7814 }
7815 /* Look for the closing `)'. */
7817 postfix_expression
7819 tf_warning_or_error);
7821 }
7824 {
7825 tree expression;
7826 tree type;
7827 /* Consume the `__builtin_bit_cast' token. */
7829 /* Look for the opening `('. */
7830 matching_parens parens;
7832 location_t type_location
7834 /* Parse the type-id. */
7835 {
7838 }
7839 /* Look for the `,'. */
7841 /* Now, parse the assignment-expression. */
7843 /* Look for the closing `)'. */
7845 postfix_expression
7847 tf_warning_or_error);
7849 }
7852 {
7853 tree type;
7855 /* If the next thing is a simple-type-specifier, we may be
7856 looking at a functional cast. We could also be looking at
7857 an id-expression. So, we try the functional cast, and if
7858 that doesn't work we fall back to the primary-expression. */
7860 /* Look for the simple-type-specifier. */
7864 CP_PARSER_FLAGS_NONE);
7866 /* Parse the cast itself. */
7868 postfix_expression
7870 /* If that worked, we're done. */
7874 /* If the functional-cast didn't work out, try a
7875 compound-literal. */
7878 {
7883 matching_parens parens;
7886 /* Avoid calling cp_parser_type_id pointlessly, see comment
7887 in cp_parser_cast_expression about c++/29234. */
7890 else
7891 {
7892 /* Parse the type. */
7898 }
7900 /* If things aren't going well, there's no need to
7901 keep going. */
7903 /* Parse the brace-enclosed initializer list. */
7905 /* If that worked, we're definitely looking at a
7906 compound-literal expression. */
7908 {
7909 /* Warn the user that a compound literal is not
7910 allowed in standard C++. */
7913 /* For simplicity, we disallow compound literals in
7914 constant-expressions. We could
7915 allow compound literals of integer type, whose
7916 initializer was a constant, in constant
7917 expressions. Permitting that usage, as a further
7918 extension, would not change the meaning of any
7919 currently accepted programs. (Of course, as
7920 compound literals are not part of ISO C++, the
7921 standard has nothing to say.) */
7923 NIC_NCC))
7924 {
7927 }
7928 /* Form the representation of the compound-literal. */
7929 postfix_expression
7934 }
7935 }
7937 /* It must be a primary-expression. */
7938 postfix_expression
7941 decltype_p,
7943 }
7945 }
7947 /* Note that we don't need to worry about calling build_cplus_new on a
7948 class-valued CALL_EXPR in decltype when it isn't the end of the
7949 postfix-expression; unary_complex_lvalue will take care of that for
7950 all these cases. */
7952 /* Keep looping until the postfix-expression is complete. */
7954 {
7958 /* It is not a Koenig lookup function call. */
7959 postfix_expression
7962 /* Peek at the next token. */
7966 {
7969 {
7971 "two consecutive %<[%> shall "
7974 }
7975 postfix_expression
7977 postfix_expression,
7979 decltype_p);
7988 /* postfix-expression ( expression-list [opt] ) */
7989 {
8001 tree stripped_expression
8003 is_builtin_constant_p
8006 {
8007 /* The whole point of __builtin_constant_p is to allow
8008 non-constant expressions to appear as arguments. */
8009 saved_integral_constant_expression_p
8011 saved_non_integral_constant_expression_p
8014 }
8017 BUILT_IN_CLASSIFY_TYPE))
8018 {
8019 /* __builtin_classify_type (type) */
8026 NULL);
8029 cp_unevaluated uev;
8031 matching_parens parens;
8036 {
8038 {
8046 }
8047 else
8048 {
8049 postfix_expression
8052 }
8054 }
8055 }
8056 args = (cp_parser_parenthesized_expression_list
8063 {
8064 parser->integral_constant_expression_p
8066 parser->non_integral_constant_expression_p
8068 }
8071 {
8074 }
8076 /* Function calls are not permitted in
8077 constant-expressions. */
8080 NIC_FUNC_CALL))
8081 {
8085 }
8090 {
8092 /* In C++20, we may need to perform ADL for a template
8093 name. */
8096 {
8098 {
8101 postfix_expression
8103 complain);
8104 }
8105 else
8106 postfix_expression
8108 }
8109 /* We do not perform argument-dependent lookup if
8110 normal lookup finds a non-function, in accordance
8111 with the expected resolution of DR 218. */
8114 {
8115 /* Do not do argument dependent lookup if regular
8116 lookup finds a member function or a block-scope
8117 function declaration. [basic.lookup.argdep]/3 */
8121 {
8127 {
8130 }
8131 }
8134 {
8137 postfix_expression
8139 complain);
8140 }
8141 }
8142 }
8144 /* Temporarily set input_location to the combined location
8145 with call expression range, as e.g. build_out_target_exprs
8146 called from convert_default_arg relies on input_location,
8147 so updating it only when the call is fully built results
8148 in inconsistencies between location handling in templates
8149 and outside of templates. */
8152 close_paren_loc);
8158 postfix_expression = (build_offset_ref_call_from_tree
8160 complain));
8161 else
8162 /* All other function calls. */
8163 {
8168 {
8172 }
8174 postfix_expression
8176 disallow_virtual,
8177 koenig_p,
8178 complain);
8179 }
8184 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
8188 }
8193 /* postfix-expression . template [opt] id-expression
8194 postfix-expression . pseudo-destructor-name
8195 postfix-expression -> template [opt] id-expression
8196 postfix-expression -> pseudo-destructor-name */
8198 /* Consume the `.' or `->' operator. */
8201 postfix_expression
8203 postfix_expression,
8210 /* postfix-expression ++ */
8211 /* Consume the `++' token. */
8213 /* Generate a representation for the complete expression. */
8214 postfix_expression
8216 POSTINCREMENT_EXPR);
8217 /* Increments may not appear in constant-expressions. */
8225 /* postfix-expression -- */
8226 /* Consume the `--' token. */
8228 /* Generate a representation for the complete expression. */
8229 postfix_expression
8231 POSTDECREMENT_EXPR);
8232 /* Decrements may not appear in constant-expressions. */
8243 return is_member_access
8244 ? postfix_expression
8246 else
8248 }
8249 }
8250 }
8252 /* Helper function for cp_parser_parenthesized_expression_list and
8253 cp_parser_postfix_open_square_expression. Parse a single element
8254 of parenthesized expression list. */
8256 static cp_expr
8260 {
8264 /* Parse the next assignment-expression. */
8266 {
8267 /* A braced-init-list. */
8272 ? &expr_non_constant_p
8276 }
8278 {
8284 }
8285 else
8288 /* If we have an ellipsis, then this is an expression expansion. */
8291 {
8292 /* Consume the `...'. */
8295 /* Build the argument pack. */
8297 }
8299 }
8301 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8302 by cp_parser_builtin_offsetof. We're looking for
8304 postfix-expression [ expression ]
8305 postfix-expression [ braced-init-list ] (C++11)
8306 postfix-expression [ expression-list[opt] ] (C++23)
8308 FOR_OFFSETOF is set if we're being called in that context, which
8309 changes how we deal with integer constant expressions. */
8311 static tree
8313 tree postfix_expression,
8316 {
8323 /* Consume the `[' token. */
8333 /* Parse the index expression. */
8334 /* ??? For offsetof, there is a question of what to allow here. If
8335 offsetof is not being used in an integral constant expression context,
8336 then we *could* get the right answer by computing the value at runtime.
8337 If we are in an integral constant expression context, then we might
8338 could accept any constant expression; hard to say without analysis.
8339 Rather than open the barn door too wide right away, allow only integer
8340 constant expressions here. */
8345 {
8350 {
8352 {
8353 cp_expr expr
8355 /*cast_p=*/
8357 /*allow_exp_p=*/
8359 /*non_cst_p=*/
8360 NULL);
8367 else
8370 /* If the next token isn't a `,', then we are done. */
8375 {
8378 }
8380 /* Otherwise, consume the `,' and keep going. */
8382 }
8385 }
8387 {
8391 }
8392 else
8396 }
8404 {
8408 }
8411 {
8415 {
8417 {
8418 cp_expr expr
8420 /*cast_p=*/
8422 /*allow_exp_p=*/
8424 /*non_cst_p=*/
8425 NULL);
8429 else
8433 {
8437 }
8438 }
8439 else
8440 length
8444 }
8449 {
8452 }
8453 else
8457 length);
8458 }
8462 /* Look for the closing `]'. */
8465 /* Build the ARRAY_REF. */
8468 tf_warning_or_error
8471 /* When not doing offsetof, array references are not permitted in
8472 constant-expressions. */
8478 }
8480 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8481 dereference of incomplete type, returns true if error_mark_node should
8482 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8483 and *DEPENDENT_P. */
8485 bool
8488 {
8489 /* In a template, be permissive by treating an object expression
8490 of incomplete type as dependent (after a pedwarn). */
8491 diagnostic_t kind = (processing_template_decl
8495 {
8507 /* Don't emit any diagnostic for OVERLOADs. */
8511 /* Avoid clobbering e.g. DECLs. */
8515 }
8527 {
8530 }
8532 }
8534 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8535 by cp_parser_builtin_offsetof. We're looking for
8537 postfix-expression . template [opt] id-expression
8538 postfix-expression . pseudo-destructor-name
8539 postfix-expression -> template [opt] id-expression
8540 postfix-expression -> pseudo-destructor-name
8542 FOR_OFFSETOF is set if we're being called in that context. That sorta
8543 limits what of the above we'll actually accept, but nevermind.
8544 TOKEN_TYPE is the "." or "->" token, which will already have been
8545 removed from the stream. */
8547 static tree
8550 cp_expr postfix_expression,
8552 location_t location)
8553 {
8554 tree name;
8560 /* If this is a `->' operator, dereference the pointer. */
8563 tf_warning_or_error);
8564 /* Check to see whether or not the expression is type-dependent and
8565 not the current instantiation. */
8567 /* The identifier following the `->' or `.' is not qualified. */
8573 /* Enter the scope corresponding to the type of the object
8574 given by the POSTFIX_EXPRESSION. */
8576 {
8578 /* According to the standard, no expression should ever have
8579 reference type. Unfortunately, we do not currently match
8580 the standard in this respect in that our internal representation
8581 of an expression may have reference type even when the standard
8582 says it does not. Therefore, we have to manually obtain the
8583 underlying type here. */
8585 /* The type of the POSTFIX_EXPRESSION must be complete. */
8586 /* Unlike the object expression in other contexts, *this is not
8587 required to be of complete type for purposes of class member
8588 access (5.2.5) outside the member function body. */
8592 {
8598 }
8601 {
8602 /* Let the name lookup machinery know that we are processing a
8603 class member access expression. */
8605 /* If something went wrong, we want to be able to discern that case,
8606 as opposed to the case where there was no SCOPE due to the type
8607 of expression being dependent. */
8610 /* If the SCOPE was erroneous, make the various semantic analysis
8611 functions exit quickly -- and without issuing additional error
8612 messages. */
8615 }
8616 }
8619 {
8621 /* If we don't have a (type-dependent) object of class type, use
8622 typeof to figure out the type of the object. */
8626 }
8628 /* Assume this expression is not a pseudo-destructor access. */
8631 /* If the SCOPE is a scalar type, then, if this is a valid program,
8632 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8633 is type dependent, it can be pseudo-destructor-name or something else.
8634 Try to parse it as pseudo-destructor-name first. */
8636 {
8637 tree s;
8638 tree type;
8641 /* Parse the pseudo-destructor-name. */
8650 {
8652 postfix_expression
8655 }
8656 }
8659 {
8660 /* If the SCOPE is not a scalar type, we are looking at an
8661 ordinary class member access expression, rather than a
8662 pseudo-destructor-name. */
8665 /* Parse the id-expression. */
8666 name = (cp_parser_id_expression
8673 /* In general, build a SCOPE_REF if the member name is qualified.
8674 However, if the name was not dependent and has already been
8675 resolved; there is no need to build the SCOPE_REF. For example;
8677 struct X { void f(); };
8678 template <typename T> void f(T* t) { t->X::f(); }
8680 Even though "t" is dependent, "X::f" is not and has been resolved
8681 to a BASELINK; there is no need to include scope information. */
8683 /* But we do need to remember that there was an explicit scope for
8684 virtual function calls. */
8688 /* If the name is a template-id that names a type, we will get a
8689 TYPE_DECL here. That is invalid code. */
8691 {
8694 }
8695 else
8696 {
8698 {
8700 {
8704 }
8705 else
8708 name,
8709 template_p);
8713 }
8715 adjust_result_of_qualified_name_lookup
8717 postfix_expression
8719 template_p,
8720 tf_warning_or_error);
8721 /* Build a location e.g.:
8722 ptr->access_expr
8723 ~~~^~~~~~~~~~~~~
8724 where the caret is at the deref token, ranging from
8725 the start of postfix_expression to the end of the access expr. */
8726 location_t combined_loc
8729 }
8730 }
8732 /* We no longer need to look up names in the scope of the object on
8733 the left-hand side of the `.' or `->' operator. */
8736 /* Outside of offsetof, these operators may not appear in
8737 constant-expressions. */
8739 && (cp_parser_non_integral_constant_expression
8744 }
8746 /* Parse a parenthesized expression-list.
8748 expression-list:
8749 assignment-expression
8750 expression-list, assignment-expression
8752 attribute-list:
8753 expression-list
8754 identifier
8755 identifier, expression-list
8757 CAST_P is true if this expression is the target of a cast.
8759 ALLOW_EXPANSION_P is true if this expression allows expansion of an
8760 argument pack.
8762 WRAP_LOCATIONS_P is true if expressions within this list for which
8763 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8764 their source locations.
8766 Returns a vector of trees. Each element is a representation of an
8767 assignment-expression. NULL is returned if the ( and or ) are
8768 missing. An empty, but allocated, vector is returned on no
8769 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8770 if we are parsing an attribute list for an attribute that wants a
8771 plain identifier argument, normal_attr for an attribute that wants
8772 an expression, or non_attr if we aren't parsing an attribute list. If
8773 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8774 not all of the expressions in the list were constant.
8775 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8776 will be written to with the location of the closing parenthesis. If
8777 an error occurs, it may or may not be written to. */
8787 {
8792 /* Assume all the expressions will be constant. */
8796 matching_parens parens;
8802 /* Within a parenthesized expression, a `>' token is always
8803 the greater-than operator. */
8804 saved_greater_than_is_operator_p
8813 /* Consume expressions until there are no more. */
8816 {
8817 /* At the beginning of attribute lists, check to see if the
8818 next token is an identifier. */
8826 else
8827 expr
8829 allow_expansion_p,
8830 non_constant_p);
8835 /* Add it to the list. We add error_mark_node
8836 expressions to the list, so that we can still tell if
8837 the correct form for a parenthesized expression-list
8838 is found. That gives better errors. */
8844 /* After the first item, attribute lists look the same as
8845 expression lists. */
8848 get_comma:;
8849 /* If the next token isn't a `,', then we are done. */
8853 /* Otherwise, consume the `,' and keep going. */
8855 }
8861 {
8864 skip_comma:;
8865 /* We try and resync to an unnested comma, as that will give the
8866 user better diagnostics. */
8874 {
8875 parser->greater_than_is_operator_p
8879 }
8880 }
8882 parser->greater_than_is_operator_p
8887 }
8889 /* Parse a pseudo-destructor-name.
8891 pseudo-destructor-name:
8892 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
8893 :: [opt] nested-name-specifier template template-id :: ~ type-name
8894 :: [opt] nested-name-specifier [opt] ~ type-name
8896 If either of the first two productions is used, sets *SCOPE to the
8897 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
8898 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
8899 or ERROR_MARK_NODE if the parse fails. */
8901 static void
8903 tree object,
8906 {
8909 /* Handle ~auto. */
8913 {
8916 "%<~auto%> only available with "
8923 }
8925 /* Assume that things will not work out. */
8928 /* Look for the optional `::' operator. */
8930 /* Look for the optional nested-name-specifier. */
8931 nested_name_specifier_p
8938 /* Now, if we saw a nested-name-specifier, we might be doing the
8939 second production. */
8942 {
8943 /* Consume the `template' keyword. */
8945 /* Parse the template-id. */
8949 class_type,
8951 /* Look for the `::' token. */
8953 }
8954 /* If the next token is not a `~', then there might be some
8955 additional qualification. */
8957 {
8958 /* At this point, we're looking for "type-name :: ~". The type-name
8959 must not be a class-name, since this is a pseudo-destructor. So,
8960 it must be either an enum-name, or a typedef-name -- both of which
8961 are just identifiers. So, we peek ahead to check that the "::"
8962 and "~" tokens are present; if they are not, then we can avoid
8963 calling type_name. */
8967 {
8970 }
8972 /* Look for the type-name. */
8977 /* Look for the `::' token. */
8979 }
8980 else
8983 /* Look for the `~'. */
8986 /* Once we see the ~, this has to be a pseudo-destructor. */
8990 /* Look for the type-name again. We are not responsible for
8991 checking that it matches the first type-name. */
8993 }
8995 /* Parse a unary-expression.
8997 unary-expression:
8998 postfix-expression
8999 ++ cast-expression
9000 -- cast-expression
9001 await-expression
9002 unary-operator cast-expression
9003 sizeof unary-expression
9004 sizeof ( type-id )
9005 alignof ( type-id ) [C++0x]
9006 new-expression
9007 delete-expression
9009 GNU Extensions:
9011 unary-expression:
9012 __extension__ cast-expression
9013 __alignof__ unary-expression
9014 __alignof__ ( type-id )
9015 alignof unary-expression [C++0x]
9016 __real__ cast-expression
9017 __imag__ cast-expression
9018 && identifier
9019 sizeof ( type-id ) { initializer-list , [opt] }
9020 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
9021 __alignof__ ( type-id ) { initializer-list , [opt] }
9023 ADDRESS_P is true iff the unary-expression is appearing as the
9024 operand of the `&' operator. CAST_P is true if this expression is
9025 the target of a cast.
9027 Returns a representation of the expression. */
9029 static cp_expr
9032 {
9036 /* Peek at the next token. */
9038 /* Some keywords give away the kind of expression. */
9040 {
9044 {
9047 {
9055 /* Consume the token. */
9057 /* Parse the operand. */
9060 /* Construct a location e.g. :
9061 alignof (expr)
9062 ^~~~~~~~~~~~~~
9063 with start == caret at the start of the "alignof"/"sizeof"
9064 token, with the endpoint at the final closing paren. */
9065 location_t compound_loc
9071 else
9072 {
9073 /* ISO C++ defines alignof only with types, not with
9074 expressions. So pedwarn if alignof is used with a non-
9075 type expression. However, __alignof__ is ok. */
9078 "ISO C++ does not allow %<alignof%> "
9083 }
9084 /* For SIZEOF_EXPR, just issue diagnostics, but keep
9085 SIZEOF_EXPR with the original operand. */
9087 {
9089 {
9091 {
9094 error_mark_node));
9096 }
9097 else
9102 }
9103 }
9108 }
9120 {
9121 /* The saved value of the PEDANTIC flag. */
9123 tree expr;
9125 /* Save away the PEDANTIC flag. */
9127 /* Parse the cast-expression. */
9129 /* Restore the PEDANTIC flag. */
9133 }
9137 {
9138 tree expression;
9140 /* Consume the `__real__' or `__imag__' token. */
9142 /* Parse the cast-expression. */
9144 /* Create the complete representation. */
9149 tf_warning_or_error);
9150 }
9158 {
9159 tree expr;
9168 matching_parens parens;
9172 parser->type_definition_forbidden_message
9175 saved_integral_constant_expression_p
9177 saved_non_integral_constant_expression_p
9181 saved_greater_than_is_operator_p
9193 parser->greater_than_is_operator_p
9196 parser->integral_constant_expression_p
9198 parser->non_integral_constant_expression_p
9205 /* Construct a location of the form:
9206 noexcept (expr)
9207 ^~~~~~~~~~~~~~~
9208 with start == caret, finishing at the close-paren. */
9209 location_t noexcept_loc
9213 noexcept_loc);
9214 }
9217 {
9218 tree expr;
9221 /* Consume the `co_await' token. */
9223 /* Parse its cast-expression. */
9228 /* Handle [expr.await]. */
9230 }
9234 }
9235 }
9237 /* Look for the `:: new' and `:: delete', which also signal the
9238 beginning of a new-expression, or delete-expression,
9239 respectively. If the next token is `::', then it might be one of
9240 these. */
9242 {
9245 /* See if the token after the `::' is one of the keywords in
9246 which we're interested. */
9248 /* If it's `new', we have a new-expression. */
9251 /* Similarly, for `delete'. */
9254 }
9256 /* Look for a unary operator. */
9258 /* The `++' and `--' operators can be handled similarly, even though
9259 they are not technically unary-operators in the grammar. */
9261 {
9266 /* Handle the GNU address-of-label extension. */
9269 {
9270 tree identifier;
9271 tree expression;
9274 /* Consume the '&&' token. */
9276 /* Look for the identifier. */
9278 /* Construct a location of the form:
9279 &&label
9280 ^~~~~~~
9281 with caret==start at the "&&", finish at the end of the label. */
9282 location_t combined_loc
9284 /* Create an expression representing the address. */
9289 NIC_ADDR_LABEL))
9292 }
9293 }
9295 {
9296 cp_expr cast_expression;
9302 /* Consume the operator token. */
9306 /* Parse the cast-expression. */
9307 cast_expression
9312 pidk);
9314 /* Make a location:
9315 OP_TOKEN CAST_EXPRESSION
9316 ^~~~~~~~~~~~~~~~~~~~~~~~~
9317 with start==caret at the operator token, and
9318 extending to the end of the cast_expression. */
9321 /* Now, build an appropriate representation. */
9323 {
9328 complain);
9329 /* TODO: build_x_indirect_ref does not always honor the
9330 location, so ensure it is set. */
9336 /* Fall through. */
9339 cast_expression,
9341 /* TODO: build_x_unary_op does not always honor the location,
9342 so ensure it is set. */
9350 /* Fall through. */
9352 /* Immediately fold negation of a constant, unless the constant is 0
9353 (since -0 == 0) or it would overflow. */
9355 {
9356 tree stripped_expr
9361 {
9364 stripped_expr);
9366 {
9369 }
9370 }
9371 }
9372 /* Fall through. */
9381 }
9385 non_constant_p))
9389 }
9393 decltype_p,
9394 pidk);
9395 }
9397 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
9398 unary-operator, the corresponding tree code is returned. */
9400 static enum tree_code
9402 {
9404 {
9425 }
9426 }
9428 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9429 Returns a representation of the expression. */
9431 static tree
9433 {
9436 /* Consume the __builtin_has_attribute token. */
9439 matching_parens parens;
9443 /* Types cannot be defined in a `sizeof' expression. Save away the
9444 old message. */
9448 parser->type_definition_forbidden_message
9450 parser->type_definition_forbidden_message_arg
9453 /* The restrictions on constant-expressions do not apply inside
9454 sizeof expressions. */
9455 bool saved_integral_constant_expression_p
9457 bool saved_non_integral_constant_expression_p
9461 /* Do not actually evaluate the expression. */
9467 /* We can't be sure yet whether we're looking at a type-id or an
9468 expression. */
9473 /* Look for the type-id. */
9479 /* If the type-id production did not work out, then we must be
9480 looking at an expression. */
9486 /* Go back to evaluating expressions. */
9490 /* And restore the old one. */
9493 parser->integral_constant_expression_p
9495 parser->non_integral_constant_expression_p
9498 /* Consume the comma if it's there. */
9500 {
9504 }
9506 /* Parse the attribute specification. */
9510 {
9516 else
9517 {
9518 /* Fold constant expressions used in attributes first. */
9521 /* Finally, see if OPER has been declared with ATTR. */
9523 }
9526 }
9527 else
9528 {
9531 }
9533 /* Construct a location e.g. :
9534 __builtin_has_attribute (oper, attr)
9535 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9536 with start == caret at the start of the built-in token,
9537 and with the endpoint at the final closing paren. */
9538 location_t compound_loc
9545 }
9547 /* Parse a new-expression.
9549 new-expression:
9550 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9551 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9553 Returns a representation of the expression. */
9555 static tree
9557 {
9560 tree type;
9563 tree ret;
9567 /* Look for the optional `::' operator. */
9568 global_scope_p
9572 /* Look for the `new' operator. */
9574 /* There's no easy way to tell a new-placement from the
9575 `( type-id )' construct. */
9577 /* Look for a new-placement. */
9579 /* If that didn't work out, there's no new-placement. */
9581 {
9585 }
9587 /* If the next token is a `(', then we have a parenthesized
9588 type-id. */
9590 {
9594 /* Consume the `('. */
9595 matching_parens parens;
9598 /* Parse the type-id. */
9599 parser->type_definition_forbidden_message
9601 {
9604 }
9607 /* Look for the closing `)'. */
9610 /* There should not be a direct-new-declarator in this production,
9611 but GCC used to allowed this, so we check and emit a sensible error
9612 message for this case. */
9614 {
9620 }
9621 }
9622 /* Otherwise, there must be a new-type-id. */
9623 else
9626 /* If the next token is a `(' or '{', then we have a new-initializer. */
9631 else
9634 /* A new-expression may not appear in an integral constant
9635 expression. */
9638 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9639 of a new-type-id or type-id of a new-expression, the new-expression shall
9640 contain a new-initializer of the form ( assignment-expression )".
9641 Additionally, consistently with the spirit of DR 1467, we want to accept
9642 'new auto { 2 }' too. */
9648 {
9650 "initialization of new-expression for type %<auto%> "
9653 }
9654 else
9655 {
9656 /* Construct a location e.g.:
9657 ptr = new int[100]
9658 ^~~~~~~~~~~~
9659 with caret == start at the start of the "new" token, and the end
9660 at the end of the final token we consumed. */
9663 /* Create a representation of the new-expression. */
9666 }
9674 }
9676 /* Parse a new-placement.
9678 new-placement:
9679 ( expression-list )
9681 Returns the same representation as for an expression-list. */
9685 {
9688 /* Parse the expression-list. */
9689 expression_list = (cp_parser_parenthesized_expression_list
9698 }
9700 /* Parse a new-type-id.
9702 new-type-id:
9703 type-specifier-seq new-declarator [opt]
9705 Returns the TYPE allocated. If the new-type-id indicates an array
9706 type, *NELTS is set to the number of elements in the last array
9707 bound; the TYPE will not include the last array bound. */
9709 static tree
9711 {
9712 cp_decl_specifier_seq type_specifier_seq;
9718 /* The type-specifier sequence must not contain type definitions.
9719 (It cannot contain declarations of new types either, but if they
9720 are not definitions we will catch that because they are not
9721 complete.) */
9723 parser->type_definition_forbidden_message
9725 /* Parse the type-specifier-seq. */
9730 /* Restore the old message. */
9736 /* Parse the new-declarator. */
9739 /* Determine the number of elements in the last array dimension, if
9740 any. */
9742 /* Skip down to the last array dimension. */
9747 {
9750 }
9755 {
9758 }
9761 {
9770 else
9772 }
9775 }
9777 /* Parse an (optional) new-declarator.
9779 new-declarator:
9780 ptr-operator new-declarator [opt]
9781 direct-new-declarator
9783 Returns the declarator. */
9787 {
9790 cp_cv_quals cv_quals;
9792 /* We don't know if there's a ptr-operator next, or not. */
9794 /* Look for a ptr-operator. */
9796 /* If that worked, look for more new-declarators. */
9798 {
9801 /* Parse another optional declarator. */
9804 declarator = cp_parser_make_indirect_declarator
9808 }
9810 /* If the next token is a `[', there is a direct-new-declarator. */
9815 }
9817 /* Parse a direct-new-declarator.
9819 direct-new-declarator:
9820 [ expression ]
9821 direct-new-declarator [constant-expression]
9823 */
9827 {
9832 {
9833 tree expression;
9836 /* Look for the opening `['. */
9842 else
9844 /* The standard requires that the expression have integral
9845 type. DR 74 adds enumeration types. We believe that the
9846 real intent is that these expressions be handled like the
9847 expression in a `switch' condition, which also allows
9848 classes with a single conversion to integral or
9849 enumeration type. */
9851 {
9852 expression
9854 expression,
9857 {
9859 "expression in new-declarator must have integral "
9862 }
9863 }
9865 /* Look for the closing `]'. */
9868 /* Add this bound to the declarator. */
9871 /* If the next token is not a `[', then there are no more
9872 bounds. */
9876 }
9879 }
9881 /* Parse a new-initializer.
9883 new-initializer:
9884 ( expression-list [opt] )
9885 braced-init-list
9887 Returns a representation of the expression-list. */
9891 {
9895 {
9901 }
9902 else
9903 expression_list = (cp_parser_parenthesized_expression_list
9909 }
9911 /* Parse a delete-expression.
9913 delete-expression:
9914 :: [opt] delete cast-expression
9915 :: [opt] delete [ ] cast-expression
9917 Returns a representation of the expression. */
9919 static tree
9921 {
9924 tree expression;
9927 /* Look for the optional `::' operator. */
9928 global_scope_p
9932 /* Look for the `delete' keyword. */
9934 /* See if the array syntax is in use. */
9936 {
9937 /* Consume the `[' token. */
9939 /* Look for the `]' token. */
9941 /* Remember that this is the `[]' construct. */
9943 }
9944 else
9947 /* Parse the cast-expression. */
9950 /* A delete-expression may not appear in an integral constant
9951 expression. */
9955 /* Construct a location e.g.:
9956 delete [ ] ptr
9957 ^~~~~~~~~~~~~~
9958 with caret == start at the start of the "delete" token, and
9959 the end at the end of the final token we consumed. */
9966 }
9968 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9969 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9970 0 otherwise. */
9972 static int
9974 {
9977 {
10019 /* In ((type ()) () the last () isn't a valid cast-expression,
10020 so the whole must be parsed as postfix-expression. */
10025 /* '[' may start a primary-expression in obj-c++ and in C++11,
10026 as a lambda-expression, eg, '(void)[]{}'. */
10033 /* '++' and '--' may or may not start a cast-expression:
10035 struct T { void operator++(int); };
10036 void f() { (T())++; }
10038 vs
10040 int a;
10041 (int)++a; */
10046 }
10047 }
10049 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
10050 in the order: const_cast, static_cast, reinterpret_cast.
10052 Don't suggest dynamic_cast.
10054 Return the first legal cast kind found, or NULL otherwise. */
10058 {
10059 tree trial;
10061 /* Reuse the parser logic by attempting to build the various kinds of
10062 cast, with "complain" disabled.
10063 Identify the first such cast that is valid. */
10065 /* Don't attempt to run such logic within template processing. */
10069 /* First try const_cast. */
10074 /* If that fails, try static_cast. */
10079 /* Finally, try reinterpret_cast. */
10081 tf_none);
10085 /* No such cast possible. */
10087 }
10089 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
10090 suggesting how to convert a C-style cast of the form:
10092 (DST_TYPE)ORIG_EXPR
10094 to a C++-style cast.
10096 The primary range of RICHLOC is asssumed to be that of the original
10097 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
10098 of the parens in the C-style cast. */
10100 static void
10103 tree dst_type)
10104 {
10105 /* This function is non-trivial, so bail out now if the warning isn't
10106 going to be emitted. */
10110 /* Try to find a legal C++ cast, trying them in order:
10111 const_cast, static_cast, reinterpret_cast. */
10116 /* Replace the open paren with "CAST_SUGGESTION<". */
10117 pretty_printer pp;
10122 /* Replace the close paren with "> (". */
10125 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
10127 }
10130 /* Parse a cast-expression.
10132 cast-expression:
10133 unary-expression
10134 ( type-id ) cast-expression
10136 ADDRESS_P is true iff the unary-expression is appearing as the
10137 operand of the `&' operator. CAST_P is true if this expression is
10138 the target of a cast.
10140 Returns a representation of the expression. */
10142 static cp_expr
10145 {
10146 /* If it's a `(', then we might be looking at a cast. */
10148 {
10154 /* There's no way to know yet whether or not this is a cast.
10155 For example, `(int (3))' is a unary-expression, while `(int)
10156 3' is a cast. So, we resort to parsing tentatively. */
10158 /* Types may not be defined in a cast. */
10160 parser->type_definition_forbidden_message
10162 /* Consume the `('. */
10163 matching_parens parens;
10168 /* A very tricky bit is that `(struct S) { 3 }' is a
10169 compound-literal (which we permit in C++ as an extension).
10170 But, that construct is not a cast-expression -- it is a
10171 postfix-expression. (The reason is that `(struct S) { 3 }.i'
10172 is legal; if the compound-literal were a cast-expression,
10173 you'd need an extra set of parentheses.) But, if we parse
10174 the type-id, and it happens to be a class-specifier, then we
10175 will commit to the parse at that point, because we cannot
10176 undo the action that is done when creating a new class. So,
10177 then we cannot back up and do a postfix-expression.
10179 Another tricky case is the following (c++/29234):
10181 struct S { void operator () (); };
10183 void foo ()
10184 {
10185 ( S()() );
10186 }
10188 As a type-id we parse the parenthesized S()() as a function
10189 returning a function, groktypename complains and we cannot
10190 back up in this case either.
10192 Therefore, we scan ahead to the closing `)', and check to see
10193 if the tokens after the `)' can start a cast-expression. Otherwise
10194 we are dealing with an unary-expression, a postfix-expression
10195 or something else.
10197 Yet another tricky case, in C++11, is the following (c++/54891):
10199 (void)[]{};
10201 The issue is that usually, besides the case of lambda-expressions,
10202 the parenthesized type-id cannot be followed by '[', and, eg, we
10203 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
10204 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
10205 we don't commit, we try a cast-expression, then an unary-expression.
10207 Save tokens so that we can put them back. */
10210 /* We may be looking at a cast-expression. */
10213 cast_expression
10216 /* Roll back the tokens we skipped. */
10218 /* If we aren't looking at a cast-expression, simulate an error so
10219 that the call to cp_parser_error_occurred below returns true. */
10222 else
10223 {
10226 /* Look for the type-id. */
10228 /* Look for the closing `)'. */
10233 }
10235 /* Restore the saved message. */
10238 /* At this point this can only be either a cast or a
10239 parenthesized ctor such as `(T ())' that looks like a cast to
10240 function returning T. */
10242 {
10243 /* Only commit if the cast-expression doesn't start with
10244 '++', '--', or '[' in C++11. */
10252 pidk);
10255 {
10256 /* Warn about old-style casts, if so requested. */
10261 {
10267 }
10269 /* Only type conversions to integral or enumeration types
10270 can be used in constant-expressions. */
10273 NIC_CAST))
10276 /* Perform the cast. */
10277 /* Make a location:
10278 (TYPE) EXPR
10279 ^~~~~~~~~~~
10280 with start==caret at the open paren, extending to the
10281 end of "expr". */
10283 open_paren_loc,
10287 }
10288 }
10289 else
10291 }
10293 /* If we get here, then it's not a cast, so it must be a
10294 unary-expression. */
10297 }
10299 /* Parse a binary expression of the general form:
10301 pm-expression:
10302 cast-expression
10303 pm-expression .* cast-expression
10304 pm-expression ->* cast-expression
10306 multiplicative-expression:
10307 pm-expression
10308 multiplicative-expression * pm-expression
10309 multiplicative-expression / pm-expression
10310 multiplicative-expression % pm-expression
10312 additive-expression:
10313 multiplicative-expression
10314 additive-expression + multiplicative-expression
10315 additive-expression - multiplicative-expression
10317 shift-expression:
10318 additive-expression
10319 shift-expression << additive-expression
10320 shift-expression >> additive-expression
10322 relational-expression:
10323 shift-expression
10324 relational-expression < shift-expression
10325 relational-expression > shift-expression
10326 relational-expression <= shift-expression
10327 relational-expression >= shift-expression
10329 GNU Extension:
10331 relational-expression:
10332 relational-expression <? shift-expression
10333 relational-expression >? shift-expression
10335 equality-expression:
10336 relational-expression
10337 equality-expression == relational-expression
10338 equality-expression != relational-expression
10340 and-expression:
10341 equality-expression
10342 and-expression & equality-expression
10344 exclusive-or-expression:
10345 and-expression
10346 exclusive-or-expression ^ and-expression
10348 inclusive-or-expression:
10349 exclusive-or-expression
10350 inclusive-or-expression | exclusive-or-expression
10352 logical-and-expression:
10353 inclusive-or-expression
10354 logical-and-expression && inclusive-or-expression
10356 logical-or-expression:
10357 logical-and-expression
10358 logical-or-expression || logical-and-expression
10360 All these are implemented with a single function like:
10362 binary-expression:
10363 simple-cast-expression
10364 binary-expression <token> binary-expression
10366 CAST_P is true if this expression is the target of a cast.
10368 The binops_by_token map is used to get the tree codes for each <token> type.
10369 binary-expressions are associated according to a precedence table. */
10371 #define TOKEN_PRECEDENCE(token) \
10372 (((token->type == CPP_GREATER \
10373 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
10374 && !parser->greater_than_is_operator_p) \
10375 ? PREC_NOT_OPERATOR \
10376 : binops_by_token[token->type].prec)
10378 static cp_expr
10384 {
10385 cp_parser_expression_stack stack;
10388 cp_parser_expression_stack_entry current;
10389 cp_expr rhs;
10393 tree overload;
10395 /* Parse the first expression. */
10406 {
10407 /* Get an operator token. */
10413 {
10415 "%<>>%> operator is treated"
10419 }
10424 /* This is a fold-expression; handle it later. */
10427 /* Popping an entry off the stack means we completed a subexpression:
10428 - either we found a token which is not an operator (`>' where it is not
10429 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10430 will happen repeatedly;
10431 - or, we found an operator which has lower priority. This is the case
10432 where the recursive descent *ascends*, as in `3 * 4 + 5' after
10433 parsing `3 * 4'. */
10435 {
10438 else
10440 }
10442 get_rhs:
10447 /* We used the operator token. */
10450 /* For "false && x" or "true || x", x will never be executed;
10451 disable warnings while evaluating it. */
10456 {
10459 }
10461 /* Extract another operand. It may be the RHS of this expression
10462 or the LHS of a new, higher priority expression. */
10467 /* Get another operator token. Look up its precedence to avoid
10468 building a useless (immediately popped) stack entry for common
10469 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10476 {
10477 /* ... and prepare to parse the RHS of the new, higher priority
10478 expression. Since precedence levels on the stack are
10479 monotonically increasing, we do not have to care about
10480 stack overflows. */
10489 pop:
10491 /* If the stack is not empty, we have parsed into LHS the right side
10492 (`4' in the example above) of an expression we had suspended.
10493 We can use the information on the stack to recover the LHS (`3')
10494 from the stack together with the tree code (`MULT_EXPR'), and
10495 the precedence of the higher level subexpression
10496 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10497 which will be used to actually build the additive expression. */
10502 }
10504 /* Undo the disabling of warnings done above. */
10506 {
10509 }
10514 /* Avoid warning for !!x == y. */
10519 /* Avoid warning for !b == y where b is boolean. */
10523 /* Avoid warning for !!b == y where b is boolean. */
10535 /* Don't warn for named "xor" (as opposed to '^'). */
10539 check_for_xor_used_as_pow
10552 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10553 ERROR_MARK for everything that is not a binary expression.
10554 This makes warn_about_parentheses miss some warnings that
10555 involve unary operators. For unary expressions we should
10556 pass the correct tree_code unless the unary expression was
10557 surrounded by parentheses.
10558 */
10562 {
10565 else
10566 {
10569 current.lhs
10572 == tcc_comparison
10576 }
10577 }
10578 else
10579 {
10585 /* TODO: build_x_binary_op doesn't always honor the location. */
10587 }
10590 /* If the binary operator required the use of an overloaded operator,
10591 then this expression cannot be an integral constant-expression.
10592 An overloaded operator can be used even if both operands are
10593 otherwise permissible in an integral constant-expression if at
10594 least one of the operands is of enumeration type. */
10598 NIC_OVERLOADED))
10600 }
10603 }
10605 static cp_expr
10610 {
10613 }
10615 /* Parse the `? expression : assignment-expression' part of a
10616 conditional-expression. The LOGICAL_OR_EXPR is the
10617 logical-or-expression that started the conditional-expression.
10618 Returns a representation of the entire conditional-expression.
10620 This routine is used by cp_parser_assignment_expression
10621 and cp_parser_conditional_expression.
10623 ? expression : assignment-expression
10625 GNU Extensions:
10627 ? : assignment-expression */
10629 static tree
10631 {
10633 cp_expr assignment_expr;
10637 /* Consume the `?' token. */
10642 {
10645 /* Implicit true clause. */
10647 c_inhibit_evaluation_warnings +=
10650 }
10651 else
10652 {
10655 /* Parse the expression. */
10656 c_inhibit_evaluation_warnings +=
10659 c_inhibit_evaluation_warnings +=
10663 }
10665 /* The next token should be a `:'. */
10667 /* Parse the assignment-expression. */
10669 c_inhibit_evaluation_warnings -=
10672 /* Make a location:
10673 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10674 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10675 with the caret at the "?", ranging from the start of
10676 the logical_or_expr to the end of the assignment_expr. */
10681 /* Build the conditional-expression. */
10683 expr,
10684 assignment_expr,
10685 tf_warning_or_error);
10686 }
10688 /* Parse a conditional-expression.
10690 conditional-expression:
10691 logical-or-expression
10692 logical-or-expression ? expression : assignment-expression
10694 GNU Extensions:
10696 logical-or-expression ? : assignment-expression */
10698 static cp_expr
10700 {
10703 /* If the next token is a `?' then we're actually looking at
10704 a conditional-expression; otherwise we're done. */
10708 }
10710 /* Parse an assignment-expression.
10712 assignment-expression:
10713 conditional-expression
10714 logical-or-expression assignment-operator assignment_expression
10715 throw-expression
10716 yield-expression
10718 CAST_P is true if this expression is the target of a cast.
10719 DECLTYPE_P is true if this expression is the operand of decltype.
10721 Returns a representation for the expression. */
10723 static cp_expr
10726 {
10727 cp_expr expr;
10729 /* If the next token is the `throw' keyword, then we're looking at
10730 a throw-expression. */
10733 /* If the next token is the `co_yield' keyword, then we're looking at
10734 a yield-expression. */
10737 /* Otherwise, it must be that we are looking at a
10738 logical-or-expression. */
10739 else
10740 {
10741 /* Parse the binary expressions (logical-or-expression). */
10743 decltype_p,
10745 /* If the next token is a `?' then we're actually looking at a
10746 conditional-expression. */
10749 else
10750 {
10753 /* If it's an assignment-operator, we're using the second
10754 production. */
10755 enum tree_code assignment_operator
10758 {
10759 /* Parse the right-hand side of the assignment. */
10765 /* An assignment may not appear in a
10766 constant-expression. */
10768 NIC_ASSIGNMENT))
10770 /* Build the assignment expression. Its default
10771 location:
10772 LHS = RHS
10773 ~~~~^~~~~
10774 is the location of the '=' token as the
10775 caret, ranging from the start of the lhs to the
10776 end of the rhs. */
10781 assignment_operator,
10784 /* TODO: build_x_modify_expr doesn't honor the location,
10785 so we must set it here. */
10787 }
10788 }
10789 }
10792 }
10794 /* Parse an (optional) assignment-operator.
10796 assignment-operator: one of
10797 = *= /= %= += -= >>= <<= &= ^= |=
10799 GNU Extension:
10801 assignment-operator: one of
10802 <?= >?=
10804 If the next token is an assignment operator, the corresponding tree
10805 code is returned, and the token is consumed. For example, for
10806 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
10807 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
10808 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
10809 operator, ERROR_MARK is returned. */
10811 static enum tree_code
10813 {
10817 /* Peek at the next token. */
10821 {
10867 /* Nothing else is an assignment operator. */
10869 }
10871 /* An operator followed by ... is a fold-expression, handled elsewhere. */
10876 /* If it was an assignment operator, consume it. */
10881 }
10883 /* Parse an expression.
10885 expression:
10886 assignment-expression
10887 expression , assignment-expression
10889 CAST_P is true if this expression is the target of a cast.
10890 DECLTYPE_P is true if this expression is the immediate operand of decltype,
10891 except possibly parenthesized or on the RHS of a comma (N3276).
10892 WARN_COMMA_P is true if a comma should be diagnosed.
10894 Returns a representation of the expression. */
10896 static cp_expr
10899 {
10904 {
10905 cp_expr assignment_expression;
10907 /* Parse the next assignment-expression. */
10908 assignment_expression
10911 /* We don't create a temporary for a call that is the immediate operand
10912 of decltype or on the RHS of a comma. But when we see a comma, we
10913 need to create a temporary for a call on the LHS. */
10918 assignment_expression
10922 /* If this is the first assignment-expression, we can just
10923 save it away. */
10926 else
10927 {
10928 /* Create a location with caret at the comma, ranging
10929 from the start of the LHS to the end of the RHS. */
10937 }
10938 /* If the next token is not a comma, or we're in a fold-expression, then
10939 we are done with the expression. */
10943 /* Consume the `,'. */
10946 {
10947 /* [depr.comma.subscript]: A comma expression appearing as
10948 the expr-or-braced-init-list of a subscripting expression
10949 is deprecated. A parenthesized comma expression is not
10950 deprecated. */
10952 "top-level comma expression in array subscript "
10955 }
10957 /* A comma operator cannot appear in a constant-expression. */
10960 }
10963 }
10965 /* Parse a constant-expression.
10967 constant-expression:
10968 conditional-expression
10970 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
10971 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
10972 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
10973 is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
10974 greater than 1, this isn't really a constant-expression, only a
10975 potentially constant-evaluated expression. If STRICT_P is true,
10976 only parse a conditional-expression, otherwise parse an
10977 assignment-expression. See below for rationale. */
10979 static cp_expr
10984 {
10985 /* It might seem that we could simply parse the
10986 conditional-expression, and then check to see if it were
10987 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
10988 one that the compiler can figure out is constant, possibly after
10989 doing some simplifications or optimizations. The standard has a
10990 precise definition of constant-expression, and we must honor
10991 that, even though it is somewhat more restrictive.
10993 For example:
10995 int i[(2, 3)];
10997 is not a legal declaration, because `(2, 3)' is not a
10998 constant-expression. The `,' operator is forbidden in a
10999 constant-expression. However, GCC's constant-folding machinery
11000 will fold this operation to an INTEGER_CST for `3'. */
11002 /* Save the old settings. */
11003 bool saved_integral_constant_expression_p
11005 bool saved_allow_non_integral_constant_expression_p
11007 bool saved_non_integral_constant_expression_p
11009 /* We are now parsing a constant-expression. */
11011 parser->allow_non_integral_constant_expression_p
11015 /* A manifestly constant-evaluated expression is evaluated even in an
11016 unevaluated operand. */
11019 /* Although the grammar says "conditional-expression", when not STRICT_P,
11020 we parse an "assignment-expression", which also permits
11021 "throw-expression" and the use of assignment operators. In the case
11022 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
11023 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
11024 actually essential that we look for an assignment-expression.
11025 For example, cp_parser_initializer_clauses uses this function to
11026 determine whether a particular assignment-expression is in fact
11027 constant. */
11028 cp_expr expression;
11031 else
11033 /* Restore the old settings. */
11034 parser->integral_constant_expression_p
11036 parser->allow_non_integral_constant_expression_p
11040 {
11041 /* Require an rvalue constant expression here; that's what our
11042 callers expect. Reference constant expressions are handled
11043 separately in e.g. cp_parser_template_argument. */
11052 }
11055 parser->non_integral_constant_expression_p
11059 }
11061 /* Parse __builtin_offsetof.
11063 offsetof-expression:
11064 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
11066 offsetof-member-designator:
11067 id-expression
11068 | offsetof-member-designator "." id-expression
11069 | offsetof-member-designator "[" expression "]"
11070 | offsetof-member-designator "->" id-expression */
11072 static cp_expr
11074 {
11076 tree type;
11077 cp_expr expr;
11078 cp_id_kind dummy;
11080 location_t finish_loc;
11082 /* We're about to accept non-integral-constant things, but will
11083 definitely yield an integral constant expression. Save and
11084 restore these values around our local parsing. */
11090 /* Consume the "__builtin_offsetof" token. */
11092 /* Consume the opening `('. */
11093 matching_parens parens;
11095 /* Parse the type-id. */
11097 {
11099 parser->type_definition_forbidden_message
11103 }
11104 /* Look for the `,'. */
11108 /* Build the (type *)null that begins the traditional offsetof macro. */
11109 tree object_ptr
11113 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
11117 {
11120 {
11122 /* offsetof-member-designator "[" expression "]" */
11128 /* offsetof-member-designator "->" identifier */
11131 /* FALLTHRU */
11134 /* offsetof-member-designator "." identifier */
11142 /* Consume the ")" token. */
11148 /* Error. We know the following require will fail, but
11149 that gives the proper error message. */
11154 }
11155 }
11157 success:
11158 /* Make a location of the form:
11159 __builtin_offsetof (struct s, f)
11160 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
11161 with caret at the type-id, ranging from the start of the
11162 "_builtin_offsetof" token to the close paren. */
11164 /* The result will be an INTEGER_CST, so we need to explicitly
11165 preserve the location. */
11168 failure:
11174 }
11176 /* Parse a builtin trait expression or type. */
11178 static cp_expr
11180 {
11187 /* Get location of initial token. */
11190 /* Consume the token. */
11193 matching_parens parens;
11196 else
11200 {
11209 }
11211 /* __type_pack_element takes an expression as its first argument and uses
11212 template-id syntax instead of function call syntax (for consistency
11213 with Clang). We special case these properties of __type_pack_element
11214 here and elsewhere. */
11216 else
11217 {
11220 }
11226 {
11230 {
11232 {
11234 "trailing argument to %<__type_pack_element%> "
11237 }
11238 }
11240 }
11242 {
11245 {
11248 }
11252 }
11254 {
11257 {
11261 {
11264 }
11268 }
11272 }
11276 /* cp_parser_enclosed_template_argument_list above already took care
11278 else
11281 /* Construct a location of the form:
11282 __is_trivially_copyable(_Tp)
11283 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
11284 with start == caret, finishing at the close-paren. */
11287 /* Complete the trait expression, which may mean either processing
11288 the trait expr now or saving it for template instantiation. */
11290 {
11298 else
11300 }
11301 }
11303 /* Parse a lambda expression.
11305 lambda-expression:
11306 lambda-introducer lambda-declarator [opt] compound-statement
11307 lambda-introducer < template-parameter-list > requires-clause [opt]
11308 lambda-declarator [opt] compound-statement
11310 Returns a representation of the expression. */
11312 static cp_expr
11314 {
11316 tree type;
11324 {
11325 /* C++20 allows lambdas in unevaluated context, but one in the type of a
11326 non-type parameter is nonsensical.
11328 Distinguish a lambda in the parameter type from a lambda in the
11329 default argument by looking at local_variables_forbidden_p, which is
11330 only set in default arguments. */
11332 {
11337 }
11338 }
11340 {
11342 {
11344 "lambda-expression in unevaluated context"
11347 }
11349 }
11351 {
11353 {
11357 }
11359 }
11361 /* We may be in the middle of deferred access check. Disable
11362 it now. */
11376 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11379 /* Now that we've started the type, add the capture fields for any
11380 explicit captures. */
11383 {
11384 /* Inside the class, surrounding template-parameter-lists do not apply. */
11385 unsigned int saved_num_template_parameter_lists
11389 bool fully_implicit_function_template_p
11393 bool auto_is_implicit_function_template_parm_p
11406 /* The body of a lambda in a discarded statement is not discarded. */
11410 /* Similarly the body of a lambda in immediate function context is not
11411 in immediate function context. */
11415 /* By virtue of defining a local class, a lambda expression has access to
11416 the private variables of enclosing classes. */
11429 {
11432 }
11434 /* The capture list was built up in reverse order; fix that now. */
11449 parser->fully_implicit_function_template_p
11453 parser->auto_is_implicit_function_template_parm_p
11456 }
11458 /* This field is only used during parsing of the lambda. */
11461 /* This lambda shouldn't have any proxies left at this point. */
11463 /* And now that we're done, push proxies for an enclosing lambda. */
11466 /* Update the lambda expression to a range. */
11473 else
11481 }
11483 /* Parse the beginning of a lambda expression.
11485 lambda-introducer:
11486 [ lambda-capture [opt] ]
11488 LAMBDA_EXPR is the current representation of the lambda expression. */
11490 static void
11492 {
11493 /* Need commas after the first capture. */
11496 /* Eat the leading `['. */
11499 /* Record default capture mode. "[&" "[=" "[&," "[=," */
11509 {
11515 }
11521 {
11523 tree capture_id;
11524 tree capture_init_expr;
11528 enum capture_kind_type
11529 {
11530 BY_COPY,
11531 BY_REFERENCE
11532 };
11536 {
11539 }
11543 else
11546 /* Possibly capture `this'. */
11548 {
11553 "explicit by-copy capture of %<this%> "
11554 "with by-copy capture default only available with "
11560 this_identifier);
11561 else
11566 }
11568 /* Possibly capture `*this'. */
11571 {
11575 "%<*this%> capture only available with "
11582 this_identifier);
11583 else
11588 }
11590 /* But reject `&this'. */
11593 {
11599 }
11601 /* Remember whether we want to capture as a reference or not. */
11603 {
11606 }
11611 {
11615 "pack init-capture only available with "
11619 }
11621 /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11624 {
11629 }
11631 /* Get the identifier. */
11636 /* Would be nice to have a cp_parser_skip_to_closing_x for general
11637 delimiters, but I modified this to stop on unnested ']' as well. It
11638 was already changed to stop on unnested '}', so the
11639 "closing_parenthesis" name is no more misleading with my change. */
11640 {
11646 }
11648 /* Find the initializer for this capture. */
11652 {
11653 /* An explicit initializer exists. */
11656 "lambda capture initializers "
11664 {
11667 }
11670 }
11671 else
11672 {
11675 /* Turn the identifier into an id-expression. */
11676 capture_init_expr
11681 {
11684 }
11687 {
11690 capture_init_expr);
11695 }
11698 {
11701 capture_init_expr))
11705 }
11707 capture_init_expr
11708 = finish_id_expression
11710 capture_init_expr,
11724 {
11729 {
11730 /* If what follows is an initializer, the second '...' is
11731 invalid. But for cases like [...xs...], the first one
11732 is invalid. */
11739 }
11740 }
11741 }
11745 {
11750 capture_id);
11754 "capture of %qD redundant with by-reference capture "
11756 }
11758 /* Check for duplicates.
11759 Optimize for the zero or one explicit captures cases and only create
11760 the hash_set after adding second capture. */
11768 else
11769 {
11772 }
11778 else
11783 /* If there is any qualification still in effect, clear it
11784 now; we will be starting fresh with the next capture. */
11788 }
11791 }
11793 /* Parse the (optional) middle of a lambda expression.
11795 lambda-declarator:
11796 ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
11797 lambda-specifiers (C++23)
11799 lambda-specifiers:
11800 decl-specifier-seq [opt] noexcept-specifier [opt]
11801 attribute-specifier-seq [opt] trailing-return-type [opt]
11803 LAMBDA_EXPR is the current representation of the lambda expression. */
11805 static bool
11807 {
11808 /* 5.1.1.4 of the standard says:
11809 If a lambda-expression does not include a lambda-declarator, it is as if
11810 the lambda-declarator were ().
11811 This means an empty parameter list, no attributes, and no exception
11812 specification. */
11823 cp_decl_specifier_seq lambda_specs;
11825 /* A lambda op() is const unless explicitly 'mutable'. */
11828 /* The template-parameter-list is optional, but must begin with
11829 an opening angle if present. */
11831 {
11835 "lambda templates are only available with "
11843 /* We may have a constrained generic lambda; parse the requires-clause
11844 immediately after the template-parameter-list and combine with any
11845 shorthand constraints present. */
11848 {
11853 }
11855 /* We just processed one more parameter list. */
11857 }
11859 /* Committee discussion supports allowing attributes here. */
11862 /* The parameter-declaration-clause is optional (unless
11863 template-parameter-list was given), but must begin with an
11864 opening parenthesis if present. */
11866 {
11867 matching_parens parens;
11872 /* Parse parameters. */
11873 param_list
11874 = cp_parser_parameter_declaration_clause
11877 /* Default arguments shall not be specified in the
11878 parameter-declaration-clause of a lambda-declarator. */
11883 OPT_Wc__14_extensions,
11888 }
11892 /* [expr.prim.lambda.general]
11893 lambda-specifier:
11894 consteval, constexpr, mutable, static
11895 [4] A lambda-specifier-seq shall contain at most one of each
11896 lambda-specifier and shall not contain both constexpr and consteval.
11897 The lambda-specifier-seq shall not contain both mutable and static. */
11901 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
11905 {
11907 "parameter declaration before lambda declaration "
11908 "specifiers only optional with %<-std=c++2b%> or "
11911 }
11912 /* Peek at the params, see if we have an xobj parameter. */
11914 {
11916 /* We still need grokdeclarator to see that this is an xobj function
11917 and finish the rest of the work, don't mutate it. */
11920 /* [expr.prim.lambda.closure-5]
11921 Given a lambda with a lambda-capture, the type of the explicit object
11922 parameter, if any, of the lambda's function call operator (possibly
11923 instantiated from a function call operator template) shall be either:
11924 -- the closure type,
11925 -- a class type derived from the closure type, or
11926 -- a reference to a possibly cv-qualified such type. */
11927 bool const unrelated_with_captures
11930 /* Since a lambda's type is anonymous, we can assume an xobj
11931 parameter is unrelated to the closure if it is non-dependent.
11932 If it is dependent we handle it at instantiation time. */
11935 {
11937 "a lambda with captures may not have an explicit object "
11940 }
11942 /* [expr.prim.lambda.general-4]
11943 If the lambda-declarator contains an explicit object parameter
11944 ([dcl.fct]), then no lambda-specifier in the lambda-specifier-seq
11945 shall be mutable or static. */
11947 {
11948 auto_diagnostic_group d;
11950 "%<mutable%> lambda specifier "
11952 /* Tell the user how to do what they probably meant, maybe fixits
11953 would be appropriate later? */
11955 /* The following hints don't make sense when we already have an
11959 "the passed in closure object will not be mutated because "
11963 "declare the explicit object parameter as non-const "
11965 else
11967 "explicit object parameter is already a mutable "
11969 }
11971 {
11972 auto_diagnostic_group d;
11974 "%<static%> lambda specifier "
11978 }
11979 }
11981 {
11983 }
11985 {
11986 /* [expr.prim.lambda.general-4]
11987 If the lambda-specifier-seq contains static, there shall be no
11988 lambda-capture. */
11993 else
11994 {
11997 }
11998 }
12002 {
12004 "parameter declaration before lambda transaction "
12005 "qualifier only optional with %<-std=c++2b%> or "
12008 }
12010 /* Parse optional exception specification. */
12011 exception_spec
12015 {
12017 "parameter declaration before lambda exception "
12018 "specification only optional with %<-std=c++2b%> or "
12021 }
12023 /* GCC 8 accepted attributes here, and this is the place for standard C++11
12024 attributes that appertain to the function type. */
12027 else
12030 /* Parse optional trailing return type. */
12032 {
12035 "parameter declaration before lambda trailing "
12036 "return type only optional with %<-std=c++2b%> or "
12040 }
12042 /* Also allow GNU attributes at the very end of the declaration, the usual
12043 place for GNU attributes. */
12048 {
12049 /* Parse optional trailing requires clause. */
12052 /* The function parameters must be in scope all the way until after the
12053 trailing-return-type in case of decltype. */
12055 }
12057 /* Create the function call operator.
12059 Messing with declarators like this is no uglier than building up the
12060 FUNCTION_DECL by hand, and this is less likely to get out of sync with
12061 other code. */
12062 {
12063 cp_decl_specifier_seq return_type_specs;
12065 tree fco;
12072 {
12076 else
12078 "lambda only available with %<-std=c++17%> or "
12080 }
12085 {
12089 }
12097 VIRT_SPEC_UNSPECIFIED,
12098 REF_QUAL_NONE,
12099 tx_qual,
12100 exception_spec,
12101 return_type,
12102 trailing_requires_clause,
12103 std_attrs,
12104 UNKNOWN_LOCATION);
12107 declarator,
12110 {
12114 /* Give the object parameter a different name. */
12117 }
12119 {
12123 }
12133 }
12134 }
12136 /* Parse the body of a lambda expression, which is simply
12138 compound-statement
12140 but which requires special handling.
12141 LAMBDA_EXPR is the current representation of the lambda expression. */
12143 static void
12145 {
12147 unsigned char local_variables_forbidden_p
12151 /* The body of a lambda-expression is not a subexpression of the enclosing
12152 expression. */
12153 cp_evaluated ev;
12157 else
12158 /* Still increment function_depth so that we don't GC in the
12159 middle of an expression. */
12167 /* Clear this in case we're in the middle of a default argument. */
12171 {
12176 /* Originally C++11 required us to peek for 'return expr'; and
12177 process it specially here to deduce the return type. N3638
12178 removed the need for that. */
12182 }
12189 else
12191 }
12193 /* Statements [gram.stmt.stmt] */
12195 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
12197 static void
12199 {
12203 /* A concept is never expanded normally. */
12209 }
12211 struct cp_omp_attribute_data
12212 {
12215 c_omp_directive_kind kind;
12216 };
12218 /* Handle omp::directive and omp::sequence attributes in ATTRS
12219 (if any) at the start of a statement or in attribute-declaration. */
12221 static tree
12223 {
12234 {
12235 cnt++;
12237 {
12243 {
12245 "mixing OpenMP directives with attribute and pragma "
12249 }
12251 {
12255 }
12258 {
12266 else
12269 }
12275 {
12277 "unknown OpenMP directive name in %qs attribute "
12281 }
12284 {
12285 /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
12286 depend/doacross clause. */
12299 }
12301 {
12302 /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
12306 paren_depth++;
12308 paren_depth--;
12319 {
12322 }
12323 }
12328 }
12329 cp_omp_attribute_data v = {};
12332 }
12333 else
12346 {
12351 }
12352 else
12353 {
12355 {
12358 }
12359 }
12362 {
12364 "OpenMP construct among %<omp::directive%> attributes"
12365 " requires all %<omp::directive%> attributes on the"
12368 }
12370 {
12372 "multiple OpenMP standalone directives among"
12373 " %<omp::directive%> attributes must be all within the"
12376 }
12382 {
12384 "standalone OpenMP directives in %<omp::directive%> attribute"
12387 }
12389 {
12393 {
12395 "mixing OpenMP directives with attribute and pragma "
12398 }
12399 }
12403 tokens++;
12408 {
12415 cp_token tok = {};
12423 tok = {};
12428 }
12429 cp_token tok = {};
12441 /* Move the current source position to that of the first token in the
12442 new lexer. */
12445 }
12447 /* True if and only if the name is one of the contract types. */
12449 static bool
12451 {
12455 }
12457 /* Handle omp::directive and omp::sequence attributes in *PATTRS
12458 (if any) at the start or after declaration-id of a declaration. */
12460 static void
12464 {
12475 {
12477 {
12484 {
12492 else
12495 }
12505 {
12507 {
12510 }
12512 {
12514 "mixing OpenMP directives with attribute and "
12517 }
12518 }
12519 }
12520 }
12523 {
12528 else
12531 }
12536 {
12545 }
12547 }
12549 /* Parse a statement.
12551 statement:
12552 labeled-statement
12553 expression-statement
12554 compound-statement
12555 selection-statement
12556 iteration-statement
12557 jump-statement
12558 declaration-statement
12559 try-block
12561 C++11:
12563 statement:
12564 labeled-statement
12565 attribute-specifier-seq (opt) expression-statement
12566 attribute-specifier-seq (opt) compound-statement
12567 attribute-specifier-seq (opt) selection-statement
12568 attribute-specifier-seq (opt) iteration-statement
12569 attribute-specifier-seq (opt) jump-statement
12570 declaration-statement
12571 attribute-specifier-seq (opt) try-block
12573 init-statement:
12574 expression-statement
12575 simple-declaration
12576 alias-declaration
12578 TM Extension:
12580 statement:
12581 atomic-statement
12583 IN_COMPOUND is true when the statement is nested inside a
12584 cp_parser_compound_statement.
12586 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12587 is a (possibly labeled) if statement which is not enclosed in braces
12588 and has an else clause. This is used to implement -Wparentheses.
12590 CHAIN is a vector of if-else-if conditions.
12592 Note that this version of parsing restricts assertions to be attached to
12593 empty statements. */
12595 static void
12599 {
12605 /* A copy of IN_COMPOUND which is set to false after seeing a label.
12606 This matters for certain pragmas. */
12609 restart:
12612 /* There is no statement yet. */
12619 /* In obj-c++, seeing '[[' might be the either the beginning of
12620 c++11 attributes, or a nested objc-message-expression. So
12621 let's parse the c++11 attributes tentatively. */
12627 {
12630 }
12633 /* Peek at the next token. */
12636 /* If we have contracts, check that they're valid in this context. */
12638 {
12646 /* Check that assertions are null statements. */
12650 }
12656 {
12660 {
12687 }
12693 {
12695 std_attrs);
12697 }
12698 }
12701 /* Remember the location of the first token in the statement. */
12705 /* If this is a keyword, then that will often determine what kind of
12706 statement we have. */
12708 {
12712 {
12715 /* Looks like a labeled-statement with a case label.
12716 Parse the label, and then use tail recursion to parse
12717 the statement. */
12746 /* Objective-C++ exception-handling constructs. */
12762 /* This must be a namespace alias definition. */
12764 {
12765 /* Attributes should be parsed as part of the
12766 declaration, so let's un-parse them. */
12769 }
12787 /* It might be a keyword like `int' that can start a
12788 declaration-statement. */
12790 }
12791 }
12793 {
12794 /* If the next token is a `:', then we are looking at a
12795 labeled-statement. */
12798 {
12799 /* Looks like a labeled-statement with an ordinary label.
12800 Parse the label, and then use tail recursion to parse
12801 the statement. */
12805 /* If there's no statement, it's not a labeled-statement, just
12806 a label. That's allowed in C++23, but only if we're at the
12807 end of a compound-statement. */
12810 {
12814 "label at end of compound statement only available "
12817 }
12821 }
12822 }
12823 /* Anything that starts with a `{' must be a compound-statement. */
12825 {
12828 }
12829 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
12830 a statement all its own. */
12832 {
12833 do_pragma:;
12836 /* Only certain OpenMP pragmas are attached to statements, and thus
12837 are considered statements themselves. All others are not. In
12838 the context of a compound, accept the pragma as a "statement" and
12839 return so that we can check for a close brace. Otherwise we
12840 require a real statement and must go back and read one. */
12842 {
12846 }
12854 {
12856 {
12863 }
12866 }
12874 }
12876 {
12879 }
12881 /* Everything else must be a declaration-statement or an
12882 expression-statement. Try for the declaration-statement
12883 first, unless we are looking at a `;', in which case we know that
12884 we have an expression-statement. */
12886 {
12888 {
12890 /* Attributes should be parsed as part of the declaration,
12891 so let's un-parse them. */
12896 /* Try to parse the declaration-statement. */
12899 /* If that worked, we're done. */
12902 /* It didn't work, restore the post-attribute position. */
12904 {
12907 {
12912 i++;
12914 {
12920 /* Don't handle OpenMP attribs on keywords that
12921 always start a declaration statement but don't
12922 accept attribute before it and therefore
12923 the tentative cp_parser_declaration_statement
12924 fails to parse because of that. */
12929 }
12932 {
12934 std_attrs
12935 = cp_parser_handle_statement_omp_attributes
12941 }
12942 }
12943 }
12944 }
12945 /* All preceding labels have been parsed at this point. */
12951 /* Look for an expression-statement instead. */
12955 attrs_loc);
12957 /* Handle [[fallthrough]];. */
12959 {
12960 /* The next token after the fallthrough attribute is ';'. */
12962 {
12963 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12965 IFN_FALLTHROUGH,
12968 }
12969 else
12973 }
12975 /* Handle [[assert: ...]]; */
12977 {
12978 /* Add the assertion as a statement in the current block. */
12982 }
12983 }
12985 /* Set the line number for the statement. */
12989 /* Allow "[[fallthrough]];" or "[[assume(cond)]];", but warn otherwise. */
12993 }
12995 /* Append ATTR to attribute list ATTRS. */
12997 tree
12999 {
13005 }
13007 /* Parse the label for a labeled-statement, i.e.
13009 label:
13010 attribute-specifier-seq[opt] identifier :
13011 attribute-specifier-seq[opt] case constant-expression :
13012 attribute-specifier-seq[opt] default :
13014 labeled-statement:
13015 label statement
13017 GNU Extension:
13018 case constant-expression ... constant-expression : statement
13020 When a label is parsed without errors, the label is added to the
13021 parse tree by the finish_* functions, so this function doesn't
13022 have to return the label. */
13024 static void
13026 {
13031 /* The next token should be an identifier. */
13035 {
13038 }
13040 /* Remember whether this case or a user-defined label is allowed to fall
13041 through to. */
13046 {
13048 {
13052 /* Consume the `case' token. */
13054 /* Parse the constant-expression. */
13061 {
13062 /* Consume the `...' token. */
13068 /* We don't need to emit warnings here, as the common code
13069 will do this for us. */
13070 }
13071 else
13075 {
13078 {
13081 }
13082 }
13083 else
13086 expr);
13087 }
13091 /* Consume the `default' token. */
13095 {
13098 {
13101 }
13102 }
13103 else
13108 /* Anything else must be an ordinary label. */
13113 }
13115 /* Require the `:' token. */
13118 /* An ordinary label may optionally be followed by attributes.
13119 However, this is only permitted if the attributes are then
13120 followed by a semicolon. This is because, for backward
13121 compatibility, when parsing
13122 lab: __attribute__ ((unused)) int i;
13123 we want the attribute to attach to "i", not "lab". */
13126 {
13127 tree attrs;
13131 /* And fallthrough always binds to the expression-statement. */
13136 ;
13137 else
13139 }
13145 }
13147 /* Parse an expression-statement.
13149 expression-statement:
13150 expression [opt] ;
13152 Returns the new EXPR_STMT -- or NULL_TREE if the expression
13153 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
13154 indicates whether this expression-statement is part of an
13155 expression statement. */
13157 static tree
13159 {
13164 /* There might be attribute fallthrough. */
13167 /* If the next token is a ';', then there is no expression
13168 statement. */
13170 {
13174 {
13175 /* If we ran into a problem, make sure we complained. */
13180 }
13181 }
13185 /* Handle [[fallthrough]];. */
13187 {
13188 /* The next token after the fallthrough attribute is ';'. */
13190 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
13193 else
13197 }
13199 /* Allow "[[fallthrough]];", but warn otherwise. */
13204 /* Give a helpful message for "A<T>::type t;" and the like. */
13207 {
13214 {
13215 /* A::A a; */
13220 }
13221 }
13223 /* Consume the final `;'. */
13228 /* This is the final expression statement of a statement
13229 expression. */
13235 }
13237 /* Parse a compound-statement.
13239 compound-statement:
13240 { statement-seq [opt] label-seq [opt] }
13242 label-seq:
13243 label
13244 label-seq label
13246 GNU extension:
13248 compound-statement:
13249 { label-declaration-seq [opt] statement-seq [opt] }
13251 label-declaration-seq:
13252 label-declaration
13253 label-declaration-seq label-declaration
13255 Returns a tree representing the statement. */
13257 static tree
13260 {
13261 tree compound_stmt;
13262 matching_braces braces;
13264 /* Consume the `{'. */
13271 /* Begin the compound-statement. */
13273 /* If the next keyword is `__label__' we have a label declaration. */
13276 /* Parse an (optional) statement-seq. */
13279 /* Consume the `}'. */
13282 /* Finish the compound-statement. */
13286 }
13288 /* Diagnose errors related to imperfectly nested loops in an OMP
13289 loop construct. This function is called when such code is seen.
13290 Only issue one such diagnostic no matter how much invalid
13291 intervening code there is in the loop.
13292 FIXME: maybe the location associated with the diagnostic should
13293 be the current parser token instead of the location of the outer loop
13294 nest. */
13296 static void
13298 {
13307 /* Only diagnose errors related to perfect nesting once. */
13309 {
13311 {
13313 "inner loops must be perfectly nested in "
13316 }
13318 {
13320 "inner loops must be perfectly nested with "
13323 }
13325 {
13327 "inner loops must be perfectly nested with "
13330 }
13331 /* TODO: Also reject loops with TILE directive. */
13334 }
13335 }
13337 /* Parse an (optional) statement-seq.
13339 statement-seq:
13340 statement
13341 statement-seq [opt] statement */
13343 static void
13345 {
13348 bool in_omp_loop_block
13351 /* Scan statements until there aren't any more. */
13353 {
13356 /* If we are looking at a `}', then we have run out of
13357 statements; the same is true if we have reached the end
13358 of file, or have stumbled upon a stray '@end'. */
13365 /* If we are in a compound statement and find 'else' then
13366 something went wrong. */
13368 {
13371 else
13372 {
13375 }
13376 }
13378 /* Handle special cases for OMP FOR canonical loop syntax. */
13380 {
13384 {
13385 /* Found the nested loop. */
13389 }
13391 {
13392 /* Prior to implementing the OpenMP 5.1 syntax for canonical
13393 loop form, GCC used to accept an empty statements as not
13394 being intervening code. Continue to do that, as an
13395 extension. */
13396 /* FIXME: Maybe issue a warning or something here? */
13398 }
13400 /* The nested compound statement may contain the next loop, or
13401 it might just be intervening code. */
13402 {
13406 }
13407 else
13408 {
13409 /* This must be intervening code. */
13411 /* Defer calling check_omp_intervening_code on pragmas until
13412 cp_parser_statement, because we can't know until we parse
13413 it whether or not the pragma is a statement. */
13418 }
13420 }
13422 /* Parse the statement. */
13424 }
13425 }
13427 /* Return true if this is the C++20 version of range-based-for with
13428 init-statement. */
13430 static bool
13432 {
13435 /* Save tokens so that we can put them back. */
13438 /* There has to be an unnested ; followed by an unnested :. */
13441 CPP_SEMICOLON,
13445 /* We found the semicolon, eat it now. */
13448 /* Now look for ':' that is not nested in () or {}. */
13451 CPP_COLON,
13454 out:
13455 /* Roll back the tokens we skipped. */
13459 }
13461 /* Return true if we're looking at (init; cond), false otherwise. */
13463 static bool
13465 {
13466 /* Save tokens so that we can put them back. */
13469 /* Look for ';' that is not nested in () or {}. */
13472 CPP_SEMICOLON,
13475 /* Roll back the tokens we skipped. */
13479 }
13481 /* Parse a selection-statement.
13483 selection-statement:
13484 if ( init-statement [opt] condition ) statement
13485 if ( init-statement [opt] condition ) statement else statement
13486 switch ( init-statement [opt] condition ) statement
13488 Returns the new IF_STMT or SWITCH_STMT.
13490 If IF_P is not NULL, *IF_P is set to indicate whether the statement
13491 is a (possibly labeled) if statement which is not enclosed in
13492 braces and has an else clause. This is used to implement
13493 -Wparentheses.
13495 CHAIN is a vector of if-else-if conditions. This is used to implement
13496 -Wduplicated-cond. */
13498 static tree
13501 {
13504 token_indent_info guard_tinfo;
13509 /* Peek at the next token. */
13513 /* See what kind of keyword it is. */
13516 {
13519 {
13520 tree statement;
13521 tree condition;
13526 RID_CONSTEXPR))
13527 {
13532 "%<if constexpr%> only available with "
13534 }
13537 {
13539 RID_CONSTEVAL))
13543 RID_CONSTEVAL))
13544 {
13547 }
13548 }
13550 {
13554 "%<if consteval%> only available with "
13565 {
13568 }
13574 {
13575 location_t before_loc
13581 }
13585 /* If the next token is `else', parse the else-clause. */
13587 RID_ELSE))
13588 {
13592 /* Consume the `else' keyword. */
13598 {
13602 }
13606 guard_tinfo);
13609 {
13610 location_t before_loc
13615 }
13618 }
13622 {
13626 }
13630 }
13632 /* Look for the `('. */
13633 matching_parens parens;
13635 {
13638 }
13640 /* Begin the selection-statement. */
13642 {
13645 }
13646 else
13649 /* Parse the optional init-statement. */
13651 {
13652 tree decl;
13655 OPT_Wc__17_extensions,
13656 "init-statement in selection statements only available "
13659 /* A non-empty init-statement can have arbitrary side
13660 effects. */
13663 }
13665 /* Parse the condition. */
13667 /* Look for the `)'. */
13673 {
13677 /* Add the condition. */
13684 /* Parse the then-clause. */
13688 /* Outside a template, the non-selected branch of a constexpr
13689 if is a 'discarded statement', i.e. unevaluated. */
13694 {
13697 }
13700 guard_tinfo);
13707 {
13711 }
13713 /* If the next token is `else', parse the else-clause. */
13715 RID_ELSE))
13716 {
13720 {
13723 }
13725 guard_tinfo
13727 /* Consume the `else' keyword. */
13730 {
13732 RID_IF)
13734 {
13735 /* We've got "if (COND) else if (COND2)". Start
13736 the condition chain and add COND as the first
13737 element. */
13741 {
13742 /* Wrap it in a NOP_EXPR so that we can set the
13743 location of the condition. */
13745 condition);
13748 }
13749 }
13751 RID_IF))
13752 /* This is if-else without subsequent if. Zap the
13753 condition chain; we would have already warned at
13754 this point. */
13756 }
13758 /* Parse the else-clause. */
13764 /* If we are currently parsing a then-clause, then
13765 IF_P will not be NULL. We set it to true to
13766 indicate that this if statement has an else clause.
13767 This may trigger the Wparentheses warning below
13768 when we get back up to the parent if statement. */
13773 {
13777 }
13778 }
13779 else
13780 {
13781 /* This if statement does not have an else clause. If
13782 NESTED_IF is true, then the then-clause has an if
13783 statement which does have an else clause. We warn
13784 about the potential ambiguity. */
13787 "suggest explicit braces to avoid ambiguous"
13790 /* We don't need the condition chain anymore. */
13792 }
13794 /* Now we're all done with the if-statement. */
13796 }
13797 else
13798 {
13802 /* Add the condition. */
13805 /* Parse the body of the switch-statement. */
13811 guard_tinfo);
13815 /* Now we're all done with the switch-statement. */
13817 }
13820 }
13826 }
13827 }
13829 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
13830 If we have seen at least one decl-specifier, and the next token is not
13831 a parenthesis (after "int (" we might be looking at a functional cast)
13832 neither we are dealing with a concept-check expression then we must be
13833 looking at a declaration. */
13835 static void
13838 {
13847 }
13849 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
13850 The declarator shall not specify a function or an array. Returns
13851 TRUE if the declarator is valid, FALSE otherwise. */
13853 static bool
13856 location_t loc)
13857 {
13861 {
13866 else
13874 }
13875 else
13877 }
13879 /* Parse a condition.
13881 condition:
13882 expression
13883 type-specifier-seq declarator = initializer-clause
13884 type-specifier-seq declarator braced-init-list
13886 GNU Extension:
13888 condition:
13889 type-specifier-seq declarator asm-specification [opt]
13890 attributes [opt] = assignment-expression
13892 Returns the expression that should be tested. */
13894 static tree
13896 {
13897 cp_decl_specifier_seq type_specifiers;
13901 /* Try the declaration first. */
13903 /* New types are not allowed in the type-specifier-seq for a
13904 condition. */
13906 parser->type_definition_forbidden_message
13908 /* Parse the type-specifier-seq. */
13910 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
13913 /* Restore the saved message. */
13916 /* Gather the attributes that were provided with the
13917 decl-specifiers. */
13922 /* If all is well, we might be looking at a declaration. */
13924 {
13925 tree decl;
13926 tree asm_specification;
13927 tree attributes;
13932 /* Parse the declarator. */
13934 CP_PARSER_FLAGS_NONE,
13940 /* Parse the attributes. */
13942 /* Parse the asm-specification. */
13944 /* If the next token is not an `=' or '{', then we might still be
13945 looking at an expression. For example:
13947 if (A(a).x)
13949 looks like a decl-specifier-seq and a declarator -- but then
13950 there is no `=', so this is an expression. */
13955 /* If we did see an `=' or '{', then we are looking at a declaration
13956 for sure. */
13958 {
13959 tree pushed_scope;
13966 /* Create the declaration. */
13973 /* Parse the initializer. */
13975 {
13979 }
13981 {
13982 /* Consume the `='. */
13986 }
13987 else
13988 {
13991 }
13995 /* Process the initializer. */
13998 asm_specification,
13999 flags);
14005 }
14006 }
14007 /* If we didn't even get past the declarator successfully, we are
14008 definitely not looking at a declaration. */
14009 else
14012 /* Otherwise, we are looking at an expression. */
14014 }
14016 /* Parses a for-statement or range-for-statement until the closing ')',
14017 not included. */
14019 static tree
14021 {
14025 /* Begin the for-statement. */
14028 /* Maybe parse the optional init-statement in a range-based for loop. */
14030 /* Checked for diagnostic purposes only. */
14032 {
14033 tree dummy;
14036 {
14038 OPT_Wc__20_extensions,
14039 "range-based %<for%> loops with initializer only "
14042 }
14043 }
14045 /* Parse the initialization. */
14051 else
14053 }
14055 static tree
14058 {
14059 /* Normal for loop */
14062 tree stmt;
14065 /* The init-statement has already been parsed in
14066 cp_parser_init_statement, so no work is needed here. */
14069 /* If there's a condition, process it. */
14073 {
14077 }
14079 {
14083 }
14085 /* Look for the `;'. */
14088 /* If there's an expression, process it. */
14094 }
14096 /* Tries to parse a range-based for-statement:
14098 range-based-for:
14099 decl-specifier-seq declarator : expression
14101 The decl-specifier-seq declarator and the `:' are already parsed by
14102 cp_parser_init_statement. If processing_template_decl it returns a
14103 newly created RANGE_FOR_STMT; if not, it is converted to a
14104 regular FOR_STMT. */
14106 static tree
14109 {
14115 /* Get the range declaration momentarily out of the way so that
14116 the range expression doesn't clash with it. */
14118 {
14120 {
14122 /* For decomposition declaration get all of the corresponding
14123 declarations out of the way. */
14127 {
14135 {
14141 }
14142 }
14143 }
14145 {
14150 }
14151 }
14155 else
14158 /* Put the range declaration(s) back into scope. */
14160 {
14164 }
14166 /* finish_omp_for has its own code for the following, so just
14167 return the range_expr instead. */
14171 /* If in template, STMT is converted to a normal for-statement
14172 at instantiation. If not, it is done just ahead. */
14174 {
14186 /* do_auto_deduction doesn't mess with template init-lists. */
14189 }
14190 else
14191 {
14195 }
14197 }
14199 /* Subroutine of cp_convert_range_for: given the initializer expression,
14200 builds up the range temporary. */
14202 static tree
14204 {
14205 /* Find out the type deduced by the declaration
14206 `auto &&__range = range_expr'. */
14211 /* Create the __range variable. */
14218 }
14220 /* Used by cp_parser_range_for in template context: we aren't going to
14221 do a full conversion yet, but we still need to resolve auto in the
14222 type of the for-range-declaration if present. This is basically
14223 a shortcut version of cp_convert_range_for. */
14225 static void
14227 {
14230 {
14233 iter_type = (cp_parser_perform_range_for_lookup
14236 {
14238 iter_type);
14241 tf_warning_or_error);
14244 tf_warning_or_error,
14245 adc_variable_type);
14248 }
14249 }
14250 }
14252 /* Warns when the loop variable should be changed to a reference type to
14253 avoid unnecessary copying. I.e., from
14255 for (const auto x : range)
14257 where range returns a reference, to
14259 for (const auto &x : range)
14261 if this version doesn't make a copy.
14263 This function also warns when the loop variable is initialized with
14264 a value of a different type resulting in a copy:
14266 int arr[10];
14267 for (const double &x : arr)
14269 DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
14270 This function is never called when processing_template_decl is on. */
14272 static void
14274 {
14286 {
14289 {
14290 auto_diagnostic_group d;
14292 "loop variable %qD of type %qT binds to a temporary "
14295 {
14297 TYPE_QUAL_CONST);
14302 }
14303 }
14305 }
14309 /* Since small trivially copyable types are cheap to copy, we suppress the
14310 warning for them. 64B is a common size of a cache line. */
14316 /* If we can initialize a reference directly, suggest that to avoid the
14317 copy. */
14320 {
14321 auto_diagnostic_group d;
14325 {
14329 }
14330 }
14331 }
14333 /* Converts a range-based for-statement into a normal
14334 for-statement, as per the definition.
14336 for (RANGE_DECL : RANGE_EXPR)
14337 BLOCK
14339 should be equivalent to:
14341 {
14342 auto &&__range = RANGE_EXPR;
14343 for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
14344 __begin != __end;
14345 ++__begin)
14346 {
14347 RANGE_DECL = *__begin;
14348 BLOCK
14349 }
14350 }
14352 If RANGE_EXPR is an array:
14353 BEGIN_EXPR = __range
14354 END_EXPR = __range + ARRAY_SIZE(__range)
14355 Else if RANGE_EXPR has a member 'begin' or 'end':
14356 BEGIN_EXPR = __range.begin()
14357 END_EXPR = __range.end()
14358 Else:
14359 BEGIN_EXPR = begin(__range)
14360 END_EXPR = end(__range);
14362 If __range has a member 'begin' but not 'end', or vice versa, we must
14363 still use the second alternative (it will surely fail, however).
14364 When calling begin()/end() in the third alternative we must use
14365 argument dependent lookup, but always considering 'std' as an associated
14366 namespace. */
14368 tree
14372 {
14380 /* If an error happened previously do nothing or else a lot of
14381 unhelpful errors would be issued. */
14383 else
14384 {
14385 tree range_temp;
14389 /* Can't bind a reference to an array of runtime bound. */
14391 else
14392 {
14397 LOOKUP_ONLYCONVERTING);
14399 }
14402 }
14404 /* The new for initialization statement. */
14406 iter_type);
14412 LOOKUP_ONLYCONVERTING);
14422 LOOKUP_ONLYCONVERTING);
14426 /* The new for condition. */
14433 /* The new increment expression. */
14436 tf_warning_or_error);
14439 /* The declaration is initialized with *__begin inside the loop body. */
14451 }
14453 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
14454 We need to solve both at the same time because the method used
14455 depends on the existence of members begin or end.
14456 Returns the type deduced for the iterator expression. */
14458 static tree
14460 {
14462 {
14465 }
14468 {
14473 }
14475 {
14476 /* If RANGE is an array, we will use pointer arithmetic. */
14479 range,
14483 }
14484 else
14485 {
14486 /* If it is not an array, we must do a bit of magic. */
14496 tf_warning_or_error);
14499 tf_warning_or_error);
14502 {
14503 /* Use the member functions. */
14506 }
14507 else
14508 {
14509 /* Use global functions with ADL. */
14510 releasing_vec vec;
14515 tf_warning_or_error);
14517 tf_warning_or_error);
14519 tf_warning_or_error);
14521 tf_warning_or_error);
14522 }
14524 /* Last common checks. */
14526 {
14527 /* If one of the expressions is an error do no more checks. */
14530 }
14533 /* Can happen, when, eg, in a template context, Koenig lookup
14534 can't resolve begin/end (c++/58503). */
14536 else
14537 {
14539 /* The unqualified type of the __begin and __end temporaries should
14540 be the same, as required by the multiple auto declaration. */
14542 {
14549 /* P0184R0 allows __begin and __end to have different types,
14550 but make sure they are comparable so we can give a better
14552 else
14556 }
14558 }
14559 }
14560 }
14562 /* Helper function for cp_parser_perform_range_for_lookup.
14563 Builds a tree for RANGE.IDENTIFIER(). */
14565 static tree
14567 {
14575 releasing_vec vec;
14579 tf_warning_or_error);
14581 }
14583 /* Parse an iteration-statement.
14585 iteration-statement:
14586 while ( condition ) statement
14587 do statement while ( expression ) ;
14588 for ( init-statement condition [opt] ; expression [opt] )
14589 statement
14591 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
14593 static tree
14596 {
14599 tree statement;
14601 token_indent_info guard_tinfo;
14603 /* Peek at the next token. */
14610 /* Remember whether or not we are already within an iteration
14611 statement. */
14614 /* Special case for OMP loop intervening code. Parsing of permitted
14615 collapsed loop nests is handled elsewhere. */
14617 {
14621 }
14623 /* See what kind of keyword it is. */
14626 {
14628 {
14629 tree condition;
14631 /* Begin the while-statement. */
14633 /* Look for the `('. */
14634 matching_parens parens;
14636 /* Parse the condition. */
14639 /* Look for the `)'. */
14641 /* Parse the dependent statement. */
14647 /* We're done with the while-statement. */
14649 }
14653 {
14654 tree expression;
14656 /* Begin the do-statement. */
14658 /* Parse the body of the do-statement. */
14665 /* Look for the `while' keyword. */
14667 /* Look for the `('. */
14668 matching_parens parens;
14670 /* Parse the expression. */
14672 /* We're done with the do-statement. */
14674 /* Look for the `)'. */
14676 /* Look for the `;'. */
14678 }
14682 {
14683 /* Look for the `('. */
14684 matching_parens parens;
14689 /* Look for the `)'. */
14692 /* Parse the body of the for-statement. */
14699 /* We're done with the for-statement. */
14701 }
14708 }
14711 }
14713 /* Parse an init-statement or the declarator of a range-based-for.
14714 Returns true if a range-based-for declaration is seen.
14716 init-statement:
14717 expression-statement
14718 simple-declaration
14719 alias-declaration */
14721 static bool
14723 {
14724 /* If the next token is a `;', then we have an empty
14725 expression-statement. Grammatically, this is also a
14726 simple-declaration, but an invalid one, because it does not
14727 declare anything. Therefore, if we did not handle this case
14728 specially, we would issue an error message about an invalid
14729 declaration. */
14731 {
14735 /* A colon is used in range-based for. */
14738 /* We're going to speculatively look for a declaration, falling back
14739 to an expression, if necessary. */
14743 {
14749 OPT_Wc__23_extensions,
14750 "alias-declaration in init-statement only "
14752 }
14753 else
14754 /* Parse the declaration. */
14757 decl);
14760 {
14761 /* It is a range-for, consume the ':'. */
14766 OPT_Wc__11_extensions,
14767 "range-based %<for%> loops only available with "
14769 }
14771 /* The ';' is not consumed yet because we told
14772 cp_parser_simple_declaration not to. */
14777 /* If the tentative parse failed, then we shall need to look for an
14778 expression-statement. */
14779 }
14780 /* If we are here, it is an expression-statement. */
14783 }
14785 /* Parse a jump-statement.
14787 jump-statement:
14788 break ;
14789 continue ;
14790 return expression [opt] ;
14791 return braced-init-list ;
14792 coroutine-return-statement;
14793 goto identifier ;
14795 GNU extension:
14797 jump-statement:
14798 goto * expression ;
14800 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
14802 static tree
14804 {
14810 /* Peek at the next token. */
14815 /* See what kind of keyword it is. */
14818 {
14822 {
14839 }
14845 {
14849 /* Fall through. */
14859 }
14865 {
14866 tree expr;
14869 {
14873 }
14876 else
14877 /* If the next token is a `;', then there is no
14878 expression. */
14880 /* Build the return-statement, check co-return first, since type
14881 deduction is not valid there. */
14886 else
14888 /* Look for the final `;'. */
14890 }
14897 {
14901 }
14903 /* Create the goto-statement. */
14905 {
14906 /* Issue a warning about this use of a GNU extension. */
14908 /* Consume the '*' token. */
14910 /* Parse the dependent expression. */
14912 }
14913 else
14915 /* Look for the final `;'. */
14922 }
14925 }
14927 /* Parse a declaration-statement.
14929 declaration-statement:
14930 block-declaration */
14932 static void
14934 {
14937 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14940 /* Parse the block-declaration. */
14943 /* Free any declarators allocated. */
14945 }
14947 /* Some dependent statements (like `if (cond) statement'), are
14948 implicitly in their own scope. In other words, if the statement is
14949 a single statement (as opposed to a compound-statement), it is
14950 none-the-less treated as if it were enclosed in braces. Any
14951 declarations appearing in the dependent statement are out of scope
14952 after control passes that point. This function parses a statement,
14953 but ensures that is in its own scope, even if it is not a
14954 compound-statement.
14956 If IF_P is not NULL, *IF_P is set to indicate whether the statement
14957 is a (possibly labeled) if statement which is not enclosed in
14958 braces and has an else clause. This is used to implement
14959 -Wparentheses.
14961 CHAIN is a vector of if-else-if conditions. This is used to implement
14962 -Wduplicated-cond.
14964 Returns the new statement. */
14966 static tree
14970 {
14971 tree statement;
14974 token_indent_info body_tinfo
14980 /* Mark if () ; with a special NOP_EXPR. */
14982 {
14993 }
14994 /* if a compound is opened, we simply parse the statement directly. */
14997 /* If the token is not a `{', then we must take special action. */
14998 else
14999 {
15000 /* Create a compound-statement. */
15002 /* Parse the dependent-statement. */
15005 /* Finish the dummy compound-statement. */
15007 }
15009 token_indent_info next_tinfo
15018 /* Return the statement. */
15020 }
15022 /* For some dependent statements (like `while (cond) statement'), we
15023 have already created a scope. Therefore, even if the dependent
15024 statement is a compound-statement, we do not want to create another
15025 scope. */
15027 static void
15030 {
15031 /* If the token is a `{', then we must take special action. */
15033 {
15034 token_indent_info body_tinfo
15040 token_indent_info next_tinfo
15049 }
15050 else
15051 {
15052 /* Avoid calling cp_parser_compound_statement, so that we
15053 don't create a new scope. Do everything else by hand. */
15054 matching_braces braces;
15056 /* If the next keyword is `__label__' we have a label declaration. */
15059 /* Parse an (optional) statement-seq. */
15062 }
15063 }
15065 /* Modules */
15067 /* Parse a module-name or module-partition.
15069 module-name:
15070 module-name-qualifier [opt] identifier
15072 module-partition:
15073 : module-name-qualifier [opt] identifier
15075 module-name-qualifier:
15076 identifier .
15077 module-name-qualifier identifier .
15079 Returns a pointer to the module object, or NULL on failure.
15080 For PARTITION_P, PARENT is the module this is a partition of. */
15085 {
15091 {
15093 {
15096 else
15099 }
15107 }
15110 }
15112 /* Parse a module-partition. Defers to cp_parser_module_name. */
15116 {
15118 }
15120 /* Named module-declaration
15121 __module ; PRAGMA_EOL
15122 __module : private ; PRAGMA_EOL (unimplemented)
15123 [__export] __module module-name module-partition [opt]
15124 attr-spec-seq-opt ; PRAGMA_EOL
15125 */
15127 static module_parse
15130 {
15131 /* We're a pseudo pragma. */
15136 {
15140 }
15143 {
15144 /* Start global module fragment. */
15149 }
15154 {
15162 {
15165 }
15166 else
15168 "private module fragment only permitted in purview"
15170 }
15172 {
15173 /* Neither the first declaration, nor in a GMF. */
15176 skip_eol:
15178 }
15179 else
15180 {
15193 }
15196 }
15198 /* Import-declaration
15199 __import module-name attr-spec-seq-opt ; PRAGMA_EOL
15200 __import module-partition attr-spec-seq-opt ; PRAGMA_EOL
15201 __import header-name attr-spec-seq-opt ; PRAGMA_EOL
15202 */
15204 static void
15207 {
15208 /* We're a pseudo pragma. */
15213 {
15216 note_lexer:
15218 " disambiguation, to prevent this being considered a"
15220 skip_eol:
15222 }
15224 {
15227 }
15228 else
15229 {
15233 {
15236 }
15238 {
15239 /* An import specifying a module-partition shall only appear after the
15240 module-declaration in a module unit: [module.import]/4. */
15245 else
15248 }
15249 else
15258 {
15259 /* Module-purview imports must not be from source inclusion
15260 [cpp.import]/7 */
15269 }
15272 }
15273 }
15275 /* export-declaration.
15277 export name-declaration
15278 export { declaration-seq-opt } */
15280 static void
15282 {
15301 {
15308 }
15309 else
15310 {
15311 /* Explicitly check if the next tokens might be a
15312 module-directive line, so we can give a clearer error message
15313 about why the directive will be rejected. */
15320 bool saved_in_unbraced_export_declaration_p
15324 parser->in_unbraced_export_declaration_p
15326 }
15329 }
15331 /* Declarations [gram.dcl.dcl] */
15333 /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
15334 is the top-level declaration sequence. That affects whether we
15335 deal with module-preamble.
15337 declaration-seq:
15338 declaration
15339 declaration-seq declaration */
15341 static void
15343 {
15345 {
15351 else
15353 }
15354 }
15356 /* Parse a declaration. The distinction between name-declaration
15357 and special-declaration is only since C++20.
15359 declaration:
15360 name-declaration
15361 special-declaration
15363 name-declaration:
15364 block-declaration
15365 nodeclspec-function-declaration
15366 function-definition
15367 template-declaration
15368 deduction-guide (C++17)
15369 linkage-specification
15370 namespace-definition
15371 empty-declaration
15372 attribute-declaration
15373 module-import-declaration (modules)
15375 special-declaration:
15376 explicit-instantiation
15377 explicit-specialization
15378 export-declaration (modules)
15380 GNU extension:
15382 declaration:
15383 __extension__ declaration */
15385 static void
15387 {
15390 /* Check for the `__extension__' keyword. */
15392 {
15393 /* Parse the qualified declaration. */
15395 /* Restore the PEDANTIC flag. */
15399 }
15401 /* P2615: Determine if we're parsing a name-declaration specifically,
15402 or if special-declarations are OK too. */
15403 bool require_name_decl_p
15408 /* Try to figure out what kind of declaration is present. */
15414 {
15416 /* A declaration consisting of a single semicolon is invalid
15417 * before C++11. Allow it unless we're being pedantic. */
15421 }
15425 CPP_SEMICOLON))
15426 {
15431 {
15434 std_attrs);
15436 {
15439 {
15441 CPP_PRAGMA));
15443 }
15445 }
15446 }
15454 }
15456 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
15461 /* Conditionally, allow attributes to precede a linkage specification. */
15463 {
15471 {
15473 /* We might have already been here. */
15475 {
15483 }
15486 }
15487 else
15488 {
15491 }
15492 }
15493 /* If we already had some attributes, and we've added more, then prepend.
15494 Otherwise attributes just contains any that we just read. */
15496 {
15500 }
15502 /* If the next token is `extern' and the following token is a string
15503 literal, then we have a linkage specification. */
15507 /* If the next token is `template', then we have either a template
15508 declaration, an explicit instantiation, or an explicit
15509 specialization. */
15511 {
15512 /* `template <>' indicates a template specialization. */
15515 {
15517 {
15518 auto_diagnostic_group d;
15525 }
15527 }
15528 /* `template <' indicates a template declaration. */
15531 /* Anything else must be an explicit instantiation. */
15532 else
15533 {
15538 }
15539 }
15540 /* If the next token is `export', it's new-style modules or
15541 old-style template. */
15543 {
15546 else
15547 {
15548 /* We check for nested exports in cp_parser_module_export. */
15554 }
15555 }
15557 {
15562 // In module purview this will be ill-formed.
15568 else
15570 }
15571 /* If the next token is `extern', 'static' or 'inline' and the one
15572 after that is `template', we have a GNU extended explicit
15573 instantiation directive. */
15580 /* If the next token is `namespace', check for a named or unnamed
15581 namespace definition. */
15590 /* An unnamed namespace definition. */
15594 /* An inline (associated) namespace definition. */
15598 /* Objective-C++ declaration/definition. */
15605 /* At this point we may have a template declared by a concept
15606 introduction. */
15611 else
15612 /* Try to parse a block-declaration, or a function-definition. */
15615 /* Free any declarators allocated. */
15617 }
15619 /* Parse a namespace-scope declaration. */
15621 static void
15623 {
15627 /* A top-level declaration can consist solely of a #pragma. A
15628 nested declaration cannot, so this is done here and not in
15629 cp_parser_declaration. (A #pragma at block scope is
15630 handled in cp_parser_statement.) */
15632 else
15633 /* Parse the declaration itself. */
15635 }
15637 /* Parse a block-declaration.
15639 block-declaration:
15640 simple-declaration
15641 asm-definition
15642 namespace-alias-definition
15643 using-declaration
15644 using-directive
15646 GNU Extension:
15648 block-declaration:
15649 __extension__ block-declaration
15651 C++0x Extension:
15653 block-declaration:
15654 static_assert-declaration
15656 If STATEMENT_P is TRUE, then this block-declaration is occurring as
15657 part of a declaration-statement. */
15659 static void
15662 {
15665 /* Check for the `__extension__' keyword. */
15667 {
15668 /* Parse the qualified declaration. */
15670 /* Restore the PEDANTIC flag. */
15674 }
15676 /* Peek at the next token to figure out which kind of declaration is
15677 present. */
15680 /* If the next keyword is `asm', we have an asm-definition. */
15682 {
15686 }
15687 /* If the next keyword is `namespace', we have a
15688 namespace-alias-definition. */
15691 /* If the next keyword is `using', we have a
15692 using-declaration, a using-directive, or an alias-declaration. */
15694 {
15699 /* If the token after `using' is `namespace', then we have a
15700 using-directive. */
15706 /* If the second token after 'using' is '=', then we have an
15707 alias-declaration. */
15713 /* Otherwise, it's a using-declaration. */
15714 else
15717 }
15718 /* If the next keyword is `__label__' we have a misplaced label
15719 declaration. */
15721 {
15725 /* If the next token is now a `;', consume it. */
15728 }
15729 /* If the next token is `static_assert' we have a static assertion. */
15732 else
15733 {
15738 /* If the next tokens after attributes is `using namespace', then we have
15739 a using-directive. */
15743 RID_NAMESPACE))
15744 {
15748 }
15749 /* If the next token after attributes is `asm', then we have
15750 an asm-definition. */
15752 {
15756 }
15757 /* Anything else must be a simple-declaration. */
15758 else
15761 }
15762 }
15764 /* Parse a simple-declaration.
15766 simple-declaration:
15767 decl-specifier-seq [opt] init-declarator-list [opt] ;
15768 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15769 brace-or-equal-initializer ;
15771 init-declarator-list:
15772 init-declarator
15773 init-declarator-list , init-declarator
15775 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
15776 function-definition as a simple-declaration.
15778 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15779 parsed declaration if it is an uninitialized single declarator not followed
15780 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15781 if present, will not be consumed. */
15783 static void
15787 {
15788 cp_decl_specifier_seq decl_specifiers;
15797 /* Defer access checks until we know what is being declared; the
15798 checks for names appearing in the decl-specifier-seq should be
15799 done as if we were in the scope of the thing being declared. */
15802 /* Parse the decl-specifier-seq. We have to keep track of whether
15803 or not the decl-specifier-seq declares a named class or
15804 enumeration type, since that is the only case in which the
15805 init-declarator-list is allowed to be empty.
15807 [dcl.dcl]
15809 In a simple-declaration, the optional init-declarator-list can be
15810 omitted only when declaring a class or enumeration, that is when
15811 the decl-specifier-seq contains either a class-specifier, an
15812 elaborated-type-specifier, or an enum-specifier. */
15814 CP_PARSER_FLAGS_OPTIONAL,
15817 /* We no longer need to defer access checks. */
15820 cp_omp_declare_simd_data odsd;
15826 /* In a block scope, a valid declaration must always have a
15827 decl-specifier-seq. By not trying to parse declarators, we can
15828 resolve the declaration/expression ambiguity more quickly. */
15831 {
15834 }
15836 /* If the next two tokens are both identifiers, the code is
15837 erroneous. The usual cause of this situation is code like:
15839 T t;
15841 where "T" should name a type -- but does not. */
15844 {
15845 /* If parsing tentatively, we should commit; we really are
15846 looking at a declaration. */
15848 /* Give up. */
15850 }
15854 /* Look for C++17 decomposition declaration. */
15862 {
15863 tree decl
15865 maybe_range_for_decl,
15868 /* The next token should be either a `,' or a `;'. */
15870 /* If it's a `;', we are done. */
15874 {
15878 }
15879 /* Anything else is an error. */
15880 else
15881 {
15882 /* If we have already issued an error message we don't need
15883 to issue another one. */
15888 /* Skip tokens until we reach the end of the statement. */
15890 /* If the next token is now a `;', consume it. */
15894 }
15895 }
15896 else
15899 tree last_type;
15901 /* NULL_TREE if both variable and function declaration are allowed,
15902 error_mark_node if function declaration are not allowed and
15903 a FUNCTION_DECL that should be diagnosed if it is followed by
15904 variable declarations. */
15905 tree auto_function_declaration;
15908 auto_specifier_p
15912 /* Keep going until we hit the `;' at the end of the simple
15913 declaration. */
15916 CPP_SEMICOLON))
15917 {
15920 tree decl;
15924 {
15925 /* If we are processing next declarator, comma is expected */
15930 {
15934 }
15935 }
15936 else
15939 /* Parse the init-declarator. */
15941 CP_PARSER_FLAGS_NONE,
15944 function_definition_allowed_p,
15946 declares_class_or_enum,
15948 maybe_range_for_decl,
15952 /* If an error occurred while parsing tentatively, exit quickly.
15953 (That usually happens when in the body of a function; each
15954 statement is treated as a declaration-statement until proven
15955 otherwise.) */
15960 {
15961 /* If the init-declarator-list contains more than one
15962 init-declarator, they shall all form declarations of
15963 variables. */
15967 {
15969 "non-variable %qD in declaration with more than one "
15973 }
15974 }
15978 {
15982 {
15983 /* If the list of declarators contains more than one declarator,
15984 the type of each declared variable is determined as described
15985 above. If the type deduced for the template parameter U is not
15986 the same in each deduction, the program is ill-formed. */
15991 }
15992 else
15994 }
15996 /* Handle function definitions specially. */
15998 {
15999 /* If the next token is a `,', then we are probably
16000 processing something like:
16002 void f() {}, *p;
16004 which is erroneous. */
16006 {
16009 "mixing"
16011 }
16012 /* Otherwise, we're done with the list of declarators. */
16013 else
16014 {
16018 }
16019 }
16022 /* The next token should be either a `,' or a `;'. */
16024 /* If it's a `,', there are more declarators to come. */
16027 /* If it's a `;', we are done. */
16031 {
16036 }
16037 /* Anything else is an error. */
16038 else
16039 {
16040 /* If we have already issued an error message we don't need
16041 to issue another one. */
16043 /* grokfndecl sets DECL_INITIAL to error_mark_node for
16044 functions. */
16048 /* Skip tokens until we reach the end of the statement. */
16050 /* If the next token is now a `;', consume it. */
16054 }
16055 /* After the first time around, a function-definition is not
16056 allowed -- even if it was OK at first. For example:
16058 int i, f() {}
16060 is not valid. */
16062 }
16064 /* Issue an error message if no declarators are present, and the
16065 decl-specifier-seq does not itself declare a class or
16066 enumeration: [dcl.dcl]/3. */
16068 {
16070 {
16074 /* Ensure an error is issued anyway when finish_decltype_type,
16075 called via cp_parser_decl_specifier_seq, returns a class or
16076 an enumeration (c++/51786). */
16079 }
16080 /* Perform any deferred access checks. */
16082 }
16084 /* Consume the `;'. */
16085 finish:
16089 {
16095 }
16097 done:
16100 }
16102 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
16103 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
16104 initializer ; */
16106 static tree
16111 {
16116 /* Parse the identifier-list. */
16123 {
16129 {
16131 {
16133 OPT_Wc__26_extensions,
16134 "structured bindings with attributed identifiers "
16135 "only available with %<-std=c++2c%> or "
16138 }
16144 }
16152 }
16156 {
16162 else
16163 {
16166 }
16167 }
16171 "structured bindings only available with "
16174 tree pushed_scope;
16181 NULL_TREE);
16188 cp_expr e;
16189 cp_decl_specifier_seq decl_specs;
16196 {
16200 else
16201 {
16204 }
16205 tree elt_pushed_scope;
16214 {
16215 /* Ensure we've diagnosed redeclaration if we aren't creating
16216 a new VAR_DECL. */
16219 }
16220 else
16224 }
16227 {
16230 }
16234 {
16242 || (is_direct_init
16245 {
16249 }
16252 {
16258 }
16259 }
16261 {
16264 /* Ensure DECL_VALUE_EXPR is created for all the decls but
16265 the underlying DECL. */
16267 }
16273 {
16276 }
16279 }
16281 /* Names of storage classes. */
16284 cp_storage_class_name[] = {
16286 };
16288 /* Parse a decl-specifier-seq.
16290 decl-specifier-seq:
16291 decl-specifier-seq [opt] decl-specifier
16292 decl-specifier attribute-specifier-seq [opt] (C++11)
16294 decl-specifier:
16295 storage-class-specifier
16296 type-specifier
16297 function-specifier
16298 friend
16299 typedef
16301 GNU Extension:
16303 decl-specifier:
16304 attributes
16306 Concepts Extension:
16308 decl-specifier:
16309 concept
16311 Set *DECL_SPECS to a representation of the decl-specifier-seq.
16313 The parser flags FLAGS is used to control type-specifier parsing.
16315 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
16316 flags:
16318 1: one of the decl-specifiers is an elaborated-type-specifier
16319 (i.e., a type declaration)
16320 2: one of the decl-specifiers is an enum-specifier or a
16321 class-specifier (i.e., a type definition)
16323 */
16325 static void
16327 cp_parser_flags flags,
16330 {
16334 cp_decl_spec ds;
16336 /* Clear DECL_SPECS. */
16339 /* Assume no class or enumeration type is declared. */
16342 /* Keep a token that additionally will be used for diagnostics. */
16344 /* Keep reading specifiers until there are no more to read. */
16346 {
16351 /* Peek at the next token. */
16354 /* Save the first token of the decl spec list for error
16355 reporting. */
16358 /* Handle attributes. */
16361 {
16362 /* Parse the attributes. */
16365 /* In a sequence of declaration specifiers, c++11 attributes
16366 appertain to the type that precede them. In that case
16367 [dcl.spec]/1 says:
16369 The attribute-specifier-seq affects the type only for
16370 the declaration it appears in, not other declarations
16371 involving the same type.
16373 But for now let's force the user to position the
16374 attribute either at the beginning of the declaration or
16375 after the declarator-id, which would clearly mean that it
16376 applies to the declarator. */
16378 {
16380 /* The c++11 attribute is at the beginning of the
16381 declaration. It appertains to the entity being
16383 else
16384 {
16386 {
16389 }
16391 {
16392 /* This is an attribute following a
16393 class-specifier. */
16398 }
16399 else
16400 {
16401 decl_specs->std_attributes
16405 }
16407 }
16408 }
16410 decl_specs->attributes
16415 }
16416 /* We know by this point that the token is not part of an attribute. */
16419 /* Special case for "this" specifier, indicating a parm is an xobj parm.
16420 The "this" specifier must be the first specifier in the declaration,
16421 after any attributes. */
16423 {
16426 {
16427 /* Don't emit diagnostics if we have already seen "this",
16428 leave it for set_and_check_decl_spec_loc. */
16430 {
16431 auto_diagnostic_group d;
16433 /* Works, need to add tests for it though. */
16438 "%<this%> must be the first specifier "
16440 }
16441 }
16444 }
16446 /* Assume we will find a decl-specifier keyword. */
16448 /* If the next token is an appropriate keyword, we can simply
16449 add it to the list. */
16451 {
16452 /* decl-specifier:
16453 friend
16454 constexpr
16455 constinit */
16458 {
16463 }
16464 else
16465 {
16467 /* Consume the token. */
16469 }
16494 /* Warn for concept as a decl-specifier. We'll rewrite these as
16495 concept declarations later. */
16497 {
16502 else
16505 }
16507 /* In C++20 a concept definition is just 'concept name = expr;'
16508 Support that syntax as a TS extension by pretending we've seen
16509 the 'bool' specifier. */
16513 {
16517 }
16520 /* function-specifier:
16521 inline
16522 virtual
16523 explicit */
16530 /* decl-specifier:
16531 typedef */
16534 /* Consume the token. */
16540 /* A constructor declarator cannot appear in a typedef. */
16542 /* The "typedef" keyword can only occur in a declaration; we
16543 may as well commit at this point. */
16547 {
16557 }
16560 /* storage-class-specifier:
16561 auto
16562 register
16563 static
16564 extern
16565 mutable
16567 GNU Extension:
16568 thread */
16571 {
16572 /* Consume the token. */
16575 /* Complain about `auto' as a storage specifier, if
16576 we're complaining about C++0x compatibility. */
16580 "%<auto%> changes meaning in C++11; "
16583 /* Set the storage class anyway. */
16585 token);
16586 }
16587 else
16588 /* C++0x auto type-specifier. */
16596 /* Consume the token. */
16599 token);
16602 /* Consume the token. */
16608 /* We did not yet find a decl-specifier yet. */
16611 }
16623 {
16629 "%qD only valid in lambda with %<-std=c++23%> or "
16631 }
16636 /* Constructors are a special case. The `S' in `S()' is not a
16637 decl-specifier; it is the beginning of the declarator. */
16638 constructor_p
16639 = (!found_decl_spec
16640 && constructor_possible_p
16641 && (cp_parser_constructor_declarator_p
16643 ds_friend))));
16645 /* If we don't have a DECL_SPEC yet, then we must be looking at
16646 a type-specifier. */
16648 {
16651 tree type_spec;
16656 type_spec
16658 decl_specs,
16664 /* If this type-specifier referenced a user-defined type
16665 (a typedef, class-name, etc.), then we can't allow any
16666 more such type-specifiers henceforth.
16668 [dcl.spec]
16670 The longest sequence of decl-specifiers that could
16671 possibly be a type name is taken as the
16672 decl-specifier-seq of a declaration. The sequence shall
16673 be self-consistent as described below.
16675 [dcl.type]
16677 As a general rule, at most one type-specifier is allowed
16678 in the complete decl-specifier-seq of a declaration. The
16679 only exceptions are the following:
16681 -- const or volatile can be combined with any other
16682 type-specifier.
16684 -- signed or unsigned can be combined with char, long,
16685 short, or int.
16687 -- ..
16689 Example:
16691 typedef char* Pc;
16692 void g (const int Pc);
16694 Here, Pc is *not* part of the decl-specifier seq; it's
16695 the declarator. Therefore, once we see a type-specifier
16696 (other than a cv-qualifier), we forbid any additional
16697 user-defined types. We *do* still allow things like `int
16698 int' to be considered a decl-specifier-seq, and issue the
16699 error message later. */
16702 /* A constructor declarator cannot follow a type-specifier. */
16704 {
16712 }
16713 }
16715 /* If we still do not have a DECL_SPEC, then there are no more
16716 decl-specifiers. */
16721 {
16725 "standard attributes must precede the decl-specifiers to "
16726 "apply to the declaration, or follow them to apply to "
16728 }
16731 /* After we see one decl-specifier, further decl-specifiers are
16732 always optional. */
16734 }
16736 /* Don't allow a friend specifier with a class definition. */
16741 }
16743 /* Parse an (optional) storage-class-specifier.
16745 storage-class-specifier:
16746 auto
16747 register
16748 static
16749 extern
16750 mutable
16752 GNU Extension:
16754 storage-class-specifier:
16755 thread
16757 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
16759 static tree
16761 {
16763 {
16767 /* Fall through for C++98. */
16775 /* Consume the token. */
16780 }
16781 }
16783 /* Parse an (optional) function-specifier.
16785 function-specifier:
16786 inline
16787 virtual
16788 explicit
16790 C++20 Extension:
16791 explicit(constant-expression)
16793 Returns an IDENTIFIER_NODE corresponding to the keyword used.
16794 Updates DECL_SPECS, if it is non-NULL. */
16796 static tree
16799 {
16802 {
16808 /* 14.5.2.3 [temp.mem]
16810 A member function template shall not be virtual. */
16814 else
16819 {
16821 /* If we see '(', it's C++20 explicit(bool). */
16822 tree expr;
16824 {
16825 matching_parens parens;
16828 /* New types are not allowed in an explicit-specifier. */
16831 parser->type_definition_forbidden_message
16836 "%<explicit(bool)%> only available with %<-std=c++20%> "
16839 /* Parse the constant-expression. */
16842 /* Restore the saved message. */
16845 }
16846 else
16847 /* The explicit-specifier explicit without a constant-expression is
16848 equivalent to the explicit-specifier explicit(true). */
16851 /* [dcl.fct.spec]
16852 "the constant-expression, if supplied, shall be a contextually
16853 converted constant expression of type bool." */
16855 /* We could evaluate it -- mark the decl as appropriate. */
16861 /* The expression was value-dependent. Remember it so that we can
16862 substitute it later. */
16865 }
16869 }
16871 /* Consume the token. */
16873 }
16875 /* Parse a linkage-specification.
16877 linkage-specification:
16878 extern string-literal { declaration-seq [opt] }
16879 extern string-literal name-declaration */
16881 static void
16883 {
16884 /* Look for the `extern' keyword. */
16885 cp_token *extern_token
16888 /* Look for the string-literal. */
16890 tree linkage;
16893 else
16897 /* Transform the literal into an identifier. If the literal is a
16898 wide-character string, or contains embedded NULs, then we can't
16899 handle it as the user wants. */
16903 {
16905 /* Assume C++ linkage. */
16907 }
16908 else
16911 /* We're now using the new linkage. */
16916 /* Preserve the location of the innermost linkage specification,
16917 tracking the locations of nested specifications via a local. */
16918 location_t saved_location
16920 /* Construct a location ranging from the start of the "extern" to
16921 the end of the string-literal, with the caret at the start, e.g.:
16922 extern "C" {
16923 ^~~~~~~~~~
16924 */
16925 parser->innermost_linkage_specification_location
16930 /* If the next token is a `{', then we're using the first
16931 production. */
16933 {
16937 /* Consume the `{' token. */
16938 matching_braces braces;
16940 /* Parse the declarations. */
16942 /* Look for the closing `}'. */
16944 }
16945 /* Otherwise, there's just one declaration. */
16946 else
16947 {
16950 saved_in_unbraced_linkage_specification_p
16954 parser->in_unbraced_linkage_specification_p
16956 }
16958 /* We're done with the linkage-specification. */
16962 /* Restore location of parent linkage specification, if any. */
16964 }
16966 /* Parse a static_assert-declaration.
16968 static_assert-declaration:
16969 static_assert ( constant-expression , string-literal ) ;
16970 static_assert ( constant-expression ) ; (C++17)
16971 static_assert ( constant-expression, conditional-expression ) ; (C++26)
16973 If MEMBER_P, this static_assert is a class member. */
16975 static void
16977 {
16978 cp_expr condition;
16979 location_t token_loc;
16980 tree message;
16982 /* Peek at the `static_assert' token so we can keep track of exactly
16983 where the static assertion started. */
16986 /* Look for the `static_assert' keyword. */
16988 RT_STATIC_ASSERT))
16991 /* We know we are in a static assertion; commit to any tentative
16992 parse. */
16996 /* Parse the `(' starting the static assertion condition. */
16997 matching_parens parens;
17000 /* Parse the constant-expression. Allow a non-constant expression
17001 here in order to give better diagnostics in finish_static_assert. */
17002 condition
17008 {
17011 "%<static_assert%> without a message "
17013 /* Eat the ')' */
17018 }
17019 else
17020 {
17021 /* Parse the separating `,'. */
17024 /* Parse the message expression. */
17027 {
17035 }
17037 {
17041 "%<static_assert%> with non-string message only "
17047 message);
17048 }
17051 else
17055 /* A `)' completes the static assertion. */
17061 }
17063 /* A semicolon terminates the declaration. */
17066 /* Get the location for the static assertion. Use that of the
17067 condition if available, otherwise, use that of the "static_assert"
17068 token. */
17073 /* Complete the static assertion, which may mean either processing
17074 the static assert now or saving it for template instantiation. */
17077 }
17079 /* Parse the expression in decltype ( expression ). */
17081 static tree
17084 {
17086 tree expr;
17088 /* First, try parsing an id-expression. */
17099 {
17102 cp_id_kind idk;
17106 /* Lookup the name we got back from the id-expression. */
17116 {
17117 /* Complete lookup of the id-expression. */
17118 expr = (finish_id_expression
17131 {
17132 /* We found an id-expression, but it was something that we
17133 should not have found. This is an error, not something
17134 we can recover from, so report the error we found and
17135 we'll recover as gracefully as possible. */
17140 }
17141 }
17146 /* We have an id-expression. */
17148 }
17151 {
17152 /* Abort the id-expression parse. */
17155 /* Parsing tentatively, again. */
17158 /* Parse a class member access. */
17166 /* We have an id-expression. */
17168 }
17171 /* We have parsed the complete id-expression or member access. */
17173 else
17174 {
17175 /* Abort our attempt to parse an id-expression or member access
17176 expression. */
17179 /* Parse a full expression. */
17182 }
17185 }
17187 /* Parse a `decltype' type. Returns the type.
17189 decltype-specifier:
17190 decltype ( expression )
17191 C++14:
17192 decltype ( auto ) */
17194 static tree
17196 {
17201 {
17202 /* Already parsed. */
17205 }
17207 /* Look for the `decltype' token. */
17211 /* Parse the opening `('. */
17212 matching_parens parens;
17216 /* Since we're going to preserve any side-effects from this parse, set up a
17217 firewall to protect our callers from cp_parser_commit_to_tentative_parse
17218 in the expression. */
17221 /* If in_declarator_p, a reparse as an expression might succeed (60361).
17222 Otherwise, commit now for better diagnostics. */
17233 {
17234 /* decltype (auto) */
17237 {
17239 "%<decltype(auto)%> type specifier only available with "
17242 }
17243 }
17244 else
17245 {
17246 /* decltype (expression) */
17248 /* Types cannot be defined in a `decltype' expression. Save away the
17249 old message and set the new one. */
17251 parser->type_definition_forbidden_message
17254 /* The restrictions on constant-expressions do not apply inside
17255 decltype expressions. */
17256 bool saved_integral_constant_expression_p
17258 bool saved_non_integral_constant_expression_p
17262 /* Within a parenthesized expression, a `>' token is always
17263 the greater-than operator. */
17264 bool saved_greater_than_is_operator_p
17268 /* Don't synthesize an implicit template type parameter here. This
17269 could happen with C++23 code like
17271 void f(decltype(new auto{0}));
17273 where we want to deduce the auto right away so that the parameter
17274 is of type 'int *'. */
17278 /* Do not actually evaluate the expression. */
17281 /* Do not warn about problems with the expression. */
17287 /* Go back to evaluating expressions. */
17291 /* The `>' token might be the end of a template-id or
17292 template-parameter-list now. */
17293 parser->greater_than_is_operator_p
17296 /* Restore the old message and the integral constant expression
17297 flags. */
17299 parser->integral_constant_expression_p
17301 parser->non_integral_constant_expression_p
17303 }
17305 /* Parse to the closing `)'. */
17307 {
17311 }
17313 /* If we got a parse error while tentative, bail out now. */
17315 {
17318 }
17321 /* Build auto. */
17323 else
17325 tf_warning_or_error);
17327 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
17328 it again. */
17345 }
17347 /* Special member functions [gram.special] */
17349 /* Parse a conversion-function-id.
17351 conversion-function-id:
17352 operator conversion-type-id
17354 Returns an IDENTIFIER_NODE representing the operator. */
17356 static tree
17358 {
17359 tree type;
17360 tree saved_scope;
17361 tree saved_qualifying_scope;
17362 tree saved_object_scope;
17365 /* Look for the `operator' token. */
17368 /* When we parse the conversion-type-id, the current scope will be
17369 reset. However, we need that information in able to look up the
17370 conversion function later, so we save it here. */
17374 /* We must enter the scope of the class so that the names of
17375 entities declared within the class are available in the
17376 conversion-type-id. For example, consider:
17378 struct S {
17379 typedef int I;
17380 operator I();
17381 };
17383 S::operator I() { ... }
17385 In order to see that `I' is a type-name in the definition, we
17386 must be in the scope of `S'. */
17389 /* Parse the conversion-type-id. */
17391 /* Leave the scope of the class, if any. */
17394 /* Restore the saved scope. */
17398 /* If the TYPE is invalid, indicate failure. */
17402 }
17404 /* Parse a conversion-type-id:
17406 conversion-type-id:
17407 type-specifier-seq conversion-declarator [opt]
17409 Returns the TYPE specified. */
17411 static tree
17413 {
17414 tree attributes;
17415 cp_decl_specifier_seq type_specifiers;
17417 tree type_specified;
17420 /* Parse the attributes. */
17424 parser->type_definition_forbidden_message
17427 /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
17428 optional in conversion-type-id. */
17436 /* If that didn't work, stop. */
17439 /* Parse the conversion-declarator. */
17447 /* Don't give this error when parsing tentatively. This happens to
17448 work because we always parse this definitively once. */
17451 {
17453 {
17456 }
17460 }
17463 }
17465 /* Parse an (optional) conversion-declarator.
17467 conversion-declarator:
17468 ptr-operator conversion-declarator [opt]
17470 */
17474 {
17477 cp_cv_quals cv_quals;
17479 /* We don't know if there's a ptr-operator next, or not. */
17481 /* Try the ptr-operator. */
17484 /* If it worked, look for more conversion-declarators. */
17486 {
17489 /* Parse another optional declarator. */
17492 declarator = cp_parser_make_indirect_declarator
17496 }
17499 }
17501 /* Parse an (optional) ctor-initializer.
17503 ctor-initializer:
17504 : mem-initializer-list */
17506 static void
17508 {
17509 /* If the next token is not a `:', then there is no
17510 ctor-initializer. */
17512 {
17513 /* Do default initialization of any bases and members. */
17517 }
17519 /* Consume the `:' token. */
17521 /* And the mem-initializer-list. */
17523 }
17525 /* Parse a mem-initializer-list.
17527 mem-initializer-list:
17528 mem-initializer ... [opt]
17529 mem-initializer ... [opt] , mem-initializer-list */
17531 static void
17533 {
17538 /* Let the semantic analysis code know that we are starting the
17539 mem-initializer-list. */
17544 /* Loop through the list. */
17546 {
17547 tree mem_initializer;
17550 /* Parse the mem-initializer. */
17552 /* If the next token is a `...', we're expanding member initializers. */
17558 {
17559 /* Consume the `...'. */
17563 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
17564 can be expanded but members cannot. */
17567 {
17572 }
17574 /* Construct the pack expansion type. */
17577 }
17580 {
17584 }
17585 /* Look for a target constructor. */
17589 {
17592 {
17596 }
17598 }
17599 /* Add it to the list, unless it was erroneous. */
17601 {
17604 }
17605 /* If the next token is not a `,', we're done. */
17608 /* Consume the `,' token. */
17610 }
17612 /* Perform semantic analysis. */
17615 }
17617 /* Parse a mem-initializer.
17619 mem-initializer:
17620 mem-initializer-id ( expression-list [opt] )
17621 mem-initializer-id braced-init-list
17623 GNU extension:
17625 mem-initializer:
17626 ( expression-list [opt] )
17628 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
17629 class) or FIELD_DECL (for a non-static data member) to initialize;
17630 the TREE_VALUE is the expression-list. An empty initialization
17631 list is represented by void_list_node. */
17633 static tree
17635 {
17636 tree mem_initializer_id;
17637 tree expression_list;
17638 tree member;
17641 /* Find out what is being initialized. */
17643 {
17647 }
17648 else
17649 {
17653 }
17659 {
17665 }
17666 else
17667 {
17679 }
17692 /* We can't attach the source location of this initializer directly to
17693 the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
17694 within the TREE_TYPE of the list node. */
17695 location_t loc
17702 }
17704 /* Parse a mem-initializer-id.
17706 mem-initializer-id:
17707 :: [opt] nested-name-specifier [opt] class-name
17708 decltype-specifier (C++11)
17709 identifier
17711 Returns a TYPE indicating the class to be initialized for the first
17712 production (and the second in C++11). Returns an IDENTIFIER_NODE
17713 indicating the data member to be initialized for the last production. */
17715 static tree
17717 {
17721 tree id;
17725 /* `typename' is not allowed in this context ([temp.res]). */
17727 {
17729 "keyword %<typename%> not allowed in this context (a qualified "
17732 }
17733 /* Look for the optional `::' operator. */
17734 global_scope_p
17738 /* Look for the optional nested-name-specifier. The simplest way to
17739 implement:
17741 [temp.res]
17743 The keyword `typename' is not permitted in a base-specifier or
17744 mem-initializer; in these contexts a qualified name that
17745 depends on a template-parameter is implicitly assumed to be a
17746 type name.
17748 is to assume that we have seen the `typename' keyword at this
17749 point. */
17750 nested_name_specifier_p
17759 /* If there is a `::' operator or a nested-name-specifier, then we
17760 are definitely looking for a class-name. */
17765 typename_type,
17769 /* Otherwise, we could also be looking for an ordinary identifier. */
17772 /* Try a decltype-specifier. */
17774 else
17775 /* Otherwise, try a class-name. */
17779 none_type,
17783 /* If we found one, we're done. */
17786 /* Otherwise, look for an ordinary identifier. */
17788 }
17790 /* Overloading [gram.over] */
17792 /* Parse an operator-function-id.
17794 operator-function-id:
17795 operator operator
17797 Returns an IDENTIFIER_NODE for the operator which is a
17798 human-readable spelling of the identifier, e.g., `operator +'. */
17800 static cp_expr
17802 {
17804 /* Look for the `operator' keyword. */
17807 /* And then the name of the operator itself. */
17809 }
17811 /* Return an identifier node for a user-defined literal operator.
17812 The suffix identifier is chained to the operator name identifier. */
17814 tree
17816 {
17817 tree identifier;
17825 }
17827 /* Parse an operator.
17829 operator:
17830 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
17831 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
17832 || ++ -- , ->* -> () []
17834 GNU Extensions:
17836 operator:
17837 <? >? <?= >?=
17839 Returns an IDENTIFIER_NODE for the operator which is a
17840 human-readable spelling of the identifier, e.g., `operator +'. */
17842 static cp_expr
17844 {
17849 /* Peek at the next token. */
17854 /* Figure out which operator we have. */
17859 {
17861 {
17862 /* The keyword should be either `new', `delete' or `co_await'. */
17869 else
17872 /* Consume the `new', `delete' or co_await token. */
17875 /* Peek at the next token. */
17877 /* If it's a `[' token then this is the array variant of the
17878 operator. */
17881 {
17882 /* Consume the `[' token. */
17884 /* Look for the `]' token. */
17889 }
17892 }
18055 /* Consume the `?'. */
18057 /* Look for the matching `:'. */
18063 {
18064 /* Consume the `('. */
18065 matching_parens parens;
18067 /* Look for the matching `)'. */
18074 }
18077 /* Consume the `['. */
18079 /* Look for the matching `]'. */
18090 /* FALLTHRU */
18099 {
18100 tree string_tree;
18106 /* Consume the string. */
18112 {
18116 }
18117 else
18118 {
18120 /* Look for the suffix identifier. */
18123 {
18126 }
18128 {
18132 }
18133 else
18134 {
18137 }
18138 }
18143 {
18146 }
18149 {
18152 }
18154 {
18157 }
18158 /* Generate a location of the form:
18159 "" _suffix_identifier
18160 ^~~~~~~~~~~~~~~~~~~~~
18161 with caret == start at the start token, finish at the end of the
18162 suffix identifier. */
18163 location_t combined_loc
18166 }
18169 /* Anything else is an error. */
18171 }
18173 /* If we have selected an identifier, we need to consume the
18174 operator token. */
18176 {
18180 }
18181 /* Otherwise, no valid operator name was present. */
18182 else
18183 {
18186 }
18190 }
18192 /* Parse a template-declaration.
18194 template-declaration:
18195 export [opt] template < template-parameter-list > declaration
18197 If MEMBER_P is TRUE, this template-declaration occurs within a
18198 class-specifier.
18200 The grammar rule given by the standard isn't correct. What
18201 is really meant is:
18203 template-declaration:
18204 export [opt] template-parameter-list-seq
18205 decl-specifier-seq [opt] init-declarator [opt] ;
18206 export [opt] template-parameter-list-seq
18207 function-definition
18209 template-parameter-list-seq:
18210 template-parameter-list-seq [opt]
18211 template < template-parameter-list >
18213 Concept Extensions:
18215 template-parameter-list-seq:
18216 template < template-parameter-list > requires-clause [opt]
18218 requires-clause:
18219 requires logical-or-expression */
18221 static void
18223 {
18224 /* Check for `export'. */
18226 {
18227 /* Consume the `export' token. */
18229 /* Warn that this use of export is deprecated. */
18234 else
18236 }
18239 }
18241 /* Parse a template-parameter-list.
18243 template-parameter-list:
18244 template-parameter
18245 template-parameter-list , template-parameter
18247 Returns a TREE_LIST. Each node represents a template parameter.
18248 The nodes are connected via their TREE_CHAINs. */
18250 static tree
18252 {
18255 /* Don't create wrapper nodes within a template-parameter-list,
18256 since we don't want to have different types based on the
18257 spelling location of constants and decls within them. */
18258 auto_suppress_location_wrappers sentinel;
18262 /* The loop below parses the template parms. We first need to know
18263 the total number of template parms to be able to compute proper
18264 canonical types of each dependent type. So after the loop, when
18265 we know the total number of template parms,
18266 end_template_parm_list computes the proper canonical types and
18267 fixes up the dependent types accordingly. */
18269 {
18270 tree parameter;
18273 location_t parm_loc;
18275 /* Parse the template-parameter. */
18280 /* Add it to the list. */
18283 parm_loc,
18284 parameter,
18285 is_non_type,
18286 is_parameter_pack);
18287 else
18288 {
18291 }
18293 /* If the next token is not a `,', we're done. */
18296 /* Otherwise, consume the `,' token. */
18298 }
18301 }
18303 /* Parse a introduction-list.
18305 introduction-list:
18306 introduced-parameter
18307 introduction-list , introduced-parameter
18309 introduced-parameter:
18310 ...[opt] identifier
18312 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
18313 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
18314 WILDCARD_DECL will also have DECL_NAME set and token location in
18315 DECL_SOURCE_LOCATION. */
18317 static tree
18319 {
18323 {
18332 /* Build placeholder. */
18340 /* If the next token is not a `,', we're done. */
18343 /* Otherwise, consume the `,' token. */
18345 }
18347 /* Convert the vec into a TREE_VEC. */
18350 tree parm;
18356 }
18358 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
18359 is an abstract declarator. */
18363 {
18368 }
18370 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
18371 is an abstract declarator. */
18375 {
18379 else
18381 }
18383 /* Returns true if TYPE would declare a constrained constrained-parameter. */
18387 {
18392 }
18394 /* Returns true if PARM declares a constrained-parameter. */
18398 {
18400 }
18402 /* Check that the type parameter is only a declarator-id, and that its
18403 type is not cv-qualified. */
18405 bool
18408 {
18413 {
18416 }
18418 /* Don't allow cv-qualified type parameters. */
18421 {
18424 }
18427 }
18429 /* Finish parsing/processing a template type parameter and checking
18430 various restrictions. */
18434 tree id,
18436 {
18439 else
18441 }
18443 static tree
18445 {
18446 /* FIXME: This should probably be copied, and we may need to adjust
18447 the template parameter depths. */
18457 }
18459 /* Finish parsing/processing a template template parameter by borrowing
18460 the template parameter list from the prototype parameter. */
18462 static tree
18464 tree proto,
18465 tree id,
18467 {
18471 }
18473 /* Create a new non-type template parameter from the given PARM
18474 declarator. */
18476 static tree
18479 {
18485 }
18487 /* Build a constrained template parameter based on the PARMDECL
18488 declarator. The type of PARMDECL is the constrained type, which
18489 refers to the prototype template parameter that ultimately
18490 specifies the type of the declared parameter. */
18492 static tree
18496 {
18502 /* Build the parameter. Return an error if the declarator was invalid. */
18503 tree parm;
18508 parmdecl);
18509 else
18514 /* Finish the parameter decl and create a node attaching the
18515 default argument and constraint. */
18520 }
18522 /* Returns true if the parsed type actually represents the declaration
18523 of a type template-parameter. */
18525 static bool
18527 {
18530 }
18532 /* Returns true if the parsed type actually represents the declaration of
18533 a template template-parameter. */
18535 static bool
18537 {
18540 }
18542 /* Parse a default argument for a type template-parameter.
18543 Note that diagnostics are handled in cp_parser_template_parameter. */
18545 static tree
18547 {
18550 /* Consume the `=' token. */
18555 /* Tell cp_parser_lambda_expression this is a default argument. */
18559 /* Parse the default-argument. */
18562 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18563 NULL);
18567 {
18571 }
18574 }
18576 /* Parse a default argument for a template template-parameter. */
18578 static tree
18580 {
18585 /* Consume the `='. */
18587 /* Parse the id-expression. */
18589 /* save token before parsing the id-expression, for error
18590 reporting */
18592 tree default_argument
18600 /* If the id-expression was a template-id that refers to
18601 a template-class, we already have the declaration here,
18602 so no further lookup is needed. */
18603 ;
18604 else
18605 /* Look up the name. */
18606 default_argument
18608 none_type,
18614 /* See if the default argument is valid. */
18618 }
18620 /* Parse a template-parameter.
18622 template-parameter:
18623 type-parameter
18624 parameter-declaration
18626 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
18627 the parameter. The TREE_PURPOSE is the default value, if any.
18628 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
18629 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
18630 set to true iff this parameter is a parameter pack. */
18632 static tree
18635 {
18638 tree parm;
18640 /* Assume it is a type parameter or a template parameter. */
18642 /* Assume it not a parameter pack. */
18644 /* Peek at the next token. */
18646 /* If it is `template', we have a type-parameter. */
18649 /* If it is `class' or `typename' we do not know yet whether it is a
18650 type parameter or a non-type parameter. Consider:
18652 template <typename T, typename T::X X> ...
18654 or:
18656 template <class C, class D*> ...
18658 Here, the first parameter is a type parameter, and the second is
18659 a non-type parameter. We can tell by looking at the token after
18660 the identifier -- if it is a `,', `=', or `>' then we have a type
18661 parameter. */
18663 {
18664 /* Peek at the token after `class' or `typename'. */
18666 /* If it's an ellipsis, we have a template type parameter
18667 pack. */
18670 /* If it's an identifier, skip it. */
18673 /* Now, see if the token looks like the end of a template
18674 parameter. */
18679 }
18681 /* Otherwise, it is a non-type parameter or a constrained parameter.
18683 [temp.param]
18685 When parsing a default template-argument for a non-type
18686 template-parameter, the first non-nested `>' is taken as the end
18687 of the template parameter-list rather than a greater-than
18688 operator. */
18689 parameter_declarator
18691 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
18698 /* If the parameter declaration is marked as a parameter pack, set
18699 *IS_PARAMETER_PACK to notify the caller. */
18704 {
18705 /* Can happen in some cases of erroneous input (c++/34892). */
18707 /* Consume the `...' for better error recovery. */
18709 }
18711 /* The parameter may have been constrained type parameter. */
18714 parameter_declarator,
18715 is_non_type);
18717 // Now we're sure that the parameter is a non-type parameter.
18728 }
18730 /* Parse a type-parameter.
18732 type-parameter:
18733 class identifier [opt]
18734 class identifier [opt] = type-id
18735 typename identifier [opt]
18736 typename identifier [opt] = type-id
18737 template < template-parameter-list > class identifier [opt]
18738 template < template-parameter-list > class identifier [opt]
18739 = id-expression
18741 GNU Extension (variadic templates):
18743 type-parameter:
18744 class ... identifier [opt]
18745 typename ... identifier [opt]
18747 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
18748 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
18749 the declaration of the parameter.
18751 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
18753 static tree
18755 {
18757 tree parameter;
18759 /* Look for a keyword to tell us what kind of parameter this is. */
18765 {
18768 {
18769 tree identifier;
18770 tree default_argument;
18772 /* If the next token is an ellipsis, we have a template
18773 argument pack. */
18775 {
18776 /* Consume the `...' token. */
18781 }
18783 /* If the next token is an identifier, then it names the
18784 parameter. */
18787 else
18790 /* Create the parameter. */
18793 /* If the next token is an `=', we have a default argument. */
18795 {
18796 default_argument
18799 /* Template parameter packs cannot have default
18800 arguments. */
18802 {
18805 "template parameter pack %qD cannot have a "
18807 else
18809 "template parameter packs cannot have "
18812 }
18815 }
18816 else
18819 /* Create the combined representation of the parameter and the
18820 default argument. */
18822 }
18826 {
18827 tree identifier;
18828 tree default_argument;
18830 /* Look for the `<'. */
18832 /* Parse the template-parameter-list. */
18834 /* Look for the `>'. */
18837 /* If template requirements are present, parse them. */
18839 {
18844 }
18846 /* Look for the `class' or 'typename' keywords. */
18848 /* If the next token is an ellipsis, we have a template
18849 argument pack. */
18851 {
18852 /* Consume the `...' token. */
18857 }
18858 /* If the next token is an `=', then there is a
18859 default-argument. If the next token is a `>', we are at
18860 the end of the parameter-list. If the next token is a `,',
18861 then we are at the end of this parameter. */
18865 {
18867 /* Treat invalid names as if the parameter were nameless. */
18870 }
18871 else
18874 /* Create the template parameter. */
18876 identifier);
18878 /* If the next token is an `=', then there is a
18879 default-argument. */
18881 {
18882 default_argument
18885 /* Template parameter packs cannot have default
18886 arguments. */
18888 {
18891 "template parameter pack %qD cannot "
18893 identifier);
18894 else
18898 }
18899 }
18900 else
18903 /* Create the combined representation of the parameter and the
18904 default argument. */
18906 }
18912 }
18915 }
18917 /* Parse a template-id.
18919 template-id:
18920 template-name < template-argument-list [opt] >
18922 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
18923 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
18924 returned. Otherwise, if the template-name names a function, or set
18925 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
18926 names a class, returns a TYPE_DECL for the specialization.
18928 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
18929 uninstantiated templates. */
18931 static tree
18937 {
18938 tree templ;
18939 tree arguments;
18940 tree template_id;
18945 /* If the next token corresponds to a template-id, there is no need
18946 to reparse it. */
18950 {
18953 }
18955 /* Avoid performing name lookup if there is no possibility of
18956 finding a template-id. */
18959 && !cp_parser_nth_token_starts_template_argument_list_p
18961 {
18964 }
18966 /* Remember where the template-id starts. */
18972 /* Parse the template-name. */
18975 check_dependency_p,
18976 is_declaration,
18977 tag_type,
18980 /* Push any access checks inside the firewall we're about to create. */
18986 /* Since we're going to preserve any side-effects from this parse, set up a
18987 firewall to protect our callers from cp_parser_commit_to_tentative_parse
18988 in the template arguments. */
18992 /* If we find the sequence `[:' after a template-name, it's probably
18993 a digraph-typo for `< ::'. Substitute the tokens and check if we can
18994 parse correctly the argument list. */
19001 {
19003 /* Change `:' into `::'. */
19005 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
19006 CPP_LESS. */
19009 /* Parse the arguments. */
19012 {
19013 /* If we couldn't parse an argument list, then we revert our changes
19014 and return simply an error. Maybe this is not a template-id
19015 after all. */
19020 }
19021 /* Otherwise, emit an error about the invalid digraph, but continue
19022 parsing because we got our argument list. */
19025 {
19028 "%<<:%> is an alternate spelling for %<[%>."
19031 {
19033 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
19036 }
19037 }
19038 }
19039 else
19040 {
19041 /* Look for the `<' that starts the template-argument-list. */
19043 {
19046 }
19047 /* Parse the arguments. */
19052 && !template_keyword_p
19055 {
19056 /* This didn't go well. */
19058 {
19059 /* C++20 says that "function-name < a;" is now ill-formed. */
19061 {
19064 "operand of %<<%> is ill-formed in C++20; wrap the "
19066 }
19067 else
19068 /* We expect "f<targs>" to be followed by "(args)". */
19072 /* Purge all subsequent tokens. */
19074 }
19075 else
19079 }
19080 }
19082 /* Set the location to be of the form:
19083 template-name < template-argument-list [opt] >
19084 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19085 with caret == start at the start of the template-name,
19086 ranging until the closing '>'. */
19087 location_t combined_loc
19090 /* Check for concepts autos where they don't belong. We could
19091 identify types in some cases of identifier TEMPL, looking ahead
19092 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
19093 types. We reject them in functions, but if what we have is an
19094 identifier, even with none_type we can't conclude it's NOT a
19095 type, we have to wait for template substitution. */
19098 /* Build a representation of the specialization. */
19101 TEMPLATE_ID_EXPR,
19105 {
19106 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
19107 template (rather than some instantiation thereof) only if
19108 is not nested within some other construct. For example, in
19109 "template <typename T> void f(T) { A<T>::", A<T> is just an
19110 instantiation of A. */
19111 bool entering_scope
19114 template_id
19116 }
19118 {
19119 /* The caller will decide whether this is a concept check or type
19120 constraint. */
19123 }
19125 {
19129 }
19132 {
19133 /* Some type template in dependent scope. */
19136 TEMPLATE_ID_EXPR,
19139 }
19140 else
19141 {
19142 /* If it's not a class-template or a template-template, it should be
19143 a function-template. */
19149 }
19151 /* If parsing tentatively, replace the sequence of tokens that makes
19152 up the template-id with a CPP_TEMPLATE_ID token. That way,
19153 should we re-parse the token stream, we will not have to repeat
19154 the effort required to do the parse, nor will we issue duplicate
19155 error messages about problems during instantiation of the
19156 template. */
19158 /* Don't do this if we had a parse error in a declarator; re-parsing
19159 might succeed if a name changes meaning (60361). */
19163 {
19164 /* Reset the contents of the START_OF_ID token. */
19168 /* Retrieve any deferred checks. Do not pop this access checks yet
19169 so the memory will not be reclaimed during token replacing below. */
19176 /* Purge all subsequent tokens. */
19179 /* ??? Can we actually assume that, if template_id ==
19180 error_mark_node, we will have issued a diagnostic to the
19181 user, as opposed to simply marking the tentative parse as
19182 failed? */
19185 }
19189 }
19191 /* Like cp_parser_template_id, called in non-type context. */
19193 static tree
19198 {
19203 /* We didn't check the arguments in cp_parser_template_id; do that now. */
19206 }
19208 /* Parse a template-name.
19210 template-name:
19211 identifier
19213 The standard should actually say:
19215 template-name:
19216 identifier
19217 operator-function-id
19219 A defect report has been filed about this issue.
19221 A conversion-function-id cannot be a template name because they cannot
19222 be part of a template-id. In fact, looking at this code:
19224 a.operator K<int>()
19226 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
19227 It is impossible to call a templated conversion-function-id with an
19228 explicit argument list, since the only allowed template parameter is
19229 the type to which it is converting.
19231 If TEMPLATE_KEYWORD_P is true, then we have just seen the
19232 `template' keyword, in a construction like:
19234 T::template f<3>()
19236 In that case `f' is taken to be a template-name, even though there
19237 is no way of knowing for sure.
19239 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
19240 name refers to a set of overloaded functions, at least one of which
19241 is a template, or an IDENTIFIER_NODE with the name of the template,
19242 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
19243 names are looked up inside uninstantiated templates. */
19245 static tree
19252 {
19253 tree identifier;
19254 tree decl;
19257 /* If the next token is `operator', then we have either an
19258 operator-function-id or a conversion-function-id. */
19260 {
19261 /* We don't know whether we're looking at an
19262 operator-function-id or a conversion-function-id. */
19264 /* Try an operator-function-id. */
19266 /* If that didn't work, try a conversion-function-id. */
19268 {
19271 }
19272 }
19273 /* Look for the identifier. */
19274 else
19277 /* If we didn't find an identifier, we don't have a template-id. */
19281 /* If the name immediately followed the `template' keyword, then it
19282 is a template-name. However, if the next token is not `<', then
19283 we do not treat it as a template-name, since it is not being used
19284 as part of a template-id. This enables us to handle constructs
19285 like:
19287 template <typename T> struct S { S(); };
19288 template <typename T> S<T>::S();
19290 correctly. We would treat `S' as a template -- if it were `S<T>'
19291 -- but we do not if there is no `<'. */
19295 {
19296 /* In a declaration, in a dependent context, we pretend that the
19297 "template" keyword was present in order to improve error
19298 recovery. For example, given:
19300 template <typename T> void f(T::X<int>);
19302 we want to treat "X<int>" as a template-id. */
19304 && !template_keyword_p
19306 && check_dependency_p
19308 /* Do not do this for dtors (or ctors), since they never
19309 need the template keyword before their name. */
19311 {
19314 /* Explain what went wrong. */
19316 identifier);
19319 /* If parsing tentatively, find the location of the "<" token. */
19322 /* Parse the template arguments so that we can issue error
19323 messages about them. */
19326 /* Skip tokens until we find a good place from which to
19327 continue parsing. */
19332 /* If parsing tentatively, permanently remove the
19333 template argument list. That will prevent duplicate
19334 error messages from being issued about the missing
19335 "template" keyword. */
19342 }
19344 /* If the "template" keyword is present, then there is generally
19345 no point in doing name-lookup, so we just return IDENTIFIER.
19346 But, if the qualifying scope is non-dependent then we can
19347 (and must) do name-lookup normally. */
19349 {
19355 {
19356 /* We're optimizing away the call to cp_parser_lookup_name, but
19357 we still need to do this. */
19361 }
19362 }
19363 }
19365 /* cp_parser_lookup_name clears OBJECT_TYPE. */
19369 /* Look up the name. */
19371 tag_type,
19374 check_dependency_p,
19380 /* 13.3 [temp.names] A < is interpreted as the delimiter of a
19381 template-argument-list if it follows a name that is not a
19382 conversion-function-id and
19383 - that follows the keyword template or a ~ after a nested-name-specifier or
19384 in a class member access expression, or
19385 - for which name lookup finds the injected-class-name of a class template
19386 or finds any declaration of a template, or
19387 - that is an unqualified name for which name lookup either finds one or
19388 more functions or finds nothing, or
19389 - that is a terminal name in a using-declarator (9.9), in a declarator-id
19390 (9.3.4), or in a type-only context other than a nested-name-specifier
19391 (13.8). */
19393 /* Handle injected-class-name. */
19396 /* If DECL is a template, then the name was a template-name. */
19398 {
19401 {
19403 tree attr;
19406 else
19409 {
19412 }
19415 {
19418 }
19419 }
19420 }
19421 else
19422 {
19423 /* Look through an overload set for any templates. */
19431 /* "an unqualified name for which name lookup either finds one or more
19432 functions or finds nothing". */
19435 && !scope
19438 {
19439 /* The "more functions" case. Just use the OVERLOAD as normally.
19440 We don't use is_overloaded_fn here to avoid considering
19441 BASELINKs. */
19443 /* Name lookup found one function. */
19445 /* Name lookup found nothing. */
19448 }
19450 /* "that follows the keyword template"..."in a type-only context" */
19458 {
19459 /* The name does not name a template. */
19462 }
19465 /* cp_parser_template_id can only handle some TYPE_DECLs. */
19468 /* Repeat the lookup at instantiation time. */
19470 }
19473 }
19475 /* Parse a template-argument-list.
19477 template-argument-list:
19478 template-argument ... [opt]
19479 template-argument-list , template-argument ... [opt]
19481 Returns a TREE_VEC containing the arguments. */
19483 static tree
19485 {
19490 /* Don't create location wrapper nodes within a template-argument-list. */
19491 auto_suppress_location_wrappers sentinel;
19495 /* Even if the template-id appears in an integral
19496 constant-expression, the contents of the argument list do
19497 not. */
19503 /* Parse the arguments. */
19505 do
19506 {
19508 /* Consume the comma. */
19511 /* Parse the template-argument. */
19514 /* If the next token is an ellipsis, we're expanding a template
19515 argument pack. */
19517 {
19519 {
19523 }
19524 /* Consume the `...' token. */
19527 /* Make the argument into a TYPE_PACK_EXPANSION or
19528 EXPR_PACK_EXPANSION. */
19530 }
19533 }
19548 }
19550 /* Parse a template-argument.
19552 template-argument:
19553 assignment-expression
19554 type-id
19555 id-expression
19557 The representation is that of an assignment-expression, type-id, or
19558 id-expression -- except that the qualified id-expression is
19559 evaluated, so that the value returned is either a DECL or an
19560 OVERLOAD.
19562 Although the standard says "assignment-expression", it forbids
19563 throw-expressions or assignments in the template argument.
19564 Therefore, we use "conditional-expression" instead. */
19566 static tree
19568 {
19569 tree argument;
19575 cp_id_kind idk;
19577 /* There's really no way to know what we're looking at, so we just
19578 try each alternative in order.
19580 [temp.arg]
19582 In a template-argument, an ambiguity between a type-id and an
19583 expression is resolved to a type-id, regardless of the form of
19584 the corresponding template-parameter.
19586 Therefore, we try a type-id first. */
19589 /* If there was no error parsing the type-id but the next token is a
19590 '>>', our behavior depends on which dialect of C++ we're
19591 parsing. In C++98, we probably found a typo for '> >'. But there
19592 are type-id which are also valid expressions. For instance:
19594 struct X { int operator >> (int); };
19595 template <int V> struct Foo {};
19596 Foo<X () >> 5> r;
19598 Here 'X()' is a valid type-id of a function type, but the user just
19599 wanted to write the expression "X() >> 5". Thus, we remember that we
19600 found a valid type-id, but we still try to parse the argument as an
19601 expression to see what happens.
19603 In C++0x, the '>>' will be considered two separate '>'
19604 tokens. */
19608 /* Similarly for >= which
19609 cp_parser_next_token_ends_template_argument_p treats for
19610 diagnostics purposes as mistyped > =, but can be valid
19611 after a type-id. */
19613 {
19616 }
19617 else
19618 {
19619 /* If the next token isn't a `,' or a `>', then this argument wasn't
19620 really finished. This means that the argument is not a valid
19621 type-id. */
19624 /* If that worked, we're done. */
19627 }
19628 /* We're still not sure what the argument will be. */
19630 /* Try a template. */
19638 /* If the next token isn't a `,' or a `>', then this argument wasn't
19639 really finished. */
19643 {
19644 /* Figure out what is being referred to. If the id-expression
19645 was for a class template specialization, then we will have a
19646 TYPE_DECL at this point. There is no need to do name lookup
19647 at this point in that case. */
19650 none_type,
19659 }
19661 {
19667 }
19668 /* It must be a non-type argument. In C++17 any constant-expression is
19669 allowed. */
19673 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
19675 -- an integral constant-expression of integral or enumeration
19676 type; or
19678 -- the name of a non-type template-parameter; or
19680 -- the name of an object or function with external linkage...
19682 -- the address of an object or function with external linkage...
19684 -- a pointer to member... */
19685 /* Look for a non-type template parameter. */
19687 {
19699 }
19701 /* If the next token is "&", the argument must be the address of an
19702 object or function with external linkage. */
19705 {
19708 }
19709 /* See if we might have an id-expression. */
19716 {
19719 address_p,
19726 else
19727 {
19728 tree probe;
19731 {
19732 /* Strip the dereference temporarily. */
19735 }
19737 /* If we're in a template, we represent a qualified-id referring
19738 to a static data member as a SCOPE_REF even if the scope isn't
19739 dependent so that we can check access control later. */
19744 {
19745 /* A variable without external linkage might still be a
19746 valid constant-expression, so no error is issued here
19747 if the external-linkage check fails. */
19750 }
19752 /* All overloaded functions are allowed; if the external
19753 linkage test does not pass, an error will be issued
19754 later. */
19755 ;
19759 /* A pointer-to-member. */
19760 ;
19762 ;
19763 else
19767 {
19771 else
19774 }
19775 }
19776 }
19777 /* If the argument started with "&", there are no other valid
19778 alternatives at this point. */
19780 {
19783 }
19785 general_expr:
19786 /* If the argument wasn't successfully parsed as a type-id followed
19787 by '>>', the argument can only be a constant expression now.
19788 Otherwise, we try parsing the constant-expression tentatively,
19789 because the argument could really be a type-id. */
19795 else
19796 {
19797 /* In C++20, we can encounter a braced-init-list. */
19802 /* With C++17 generalized non-type template arguments we need to handle
19803 lvalue constant expressions, too. */
19806 }
19814 /* We did our best to parse the argument as a non type-id, but that
19815 was the only alternative that matched (albeit with a '>' after
19816 it). We can assume it's just a typo from the user, and a
19817 diagnostic will then be issued. */
19819 }
19821 /* Parse an explicit-instantiation.
19823 explicit-instantiation:
19824 template declaration
19826 Although the standard says `declaration', what it really means is:
19828 explicit-instantiation:
19829 template decl-specifier-seq [opt] declarator [opt] ;
19831 Things like `template int S<int>::i = 5, int S<double>::j;' are not
19832 supposed to be allowed. A defect report has been filed about this
19833 issue.
19835 GNU Extension:
19837 explicit-instantiation:
19838 storage-class-specifier template
19839 decl-specifier-seq [opt] declarator [opt] ;
19840 function-specifier template
19841 decl-specifier-seq [opt] declarator [opt] ; */
19843 static void
19845 {
19847 cp_decl_specifier_seq decl_specifiers;
19852 /* Look for an (optional) storage-class-specifier or
19853 function-specifier. */
19855 {
19856 extension_specifier
19859 extension_specifier
19862 }
19864 /* Look for the `template' keyword. */
19866 /* Let the front end know that we are processing an explicit
19867 instantiation. */
19869 /* [temp.explicit] says that we are supposed to ignore access
19870 control while processing explicit instantiation directives. */
19872 /* Parse a decl-specifier-seq. */
19874 CP_PARSER_FLAGS_OPTIONAL,
19878 cp_omp_declare_simd_data odsd;
19884 /* If there was exactly one decl-specifier, and it declared a class,
19885 and there's no declarator, then we have an explicit type
19886 instantiation. */
19888 {
19891 /* Turn access control back on for names used during
19892 template instantiation. */
19897 }
19898 else
19899 {
19901 tree decl;
19903 /* Parse the declarator. */
19904 declarator
19906 CP_PARSER_FLAGS_NONE,
19917 {
19920 "explicit instantiation shall not use"
19924 "explicit instantiation shall not use"
19928 "explicit instantiation shall not use"
19933 /* Turn access control back on for names used during
19934 template instantiation. */
19936 /* Do the explicit instantiation. */
19938 }
19939 else
19940 {
19942 /* Skip the body of the explicit instantiation. */
19944 }
19945 }
19946 /* We're done with the instantiation. */
19952 }
19954 /* Parse an explicit-specialization.
19956 explicit-specialization:
19957 template < > declaration
19959 Although the standard says `declaration', what it really means is:
19961 explicit-specialization:
19962 template <> decl-specifier [opt] init-declarator [opt] ;
19963 template <> function-definition
19964 template <> explicit-specialization
19965 template <> template-declaration */
19967 static void
19969 {
19972 /* Look for the `template' keyword. */
19974 /* Look for the `<'. */
19976 /* Look for the `>'. */
19978 /* We have processed another parameter list. */
19981 /* [temp]
19983 A template ... explicit specialization ... shall not have C
19984 linkage. */
19987 {
19991 /* Give it C++ linkage to avoid confusing other parts of the
19992 front end. */
19994 }
19996 /* Let the front end know that we are beginning a specialization. */
19998 {
19999 /* If the next keyword is `template', we need to figure out
20000 whether or not we're looking a template-declaration. */
20002 {
20007 else
20009 }
20010 else
20011 /* Parse the dependent declaration. */
20017 }
20019 /* We're done with the specialization. */
20022 /* For the erroneous case of a template with C linkage, we pushed an
20023 implicit C++ linkage scope; exit that scope now. */
20027 /* We're done with this parameter list. */
20029 }
20031 /* Preserve the attributes across a garbage collect (by making it a GC
20032 root), which can occur when parsing a member function. */
20036 /* Parse a type-specifier.
20038 type-specifier:
20039 simple-type-specifier
20040 class-specifier
20041 enum-specifier
20042 elaborated-type-specifier
20043 cv-qualifier
20045 GNU Extension:
20047 type-specifier:
20048 __complex__
20050 Returns a representation of the type-specifier. For a
20051 class-specifier, enum-specifier, or elaborated-type-specifier, a
20052 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
20054 The parser flags FLAGS is used to control type-specifier parsing.
20056 If IS_DECLARATION is TRUE, then this type-specifier is appearing
20057 in a decl-specifier-seq.
20059 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
20060 class-specifier, enum-specifier, or elaborated-type-specifier, then
20061 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
20062 if a type is declared; 2 if it is defined. Otherwise, it is set to
20063 zero.
20065 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
20066 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
20067 is set to FALSE. */
20069 static tree
20071 cp_parser_flags flags,
20076 {
20082 /* Assume this type-specifier does not declare a new type. */
20085 /* And that it does not specify a cv-qualifier. */
20088 /* Peek at the next token. */
20091 /* If we're looking at a keyword, we can use that to guide the
20092 production we choose. */
20095 {
20100 /* Look for the enum-specifier. */
20102 /* If that worked, we're done. */
20104 {
20109 type_spec,
20110 token,
20113 }
20114 else
20117 /* Any of these indicate either a class-specifier, or an
20118 elaborated-type-specifier. */
20125 /* Parse tentatively so that we can back up if we don't find a
20126 class-specifier. */
20130 /* Look for the class-specifier. */
20135 /* If that worked, we're done. */
20137 {
20142 type_spec,
20143 token,
20146 }
20148 /* Fall through. */
20149 elaborated_type_specifier:
20150 /* We're declaring (not defining) a class or enum. */
20154 /* Fall through. */
20156 /* Look for an elaborated-type-specifier. */
20157 type_spec
20158 = (cp_parser_elaborated_type_specifier
20161 is_declaration));
20164 type_spec,
20165 token,
20188 /* The `__complex__' keyword is a GNU extension. */
20194 }
20196 /* Handle simple keywords. */
20198 {
20200 {
20203 }
20205 }
20207 /* If we do not already have a type-specifier, assume we are looking
20208 at a simple-type-specifier. */
20210 decl_specs,
20211 flags);
20213 /* If we didn't find a type-specifier, and a type-specifier was not
20214 optional in this context, issue an error message. */
20216 {
20219 }
20222 }
20224 /* Parse a simple-type-specifier.
20226 simple-type-specifier:
20227 :: [opt] nested-name-specifier [opt] type-name
20228 :: [opt] nested-name-specifier template template-id
20229 char
20230 wchar_t
20231 bool
20232 short
20233 int
20234 long
20235 signed
20236 unsigned
20237 float
20238 double
20239 void
20241 C++11 Extension:
20243 simple-type-specifier:
20244 auto
20245 decltype ( expression )
20246 char16_t
20247 char32_t
20248 __underlying_type ( type-id )
20250 C++17 extension:
20252 nested-name-specifier(opt) template-name
20254 GNU Extension:
20256 simple-type-specifier:
20257 __int128
20258 __typeof__ unary-expression
20259 __typeof__ ( type-id )
20260 __typeof__ ( type-id ) { initializer-list , [opt] }
20262 Concepts Extension:
20264 simple-type-specifier:
20265 constrained-type-specifier
20267 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
20268 appropriately updated. */
20270 static tree
20273 cp_parser_flags flags)
20274 {
20279 /* Peek at the next token. */
20282 /* If we're looking at a keyword, things are easy. */
20284 {
20322 {
20325 /* Check if the alternate "__intN__" form has been used instead of
20326 "__intN". */
20330 }
20352 CASE_RID_FLOATN_NX:
20367 {
20368 /* The 'auto' might be the placeholder return type for a function decl
20369 with trailing return type. */
20378 {
20380 {
20387 }
20390 {
20393 }
20396 }
20400 {
20403 }
20406 {
20409 }
20410 else
20414 {
20417 "use of %<auto%> in lambda parameter declaration "
20418 "only available with "
20420 }
20423 "use of %<auto%> in template argument "
20427 "use of %<auto%> in parameter declaration "
20431 "use of %<auto%> in parameter declaration "
20432 "only available with "
20434 }
20435 else
20440 /* Since DR 743, decltype can either be a simple-type-specifier by
20441 itself or begin a nested-name-specifier. Parsing it will replace
20442 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
20443 handling below decide what to do. */
20449 /* Consume the `typeof' token. */
20451 /* Parse the operand to `typeof'. */
20453 /* If it is not already a TYPE, take its type. */
20459 token,
20465 /* If token is a type-yielding built-in traits, parse it. */
20468 {
20472 token,
20476 }
20479 }
20481 /* If token is an already-parsed decltype not followed by ::,
20482 it's a simple-type-specifier. */
20485 {
20488 {
20490 token,
20492 /* Remember that we are handling a decltype in order to
20493 implement the resolution of DR 1510 when the argument
20494 isn't instantiation dependent. */
20496 }
20499 }
20501 /* If the type-specifier was for a built-in type, we're done. */
20503 {
20504 /* Record the type. */
20511 type,
20512 token,
20517 /* Consume the token. */
20523 /* There is no valid C++ program where a non-template type is
20524 followed by a "<". That usually indicates that the user thought
20525 that the type was a template. */
20530 }
20532 /* The type-specifier must be a user-defined type. */
20534 {
20540 /* Don't gobble tokens or issue error messages if this is an
20541 optional type-specifier. */
20545 /* Remember current tentative parsing state -- if we know we need
20546 a type, we can give better diagnostics here. */
20551 /* Look for the optional `::' operator. */
20552 global_p
20556 /* Look for the nested-name specifier. */
20557 qualified_p
20564 /* If we have seen a nested-name-specifier, and the next token
20565 is `template', then we are using the template-id production. */
20568 {
20569 /* Look for the template-id. */
20573 none_type,
20575 /* If the template-id did not name a type, we are out of
20576 luck. */
20578 {
20579 /* ...unless we pretend we have seen 'typename'. */
20583 else
20584 {
20587 }
20588 }
20589 }
20590 /* DR 1812: A < following a qualified-id in a typename-specifier
20591 could safely be assumed to begin a template argument list, so
20592 the template keyword should be optional. */
20594 && qualified_p
20595 && typename_p
20597 {
20603 none_type,
20605 /* This is handled below, so back off. */
20616 }
20618 /* Otherwise, look for a type-name. */
20620 {
20629 }
20632 {
20633 /* Try for a type-constraint with template arguments. We check
20634 decl_specs here to avoid trying this for a functional cast. */
20641 none_type,
20644 {
20649 /* Perhaps it's a concept-check expression. */
20651 }
20652 else
20657 }
20660 {
20661 /* Try class template argument deduction or type-constraint without
20662 template arguments. */
20666 {
20667 location_t loc
20670 none_type,
20682 else
20683 {
20688 }
20689 }
20690 else
20692 }
20694 /* If it didn't work out, we don't have a TYPE. */
20699 /* Keep track of all name-lookups performed in class scopes. */
20701 && !global_p
20702 && !qualified_p
20709 token,
20711 }
20713 /* If we didn't get a type-name, issue an error message. */
20715 {
20718 }
20721 {
20722 /* See if TYPE is an Objective-C type, and if so, parse and
20723 accept any protocol references following it. Do this before
20724 the cp_parser_check_for_invalid_template_id() call, because
20725 Objective-C types can be followed by '<...>' which would
20726 enclose protocol names rather than template arguments, and so
20727 everything is fine. */
20730 {
20734 /* Clobber the "unqualified" type previously entered into
20735 DECL_SPECS with the new, improved protocol-qualified version. */
20740 }
20742 /* There is no valid C++ program where a non-template type is
20743 followed by a "<". That usually indicates that the user
20744 thought that the type was a template. */
20746 none_type,
20748 }
20751 }
20753 /* Parse the remainder of a placholder-type-specifier.
20755 placeholder-type-specifier:
20756 type-constraint_opt auto
20757 type-constraint_opt decltype(auto)
20759 The raw form of the constraint is parsed in cp_parser_simple_type_specifier
20760 and passed as TMPL. This function converts TMPL to an actual type-constraint,
20761 parses the placeholder type, and performs some contextual syntactic analysis.
20763 LOC provides the location of the template name.
20765 TENTATIVE is true if the type-specifier parsing is tentative; in that case,
20766 don't give an error if TMPL isn't a valid type-constraint, as the template-id
20767 might actually be a concept-check,
20769 Note that the Concepts TS allows the auto or decltype(auto) to be
20770 omitted in a constrained-type-specifier. */
20772 static tree
20775 {
20781 /* Get the arguments as written for subsequent analysis. */
20784 {
20787 }
20788 else
20789 /* A concept-name with no arguments can't be an expression. */
20794 /* Get the concept and prototype parameter for the constraint. */
20801 /* As per the standard, require auto or decltype(auto), except in some
20802 cases (template parameter lists, -fconcepts-ts enabled). */
20805 {
20809 {
20811 matching_parens parens;
20815 }
20816 }
20818 /* A type constraint constrains a contextually determined type or type
20819 parameter pack. However, the Concepts TS does allow concepts
20820 to introduce non-type and template template parameters. */
20822 {
20825 {
20827 {
20830 }
20832 }
20833 }
20835 /* In a template parameter list, a type-parameter can be introduced
20836 by type-constraints alone. */
20838 {
20839 /* In a default argument we may not be creating new parameters. */
20841 {
20842 /* If this assert turns out to be false, do error() instead. */
20845 }
20847 }
20849 /* Diagnose issues placeholder issues. */
20853 {
20855 /* Perhaps it's a concept-check expression (c++/91073). */
20862 /* Fall through. This is an error of omission. */
20863 }
20865 {
20866 /* A trailing return type only allows type-constraints. */
20869 }
20871 /* In a parameter-declaration-clause, a placeholder-type-specifier
20872 results in an invented template parameter. */
20874 {
20876 {
20882 }
20885 }
20887 /* Determine if the type should be deduced using template argument
20888 deduction or decltype deduction. Note that the latter is always
20889 used for type-constraints in trailing return types. */
20894 /* Otherwise, this is the type of a variable or return type. */
20897 else
20899 }
20901 /* Parse a type-name.
20903 type-name:
20904 class-name
20905 enum-name
20906 typedef-name
20907 simple-template-id [in c++0x]
20909 enum-name:
20910 identifier
20912 typedef-name:
20913 identifier
20915 Concepts:
20917 type-name:
20918 concept-name
20919 partial-concept-id
20921 concept-name:
20922 identifier
20924 Returns a TYPE_DECL for the type. */
20926 static tree
20928 {
20929 tree type_decl;
20931 /* We can't know yet whether it is a class-name or not. */
20933 /* Try a class-name. */
20935 typename_keyword_p,
20937 none_type,
20941 /* If it's not a class-name, keep looking. */
20943 {
20945 /* It must be a typedef-name or an enum-name. */
20949 /* It is either a simple-template-id representing an
20950 instantiation of an alias template... */
20954 none_type,
20956 /* Note that this must be an instantiation of an alias template
20957 because [temp.names]/6 says:
20959 A template-id that names an alias template specialization
20960 is a type-name.
20962 Whereas [temp.names]/7 says:
20964 A simple-template-id that names a class template
20965 specialization is a class-name.
20967 With concepts, this could also be a partial-concept-id that
20968 declares a non-type template parameter. */
20973 else
20977 /* ... Or a typedef-name or an enum-name. */
20979 }
20982 }
20984 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
20985 or a concept-name.
20987 enum-name:
20988 identifier
20990 typedef-name:
20991 identifier
20993 concept-name:
20994 identifier
20996 Returns a TYPE_DECL for the type. */
20998 static tree
21000 {
21001 tree type_decl;
21002 tree identifier;
21009 /* Look up the type-name. */
21016 {
21017 /* See if this is an Objective-C type. */
21022 }
21024 /* Issue an error if we did not find a type-name. */
21026 /* In Objective-C, we have the complication that class names are
21027 normally type names and start declarations (eg, the
21028 "NSObject" in "NSObject *object;"), but can be used in an
21029 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
21030 is an expression. So, a classname followed by a dot is not a
21031 valid type-name. */
21034 {
21039 }
21040 /* Remember that the name was used in the definition of the
21041 current class so that we can check later to see if the
21042 meaning would have been different after the class was
21043 entirely defined. */
21049 }
21051 /* Parse an elaborated-type-specifier. Note that the grammar given
21052 here incorporates the resolution to DR68.
21054 elaborated-type-specifier:
21055 class-key :: [opt] nested-name-specifier [opt] identifier
21056 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
21057 enum-key :: [opt] nested-name-specifier [opt] identifier
21058 typename :: [opt] nested-name-specifier identifier
21059 typename :: [opt] nested-name-specifier template [opt]
21060 template-id
21062 GNU extension:
21064 elaborated-type-specifier:
21065 class-key attributes :: [opt] nested-name-specifier [opt] identifier
21066 class-key attributes :: [opt] nested-name-specifier [opt]
21067 template [opt] template-id
21068 enum attributes :: [opt] nested-name-specifier [opt] identifier
21070 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
21071 declared `friend'. If IS_DECLARATION is TRUE, then this
21072 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
21073 something is being declared.
21075 Returns the TYPE specified. */
21077 static tree
21081 {
21083 tree identifier;
21086 tree globalscope;
21089 /* For class and enum types the location of the class-key or enum-key. */
21091 /* For a scoped enum, the 'class' or 'struct' keyword id. */
21094 /* See if we're looking at the `enum' keyword. */
21096 {
21097 /* Consume the `enum' token. */
21099 /* Remember that it's an enumeration type. */
21101 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
21102 enums) is used here. */
21106 {
21114 /* Consume the `struct' or `class' and parse it anyway. */
21116 /* Create a combined location for the whole scoped-enum-key. */
21118 }
21119 else
21122 /* Parse the attributes. */
21124 }
21125 /* Or, it might be `typename'. */
21127 RID_TYPENAME))
21128 {
21129 /* Consume the `typename' token. */
21131 /* Remember that it's a `typename' type. */
21133 }
21134 /* Otherwise it must be a class-key. */
21135 else
21136 {
21141 /* Parse the attributes. */
21143 }
21145 /* Look for the `::' operator. */
21148 /* Look for the nested-name-specifier. */
21149 tree nested_name_specifier;
21151 {
21152 nested_name_specifier
21157 is_declaration);
21160 }
21161 else
21162 /* Even though `typename' is not present, the proposed resolution
21163 to Core Issue 180 says that in `class A<T>::B', `B' should be
21164 considered a type-name, even if `A<T>' is dependent. */
21165 nested_name_specifier
21170 is_declaration);
21171 /* For everything but enumeration types, consider a template-id.
21172 For an enumeration type, consider only a plain identifier. */
21174 {
21176 tree decl;
21178 /* Allow the `template' keyword. */
21180 /* If we didn't see `template', we don't know if there's a
21181 template-id or not. */
21184 /* The `template' keyword must follow a nested-name-specifier. */
21186 {
21190 }
21192 /* Parse the template-id. */
21196 tag_type,
21197 is_declaration);
21198 /* If we didn't find a template-id, look for an ordinary
21199 identifier. */
21201 ;
21202 /* We can get here when cp_parser_template_id, called by
21203 cp_parser_class_name with tag_type == none_type, succeeds
21204 and caches a BASELINK. Then, when called again here,
21205 instead of failing and returning an error_mark_node
21206 returns it (see template/typename17.C in C++11).
21207 ??? Could we diagnose this earlier? */
21209 {
21212 }
21213 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
21214 in effect, then we must assume that, upon instantiation, the
21215 template will correspond to a class. */
21219 typename_type,
21221 /* If the `typename' keyword is in effect and DECL is not a type
21222 decl, then type is non existent. */
21224 ;
21226 {
21230 /* If the next token is a semicolon, this must be a specialization,
21231 instantiation, or friend declaration. Check the scope while we
21232 still know whether or not we had a nested-name-specifier. */
21237 }
21240 }
21243 {
21248 {
21251 }
21253 /* For a `typename', we needn't call xref_tag. */
21259 /* Template parameter lists apply only if we are not within a
21260 function parameter list. */
21261 bool template_parm_lists_apply
21270 /* Look up a qualified name in the usual way. */
21272 {
21273 tree decl;
21274 tree ambiguous_decls;
21277 tag_type,
21284 /* If the lookup was ambiguous, an error will already have been
21285 issued. */
21289 /* If we are parsing friend declaration, DECL may be a
21290 TEMPLATE_DECL tree node here. However, we need to check
21291 whether this TEMPLATE_DECL results in valid code. Consider
21292 the following example:
21294 namespace N {
21295 template <class T> class C {};
21296 }
21297 class X {
21298 template <class T> friend class N::C; // #1, valid code
21299 };
21300 template <class T> class Y {
21301 friend class N::C; // #2, invalid code
21302 };
21304 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
21305 name lookup of `N::C'. We see that friend declaration must
21306 be template for the code to be valid. Note that
21307 processing_template_decl does not work here since it is
21308 always 1 for the above two cases. */
21310 decl = (cp_parser_maybe_treat_template_as_class
21315 {
21317 identifier,
21320 }
21323 {
21327 allow_template);
21331 }
21333 /* Forward declarations of nested types, such as
21335 class C1::C2;
21336 class C1::C2::C3;
21338 are invalid unless all components preceding the final '::'
21339 are complete. If all enclosing types are complete, these
21340 declarations become merely pointless.
21342 Invalid forward declarations of nested types are errors
21343 caught elsewhere in parsing. Those that are pointless arrive
21344 here. */
21352 }
21353 else
21354 {
21355 /* An elaborated-type-specifier sometimes introduces a new type and
21356 sometimes names an existing type. Normally, the rule is that it
21357 introduces a new type only if there is not an existing type of
21358 the same name already in scope. For example, given:
21360 struct S {};
21361 void f() { struct S s; }
21363 the `struct S' in the body of `f' is the same `struct S' as in
21364 the global scope; the existing definition is used. However, if
21365 there were no global declaration, this would introduce a new
21366 local class named `S'.
21368 An exception to this rule applies to the following code:
21370 namespace N { struct S; }
21372 Here, the elaborated-type-specifier names a new type
21373 unconditionally; even if there is already an `S' in the
21374 containing scope this declaration names a new type.
21375 This exception only applies if the elaborated-type-specifier
21376 forms the complete declaration:
21378 [class.name]
21380 A declaration consisting solely of `class-key identifier ;' is
21381 either a redeclaration of the name in the current scope or a
21382 forward declaration of the identifier as a class name. It
21383 introduces the name into the current scope.
21385 We are in this situation precisely when the next token is a `;'.
21387 An exception to the exception is that a `friend' declaration does
21388 *not* name a new type; i.e., given:
21390 struct S { friend struct T; };
21392 `T' is not a new type in the scope of `S'.
21394 Also, `new struct S' or `sizeof (struct S)' never results in the
21395 definition of a new type; a new type can only be declared in a
21396 declaration context. */
21398 TAG_how how;
21401 /* Friends have special name lookup rules. */
21405 CPP_SEMICOLON))
21406 /* This is a `class-key identifier ;' */
21408 else
21412 (template_parm_lists_apply
21415 /* An unqualified name was used to reference this type, so
21416 there were no qualifying templates. */
21426 }
21427 }
21432 /* Allow attributes on forward declarations of classes. */
21434 {
21445 {
21449 }
21452 else
21454 "attributes ignored on elaborated-type-specifier that is "
21456 }
21460 else
21461 {
21462 /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
21463 for alias definition. */
21467 decl_class);
21469 /* Indicate whether this class was declared as a `class' or as a
21470 `struct'. */
21473 }
21475 /* A "<" cannot follow an elaborated type specifier. If that
21476 happens, the user was probably trying to form a template-id. */
21481 }
21483 /* Parse an enum-specifier.
21485 enum-specifier:
21486 enum-head { enumerator-list [opt] }
21487 enum-head { enumerator-list , } [C++0x]
21489 enum-head:
21490 enum-key identifier [opt] enum-base [opt]
21491 enum-key nested-name-specifier identifier enum-base [opt]
21493 enum-key:
21494 enum
21495 enum class [C++0x]
21496 enum struct [C++0x]
21498 enum-base: [C++0x]
21499 : type-specifier-seq
21501 opaque-enum-specifier:
21502 enum-key identifier enum-base [opt] ;
21504 GNU Extensions:
21505 enum-key attributes[opt] identifier [opt] enum-base [opt]
21506 { enumerator-list [opt] }attributes[opt]
21507 enum-key attributes[opt] identifier [opt] enum-base [opt]
21508 { enumerator-list, }attributes[opt] [C++0x]
21510 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
21511 if the token stream isn't an enum-specifier after all. */
21513 static tree
21515 {
21516 tree identifier;
21518 tree prev_scope;
21520 tree attributes;
21531 /* Parse tentatively so that we can back up if we don't find a
21532 enum-specifier. */
21535 /* Caller guarantees that the current token is 'enum', an identifier
21536 possibly follows, and the token after that is an opening brace.
21537 If we don't have an identifier, fabricate an anonymous name for
21538 the enumeration being defined. */
21541 /* Parse the "class" or "struct", which indicates a scoped
21542 enumeration type in C++0x. */
21545 {
21549 /* Consume the `struct' or `class' token. */
21553 }
21557 /* Clear the qualification. */
21562 /* Figure out in what scope the declaration is being placed. */
21568 nested_name_specifier
21576 {
21577 tree name;
21581 enum_type,
21586 input_location);
21588 {
21591 {
21592 /* Are template enums allowed in ISO? */
21596 /* ignore a typename reference, for it will be solved by name
21597 in start_enum. */
21599 }
21600 }
21603 else
21604 {
21609 }
21610 }
21611 else
21612 {
21615 else
21616 {
21622 }
21623 }
21626 /* Check for the `:' that denotes a specified underlying type in C++0x.
21627 Note that a ':' could also indicate a bitfield width, however. */
21630 {
21631 cp_decl_specifier_seq type_specifiers;
21633 /* Consume the `:'. */
21637 auto tdf
21641 /* Parse the type-specifier-seq. */
21647 /* At this point this is surely not elaborated type specifier. */
21656 /* If that didn't work, stop. */
21658 {
21664 }
21665 }
21667 /* Look for the `{' but don't consume it yet. */
21669 {
21671 {
21677 }
21678 /* An opaque-enum-specifier must have a ';' here. */
21681 {
21684 OPT_Welaborated_enum_base,
21685 "declaration of enumeration with "
21686 "fixed underlying type and no enumerator list is "
21688 else
21690 }
21691 }
21697 {
21699 {
21703 }
21706 }
21708 /* Issue an error message if type-definitions are forbidden here. */
21711 else
21712 /* Create the new type. We do this before consuming the opening
21713 brace so the enum will be recorded as being on the line of its
21714 tag (or the 'enum' keyword, if there is no tag). */
21718 /* If the next token is not '{' it is an opaque-enum-specifier or an
21719 elaborated-type-specifier. */
21721 {
21726 {
21727 /* The following catches invalid code such as:
21728 enum class S<int>::E { A, B, C }; */
21736 {
21740 nested_name_specifier);
21742 }
21745 {
21747 "%qT for enum declaration does not name a class "
21750 }
21751 /* If that scope does not contain the scope in which the
21752 class was originally declared, the program is invalid. */
21754 nested_name_specifier))
21755 {
21758 "declaration of %qD in namespace %qD which does not "
21761 else
21763 "declaration of %qD in %qD which does not "
21767 }
21768 /* If that scope is the scope where the declaration is being placed
21769 the program is invalid. */
21773 {
21777 }
21778 }
21783 /* Consume the opening brace. */
21784 matching_braces braces;
21791 {
21795 }
21796 else
21797 {
21803 }
21807 /* If the next token is not '}', then there are some enumerators. */
21809 {
21811 /* Don't warn for enum {} a; here. */
21815 }
21816 else
21817 {
21818 /* We've seen a '{' so we know we're in an enum-specifier.
21819 Commit to any tentative parse to get syntax errors. */
21822 }
21824 /* Consume the final '}'. */
21829 }
21830 else
21831 {
21832 /* If a ';' follows, then it is an opaque-enum-specifier
21833 and additional restrictions apply. */
21835 {
21842 }
21843 }
21845 /* Look for trailing attributes to apply to this enumeration, and
21846 apply them if appropriate. */
21848 {
21851 trailing_attr,
21853 }
21855 /* Finish up the enumeration. */
21857 {
21862 }
21865 {
21867 {
21870 }
21873 }
21875 }
21877 /* Parse an enumerator-list. The enumerators all have the indicated
21878 TYPE.
21880 enumerator-list:
21881 enumerator-definition
21882 enumerator-list , enumerator-definition */
21884 static void
21886 {
21888 {
21889 /* Parse an enumerator-definition. */
21892 /* If the next token is not a ',', we've reached the end of
21893 the list. */
21896 /* Otherwise, consume the `,' and keep going. */
21898 /* If the next token is a `}', there is a trailing comma. */
21900 {
21905 }
21906 }
21907 }
21909 /* Parse an enumerator-definition. The enumerator has the indicated
21910 TYPE.
21912 enumerator-definition:
21913 enumerator
21914 enumerator = constant-expression
21916 enumerator:
21917 identifier
21919 GNU Extensions:
21921 enumerator-definition:
21922 enumerator attributes [opt]
21923 enumerator attributes [opt] = constant-expression */
21925 static void
21927 {
21928 tree identifier;
21929 tree value;
21930 location_t loc;
21932 /* Save the input location because we are interested in the location
21933 of the identifier and not the location of the explicit value. */
21936 /* Look for the identifier. */
21941 /* Parse any specified attributes. */
21944 /* If the next token is an '=', then there is an explicit value. */
21946 {
21947 /* Consume the `=' token. */
21949 /* Parse the value. */
21951 }
21952 else
21955 /* If we are processing a template, make sure the initializer of the
21956 enumerator doesn't contain any bare template parameter pack. */
21958 {
21959 /* In a lambda it should work, but doesn't currently. */
21961 {
21964 }
21965 }
21969 /* Create the enumerator. */
21971 }
21973 /* Parse a namespace-name.
21975 namespace-name:
21976 original-namespace-name
21977 namespace-alias
21979 Returns the NAMESPACE_DECL for the namespace. */
21981 static tree
21983 {
21984 tree identifier;
21985 tree namespace_decl;
21989 /* Get the name of the namespace. */
21994 /* Look up the identifier in the currently active scope. Look only
21995 for namespaces, due to:
21997 [basic.lookup.udir]
21999 When looking up a namespace-name in a using-directive or alias
22000 definition, only namespace names are considered.
22002 And:
22004 [basic.lookup.qual]
22006 During the lookup of a name preceding the :: scope resolution
22007 operator, object, function, and enumerator names are ignored.
22009 (Note that cp_parser_qualifying_entity only calls this
22010 function if the token after the name is the scope resolution
22011 operator.) */
22013 none_type,
22019 /* If it's not a namespace, issue an error. */
22022 {
22024 {
22025 auto_diagnostic_group d;
22026 name_hint hint;
22030 identifier,
22033 {
22039 }
22040 else
22042 identifier);
22043 }
22044 else
22047 }
22050 }
22052 /* Parse a namespace-definition.
22054 namespace-definition:
22055 named-namespace-definition
22056 unnamed-namespace-definition
22058 named-namespace-definition:
22059 original-namespace-definition
22060 extension-namespace-definition
22062 original-namespace-definition:
22063 namespace identifier { namespace-body }
22065 extension-namespace-definition:
22066 namespace original-namespace-name { namespace-body }
22068 unnamed-namespace-definition:
22069 namespace { namespace-body } */
22071 static void
22073 {
22074 tree identifier;
22084 {
22087 }
22089 /* Look for the `namespace' keyword. */
22090 cp_token* token
22093 /* Parse any specified attributes before the identifier. */
22097 {
22101 RID_INLINE);
22103 {
22107 "definitions only available with %<-std=c++20%> or "
22110 }
22113 {
22118 "standard attributes on namespaces must precede "
22121 /* Parse any attributes specified after the identifier. */
22123 }
22126 {
22127 /* Don't forget that the innermost namespace might have been
22128 marked as inline. Use |= because we cannot overwrite
22129 IS_INLINE in case the outermost namespace is inline, but
22130 there are no nested inlines. */
22133 }
22137 "nested namespace definitions only available with "
22140 /* Nested namespace names can create new namespaces (unlike
22141 other qualified-ids). */
22146 else
22149 }
22161 /* Start the namespace. */
22168 /* Look for the `{' to validate starting the namespace. */
22169 matching_braces braces;
22171 {
22172 /* Parse the body of the namespace. */
22175 /* Look for the final `}'. */
22177 }
22182 /* Pop the nested namespace definitions. */
22185 }
22187 /* Parse a namespace-body.
22189 namespace-body:
22190 declaration-seq [opt] */
22192 static void
22194 {
22196 }
22198 /* Parse a namespace-alias-definition.
22200 namespace-alias-definition:
22201 namespace identifier = qualified-namespace-specifier ; */
22203 static void
22205 {
22206 tree identifier;
22207 tree namespace_specifier;
22211 /* Look for the `namespace' keyword. */
22213 /* Look for the identifier. */
22217 /* Look for the `=' token. */
22220 {
22222 /* Skip the definition. */
22227 }
22229 /* Look for the qualified-namespace-specifier. */
22230 namespace_specifier
22233 /* Look for the `;' token. */
22236 /* Register the alias in the symbol table. */
22238 }
22240 /* Parse a qualified-namespace-specifier.
22242 qualified-namespace-specifier:
22243 :: [opt] nested-name-specifier [opt] namespace-name
22245 Returns a NAMESPACE_DECL corresponding to the specified
22246 namespace. */
22248 static tree
22250 {
22251 /* Look for the optional `::'. */
22255 /* Look for the optional nested-name-specifier. */
22263 }
22265 /* Subroutine of cp_parser_using_declaration. */
22267 static tree
22269 {
22272 {
22273 /* Create the USING_DECL. */
22282 /* Add it to the list of members in this class. */
22284 }
22285 else
22288 }
22290 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
22291 access declaration.
22293 using-declaration:
22294 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
22295 using :: unqualified-id ;
22297 access-declaration:
22298 qualified-id ;
22300 */
22302 static bool
22305 {
22309 tree identifier;
22310 tree qscope;
22315 {
22318 }
22319 else
22320 {
22321 /* Look for the `using' keyword. */
22324 again:
22325 /* Peek at the next token. */
22327 /* See if it's `typename'. */
22329 {
22330 /* Remember that we've seen it. */
22332 /* Consume the `typename' token. */
22334 }
22335 }
22337 /* Look for the optional global scope qualification. */
22338 global_scope_p
22343 /* If we saw `typename', or didn't see `::', then there must be a
22344 nested-name-specifier present. */
22346 {
22352 {
22355 }
22356 }
22357 /* Otherwise, we could be in either of the two productions. In that
22358 case, treat the nested-name-specifier as optional. */
22359 else
22373 /* If the qualifying scope of an access-declaration isn't a class
22374 or enumeration type then it can't be valid. */
22378 /* Something has already gone wrong; there's no need to parse
22379 further. Since an error has occurred, the return value of
22380 cp_parser_parse_definitely will be false, as required. */
22384 /* Parse the unqualified-id. */
22392 {
22397 }
22399 {
22403 "pack expansion in using-declaration only available "
22406 /* A parameter pack can appear in the qualifying scope, and/or in the
22407 terminal name (if naming a conversion function). Logically they're
22408 part of a single pack expansion of the overall USING_DECL, but we
22409 express them as separate pack expansions within the USING_DECL since
22410 we can't create a pack expansion over a USING_DECL. */
22413 {
22416 }
22420 {
22424 }
22426 {
22427 /* Issue an error in terms using a SCOPE_REF that includes both
22428 components. */
22429 tree name
22434 }
22435 }
22437 /* The function we call to handle a using-declaration is different
22438 depending on what scope we are in. */
22440 ;
22443 /* [namespace.udecl]
22445 A using declaration shall not name a template-id. */
22448 else
22449 {
22453 {
22456 }
22457 }
22461 {
22465 "comma-separated list in using-declaration only available "
22468 }
22470 /* Look for the final `;'. */
22475 "access declarations are deprecated "
22476 "in favor of using-declarations; "
22480 }
22482 /* C++20 using enum declaration.
22484 using-enum-declaration :
22485 using elaborated-enum-specifier ; */
22487 static void
22489 {
22492 /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
22493 breaks one of the motivating examples in using-enum-5.C.
22494 cp_parser_simple_type_specifier seems to be closer to what we actually
22495 want, though that hasn't been properly specified yet. */
22497 /* Consume 'enum'. */
22503 tree type = (cp_parser_simple_type_specifier
22510 {
22513 }
22517 /* The elaborated-enum-specifier shall not name a dependent type and the type
22518 shall have a reachable enum-specifier. */
22532 {
22534 auto_diagnostic_group g;
22538 ;
22541 else
22543 }
22545 /* A using-enum-declaration introduces the enumerator names of the named
22546 enumeration as if by a using-declaration for each enumerator. */
22550 }
22552 /* Parse an alias-declaration.
22554 alias-declaration:
22555 using identifier attribute-specifier-seq [opt] = type-id */
22557 static tree
22559 {
22563 cp_decl_specifier_seq decl_specs;
22567 /* Look for the `using' keyword. */
22568 cp_token *using_token
22590 /* Now we are going to parse the type-id of the declaration. */
22592 /*
22593 [dcl.type]/3 says:
22595 "A type-specifier-seq shall not define a class or enumeration
22596 unless it appears in the type-id of an alias-declaration (7.1.3) that
22597 is not the declaration of a template-declaration."
22599 In other words, if we currently are in an alias template, the
22600 type-id should not define a type.
22602 So let's set parser->type_definition_forbidden_message in that
22603 case; cp_parser_check_type_definition (called by
22604 cp_parser_class_specifier) will then emit an error if a type is
22605 defined in the type-id. */
22607 {
22611 }
22616 /* Restore the error message if need be. */
22622 {
22625 }
22627 /* A typedef-name can also be introduced by an alias-declaration. The
22628 identifier following the using keyword becomes a typedef-name. It has
22629 the same semantics as if it were introduced by the typedef
22630 specifier. In particular, it does not define a new type and it shall
22631 not appear in the type-id. */
22636 {
22639 ds_attribute,
22640 attrs_token);
22641 }
22643 ds_typedef,
22644 using_token);
22646 ds_alias,
22647 using_token);
22654 id_location,
22664 else
22675 /* If decl is a template, return its TEMPLATE_DECL so that it gets
22676 added into the symbol table; otherwise, return the TYPE_DECL. */
22680 {
22684 }
22687 }
22689 /* Parse a using-directive.
22691 using-directive:
22692 attribute-specifier-seq [opt] using namespace :: [opt]
22693 nested-name-specifier [opt] namespace-name ; */
22695 static void
22697 {
22698 tree namespace_decl;
22701 {
22702 /* Error during attribute parsing that resulted in skipping
22703 to next semicolon. */
22706 }
22708 /* Look for the `using' keyword. */
22710 /* And the `namespace' keyword. */
22712 /* Look for the optional `::' operator. */
22714 /* And the optional nested-name-specifier. */
22720 /* Get the namespace being used. */
22723 /* And any specified GNU attributes. */
22727 /* Update the symbol table. */
22730 /* Look for the final `;'. */
22732 }
22734 /* Parse an asm-definition.
22736 asm-qualifier:
22737 volatile
22738 inline
22739 goto
22741 asm-qualifier-list:
22742 asm-qualifier
22743 asm-qualifier-list asm-qualifier
22745 asm-definition:
22746 asm ( string-literal ) ;
22748 GNU Extension:
22750 asm-definition:
22751 asm asm-qualifier-list [opt] ( string-literal ) ;
22752 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
22753 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
22754 : asm-operand-list [opt] ) ;
22755 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
22756 : asm-operand-list [opt]
22757 : asm-clobber-list [opt] ) ;
22758 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
22759 : asm-clobber-list [opt]
22760 : asm-goto-list ) ;
22762 The form with asm-goto-list is valid if and only if the asm-qualifier-list
22763 contains goto, and is the only allowed form in that case. No duplicates are
22764 allowed in an asm-qualifier-list. */
22766 static void
22768 {
22773 tree asm_stmt;
22781 /* Look for the `asm' keyword. */
22784 /* In C++20, unevaluated inline assembly is permitted in constexpr
22785 functions. */
22790 "function only available with %<-std=c++20%> or "
22793 /* Handle the asm-qualifier-list. */
22801 {
22805 {
22808 {
22812 }
22813 else
22814 {
22819 }
22825 {
22829 }
22830 else
22839 {
22843 }
22844 else
22859 }
22861 }
22868 {
22871 }
22873 /* Look for the opening `('. */
22876 /* Look for the string. */
22880 {
22884 }
22886 /* If we're allowing GNU extensions, check for the extended assembly
22887 syntax. Unfortunately, the `:' tokens need not be separated by
22888 a space in C, and so, for compatibility, we tolerate that here
22889 too. Doing that means that we have to treat the `::' operator as
22890 two `:' tokens. */
22895 {
22900 /* The extended syntax was used. */
22903 /* Look for outputs. */
22905 {
22906 /* Consume the `:'. */
22908 /* Parse the output-operands. */
22910 CPP_COLON)
22912 CPP_SCOPE)
22914 CPP_CLOSE_PAREN))
22915 {
22919 }
22920 }
22921 /* If the next token is `::', there are no outputs, and the
22922 next token is the beginning of the inputs. */
22924 /* The inputs are coming next. */
22927 /* Look for inputs. */
22930 {
22931 /* Consume the `:' or `::'. */
22933 /* Parse the output-operands. */
22935 CPP_COLON)
22937 CPP_SCOPE)
22939 CPP_CLOSE_PAREN))
22940 {
22944 }
22945 }
22947 /* The clobbers are coming next. */
22950 /* Look for clobbers. */
22953 {
22955 /* Consume the `:' or `::'. */
22957 /* Parse the clobbers. */
22959 CPP_COLON)
22961 CPP_CLOSE_PAREN))
22963 }
22965 /* The labels are coming next. */
22968 /* Look for labels. */
22971 {
22973 /* Consume the `:' or `::'. */
22975 /* Parse the labels. */
22977 }
22981 }
22985 /* Look for the closing `)'. */
22993 {
22994 /* Create the ASM_EXPR. */
22996 {
22999 /* If the extended syntax was not used, mark the ASM_EXPR. */
23001 {
23007 }
23008 }
23009 else
23011 }
23016 }
23018 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
23019 type that comes from the decl-specifier-seq. */
23021 static tree
23023 {
23026 {
23039 }
23042 }
23044 /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
23045 a construct looks like a variable definition but is actually a function
23046 declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
23047 is the declarator for this function declaration. */
23049 static void
23052 {
23053 /* Only warn if we are declaring a function at block scope. */
23057 /* And only if there is no storage class specified. */
23069 /* Don't warn when the whole declarator (not just the declarator-id!)
23070 was parenthesized. That is, don't warn for int(n()) but do warn
23071 for int(f)(). */
23075 tree type;
23077 {
23082 /* If the return type is void there is no ambiguity. */
23085 }
23087 /* Code like long f(); will have null ->type. If we have any
23088 type-specifiers, pretend we've seen int. */
23090 else
23093 auto_diagnostic_group d;
23098 /* The T t() case. */
23100 {
23102 "empty parentheses were disambiguated as a function "
23104 {
23105 /* () means value-initialization (C++03 and up); {} (C++11 and up)
23106 means value-initialization or aggregate-initialization, nothing
23107 means default-initialization. We can only suggest removing the
23108 parentheses/adding {} if T has a default constructor. */
23110 {
23116 {
23120 else
23123 }
23124 }
23125 }
23127 }
23129 /* If we had (...) or the parameter-list wasn't parenthesized,
23130 we're done. */
23134 /* The T t(X()) case. */
23136 {
23138 "parentheses were disambiguated as a function "
23140 {
23142 /* {}-initialization means that we can use an initializer-list
23143 constructor if no default constructor is available, so don't
23144 suggest using {} for classes that have an initializer_list
23145 constructor. */
23147 {
23152 }
23153 else
23154 {
23158 }
23159 }
23160 }
23161 /* The T t(X(), X()) case. */
23163 "parentheses were disambiguated as a function "
23165 {
23168 {
23173 }
23174 }
23175 }
23177 /* If DECLARATOR with DECL_SPECS is a function declarator that has
23178 the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
23179 has the same meaning as in cp_parser_declarator. */
23181 static void
23186 {
23192 {
23200 {
23204 }
23205 }
23206 }
23208 /* Declarators [gram.dcl.decl] */
23210 /* Parse an init-declarator.
23212 init-declarator:
23213 declarator initializer [opt]
23215 GNU Extension:
23217 init-declarator:
23218 declarator asm-specification [opt] attributes [opt] initializer [opt]
23220 function-definition:
23221 decl-specifier-seq [opt] declarator ctor-initializer [opt]
23222 function-body
23223 decl-specifier-seq [opt] declarator function-try-block
23225 GNU Extension:
23227 function-definition:
23228 __extension__ function-definition
23230 TM Extension:
23232 function-definition:
23233 decl-specifier-seq [opt] declarator function-transaction-block
23235 The parser flags FLAGS is used to control type-specifier parsing.
23237 The DECL_SPECIFIERS apply to this declarator. Returns a
23238 representation of the entity declared. If MEMBER_P is TRUE, then
23239 this declarator appears in a class scope. The new DECL created by
23240 this declarator is returned.
23242 The CHECKS are access checks that should be performed once we know
23243 what entity is being declared (and, therefore, what classes have
23244 befriended it).
23246 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
23247 for a function-definition here as well. If the declarator is a
23248 declarator for a function-definition, *FUNCTION_DEFINITION_P will
23249 be TRUE upon return. By that point, the function-definition will
23250 have been completely parsed.
23252 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
23253 is FALSE.
23255 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
23256 parsed declaration if it is an uninitialized single declarator not followed
23257 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
23258 if present, will not be consumed. If returned, this declarator will be
23259 created with SD_INITIALIZED but will not call cp_finish_decl.
23261 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
23262 and there is an initializer, the pointed location_t is set to the
23263 location of the '=' or `(', or '{' in C++11 token introducing the
23264 initializer. */
23266 static tree
23268 cp_parser_flags flags,
23278 {
23282 tree prefix_attributes;
23284 tree asm_specification;
23285 tree initializer;
23287 tree scope;
23289 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
23290 initialized with "= ..", CPP_OPEN_PAREN if initialized with
23291 "(...)". */
23306 /* Assume that this is not the declarator for a function
23307 definition. */
23311 /* Default arguments are only permitted for function parameters. */
23315 /* Defer access checks while parsing the declarator; we cannot know
23316 what names are accessible until we know what is being
23317 declared. */
23322 /* Parse the declarator. */
23323 declarator
23328 /* Gather up the deferred checks. */
23333 /* If the DECLARATOR was erroneous, there's no need to go
23334 further. */
23338 /* Check that the number of template-parameter-lists is OK. */
23348 /* Figure out what scope the entity declared by the DECLARATOR is
23349 located in. `grokdeclarator' sometimes changes the scope, so
23350 we compute it now. */
23353 /* Perform any lookups in the declared type which were thought to be
23354 dependent, but are not in the scope of the declarator. */
23355 decl_specifiers->type
23358 /* If we're allowing GNU extensions, look for an
23359 asm-specification. */
23361 {
23362 /* Look for an asm-specification. */
23365 }
23366 else
23369 /* Gather the attributes that were provided with the
23370 decl-specifiers. */
23373 /* Look for attributes. */
23377 /* Peek at the next token. */
23383 {
23384 /* Handle C++17 deduction guides. Note that class-scope
23385 non-template deduction guides are instead handled in
23386 cp_parser_member_declaration. */
23388 decl_specifiers,
23389 declarator,
23395 /* Check to see if the token indicates the start of a
23396 function-definition. */
23398 {
23400 {
23401 /* If a function-definition should not appear here, issue an
23402 error message. */
23406 }
23408 location_t func_brace_location
23411 /* Neither attributes nor an asm-specification are allowed
23412 on a function-definition. */
23415 "an %<asm%> specification is not allowed "
23419 "attributes are not allowed "
23421 /* This is a function-definition. */
23424 /* Parse the function definition. */
23427 decl_specifiers,
23428 declarator,
23429 prefix_attributes);
23430 else
23431 decl =
23432 (cp_parser_function_definition_from_specifiers_and_declarator
23436 {
23437 /* This is where the prologue starts... */
23440 }
23443 }
23444 }
23446 {
23447 /* A non-template declaration involving a function parameter list
23448 containing an implicit template parameter will be made into a
23449 template. If the resulting declaration is not going to be an
23450 actual function then finish the template scope here to prevent it.
23451 An error message will be issued once we have a decl to talk about.
23453 FIXME probably we should do type deduction rather than create an
23454 implicit template, but the standard currently doesn't allow it. */
23457 }
23459 /* [dcl.dcl]
23461 Only in function declarations for constructors, destructors, type
23462 conversions, and deduction guides can the decl-specifier-seq be omitted.
23464 We explicitly postpone this check past the point where we handle
23465 function-definitions because we tolerate function-definitions
23466 that are missing their return types in some modes. */
23468 {
23472 }
23474 /* An `=' or an '{' in C++11, indicate an initializer. An '(' may indicate
23475 an initializer as well. */
23479 {
23480 /* Don't get fooled into thinking that F(i)(1)(2) is an initializer.
23481 It isn't; it's an expression. (Here '(i)' would have already been
23482 parsed as a declarator.) */
23485 {
23492 /* If this is an initializer, only a ',' or ';' can follow: either
23493 we have another init-declarator, or we're at the end of an
23494 init-declarator-list which can only be followed by a ';'. */
23499 /* Not an init-declarator. */
23501 }
23513 {
23519 }
23520 }
23521 else
23522 {
23523 /* If the init-declarator isn't initialized and isn't followed by a
23524 `,' or `;', it's not a valid init-declarator. */
23527 {
23530 else
23531 {
23535 }
23536 }
23539 }
23541 /* Because start_decl has side-effects, we should only call it if we
23542 know we're going ahead. By this point, we know that we cannot
23543 possibly be looking at any other construct. */
23546 /* Enter the newly declared entry in the symbol table. If we're
23547 processing a declaration in a class-specifier, we wait until
23548 after processing the initializer. */
23550 {
23558 /* Adjust location of decl if declarator->id_loc is more appropriate:
23559 set, and decl wasn't merged with another decl, in which case its
23560 location would be different from input_location, and more accurate. */
23565 }
23567 /* Enter the SCOPE. That way unqualified names appearing in the
23568 initializer will be looked up in SCOPE. */
23571 /* Perform deferred access control checks, now that we know in which
23572 SCOPE the declared entity resides. */
23574 {
23577 /* If the entity being declared is a function, pretend that we
23578 are in its scope. If it is a `friend', it may have access to
23579 things that would not otherwise be accessible. */
23581 {
23584 }
23586 /* Perform access checks for template parameters. */
23589 /* Perform the access control checks for the declarator and the
23590 decl-specifiers. */
23593 /* Restore the saved value. */
23596 }
23598 /* Parse the initializer. */
23603 {
23605 {
23608 else
23609 {
23610 /* If the declaration was erroneous, we don't really
23611 know what the user intended, so just silently
23612 consume the initializer. */
23619 }
23620 }
23621 else
23622 {
23623 /* We want to record the extra mangling scope for in-class
23624 initializers of class members and initializers of static
23625 data member templates and namespace-scope initializers.
23626 The former involves deferring parsing of the initializer
23627 until end of class as with default arguments. So right
23628 here we only handle the latter two. */
23632 && !member_p
23645 }
23646 }
23648 /* The old parser allows attributes to appear after a parenthesized
23649 initializer. Mark Mitchell proposed removing this functionality
23650 on the GCC mailing lists on 2002-08-13. This parser accepts the
23651 attributes -- but ignores them. Made a permerror in GCC 8. */
23657 {
23660 {
23664 }
23665 }
23667 /* And now complain about a non-function implicit template. */
23672 /* For an in-class declaration, use `grokfield' to create the
23673 declaration. */
23675 {
23677 {
23680 }
23689 }
23691 /* Finish processing the declaration. But, skip member
23692 declarations. */
23694 {
23697 asm_specification,
23698 /* If the initializer is in parentheses, then this is
23699 a direct-initialization, which means that an
23700 `explicit' constructor is OK. Otherwise, an
23701 `explicit' constructor cannot be used. */
23704 }
23707 /* Core issue #226 (C++0x only): A default template-argument
23708 shall not be specified in a friend class template
23709 declaration. */
23718 {
23721 else
23723 }
23730 }
23732 /* Parse a declarator.
23734 declarator:
23735 direct-declarator
23736 ptr-operator declarator
23738 abstract-declarator:
23739 ptr-operator abstract-declarator [opt]
23740 direct-abstract-declarator
23742 GNU Extensions:
23744 declarator:
23745 attributes [opt] direct-declarator
23746 attributes [opt] ptr-operator declarator
23748 abstract-declarator:
23749 attributes [opt] ptr-operator abstract-declarator [opt]
23750 attributes [opt] direct-abstract-declarator
23752 The parser flags FLAGS is used to control type-specifier parsing.
23754 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
23755 detect constructors, destructors, deduction guides, or conversion operators.
23756 It is set to -1 if the declarator is a name, and +1 if it is a
23757 function. Otherwise it is set to zero. Usually you just want to
23758 test for >0, but internally the negative value is used.
23760 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
23761 a decl-specifier-seq unless it declares a constructor, destructor,
23762 or conversion. It might seem that we could check this condition in
23763 semantic analysis, rather than parsing, but that makes it difficult
23764 to handle something like `f()'. We want to notice that there are
23765 no decl-specifiers, and therefore realize that this is an
23766 expression, not a declaration.)
23768 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
23769 the declarator is a direct-declarator of the form "(...)".
23771 MEMBER_P is true iff this declarator is a member-declarator.
23773 FRIEND_P is true iff this declarator is a friend.
23775 STATIC_P is true iff the keyword static was seen. */
23779 cp_parser_declarator_kind dcl_kind,
23780 cp_parser_flags flags,
23784 {
23787 cp_cv_quals cv_quals;
23788 tree class_type;
23791 /* Assume this is not a constructor, destructor, or type-conversion
23792 operator. */
23799 /* Check for the ptr-operator production. */
23801 /* Parse the ptr-operator. */
23807 /* If that worked, then we have a ptr-operator. */
23809 {
23810 /* If a ptr-operator was found, then this declarator was not
23811 parenthesized. */
23814 /* The dependent declarator is optional if we are parsing an
23815 abstract-declarator. */
23819 /* Parse the dependent declarator. */
23825 /* If we are parsing an abstract-declarator, we must handle the
23826 case where the dependent declarator is absent. */
23831 declarator = cp_parser_make_indirect_declarator
23833 }
23834 /* Everything else is a direct-declarator. */
23835 else
23836 {
23839 CPP_OPEN_PAREN);
23843 }
23848 }
23850 /* Parse a direct-declarator or direct-abstract-declarator.
23852 direct-declarator:
23853 declarator-id
23854 direct-declarator ( parameter-declaration-clause )
23855 cv-qualifier-seq [opt]
23856 ref-qualifier [opt]
23857 exception-specification [opt]
23858 direct-declarator [ constant-expression [opt] ]
23859 ( declarator )
23861 direct-abstract-declarator:
23862 direct-abstract-declarator [opt]
23863 ( parameter-declaration-clause )
23864 cv-qualifier-seq [opt]
23865 ref-qualifier [opt]
23866 exception-specification [opt]
23867 direct-abstract-declarator [opt] [ constant-expression [opt] ]
23868 ( abstract-declarator )
23870 Returns a representation of the declarator. DCL_KIND is
23871 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
23872 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
23873 we are parsing a direct-declarator. It is
23874 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
23875 of ambiguity we prefer an abstract declarator, as per
23876 [dcl.ambig.res].
23877 The parser flags FLAGS is used to control type-specifier parsing.
23878 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
23879 as for cp_parser_declarator. */
23883 cp_parser_declarator_kind dcl_kind,
23884 cp_parser_flags flags,
23887 {
23898 {
23899 /* Peek at the next token. */
23902 {
23903 /* This is either a parameter-declaration-clause, or a
23904 parenthesized declarator. When we know we are parsing a
23905 named declarator, it must be a parenthesized declarator
23906 if FIRST is true. For instance, `(int)' is a
23907 parameter-declaration-clause, with an omitted
23908 direct-abstract-declarator. But `((*))', is a
23909 parenthesized abstract declarator. Finally, when T is a
23910 template parameter `(T)' is a
23911 parameter-declaration-clause, and not a parenthesized
23912 named declarator.
23914 We first try and parse a parameter-declaration-clause,
23915 and then try a nested declarator (if FIRST is true).
23917 It is not an error for it not to be a
23918 parameter-declaration-clause, even when FIRST is
23919 false. Consider,
23921 int i (int);
23922 int i (3);
23924 The first is the declaration of a function while the
23925 second is the definition of a variable, including its
23926 initializer.
23928 Having seen only the parenthesis, we cannot know which of
23929 these two alternatives should be selected. Even more
23930 complex are examples like:
23932 int i (int (a));
23933 int i (int (3));
23935 The former is a function-declaration; the latter is a
23936 variable initialization.
23938 Thus again, we try a parameter-declaration-clause, and if
23939 that fails, we back out and return. */
23942 {
23943 tree params;
23948 /* In a member-declarator, the only valid interpretation
23949 of a parenthesis is the start of a
23950 parameter-declaration-clause. (It is invalid to
23951 initialize a static data member with a parenthesized
23952 initializer; only the "=" form of initialization is
23953 permitted.) */
23957 /* Consume the `('. */
23959 matching_parens parens;
23962 {
23963 /* If this is going to be an abstract declarator, we're
23964 in a declarator and we can't have default args. */
23967 }
23971 /* Parse the parameter-declaration-clause. */
23972 params
23974 const location_t parens_end
23977 /* Consume the `)'. */
23980 /* For code like
23981 int x(auto(42));
23982 A a(auto(i), 42);
23983 we have synthesized an implicit template parameter and marked
23984 what we thought was a function as an implicit function template.
23985 But now, having seen the whole parameter list, we know it's not
23986 a function declaration, so undo that. */
23989 /* Don't do this for the inner (). */
23993 /* If all went well, parse the cv-qualifier-seq,
23994 ref-qualifier and the exception-specification. */
23996 {
23997 cp_cv_quals cv_quals;
23998 cp_virt_specifiers virt_specifiers;
23999 cp_ref_qualifier ref_qual;
24000 tree exception_specification;
24001 tree late_return;
24002 tree attrs;
24005 unsigned char local_variables_forbidden_p
24007 /* 'this' is not allowed in static member functions. */
24017 /* Parse the cv-qualifier-seq. */
24019 /* Parse the ref-qualifier. */
24021 /* Parse the tx-qualifier. */
24027 /* DR 1207: 'this' is in scope after the cv-quals. */
24030 /* If it turned out that this is e.g. a pointer to a
24031 function, we don't want to delay noexcept parsing. */
24035 /* Parse the exception-specification. */
24036 exception_specification
24038 flags);
24042 cp_omp_declare_simd_data odsd;
24044 && declarator
24047 {
24051 }
24053 /* In here, we handle cases where attribute is used after
24054 the function declaration. For example:
24055 void func (int x) __attribute__((vector(..))); */
24058 late_return
24060 requires_clause);
24064 /* Parse the virt-specifier-seq. */
24068 parens_start,
24069 parens_end);
24070 /* Create the function-declarator. */
24072 params,
24073 cv_quals,
24074 virt_specifiers,
24075 ref_qual,
24076 tx_qual,
24077 exception_specification,
24078 late_return,
24079 requires_clause,
24080 attrs,
24081 parens_loc);
24083 /* Any subsequent parameter lists are to do with
24084 return type, so are not those of the declared
24085 function. */
24091 /* Restore the state of local_variables_forbidden_p. */
24092 parser->local_variables_forbidden_p
24094 }
24096 /* Remove the function parms from scope. */
24100 /* Repeat the main loop. */
24102 }
24104 /* If this is the first, we can try a parenthesized
24105 declarator. */
24107 {
24114 /* Consume the `('. */
24115 matching_parens parens;
24117 /* Parse the nested declarator. */
24120 declarator
24122 ctor_dtor_or_conv_p,
24128 /* Expect a `)'. */
24136 }
24137 /* Otherwise, we must be done. */
24138 else
24140 }
24144 {
24145 /* Parse an array-declarator. */
24155 /* Consume the `['. */
24157 /* Peek at the next token. */
24159 /* If the next token is `]', then there is no
24160 constant-expression. */
24162 {
24164 bounds
24176 {
24177 /* Normally, the array bound must be an integral constant
24178 expression. However, as an extension, we allow VLAs
24179 in function scopes as long as they aren't part of a
24180 parameter declaration. */
24184 }
24187 {
24188 /* Remember this wasn't a constant-expression. */
24191 }
24192 }
24193 else
24195 /* Look for the closing `]'. */
24197 {
24200 }
24205 }
24207 {
24208 {
24209 tree qualifying_scope;
24210 tree unqualified_name;
24211 tree attrs;
24212 special_function_kind sfk;
24217 /* Parse a declarator-id */
24220 {
24223 /* If we see an ellipsis, we should be looking at a
24224 parameter pack. */
24226 {
24227 /* Consume the `...' */
24231 }
24232 }
24235 unqualified_name
24239 {
24243 {
24244 /* Check whether an error occurred. */
24247 /* We already consumed the ellipsis to mark a
24248 parameter pack, but we have no way to report it,
24249 so abort the tentative parse. We will be exiting
24250 immediately anyway. */
24252 }
24253 else
24259 && (qualifying_scope
24261 {
24264 }
24265 }
24270 {
24275 }
24281 {
24282 /* In the declaration of a member of a template class
24283 outside of the class itself, the SCOPE will sometimes
24284 be a TYPENAME_TYPE. For example, given:
24286 template <typename T>
24287 int S<T>::R::i = 3;
24289 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
24290 this context, we must resolve S<T>::R to an ordinary
24291 type, rather than a typename type.
24293 The reason we normally avoid resolving TYPENAME_TYPEs
24294 is that a specialization of `S' might render
24295 `S<T>::R' not a type. However, if `S' is
24296 specialized, then this `i' will not be used, so there
24297 is no harm in resolving the types here. */
24298 tree type;
24300 /* Resolve the TYPENAME_TYPE. */
24303 /* If that failed, the declarator is invalid. */
24305 {
24308 "cannot define member of dependent typedef "
24310 else
24315 }
24317 }
24322 {
24323 tree class_type;
24328 else
24332 {
24336 {
24337 /* We do not attempt to print the declarator
24338 here because we do not have enough
24339 information about its original syntactic
24340 form. */
24344 }
24347 {
24351 "use %<%T::%D%> instead of %<%T::%D%> to "
24353 class_type,
24358 }
24360 }
24363 {
24370 for an unnamed type, even if the type
24371 got a name for linkage purposes. */
24373 /* Handle correctly (c++/19200):
24375 struct S {
24376 struct T{};
24377 friend void S(T);
24378 };
24380 and also:
24382 namespace N {
24383 void S();
24384 }
24386 struct S {
24387 friend void N::S();
24388 }; */
24391 class_type))
24400 }
24401 }
24403 unqualified_name,
24411 /* We're looking for this case in [temp.res]:
24412 A qualified-id is assumed to name a type if [...]
24413 - it is a decl-specifier of the decl-specifier-seq of a
24414 parameter-declaration in a declarator of a function or
24415 function template declaration, ... */
24421 {
24422 /* ...whose declarator-id is qualified. If it isn't, never
24423 assume the parameters to refer to types. */
24426 else
24427 {
24428 /* Now we have something like
24429 template <typename T> int C::x(S::p);
24430 which can be a function template declaration or a
24431 variable template definition. If name lookup for
24432 the declarator-id C::x finds one or more function
24433 templates, assume S::p to name a type. Otherwise,
24434 don't. */
24435 tree decl
24437 none_type,
24445 /* Allow
24446 template<typename T>
24447 A<T>::A(T::type) { } */
24450 qualifying_scope)))
24452 }
24453 }
24454 }
24456 handle_declarator:;
24459 {
24460 /* Any names that appear after the declarator-id for a
24461 member are looked up in the containing scope. */
24463 {
24464 /* But declarations with qualified-ids can't appear in a
24465 function. */
24469 }
24471 }
24475 /* Default args are only allowed on function
24476 declarations. */
24478 else
24482 }
24483 /* We're done. */
24484 else
24486 }
24488 /* For an abstract declarator, we might wind up with nothing at this
24489 point. That's an error; the declarator is not optional. */
24493 {
24494 /* Record overly parenthesized declarator so we can give a
24495 diagnostic about confusing decl/expr disambiguation. */
24497 {
24498 /* If the open and close parens are on different lines, this
24499 is probably a formatting thing, so ignore. */
24504 }
24509 }
24511 /* If we entered a scope, we must exit it now. */
24519 }
24521 /* Parse a ptr-operator.
24523 ptr-operator:
24524 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24525 * cv-qualifier-seq [opt]
24526 &
24527 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
24528 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
24530 GNU Extension:
24532 ptr-operator:
24533 & cv-qualifier-seq [opt]
24535 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
24536 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
24537 an rvalue reference. In the case of a pointer-to-member, *TYPE is
24538 filled in with the TYPE containing the member. *CV_QUALS is
24539 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
24540 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
24541 Note that the tree codes returned by this function have nothing
24542 to do with the types of trees that will be eventually be created
24543 to represent the pointer or reference type being parsed. They are
24544 just constants with suggestive names. */
24545 static enum tree_code
24550 {
24555 /* Assume that it's not a pointer-to-member. */
24557 /* And that there are no cv-qualifiers. */
24560 /* Peek at the next token. */
24563 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
24573 {
24574 /* Consume the `*', `&' or `&&'. */
24577 /* A `*' can be followed by a cv-qualifier-seq, and so can a
24578 `&', if we are allowing GNU extensions. (The only qualifier
24579 that can legally appear after `&' is `restrict', but that is
24580 enforced during semantic analysis. */
24588 }
24589 else
24590 {
24591 /* Try the pointer-to-member case. */
24593 /* Look for the optional `::' operator. */
24596 /* Look for the nested-name specifier. */
24603 /* If we found it, and the next token is a `*', then we are
24604 indeed looking at a pointer-to-member operator. */
24607 {
24608 /* Indicate that the `*' operator was used. */
24616 else
24617 {
24618 /* The type of which the member is a member is given by the
24619 current SCOPE. */
24621 /* The next name will not be qualified. */
24625 /* Look for optional c++11 attributes. */
24629 /* Look for the optional cv-qualifier-seq. */
24631 }
24632 }
24633 /* If that didn't work we don't have a ptr-operator. */
24636 }
24639 }
24641 /* Parse an (optional) cv-qualifier-seq.
24643 cv-qualifier-seq:
24644 cv-qualifier cv-qualifier-seq [opt]
24646 cv-qualifier:
24647 const
24648 volatile
24650 GNU Extension:
24652 cv-qualifier:
24653 __restrict__
24655 Returns a bitmask representing the cv-qualifiers. */
24657 static cp_cv_quals
24659 {
24663 {
24665 cp_cv_quals cv_qualifier;
24667 /* Peek at the next token. */
24669 /* See if it's a cv-qualifier. */
24671 {
24687 }
24693 {
24698 }
24699 else
24700 {
24703 }
24704 }
24707 }
24709 /* Parse an (optional) ref-qualifier
24711 ref-qualifier:
24712 &
24713 &&
24715 Returns cp_ref_qualifier representing ref-qualifier. */
24717 static cp_ref_qualifier
24719 {
24722 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
24727 {
24732 {
24744 }
24749 {
24752 }
24753 else
24754 {
24757 }
24758 }
24761 }
24763 /* Parse an optional tx-qualifier.
24765 tx-qualifier:
24766 transaction_safe
24767 transaction_safe_dynamic */
24769 static tree
24771 {
24774 {
24779 {
24783 {
24786 {
24789 }
24790 else
24792 }
24793 }
24794 }
24796 }
24798 /* Parse an (optional) virt-specifier-seq.
24800 virt-specifier-seq:
24801 virt-specifier virt-specifier-seq [opt]
24803 virt-specifier:
24804 override
24805 final
24807 Returns a bitmask representing the virt-specifiers. */
24809 static cp_virt_specifiers
24811 {
24815 {
24817 cp_virt_specifiers virt_specifier;
24819 /* Peek at the next token. */
24821 /* See if it's a virt-specifier-qualifier. */
24825 {
24828 }
24830 {
24833 }
24835 {
24837 }
24838 else
24842 {
24847 }
24848 else
24849 {
24852 }
24853 }
24855 }
24857 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
24858 is in scope even though it isn't real. */
24860 void
24862 {
24863 tree this_parm;
24866 {
24867 /* We don't clear this between NSDMIs. Is it already what we want? */
24874 }
24877 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
24879 current_class_ref
24882 }
24884 /* Return true iff our current scope is a non-static data member
24885 initializer. */
24887 bool
24889 {
24890 /* We recognize NSDMI context by the context-less 'this' pointer set up
24891 by the function above. */
24897 }
24899 /* True if we're parsing a function declarator. */
24901 bool
24903 {
24904 /* this_entity is NULL for a function parameter scope while parsing the
24905 declarator; it is set when parsing the body of the function. */
24908 }
24910 /* Parse a late-specified return type, if any. This is not a separate
24911 non-terminal, but part of a function declarator, which looks like
24913 -> trailing-type-specifier-seq abstract-declarator(opt)
24915 Returns the type indicated by the type-id.
24917 In addition to this, parse any queued up #pragma omp declare simd
24918 clauses, and #pragma acc routine clauses.
24920 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
24921 function. */
24923 static tree
24926 {
24930 && declarator
24934 && declarator
24937 /* Peek at the next token. */
24939 /* A late-specified return type is indicated by an initial '->'. */
24948 {
24949 /* Consume the ->. */
24953 }
24955 /* Function declarations may be followed by a trailing
24956 requires-clause. */
24960 declarator->attributes
24964 declarator->attributes
24969 }
24971 /* Parse a declarator-id.
24973 declarator-id:
24974 id-expression
24975 :: [opt] nested-name-specifier [opt] type-name
24977 In the `id-expression' case, the value returned is as for
24978 cp_parser_id_expression if the id-expression was an unqualified-id.
24979 If the id-expression was a qualified-id, then a SCOPE_REF is
24980 returned. The first operand is the scope (either a NAMESPACE_DECL
24981 or TREE_TYPE), but the second is still just a representation of an
24982 unqualified-id. */
24984 static tree
24986 {
24987 tree id;
24988 /* The expression must be an id-expression. Assume that qualified
24989 names are the names of types so that:
24991 template <class T>
24992 int S<T>::R::i = 3;
24994 will work; we must treat `S<T>::R' as the name of a type.
24995 Similarly, assume that qualified names are templates, where
24996 required, so that:
24998 template <class T>
24999 int S<T>::R<T>::i = 3;
25001 will work, too. */
25007 optional_p);
25011 }
25013 /* Parse a type-id.
25015 type-id:
25016 type-specifier-seq abstract-declarator [opt]
25018 The parser flags FLAGS is used to control type-specifier parsing.
25020 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
25022 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
25023 i.e. we've just seen "->".
25025 Returns the TYPE specified. */
25027 static tree
25031 {
25032 cp_decl_specifier_seq type_specifier_seq;
25035 /* Parse the type-specifier-seq. */
25038 is_trailing_return,
25046 /* A bare template name as a template argument is a template template
25047 argument, not a placeholder, so fail parsing it as a type argument. */
25048 {
25052 }
25056 /* There might or might not be an abstract declarator. */
25058 /* Look for the declarator. */
25059 abstract_declarator
25066 /* Check to see if there really was a declarator. */
25071 /* The concepts TS allows 'auto' as a type-id. */
25074 /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
25075 outside the template-argument-list context here only for the sake of
25076 diagnostic: grokdeclarator then can emit a better error message for
25077 e.g. using T = auto. */
25083 && !auto_typeid_ok
25084 /* None of the valid uses of 'auto' in C++14 involve the type-id
25085 nonterminal, but it is valid in a trailing-return-type. */
25088 {
25089 /* A type-id with type 'auto' is only ok if the abstract declarator
25090 is a function declarator with a late-specified return type.
25092 A type-id with 'auto' is also valid in a trailing-return-type
25093 in a compound-requirement. */
25100 else
25101 {
25103 {
25106 {
25107 auto_diagnostic_group g;
25111 tmpl);
25113 tmpl);
25114 }
25117 auto_node);
25118 else
25120 }
25122 }
25123 }
25126 is_template_arg);
25127 }
25129 /* Wrapper for cp_parser_type_id_1. */
25131 static tree
25134 {
25136 }
25138 /* Wrapper for cp_parser_type_id_1. */
25140 static tree
25142 {
25144 parser->type_definition_forbidden_message
25150 /* cp_parser_type_id_1 checks for auto, but only for
25151 ->auto_is_implicit_function_template_parm_p. */
25153 {
25156 }
25158 }
25160 /* Wrapper for cp_parser_type_id_1. */
25162 static tree
25164 {
25167 }
25169 /* Parse a type-specifier-seq.
25171 type-specifier-seq:
25172 type-specifier type-specifier-seq [opt]
25174 GNU extension:
25176 type-specifier-seq:
25177 attributes type-specifier-seq [opt]
25179 The parser flags FLAGS is used to control type-specifier parsing.
25181 If IS_DECLARATION is true, we are at the start of a "condition" or
25182 exception-declaration, so we might be followed by a declarator-id.
25184 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
25185 i.e. we've just seen "->".
25187 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
25189 static void
25191 cp_parser_flags flags,
25195 {
25199 /* Clear the TYPE_SPECIFIER_SEQ. */
25203 /* In the context of a trailing return type, enum E { } is an
25204 elaborated-type-specifier followed by a function-body, not an
25205 enum-specifier. */
25209 /* Parse the type-specifiers and attributes. */
25211 {
25212 tree type_specifier;
25215 /* Check for attributes first. */
25217 {
25218 /* GNU attributes at the end of a declaration apply to the
25219 declaration as a whole, not to the trailing return type. So look
25220 ahead to see if these attributes are at the end. */
25223 {
25229 }
25230 type_specifier_seq->attributes
25234 }
25236 /* record the token of the beginning of the type specifier seq,
25237 for error reporting purposes*/
25241 /* Look for the type-specifier. */
25243 flags,
25244 type_specifier_seq,
25246 NULL,
25249 {
25250 /* If the first type-specifier could not be found, this is not a
25251 type-specifier-seq at all. */
25253 {
25254 /* Set in_declarator_p to avoid skipping to the semicolon. */
25266 }
25267 /* If subsequent type-specifiers could not be found, the
25268 type-specifier-seq is complete. */
25270 }
25273 /* The standard says that a condition can be:
25275 type-specifier-seq declarator = assignment-expression
25277 However, given:
25279 struct S {};
25280 if (int S = ...)
25282 we should treat the "S" as a declarator, not as a
25283 type-specifier. The standard doesn't say that explicitly for
25284 type-specifier-seq, but it does say that for
25285 decl-specifier-seq in an ordinary declaration. Perhaps it
25286 would be clearer just to allow a decl-specifier-seq here, and
25287 then add a semantic restriction that if any decl-specifiers
25288 that are not type-specifiers appear, the program is invalid. */
25291 }
25292 }
25294 /* Return whether the function currently being declared has an associated
25295 template parameter list. */
25297 static bool
25299 {
25312 }
25314 /* Parse a parameter-declaration-clause.
25316 parameter-declaration-clause:
25317 parameter-declaration-list [opt] ... [opt]
25318 parameter-declaration-list , ...
25320 The parser flags FLAGS is used to control type-specifier parsing.
25322 Returns a representation for the parameter declarations. A return
25323 value of NULL indicates a parameter-declaration-clause consisting
25324 only of an ellipsis. */
25326 static tree
25328 cp_parser_flags flags)
25329 {
25330 tree parameters;
25338 && !processing_template_parmlist
25339 && !processing_explicit_instantiation
25340 /* default_arg_ok_p tracks whether this is a parameter-clause for an
25341 actual function or a random abstract declarator. */
25347 /* Peek at the next token. */
25349 /* Check for trivial parameter-declaration-clauses. */
25351 {
25352 /* Consume the `...' token. */
25355 }
25357 /* There are no parameters. */
25359 /* Check for `(void)', too, which is a special case. */
25363 {
25364 /* Consume the `void' token. */
25366 /* There are no parameters. */
25368 }
25370 /* A vector of parameters that haven't been pushed yet. */
25373 /* Parse the parameter-declaration-list. */
25376 /* If a parse error occurred while parsing the
25377 parameter-declaration-list, then the entire
25378 parameter-declaration-clause is erroneous. */
25382 /* Peek at the next token. */
25384 /* If it's a `,', the clause should terminate with an ellipsis. */
25386 {
25387 /* Consume the `,'. */
25389 /* Expect an ellipsis. */
25390 ellipsis_p
25392 }
25393 /* It might also be `...' if the optional trailing `,' was
25394 omitted. */
25396 {
25397 /* Consume the `...' token. */
25399 /* And remember that we saw it. */
25401 }
25402 else
25405 /* A valid parameter-declaration-clause can only be followed by a ')'.
25406 So it's time to push all the parameters we have seen now that we
25407 know we have a valid declaration. Note that here we may not have
25408 committed yet, nor should we. Pushing here will detect the error
25409 of redefining a parameter. */
25411 {
25415 /* Delayed checking of auto parameters. */
25420 {
25424 }
25425 }
25427 /* Finish the parameter list. */
25432 }
25434 /* Parse a parameter-declaration-list.
25436 parameter-declaration-list:
25437 parameter-declaration
25438 parameter-declaration-list , parameter-declaration
25440 The parser flags FLAGS is used to control type-specifier parsing.
25441 PENDING_DECLS is a vector of parameters that haven't been pushed yet.
25443 Returns a representation of the parameter-declaration-list, as for
25444 cp_parser_parameter_declaration_clause. However, the
25445 `void_list_node' is never appended to the list. */
25447 static tree
25449 cp_parser_flags flags,
25451 {
25457 /* The special considerations that apply to a function within an
25458 unbraced linkage specifications do not apply to the parameters
25459 to the function. */
25460 saved_in_unbraced_linkage_specification_p
25464 /* Look for more parameters. */
25466 {
25471 /* Parse the parameter. */
25472 parameter
25477 /* We don't know yet if the enclosing context is unavailable or deprecated,
25478 so wait and deal with it in grokparms if appropriate. */
25482 {
25485 PARM,
25490 }
25494 /* If a parse error occurred parsing the parameter declaration,
25495 then the entire parameter-declaration-list is erroneous. */
25497 {
25500 }
25507 {
25508 /* We cannot always pushdecl while parsing tentatively because
25509 it may have side effects and we can't be sure yet if we're
25510 parsing a declaration, e.g.:
25512 S foo(int(x), int(x), int{x});
25514 where it's not clear if we're dealing with a constructor call
25515 or a function declaration until we've seen the last argument
25516 which breaks it up.
25517 It's safe to pushdecl so long as it doesn't result in a clash
25518 with an already-pushed parameter. But we don't delay pushing
25519 different parameters to handle
25521 S foo(int(i), decltype(i) j = 42);
25523 which is valid. */
25526 /* See if PARAMETERS already contains a parameter with the same
25527 DECL_NAME as DECL. */
25533 }())
25535 else
25537 }
25540 {
25544 }
25546 /* Add the new parameter to the list. */
25550 /* If the parameters were parenthesized, it's the case of
25551 T foo(X(x)) which looks like a variable definition but
25552 is a function declaration. */
25556 /* Peek at the next token. */
25559 /* These are for Objective-C++ */
25562 /* The parameter-declaration-list is complete. */
25565 {
25568 /* Peek at the next token. */
25570 /* If it's an ellipsis, then the list is complete. */
25573 /* Otherwise, there must be more parameters. Consume the
25574 `,'. */
25576 /* When parsing something like:
25578 int i(float f, double d)
25580 we can tell after seeing the declaration for "f" that we
25581 are not looking at an initialization of a variable "i",
25582 but rather at the declaration of a function "i".
25584 Due to the fact that the parsing of template arguments
25585 (as specified to a template-id) requires backtracking we
25586 cannot use this technique when inside a template argument
25587 list. */
25591 /* However, a parameter-declaration of the form
25592 "float(f)" (which is a valid declaration of a
25593 parameter "f") can also be interpreted as an
25594 expression (the conversion of "f" to "float"). */
25597 }
25598 else
25599 {
25607 }
25608 }
25610 parser->in_unbraced_linkage_specification_p
25613 /* Reset implicit_template_scope if we are about to leave the function
25614 parameter list that introduced it. Note that for out-of-line member
25615 definitions, there will be one or more class scopes before we get to
25616 the template parameter scope. */
25620 {
25624 {
25627 }
25628 }
25631 }
25633 /* Parse a parameter declaration.
25635 parameter-declaration:
25636 decl-specifier-seq ... [opt] declarator
25637 decl-specifier-seq declarator = assignment-expression
25638 decl-specifier-seq ... [opt] abstract-declarator [opt]
25639 decl-specifier-seq abstract-declarator [opt] = assignment-expression
25641 The parser flags FLAGS is used to control type-specifier parsing.
25643 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
25644 declares a template parameter. (In that case, a non-nested `>'
25645 token encountered during the parsing of the assignment-expression
25646 is not interpreted as a greater-than operator.)
25648 Returns a representation of the parameter, or NULL if an error
25649 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
25650 true iff the declarator is of the form "(p)". */
25654 cp_parser_flags flags,
25657 {
25659 cp_decl_specifier_seq decl_specifiers;
25661 tree default_argument;
25666 /* In a template parameter, `>' is not an operator.
25668 [temp.param]
25670 When parsing a default template-argument for a non-type
25671 template-parameter, the first non-nested `>' is taken as the end
25672 of the template parameter-list rather than a greater-than
25673 operator. */
25675 /* Type definitions may not appear in parameter types. */
25677 parser->type_definition_forbidden_message
25684 /* Parse the declaration-specifiers. */
25691 /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form
25692 type-constraint opt auto can be used as a decl-specifier of the
25693 decl-specifier-seq of a parameter-declaration of a function declaration
25694 or lambda-expression..." but we must not synthesize an implicit template
25695 type parameter in its declarator. That is, in "void f(auto[auto{10}]);"
25696 we want to synthesize only the first auto. */
25700 /* Complain about missing 'typename' or other invalid type names. */
25705 /* If an error occurred, there's no reason to attempt to parse the
25706 rest of the declaration. */
25708 {
25711 }
25713 /* Peek at the next token. */
25716 /* If the next token is a `)', `,', `=', `>', or `...', then there
25717 is no declarator. However, when variadic templates are enabled,
25718 there may be a declarator following `...'. */
25723 {
25727 }
25728 /* Otherwise, there should be a declarator. */
25729 else
25730 {
25734 /* After seeing a decl-specifier-seq, if the next token is not a
25735 "(" or "{", there is no possibility that the code is a valid
25736 expression. Therefore, if parsing tentatively, we commit at
25737 this point. */
25739 /* In an expression context, having seen:
25741 (int((char ...
25743 we cannot be sure whether we are looking at a
25744 function-type (taking a "char" as a parameter) or a cast
25745 of some object of type "char" to "int". */
25749 {
25751 {
25754 /* This is a CTAD expression, not a parameter declaration. */
25756 }
25757 else
25759 }
25760 /* Parse the declarator. */
25763 CP_PARSER_DECLARATOR_EITHER,
25764 CP_PARSER_FLAGS_NONE,
25766 parenthesized_p,
25771 /* After the declarator, allow more attributes. */
25772 decl_specifiers.attributes
25776 /* If the declarator is a template parameter pack, remember that and
25777 clear the flag in the declarator itself so we don't get errors
25778 from grokdeclarator. */
25780 {
25783 }
25784 }
25786 /* If the next token is an ellipsis, and we have not seen a declarator
25787 name, and if either the type of the declarator contains parameter
25788 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
25789 for, eg, abbreviated integral type names), then we actually have a
25790 parameter pack expansion expression. Otherwise, leave the ellipsis
25791 for a C-style variadic function. */
25794 bool xobj_param_p
25797 {
25802 }
25804 /* If a function parameter pack was specified and an implicit template
25805 parameter was introduced during cp_parser_parameter_declaration,
25806 change any implicit parameters introduced into packs. */
25811 {
25816 decl_specifiers.type
25818 template_parm_idx,
25819 latest_template_parm_idx);
25820 }
25823 {
25834 {
25835 /* Consume the `...'. */
25839 /* Build a pack expansion type */
25844 else
25846 }
25847 }
25853 {
25854 location_t xobj_param
25857 input_location);
25859 "an explicit object parameter cannot "
25863 }
25865 /* The restriction on defining new types applies only to the type
25866 of the parameter, not to the default argument. */
25869 /* If the next token is `=', then process a default argument. */
25871 {
25874 /* Used for diagnostics with an xobj parameter. */
25878 /* If we are defining a class, then the tokens that make up the
25879 default argument must be saved and processed later. */
25885 /* A constrained-type-specifier may declare a type
25886 template-parameter. */
25888 default_argument
25891 /* A constrained-type-specifier may declare a
25892 template-template-parameter. */
25894 default_argument
25897 /* Outside of a class definition, we can just parse the
25898 assignment-expression. */
25899 else
25900 default_argument
25904 {
25906 "default arguments are only "
25908 }
25910 || template_parameter_pack_p
25913 {
25914 /* Find the name of the parameter pack. */
25921 template_parm_p
25927 else
25929 template_parm_p
25936 }
25937 }
25938 else
25945 {
25947 {
25948 /* If there is a default_argument, eq_token should always be set. */
25950 location_t param_with_init_loc
25953 input_location);
25955 "an explicit object parameter "
25957 }
25958 /* Xobj parameters can not have default arguments, thus
25959 we can reuse the default argument field to flag the param as such. */
25961 }
25963 /* Generate a location for the parameter, ranging from the start of the
25964 initial token to the end of the final token (using input_location for
25965 the latter, set up by cp_lexer_set_source_position_from_token when
25966 consuming tokens).
25968 If we have a identifier, then use it for the caret location, e.g.
25970 extern int callee (int one, int (*two)(int, int), float three);
25971 ~~~~~~^~~~~~~~~~~~~~
25973 otherwise, reuse the start location for the caret location e.g.:
25975 extern int callee (int one, int (*)(int, int), float three);
25976 ^~~~~~~~~~~~~~~~~
25978 */
25984 input_location);
25987 declarator,
25988 default_argument,
25989 param_loc,
25990 template_parameter_pack_p);
25991 }
25993 /* Parse a default argument and return it.
25995 TEMPLATE_PARM_P is true if this is a default argument for a
25996 non-type template parameter. */
25997 static tree
25999 {
26004 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
26005 set correctly. */
26012 /* Local variable names (and the `this' keyword) may not
26013 appear in a default argument. */
26016 /* Parse the assignment-expression. */
26021 /* The "this" pointer is not valid in a default argument. */
26023 {
26028 }
26030 /* Restore the "this" pointer. */
26032 {
26035 }
26044 }
26046 /* Parse a function-body.
26048 function-body:
26049 compound_statement */
26051 static void
26053 {
26057 }
26059 /* Parse a ctor-initializer-opt followed by a function-body. Return
26060 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
26061 is true we are parsing a function-try-block. */
26063 static void
26066 {
26068 const bool check_body_p
26076 {
26079 "function-try-block body of %<constexpr%> constructor only "
26081 else
26083 "function-try-block body of %<constexpr%> function only "
26085 }
26087 /* Begin the function body. */
26089 /* Parse the optional ctor-initializer. */
26092 /* If we're parsing a constexpr constructor definition, we need
26093 to check that the constructor body is indeed empty. However,
26094 before we get to cp_parser_function_body lot of junk has been
26095 generated, so we can't just check that we have an empty block.
26096 Rather we take a snapshot of the outermost block, and check whether
26097 cp_parser_function_body changed its state. */
26099 {
26103 }
26104 /* Parse the function-body. */
26108 /* Finish the function body. */
26110 }
26112 /* Parse an initializer.
26114 initializer:
26115 = initializer-clause
26116 ( expression-list )
26118 Returns an expression representing the initializer. If no
26119 initializer is present, NULL_TREE is returned.
26121 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
26122 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
26123 set to TRUE if there is no initializer present. If there is an
26124 initializer, and it is not a constant-expression, *NON_CONSTANT_P
26125 is set to true; otherwise it is set to false. */
26127 static tree
26130 {
26132 tree init;
26134 /* Peek at the next token. */
26137 /* Let our caller know whether or not this initializer was
26138 parenthesized. */
26141 /* Assume that the initializer is constant. */
26146 {
26147 /* Consume the `='. */
26149 /* Parse the initializer-clause. */
26151 }
26153 {
26158 non_constant_p);
26163 }
26165 {
26170 }
26171 else
26172 {
26173 /* Anything else is an error. */
26176 }
26182 }
26184 /* Parse an initializer-clause.
26186 initializer-clause:
26187 assignment-expression
26188 braced-init-list
26190 Returns an expression representing the initializer.
26192 If the `assignment-expression' production is used the value
26193 returned is simply a representation for the expression.
26195 Otherwise, calls cp_parser_braced_list. */
26197 static cp_expr
26199 {
26200 cp_expr initializer;
26202 /* Assume the expression is constant. */
26206 /* If it is not a `{', then we are looking at an
26207 assignment-expression. */
26209 {
26210 initializer
26213 non_constant_p);
26214 }
26215 else
26219 }
26221 /* Parse a brace-enclosed initializer list.
26223 braced-init-list:
26224 { initializer-list , [opt] }
26225 { designated-initializer-list , [opt] }
26226 { }
26228 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
26229 the elements of the initializer-list (or NULL, if the last
26230 production is used). The TREE_TYPE for the CONSTRUCTOR will be
26231 NULL_TREE. There is no way to detect whether or not the optional
26232 trailing `,' was provided. NON_CONSTANT_P is as for
26233 cp_parser_initializer. */
26235 static cp_expr
26237 {
26238 tree initializer;
26242 /* Consume the `{' token. */
26243 matching_braces braces;
26245 /* Create a CONSTRUCTOR to represent the braced-initializer. */
26247 /* If it's not a `}', then there is a non-trivial initializer. */
26249 {
26251 /* Parse the initializer list. */
26255 /* A trailing `,' token is allowed. */
26258 }
26261 /* Now, there should be a trailing `}'. */
26268 /* Build a location of the form:
26269 { ... }
26270 ^~~~~~~
26271 with caret==start at the open brace, finish at the close brace. */
26275 }
26277 /* Consume tokens up to, but not including, the next non-nested closing `]'.
26278 Returns true iff we found a closing `]'. */
26280 static bool
26282 {
26286 {
26290 {
26294 /* FALLTHRU */
26297 /* If we've run out of tokens, then there is no closing `]'. */
26311 }
26313 /* Consume the current token, skipping it. */
26315 }
26316 }
26318 /* Consume tokens up to, and including, the next non-nested closing `]'.
26319 Returns true iff we found a closing `]'. */
26321 static bool
26323 {
26328 }
26330 /* Return true if we are looking at an array-designator, false otherwise. */
26332 static bool
26334 {
26335 /* Consume the `['. */
26340 /* Skip tokens until the next token is a closing square bracket.
26341 If we find the closing `]', and the next token is a `=', then
26342 we are looking at an array designator. */
26343 bool array_designator_p
26347 /* Roll back the tokens we skipped. */
26351 }
26353 /* Parse an initializer-list.
26355 initializer-list:
26356 initializer-clause ... [opt]
26357 initializer-list , initializer-clause ... [opt]
26359 C++20 Extension:
26361 designated-initializer-list:
26362 designated-initializer-clause
26363 designated-initializer-list , designated-initializer-clause
26365 designated-initializer-clause:
26366 designator brace-or-equal-initializer
26368 designator:
26369 . identifier
26371 GNU Extension:
26373 initializer-list:
26374 designation initializer-clause ...[opt]
26375 initializer-list , designation initializer-clause ...[opt]
26377 designation:
26378 . identifier =
26379 identifier :
26380 [ constant-expression ] =
26382 Returns a vec of constructor_elt. The VALUE of each elt is an expression
26383 for the initializer. If the INDEX of the elt is non-NULL, it is the
26384 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
26385 as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
26386 are any designators. */
26391 {
26396 /* Assume all of the expressions are constant. */
26403 /* Parse the rest of the list. */
26405 {
26407 tree designator;
26408 tree initializer;
26413 /* Handle the C++20 syntax, '. id ='. */
26421 {
26424 "C++ designated initializers only available with "
26426 /* Consume the `.'. */
26428 /* Consume the identifier. */
26431 /* Consume the `='. */
26433 else
26435 }
26436 /* Also, if the next token is an identifier and the following one is a
26437 colon, we are looking at the GNU designated-initializer
26438 syntax. */
26443 {
26444 /* Warn the user that they are using an extension. */
26447 /* Consume the identifier. */
26449 /* Consume the `:'. */
26451 }
26452 /* Also handle C99 array designators, '[ const ] ='. */
26456 {
26457 /* In C++11, [ could start a lambda-introducer. */
26463 {
26466 }
26467 else
26468 {
26473 }
26478 && (!require_potential_rvalue_constant_expression
26482 /* Warn the user that they are using an extension. */
26485 }
26486 else
26490 {
26493 }
26497 {
26501 }
26505 /* Parse the initializer. */
26508 ? &clause_non_constant_p
26510 /* If any clause is non-constant, so is the entire initializer. */
26515 /* This uses |= rather than = because C_I_D_I could have been set in
26516 cp_parser_functional_cast so we must be careful not to clear the
26517 flag. */
26520 /* If we have an ellipsis, this is an initializer pack
26521 expansion. */
26523 {
26526 /* Consume the `...'. */
26533 /* Turn the initializer into an initializer expansion. */
26535 }
26537 /* Add it to the vector. */
26540 /* If the next token is not a comma, we have reached the end of
26541 the list. */
26545 /* Peek at the next token. */
26547 /* If the next token is a `}', then we're still done. An
26548 initializer-clause can have a trailing `,' after the
26549 initializer-list and before the closing `}'. */
26553 /* Suppress location wrappers in a long initializer to save memory
26554 (14179). The cutoff is chosen arbitrarily. */
26558 /* Look one level down because it's easy. Looking deeper would require
26559 passing down a nelts pointer, and I don't think multi-level massive
26560 initializers are common enough to justify this. */
26566 /* Consume the `,' token. */
26568 }
26570 /* The same identifier shall not appear in multiple designators
26571 of a designated-initializer-list. */
26573 {
26578 {
26580 {
26582 "%<.%s%> designator used multiple times in "
26586 }
26587 else
26589 }
26593 }
26599 }
26601 /* Classes [gram.class] */
26603 /* Parse a class-name.
26605 class-name:
26606 identifier
26607 template-id
26609 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
26610 to indicate that names looked up in dependent types should be
26611 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
26612 keyword has been used to indicate that the name that appears next
26613 is a template. TAG_TYPE indicates the explicit tag given before
26614 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
26615 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
26616 is the class being defined in a class-head. If ENUM_OK is TRUE,
26617 enum-names are also accepted.
26619 Returns the TYPE_DECL representing the class. */
26621 static tree
26630 {
26631 tree decl;
26634 /* All class-names start with an identifier. */
26637 {
26640 }
26642 /* PARSER->SCOPE can be cleared when parsing the template-arguments
26643 to a template-id, so we save it here. Consider object scope too,
26644 so that make_typename_type below can use it (cp_parser_template_name
26645 considers object scope also). This may happen with code like
26647 p->template A<T>::a()
26649 where we first want to look up A<T>::a in the class of the object
26650 expression, as per [basic.lookup.classref]. */
26652 /* This only checks parser->scope to avoid duplicate errors; if
26653 ->object_type is erroneous, go on to give a parse error. */
26657 /* Any name names a type if we're following the `typename' keyword
26658 in a qualified name where the enclosing scope is type-dependent. */
26663 /* Handle the common case (an identifier, but not a template-id)
26664 efficiently. */
26667 {
26671 /* Look for the identifier. */
26675 /* If the next token isn't an identifier, we are certainly not
26676 looking at a class-name. */
26679 /* If we know this is a type-name, there's no need to look it
26680 up. */
26683 else
26684 {
26685 tree ambiguous_decls;
26686 /* If we already know that this lookup is ambiguous, then
26687 we've already issued an error message; there's no reason
26688 to check again. */
26690 {
26693 }
26694 /* If the next token is a `::', then the name must be a type
26695 name.
26697 [basic.lookup.qual]
26699 During the lookup for a name preceding the :: scope
26700 resolution operator, object, function, and enumerator
26701 names are ignored. */
26704 /* Look up the name. */
26706 tag_type,
26709 check_dependency_p,
26713 {
26717 }
26718 }
26719 }
26720 else
26721 {
26722 /* Try a template-id. */
26724 check_dependency_p,
26725 tag_type,
26726 is_declaration);
26729 }
26733 /* If this is a typename, create a TYPENAME_TYPE. */
26735 {
26740 }
26744 /* Check to see that it is really the name of a class. */
26748 /* Situations like this:
26750 template <typename T> struct A {
26751 typename T::template X<int>::I i;
26752 };
26754 are problematic. Is `T::template X<int>' a class-name? The
26755 standard does not seem to be definitive, but there is no other
26756 valid interpretation of the following `::'. Therefore, those
26757 names are considered class-names. */
26758 {
26762 }
26767 /* In Objective-C 2.0, a classname followed by '.' starts a
26768 dot-syntax expression, and it's not a type-name. */
26780 }
26782 /* Make sure that any member-function parameters are in scope.
26783 For instance, a function's noexcept-specifier can use the function's
26784 parameters:
26786 struct S {
26787 void fn (int p) noexcept(noexcept(p));
26788 };
26790 so we need to make sure name lookup can find them. This is used
26791 when we delay parsing of the noexcept-specifier. */
26793 static void
26795 {
26802 {
26806 }
26807 }
26809 /* Undo the effects of inject_parm_decls. */
26811 static void
26813 {
26816 }
26818 /* Parse a class-specifier.
26820 class-specifier:
26821 class-head { member-specification [opt] }
26823 Returns the TREE_TYPE representing the class. */
26825 tree
26827 {
26830 tree type;
26845 /* Parse the class-head. */
26848 /* If the class-head was a semantic disaster, skip the entire body
26849 of the class. */
26851 {
26855 }
26857 /* Look for the `{'. */
26858 matching_braces braces;
26860 {
26863 }
26868 /* Issue an error message if type-definitions are forbidden here. */
26870 /* Remember that we are defining one more class. */
26872 /* Inside the class, surrounding template-parameter-lists do not
26873 apply. */
26874 saved_num_template_parameter_lists
26877 /* We are not in a function body. */
26880 /* Or in a loop. */
26883 /* Or in a switch. */
26886 /* We are not immediately inside an extern "lang" block. */
26887 saved_in_unbraced_linkage_specification_p
26890 /* Or in an export-declaration. */
26891 saved_in_unbraced_export_declaration_p
26894 /* 'this' from an enclosing non-static member function is unavailable. */
26900 /* Start the class. */
26902 {
26904 /* SCOPE must be a scope nested inside current scope. */
26908 else
26910 }
26914 /* If the type is erroneous, skip the entire body of the class. */
26916 else
26917 /* Parse the member-specification. */
26920 /* Look for the trailing `}'. */
26922 /* Look for trailing attributes to apply to this class. */
26930 /* We've finished a type definition. Check for the common syntax
26931 error of forgetting a semicolon after the definition. We need to
26932 be careful, as we can't just check for not-a-semicolon and be done
26933 with it; the user might have typed:
26935 class X { } c = ...;
26936 class X { } *p = ...;
26938 and so forth. Instead, enumerate all the possible tokens that
26939 might follow this production; if we don't see one of them, then
26940 complain and silently insert the semicolon. */
26941 {
26946 /* Don't try to parse c++11 attributes here. As per the
26947 grammar, that should be a task for
26948 cp_parser_decl_specifier_seq. */
26952 {
26964 /* While it's legal for type qualifiers and storage class
26965 specifiers to follow type definitions in the grammar, only
26966 compiler testsuites contain code like that. Assume that if
26967 we see such code, then what we're really seeing is a case
26968 like:
26970 class X { }
26971 const <type> var = ...;
26973 or
26975 class Y { }
26976 static <type> func (...) ...
26978 i.e. the qualifier or specifier applies to the next
26979 declaration. To do so, however, we need to look ahead one
26980 more token to see if *that* token is a type specifier.
26982 This code could be improved to handle:
26984 class Z { }
26985 static const <type> var = ...; */
26988 {
26991 /* Handling user-defined types here would be nice, but very
26992 tricky. */
26993 want_semicolon
26996 }
27000 }
27002 /* If we don't have a type, then something is very wrong and we
27003 shouldn't try to do anything clever. Likewise for not seeing the
27004 closing brace. */
27006 {
27007 /* Locate the closing brace. */
27008 cp_token_position prev
27013 /* We want to suggest insertion of a ';' immediately *after* the
27014 closing brace, so, if we can, offset the location by 1 column. */
27021 /* If we successfully offset the location, suggest the fix-it. */
27034 else
27037 /* Unget one token and smash it to look as though we encountered
27038 a semicolon in the input stream. */
27043 }
27044 }
27046 /* If this class is not itself within the scope of another class,
27047 then we need to parse the bodies of all of the queued function
27048 definitions. Note that the queued functions defined in a class
27049 are not always processed immediately following the
27050 class-specifier for that class. Consider:
27052 struct A {
27053 struct B { void f() { sizeof (A); } };
27054 };
27056 If `f' were processed before the processing of `A' were
27057 completed, there would be no way to compute the size of `A'.
27058 Note that the nesting we are interested in here is lexical --
27059 not the semantic nesting given by TYPE_CONTEXT. In particular,
27060 for:
27062 struct A { struct B; };
27063 struct A::B { void f() { } };
27065 there is no need to delay the parsing of `A::B::f'. */
27067 {
27068 tree decl;
27075 {
27076 /* Skip default arguments, NSDMIs, etc, in order to improve
27077 error recovery (c++/71169, c++/71832). */
27081 }
27083 /* In a first pass, parse default arguments to the functions.
27084 Then, in a second pass, parse the bodies of the functions.
27085 This two-phased approach handles cases like:
27087 struct S {
27088 void f() { g(); }
27089 void g(int i = 3);
27090 };
27092 */
27094 {
27096 /* If there are default arguments that have not yet been processed,
27097 take care of them now. */
27099 {
27104 }
27105 /* Make sure that any template parameters are in scope. */
27107 /* Parse the default argument expressions. */
27109 /* Remove any template parameters from the symbol table. */
27111 }
27114 /* If there are noexcept-specifiers that have not yet been processed,
27115 take care of them now. Do this before processing NSDMIs as they
27116 may depend on noexcept-specifiers already having been processed. */
27118 {
27121 {
27126 }
27131 /* Make sure that any template parameters are in scope. */
27134 /* Make sure that any member-function parameters are in scope.
27135 This function doesn't expect ccp to be set. */
27139 /* 'this' is not allowed in static member functions. */
27140 unsigned char local_variables_forbidden_p
27145 /* Now we can parse the noexcept-specifier. */
27151 /* Update the fn's type directly -- it might have escaped
27152 beyond this decl :( */
27154 /* Update any instantiations we've already created. We must
27155 keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
27156 so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
27157 in the pattern. */
27162 /* Restore the state of local_variables_forbidden_p. */
27165 /* The finish_struct call above performed various override checking,
27166 but it skipped unparsed noexcept-specifier operands. Now that we
27167 have resolved them, check again. */
27170 /* Remove any member-function parameters from the symbol table. */
27173 /* Remove any template parameters from the symbol table. */
27175 }
27178 /* Now parse any NSDMIs. */
27180 {
27183 {
27188 }
27191 }
27194 /* Now contract attributes. */
27196 {
27199 {
27204 }
27208 /* Make sure that any template parameters are in scope. */
27211 /* Make sure that any member-function parameters are in scope.
27212 This function doesn't expect ccp to be set. */
27216 /* 'this' is not allowed in static member functions. */
27217 unsigned char local_variables_forbidden_p
27222 /* Now we can parse contract conditions. */
27224 {
27227 }
27229 /* Restore the state of local_variables_forbidden_p. */
27232 /* Remove any member-function parameters from the symbol table. */
27235 /* Remove any template parameters from the symbol table. */
27238 /* Perform any deferred contract matching. */
27240 }
27248 /* Now parse the body of the functions. */
27250 {
27251 /* OpenMP UDRs need to be parsed before all other functions. */
27258 }
27259 else
27263 }
27265 /* Put back any saved access checks. */
27268 /* Restore saved state. */
27272 parser->num_template_parameter_lists
27274 parser->in_unbraced_linkage_specification_p
27276 parser->in_unbraced_export_declaration_p
27282 }
27284 /* Parse a class-head.
27286 class-head:
27287 class-key identifier [opt] base-clause [opt]
27288 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
27289 class-key nested-name-specifier [opt] template-id
27290 base-clause [opt]
27292 class-virt-specifier:
27293 final
27295 GNU Extensions:
27296 class-key attributes identifier [opt] base-clause [opt]
27297 class-key attributes nested-name-specifier identifier base-clause [opt]
27298 class-key attributes nested-name-specifier [opt] template-id
27299 base-clause [opt]
27301 Upon return BASES is initialized to the list of base classes (or
27302 NULL, if there are none) in the same form returned by
27303 cp_parser_base_clause.
27305 Returns the TYPE of the indicated class. Sets
27306 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
27307 involving a nested-name-specifier was used, and FALSE otherwise.
27309 Returns error_mark_node if this is not a class-head.
27311 Returns NULL_TREE if the class-head is syntactically valid, but
27312 semantically invalid in a way that means we should skip the entire
27313 body of the class. */
27315 static tree
27318 {
27319 tree nested_name_specifier;
27323 tree attributes;
27324 tree bases;
27334 /* Assume no nested-name-specifier will be present. */
27336 /* Assume no template parameter lists will be used in defining the
27337 type. */
27341 /* Look for the class-key. */
27348 /* Parse the attributes. */
27353 /* If the next token is `::', that is invalid -- but sometimes
27354 people do try to write:
27356 struct ::S {};
27358 Handle this gracefully by accepting the extra qualifier, and then
27359 issuing an error about it later if this really is a
27360 class-head. If it turns out just to be an elaborated type
27361 specifier, remain silent. */
27365 /* It is OK to define an inaccessible class; for example:
27367 class A { class B; };
27368 class A::B {};
27370 So we want to ignore access when parsing the class name.
27371 However, we might be tentatively parsing what is really an
27372 elaborated-type-specifier naming a template-id, e.g.
27374 struct C<&D::m> c;
27376 In this case the tentative parse as a class-head will fail, but not
27377 before cp_parser_template_id splices in a CPP_TEMPLATE_ID token.
27378 Since dk_no_check is sticky, we must instead use dk_deferred so that
27379 any such CPP_TEMPLATE_ID token created during this tentative parse
27380 will correctly capture the access checks imposed by the template-id . */
27383 /* Determine the name of the class. Begin by looking for an
27384 optional nested-name-specifier. */
27386 nested_name_specifier
27392 /* If there was a nested-name-specifier, then there *must* be an
27393 identifier. */
27398 {
27400 /* Although the grammar says `identifier', it really means
27401 `class-name' or `template-name'. You are only allowed to
27402 define a class that has already been declared with this
27403 syntax.
27405 The proposed resolution for Core Issue 180 says that wherever
27406 you see `class T::X' you should treat `X' as a type-name.
27408 We do not know if we will see a class-name, or a
27409 template-name. We look for a class-name first, in case the
27410 class-name is a template-id; if we looked for the
27411 template-name first we would stop after the template-name. */
27418 class_type,
27422 /* If that didn't work, ignore the nested-name-specifier. */
27424 {
27430 }
27431 /* If we could not find a corresponding TYPE, treat this
27432 declaration like an unqualified declaration. */
27435 /* Otherwise, count the number of templates used in TYPE and its
27436 containing scopes. */
27437 else
27439 }
27440 /* Otherwise, the identifier is optional. */
27441 else
27442 {
27443 /* We don't know whether what comes next is a template-id,
27444 an identifier, or nothing at all. */
27446 /* Check for a template-id. */
27451 class_key,
27453 /* If that didn't work, it could still be an identifier. */
27455 {
27457 {
27460 }
27461 else
27463 }
27464 else
27465 {
27468 }
27469 }
27474 {
27476 class_key,
27478 }
27481 /* If it's not a `:' or a `{' then we can't really be looking at a
27482 class-head, since a class-head only appears as part of a
27483 class-specifier. We have to detect this situation before calling
27484 xref_tag, since that has irreversible side-effects. */
27486 {
27490 }
27492 /* At this point, we're going ahead with the class-specifier, even
27493 if some other problem occurs. */
27496 {
27501 }
27502 /* Issue the error about the overly-qualified name now. */
27504 {
27509 }
27511 {
27516 }
27518 {
27519 tree scope;
27522 /* [temp.names]: in a qualified-id formed by a class-head-name, the
27523 keyword template shall not appear at the top level. */
27527 /* Reject typedef-names in class heads. */
27529 {
27532 type);
27535 }
27537 /* Figure out in what scope the declaration is being placed. */
27539 /* If that scope does not contain the scope in which the
27540 class was originally declared, the program is invalid. */
27542 {
27545 "declaration of %qD in namespace %qD which does not "
27548 else
27554 }
27555 /* [dcl.meaning]
27557 A declarator-id shall not be qualified except for the
27558 definition of a ... nested class outside of its class
27559 ... [or] the definition or explicit instantiation of a
27560 class member of a namespace outside of its namespace. */
27564 }
27565 /* The name-declaration of an export-declaration shall not declare
27566 a partial specialization. */
27569 && !processing_specialization
27571 {
27572 auto_diagnostic_group d;
27578 }
27579 /* An explicit-specialization must be preceded by "template <>". If
27580 it is not, try to recover gracefully. */
27583 && !processing_template_parmlist
27585 {
27586 /* Build a location of this form:
27587 struct typename <ARGS>
27588 ^~~~~~~~~~~~~~~~~~~~~~
27589 with caret==start at the start token, and
27590 finishing at the end of the type. */
27591 location_t reported_loc
27593 class_head_start_location,
27599 "an explicit specialization must be preceded by"
27602 /* Take the same action that would have been taken by
27603 cp_parser_explicit_specialization. */
27606 }
27607 /* There must be no "return" statements between this point and the
27608 end of this function; set "type "to the correct return value and
27609 use "goto done;" to return. */
27610 /* Make sure that the right number of template parameters were
27611 present. */
27613 template_id_p,
27616 {
27617 /* If something went wrong, there is no point in even trying to
27618 process the class-definition. */
27621 }
27623 /* Look up the type. */
27625 {
27629 {
27633 }
27634 else
27635 {
27639 /* Check the scope while we still know whether or not we had a
27640 nested-name-specifier. */
27643 }
27646 }
27648 {
27651 /* Given:
27653 template <typename T> struct S { struct T };
27654 template <typename T> struct S<T>::T { };
27656 we will get a TYPENAME_TYPE when processing the definition of
27657 `S::T'. We need to resolve it to the actual type before we
27658 try to define it. */
27660 {
27663 {
27666 }
27667 }
27671 {
27674 }
27676 /* Enter the scope indicated by the nested-name-specifier. */
27678 /* Get the canonical version of this type. */
27680 /* Call push_template_decl if it seems like we should be defining a
27681 template either from the template headers or the type we're
27682 defining, so that we diagnose both extra and missing headers. */
27686 {
27689 {
27692 }
27693 }
27697 }
27699 {
27700 /* If the class was unnamed, create a dummy name. */
27708 }
27710 /* Diagnose class/struct/union mismatches. */
27714 /* Indicate whether this class was declared as a `class' or as a
27715 `struct'. */
27719 /* If this type was already complete, and we see another definition,
27720 that's an error. Likewise if the type is already being defined:
27721 this can happen, eg, when it's defined from within an expression
27722 (c++/84605). */
27725 {
27727 type);
27729 type);
27732 }
27737 {
27740 {
27741 /* In a lambda this should work, but doesn't currently. */
27744 }
27746 /* Apply attributes now, before any use of the class as a template
27747 argument in its base list. */
27750 }
27752 /* Associate constraints with the type. */
27756 /* We will have entered the scope containing the class; the names of
27757 base classes should be looked up in that context. For example:
27759 struct A { struct B {}; struct C; };
27760 struct A::C : B {};
27762 is valid. */
27764 /* Get the list of base-classes, if there is one. Defer access checking
27765 until the entire list has been seen, as per [class.access.general]. */
27768 {
27770 {
27773 }
27776 {
27779 }
27780 }
27781 else
27784 /* If we're really defining a class, process the base classes.
27785 If they're invalid, fail. */
27789 /* Now that all bases have been seen and attached to the class, check
27790 accessibility of the types named in the base-clause. This must be
27791 done relative to the class scope, so that we accept e.g.
27793 struct A { protected: struct B {}; };
27794 struct C : A::B, A {}; // OK: A::B is accessible via base A
27796 as per [class.access.general]. */
27803 done:
27804 /* Leave the scope given by the nested-name-specifier. We will
27805 enter the class scope itself while processing the members. */
27810 {
27813 }
27819 out:
27822 }
27824 /* Parse a class-key.
27826 class-key:
27827 class
27828 struct
27829 union
27831 Returns the kind of class-key specified, or none_type to indicate
27832 error. */
27834 static enum tag_types
27836 {
27840 /* Look for the class-key. */
27845 /* Check to see if the TOKEN is a class-key. */
27850 }
27852 /* Parse a type-parameter-key.
27854 type-parameter-key:
27855 class
27856 typename
27857 */
27859 static void
27861 {
27862 /* Look for the type-parameter-key. */
27866 {
27870 /* typename is not allowed in a template template parameter
27871 by the standard until C++17. */
27873 "ISO C++ forbids typename key in template template parameter;"
27875 }
27876 else
27880 }
27882 /* Parse an (optional) member-specification.
27884 member-specification:
27885 member-declaration member-specification [opt]
27886 access-specifier : member-specification [opt] */
27888 static void
27890 {
27892 {
27896 /* Peek at the next token. */
27898 /* If it's a `}', or EOF then we've seen all the members. */
27904 /* See if this token is a keyword. */
27907 {
27911 /* Consume the access-specifier. */
27913 /* Remember which access-specifier is active. */
27915 /* Look for the `:'. */
27920 /* Accept #pragmas at class scope. */
27922 {
27925 }
27927 /* Otherwise, the next construction must be a
27928 member-declaration. */
27930 }
27931 }
27932 }
27934 /* Parse a member-declaration.
27936 member-declaration:
27937 decl-specifier-seq [opt] member-declarator-list [opt] ;
27938 function-definition ; [opt]
27939 :: [opt] nested-name-specifier template [opt] unqualified-id ;
27940 using-declaration
27941 template-declaration
27942 alias-declaration
27944 member-declarator-list:
27945 member-declarator
27946 member-declarator-list , member-declarator
27948 member-declarator:
27949 declarator pure-specifier [opt]
27950 declarator constant-initializer [opt]
27951 identifier [opt] : constant-expression
27953 GNU Extensions:
27955 member-declaration:
27956 __extension__ member-declaration
27958 member-declarator:
27959 declarator attributes [opt] pure-specifier [opt]
27960 declarator attributes [opt] constant-initializer [opt]
27961 identifier [opt] attributes [opt] : constant-expression
27963 C++0x Extensions:
27965 member-declaration:
27966 static_assert-declaration */
27968 static void
27970 {
27971 cp_decl_specifier_seq decl_specifiers;
27972 tree prefix_attributes;
27973 tree decl;
27982 /* Check for the `__extension__' keyword. */
27984 {
27985 /* Recurse. */
27987 /* Restore the old value of the PEDANTIC flag. */
27991 }
27993 /* Check for a template-declaration. */
27995 {
27996 /* An explicit specialization here is an error condition, and we
27997 expect the specialization handler to detect and report this. */
28001 else
28005 }
28006 /* Check for a template introduction. */
28010 /* Check for a using-declaration. */
28012 {
28014 /* Parse the using-declaration. */
28018 else
28019 {
28020 tree decl;
28024 /* Note that if we actually see the '=' token after the
28025 identifier, cp_parser_alias_declaration commits the
28026 tentative parse. In that case, we really expect an
28027 alias-declaration. Otherwise, we expect a using
28028 declaration. */
28029 alias_decl_expected =
28035 else
28038 }
28040 }
28042 /* Check for @defs. */
28044 {
28049 {
28054 }
28056 }
28058 /* If the next token is `static_assert' we have a static assertion. */
28060 {
28063 }
28067 cp_omp_declare_simd_data odsd;
28071 /* Parse the decl-specifier-seq. */
28074 (CP_PARSER_FLAGS_OPTIONAL
28084 /* Check for an invalid type-name. */
28088 /* If there is no declarator, then the decl-specifier-seq should
28089 specify a type. */
28091 {
28092 /* If there was no decl-specifier-seq, and the next token is a
28093 `;', then we have something like:
28095 struct S { ; };
28097 [class.mem]
28099 Each member-declaration shall declare at least one member
28100 name of the class. */
28102 {
28105 {
28109 }
28110 }
28111 else
28112 {
28113 /* See if this declaration is a friend. */
28115 /* If there were decl-specifiers, check to see if there was
28116 a class-declaration. */
28119 /* Nested classes have already been added to the class, but
28120 a `friend' needs to be explicitly registered. */
28122 {
28123 /* If the `friend' keyword was present, the friend must
28124 be introduced with a class-key. */
28127 "in C++03 a class-key must be used "
28129 /* In this case:
28131 template <typename T> struct A {
28132 friend struct A<T>::B;
28133 };
28135 A<T>::B will be represented by a TYPENAME_TYPE, and
28136 therefore not recognized by check_tag_decl. */
28138 {
28142 }
28143 /* Warn if an attribute cannot appear here, as per
28144 [dcl.attr.grammar]/5. But not when declares_class_or_enum:
28145 we ignore attributes in elaborated-type-specifiers. */
28148 {
28153 "that appertains to a friend declaration that "
28155 }
28158 "friend declaration does not name a class or "
28160 else
28163 }
28164 /* If there is no TYPE, an error message will already have
28165 been issued. */
28167 ;
28168 /* An anonymous aggregate has to be handled specially; such
28169 a declaration really declares a data member (with a
28170 particular type), as opposed to a nested class. */
28172 {
28173 /* C++11 9.5/6. */
28176 "a storage class on an anonymous aggregate "
28179 /* Remove constructors and such from TYPE, now that we
28180 know it is an anonymous aggregate. */
28182 /* And make the corresponding data member. */
28185 /* Add it to the class. */
28187 }
28188 else
28189 cp_parser_check_access_in_redeclaration
28192 }
28193 }
28194 else
28195 {
28198 /* Clear attributes from the decl_specifiers but keep them
28199 around as prefix attributes that apply them to the entity
28200 being declared. */
28208 /* See if these declarations will be friends. */
28211 /* Keep going until we hit the `;' at the end of the
28212 declaration. */
28214 {
28216 tree first_attribute;
28217 tree initializer;
28220 /* Peek at the next token. */
28223 /* The following code wants to know early if it is a bit-field
28224 or some other declaration. Attributes can appear before
28225 the `:' token. Skip over them without consuming any tokens
28226 to peek if they are followed by `:'. */
28231 {
28232 size_t n
28235 }
28237 /* Check for a bitfield declaration. */
28243 {
28244 tree identifier;
28245 tree width;
28247 location_t id_location
28252 else
28255 /* Look for attributes that apply to the bitfield. */
28258 /* Consume the `:' token. */
28261 /* Get the width of the bitfield. */
28265 /* In C++20 and as extension for C++11 and above we allow
28266 default member initializers for bit-fields. */
28271 CPP_OPEN_BRACE)))
28272 {
28273 location_t loc
28278 "default member initializers for bit-fields "
28279 "only available with %<-std=c++20%> or "
28284 {
28288 }
28289 }
28290 else
28291 {
28292 /* Look for attributes that apply to the bitfield after
28293 the `:' token and width. This is where GCC used to
28294 parse attributes in the past, pedwarn if there is
28295 a std attribute. */
28298 "ISO C++ allows bit-field attributes only "
28302 }
28306 /* Remember which attributes are prefix attributes and
28307 which are not. */
28309 /* Combine the attributes. */
28312 /* Create the bitfield declaration. */
28315 identifier,
28316 sfk_none,
28317 id_location)
28321 attributes);
28322 }
28323 else
28324 {
28326 tree asm_specification;
28330 /* We can't delay parsing for friends,
28331 alias-declarations, and typedefs, even though the
28332 standard seems to require it. */
28337 /* Parse the declarator. */
28338 declarator
28340 flags,
28346 /* If something went wrong parsing the declarator, make sure
28347 that we at least consume some tokens. */
28349 {
28350 /* Skip to the end of the statement. */
28352 /* If the next token is not a semicolon, that is
28353 probably because we just skipped over the body of
28354 a function. So, we consume a semicolon if
28355 present, but do not issue an error message if it
28356 is not present. */
28358 CPP_SEMICOLON))
28361 }
28363 /* Handle class-scope non-template C++17 deduction guides. */
28366 declarator,
28370 cp_parser_check_for_definition_in_return_type
28374 /* Look for an asm-specification. */
28376 /* Look for attributes that apply to the declaration. */
28378 /* Remember which attributes are prefix attributes and
28379 which are not. */
28381 /* Combine the attributes. */
28384 /* If it's an `=', then we have a constant-initializer or a
28385 pure-specifier. It is not correct to parse the
28386 initializer before registering the member declaration
28387 since the member declaration should be in scope while
28388 its initializer is processed. However, the rest of the
28389 front end does not yet provide an interface that allows
28390 us to handle this correctly. */
28392 {
28393 /* In [class.mem]:
28395 A pure-specifier shall be used only in the declaration of
28396 a virtual function.
28398 A member-declarator can contain a constant-initializer
28399 only if it declares a static member of integral or
28400 enumeration type.
28402 Therefore, if the DECLARATOR is for a function, we look
28403 for a pure-specifier; otherwise, we look for a
28404 constant-initializer. When we call `grokfield', it will
28405 perform more stringent semantics checks. */
28418 {
28419 /* Don't require a constant rvalue in C++11, since we
28420 might want a reference constant. We'll enforce
28421 constancy later. */
28423 /* Parse the initializer. */
28425 }
28426 else
28427 /* Parse the initializer. */
28429 }
28432 {
28433 declarator->init_loc
28437 else
28439 }
28440 /* Detect invalid bit-field cases such as
28442 int *p : 4;
28443 int &&r : 3;
28445 and similar. */
28447 /* If there were no type specifiers, it was a
28448 constructor. */
28450 {
28451 /* This is called for a decent diagnostic only. */
28460 /* Avoid "extra ;" pedwarns. */
28462 CPP_SEMICOLON))
28465 }
28466 /* Otherwise, there is no initializer. */
28467 else
28470 /* See if we are probably looking at a function
28471 definition. We are certainly not looking at a
28472 member-declarator. Calling `grokfield' has
28473 side-effects, so we must not do it unless we are sure
28474 that we are looking at a member-declarator. */
28477 {
28478 /* The grammar does not allow a pure-specifier to be
28479 used when a member function is defined. (It is
28480 possible that this fact is an oversight in the
28481 standard, since a pure function may be defined
28482 outside of the class-specifier. */
28488 declarator,
28489 attributes);
28493 /* If the member was not a friend, declare it here. */
28496 /* Peek at the next token. */
28498 /* If the next token is a semicolon, consume it. */
28500 {
28501 location_t semicolon_loc
28506 "extra %<;%> after in-class "
28508 }
28510 }
28511 else
28515 /* Create the declaration. */
28521 {
28524 else
28526 }
28527 }
28532 /* Reset PREFIX_ATTRIBUTES. */
28534 {
28539 }
28541 /* If there is any qualification still in effect, clear it
28542 now; we will be starting fresh with the next declarator. */
28546 /* If it's a `,', then there are more declarators. */
28548 {
28551 {
28557 }
28558 }
28559 /* If the next token isn't a `;', then we have a parse error. */
28561 CPP_SEMICOLON))
28562 {
28563 /* The next token might be a ways away from where the
28564 actual semicolon is missing. Find the previous token
28565 and use that for our error position. */
28572 /* Assume that the user meant to provide a semicolon. If
28573 we were to cp_parser_skip_to_end_of_statement, we might
28574 skip to a semicolon inside a member function definition
28575 and issue nonsensical error messages. */
28577 }
28580 {
28581 /* Add DECL to the list of members. */
28583 /* Explicitly include, eg, NSDMIs, for better error
28584 recovery (c++/58650). */
28592 /* Add DECL to the queue of NSDMI to be parsed later. */
28594 }
28598 }
28599 }
28602 out:
28605 }
28607 /* Parse a pure-specifier.
28609 pure-specifier:
28610 = 0
28612 Returns INTEGER_ZERO_NODE if a pure specifier is found.
28613 Otherwise, ERROR_MARK_NODE is returned. */
28615 static tree
28617 {
28620 /* Look for the `=' token. */
28623 /* Look for the `0' token. */
28632 /* Accept = default or = delete in c++0x mode. */
28635 {
28638 }
28640 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
28642 {
28647 }
28649 {
28652 }
28655 }
28657 /* Parse a constant-initializer.
28659 constant-initializer:
28660 = constant-expression
28662 Returns a representation of the constant-expression. */
28664 static tree
28666 {
28667 /* Look for the `=' token. */
28671 /* It is invalid to write:
28673 struct S { static const int i = { 7 }; };
28675 */
28677 {
28680 /* Consume the opening brace. */
28681 matching_braces braces;
28683 /* Skip the initializer. */
28685 /* Look for the trailing `}'. */
28689 }
28692 }
28694 /* Derived classes [gram.class.derived] */
28696 /* Parse a base-clause.
28698 base-clause:
28699 : base-specifier-list
28701 base-specifier-list:
28702 base-specifier ... [opt]
28703 base-specifier-list , base-specifier ... [opt]
28705 Returns a TREE_LIST representing the base-classes, in the order in
28706 which they were declared. The representation of each node is as
28707 described by cp_parser_base_specifier.
28709 In the case that no bases are specified, this function will return
28710 NULL_TREE, not ERROR_MARK_NODE. */
28712 static tree
28714 {
28717 /* Look for the `:' that begins the list. */
28720 /* Scan the base-specifier-list. */
28722 {
28724 tree base;
28727 /* Look for the base-specifier. */
28729 /* Look for the (optional) ellipsis. */
28731 {
28732 /* Consume the `...'. */
28736 }
28738 /* Add BASE to the front of the list. */
28740 {
28742 /* Make this a pack expansion type. */
28746 {
28749 }
28750 }
28751 /* Peek at the next token. */
28753 /* If it's not a comma, then the list is complete. */
28756 /* Consume the `,'. */
28758 }
28760 /* PARSER->SCOPE may still be non-NULL at this point, if the last
28761 base class had a qualified name. However, the next name that
28762 appears is certainly not qualified. */
28768 }
28770 /* Parse a base-specifier.
28772 base-specifier:
28773 :: [opt] nested-name-specifier [opt] class-name
28774 virtual access-specifier [opt] :: [opt] nested-name-specifier
28775 [opt] class-name
28776 access-specifier virtual [opt] :: [opt] nested-name-specifier
28777 [opt] class-name
28779 Returns a TREE_LIST. The TREE_PURPOSE will be one of
28780 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
28781 indicate the specifiers provided. The TREE_VALUE will be a TYPE
28782 (or the ERROR_MARK_NODE) indicating the type that was specified. */
28784 static tree
28786 {
28794 tree type;
28796 /* Process the optional `virtual' and `access-specifier'. */
28798 {
28799 /* Peek at the next token. */
28801 /* Process `virtual'. */
28803 {
28805 /* If `virtual' appears more than once, issue an error. */
28807 {
28811 }
28815 /* Consume the `virtual' token. */
28823 /* If more than one access specifier appears, issue an
28824 error. */
28827 {
28831 }
28835 /* Consume the access-specifier. */
28843 }
28844 }
28845 /* It is not uncommon to see programs mechanically, erroneously, use
28846 the 'typename' keyword to denote (dependent) qualified types
28847 as base classes. */
28849 {
28854 else
28856 "keyword %<typename%> not allowed in this context "
28859 }
28861 /* Look for the optional `::' operator. */
28863 /* Look for the nested-name-specifier. The simplest way to
28864 implement:
28866 [temp.res]
28868 The keyword `typename' is not permitted in a base-specifier or
28869 mem-initializer; in these contexts a qualified name that
28870 depends on a template-parameter is implicitly assumed to be a
28871 type name.
28873 is to pretend that we have seen the `typename' keyword at this
28874 point. */
28880 /* If the base class is given by a qualified name, assume that names
28881 we see are type names or templates, as appropriate. */
28887 /* DR 950 allows decltype as a base-specifier. */
28889 else
28890 {
28891 /* Otherwise, look for the class-name. */
28893 class_scope_p,
28894 template_p,
28895 typename_type,
28900 }
28906 }
28908 /* Exception handling [gram.exception] */
28910 /* Save the tokens that make up the noexcept-specifier for a member-function.
28911 Returns a DEFERRED_PARSE. */
28913 static tree
28915 {
28917 /* We want everything up to, including, the final ')'. */
28921 /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
28922 to carry the information we will need. */
28924 /* Save away the noexcept-specifier; we will process it when the
28925 class is complete. */
28930 }
28932 /* Used for late processing of noexcept-specifiers of member-functions.
28933 DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
28934 we saved for later; parse it now. DECL is the declaration of the
28935 member function. */
28937 static tree
28939 {
28940 /* Make sure we've gotten something that hasn't been parsed yet. */
28945 /* Push the saved tokens for the noexcept-specifier onto the parser's
28946 lexer stack. */
28950 /* Parse the cached noexcept-specifier. */
28951 tree parsed_arg
28953 CP_PARSER_FLAGS_NONE,
28958 /* Revert to the main lexer. */
28961 /* Restore the queue. */
28964 /* And we're done. */
28966 }
28968 /* Perform late checking of overriding function with respect to their
28969 noexcept-specifiers. FNDECL is the member function that potentially
28970 overrides some virtual function with the same signature. */
28972 static void
28974 {
28976 tree base_binfo;
28982 {
28991 }
28992 }
28994 /* Parse an (optional) noexcept-specification.
28996 noexcept-specification:
28997 noexcept ( constant-expression ) [opt]
28999 If no noexcept-specification is present, returns NULL_TREE.
29000 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
29001 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
29002 there are no parentheses. CONSUMED_EXPR will be set accordingly.
29003 Otherwise, returns a noexcept specification unless RETURN_COND is true,
29004 in which case a boolean condition is returned instead. The parser flags
29005 FLAGS is used to control parsing. QUALS are qualifiers indicating whether
29006 the (member) function is `const'. */
29008 static tree
29010 cp_parser_flags flags,
29014 {
29018 /* Peek at the next token. */
29021 /* Is it a noexcept-specification? */
29023 {
29024 tree expr;
29026 /* [class.mem]/6 says that a noexcept-specifer (within the
29027 member-specification of the class) is a complete-class context of
29028 a class. So, if the noexcept-specifier has the optional expression,
29029 just save the tokens, and reparse this after we're done with the
29030 class. */
29034 /* No need to delay parsing for a number literal or true/false. */
29046 {
29047 matching_parens parens;
29051 {
29052 /* Types may not be defined in an exception-specification. */
29054 parser->type_definition_forbidden_message
29058 expr
29064 {
29067 }
29069 /* Restore the saved message. */
29071 }
29072 else
29073 {
29076 }
29079 }
29080 else
29081 {
29085 }
29087 /* We cannot build a noexcept-spec right away because this will check
29088 that expr is a constexpr. */
29091 else
29093 }
29094 else
29096 }
29098 /* Parse an (optional) exception-specification.
29100 exception-specification:
29101 throw ( type-id-list [opt] )
29103 Returns a TREE_LIST representing the exception-specification. The
29104 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
29105 control parsing. QUALS are qualifiers indicating whether the (member)
29106 function is `const'. */
29108 static tree
29110 cp_parser_flags flags)
29111 {
29113 tree type_id_list;
29116 /* Peek at the next token. */
29119 /* Is it a noexcept-specification? */
29120 type_id_list
29128 /* If it's not `throw', then there's no exception-specification. */
29134 /* Consume the `throw'. */
29137 /* Look for the `('. */
29138 matching_parens parens;
29141 /* Peek at the next token. */
29143 /* If it's not a `)', then there is a type-id-list. */
29145 {
29146 /* Types may not be defined in an exception-specification. */
29148 parser->type_definition_forbidden_message
29150 /* Parse the type-id-list. */
29152 /* Restore the saved message. */
29156 {
29160 }
29163 "dynamic exception specifications are deprecated in "
29165 }
29166 /* In C++17, throw() is equivalent to noexcept (true). throw()
29167 is deprecated in C++11 and above as well, but is still widely used,
29168 so don't warn about it yet. */
29171 else
29174 /* Look for the `)'. */
29178 }
29180 /* Parse an (optional) type-id-list.
29182 type-id-list:
29183 type-id ... [opt]
29184 type-id-list , type-id ... [opt]
29186 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
29187 in the order that the types were presented. */
29189 static tree
29191 {
29195 {
29197 tree type;
29201 /* Get the next type-id. */
29203 /* Check for invalid 'auto'. */
29205 {
29209 }
29210 /* Parse the optional ellipsis. */
29212 {
29213 /* Consume the `...'. */
29216 /* Turn the type into a pack expansion expression. */
29218 }
29219 /* Add it to the list. */
29221 /* Peek at the next token. */
29223 /* If it is not a `,', we are done. */
29226 /* Consume the `,'. */
29228 }
29231 }
29233 /* Parse a try-block.
29235 try-block:
29236 try compound-statement handler-seq */
29238 static tree
29240 {
29241 tree try_block;
29248 "%<try%> in %<constexpr%> function only "
29258 }
29260 /* Parse a function-try-block.
29262 function-try-block:
29263 try ctor-initializer [opt] function-body handler-seq */
29265 static void
29267 {
29268 tree compound_stmt;
29269 tree try_block;
29271 /* Look for the `try' keyword. */
29274 /* Let the rest of the front end know where we are. */
29276 /* Parse the function-body. */
29277 cp_parser_ctor_initializer_opt_and_function_body
29279 /* We're done with the `try' part. */
29281 /* Parse the handlers. */
29283 /* We're done with the handlers. */
29285 }
29287 /* Parse a handler-seq.
29289 handler-seq:
29290 handler handler-seq [opt] */
29292 static void
29294 {
29296 {
29299 /* Parse the handler. */
29301 /* Peek at the next token. */
29303 /* If it's not `catch' then there are no more handlers. */
29306 }
29307 }
29309 /* Parse a handler.
29311 handler:
29312 catch ( exception-declaration ) compound-statement */
29314 static void
29316 {
29317 tree handler;
29318 tree declaration;
29322 matching_parens parens;
29329 }
29331 /* Parse an exception-declaration.
29333 exception-declaration:
29334 type-specifier-seq declarator
29335 type-specifier-seq abstract-declarator
29336 type-specifier-seq
29337 ...
29339 Returns a VAR_DECL for the declaration, or NULL_TREE if the
29340 ellipsis variant is used. */
29342 static tree
29344 {
29345 cp_decl_specifier_seq type_specifiers;
29349 /* If it's an ellipsis, it's easy to handle. */
29351 {
29352 /* Consume the `...' token. */
29355 }
29357 /* Types may not be defined in exception-declarations. */
29359 parser->type_definition_forbidden_message
29362 /* Parse the type-specifier-seq. */
29367 /* If it's a `)', then there is no declarator. */
29370 else
29372 CP_PARSER_FLAGS_NONE,
29379 /* Restore the saved message. */
29386 }
29388 /* Parse a throw-expression.
29390 throw-expression:
29391 throw assignment-expression [opt]
29393 Returns a THROW_EXPR representing the throw-expression. */
29395 static tree
29397 {
29398 tree expression;
29404 /* Figure out whether or not there is an assignment-expression
29405 following the "throw" keyword. */
29413 else
29416 /* Construct a location e.g.:
29417 throw x
29418 ^~~~~~~
29419 with caret == start at the start of the "throw" token, and
29420 the end at the end of the final token we consumed. */
29426 }
29428 /* Parse a yield-expression.
29430 yield-expression:
29431 co_yield assignment-expression
29432 co_yield braced-init-list
29434 Returns a CO_YIELD_EXPR representing the yield-expression. */
29436 static tree
29438 {
29439 tree expr;
29447 {
29449 /* ??? : probably a moot point? */
29452 }
29453 else
29460 }
29462 /* GNU Extensions */
29464 /* Parse an (optional) asm-specification.
29466 asm-specification:
29467 asm ( string-literal )
29469 If the asm-specification is present, returns a STRING_CST
29470 corresponding to the string-literal. Otherwise, returns
29471 NULL_TREE. */
29473 static tree
29475 {
29476 /* Peek at the next token. */
29478 /* If the next token isn't the `asm' keyword, then there's no
29479 asm-specification. */
29483 /* Consume the `asm' token. */
29485 /* Look for the `('. */
29486 matching_parens parens;
29489 /* Look for the string-literal. */
29494 /* Look for the `)'. */
29498 }
29500 /* Parse an asm-operand-list.
29502 asm-operand-list:
29503 asm-operand
29504 asm-operand-list , asm-operand
29506 asm-operand:
29507 string-literal ( expression )
29508 [ string-literal ] string-literal ( expression )
29510 Returns a TREE_LIST representing the operands. The TREE_VALUE of
29511 each node is the expression. The TREE_PURPOSE is itself a
29512 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
29513 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
29514 is a STRING_CST for the string literal before the parenthesis. Returns
29515 ERROR_MARK_NODE if any of the operands are invalid. */
29517 static tree
29519 {
29524 {
29525 tree name;
29528 {
29529 /* Consume the `[' token. */
29531 /* Read the operand name. */
29536 /* Look for the closing `]'. */
29538 }
29539 else
29541 /* Look for the string-literal. */
29546 /* Look for the `('. */
29547 matching_parens parens;
29549 /* Parse the expression. */
29551 /* Look for the `)'. */
29559 /* Add this operand to the list. */
29561 expression,
29562 asm_operands);
29563 /* If the next token is not a `,', there are no more
29564 operands. */
29567 /* Consume the `,'. */
29569 }
29572 }
29574 /* Parse an asm-clobber-list.
29576 asm-clobber-list:
29577 string-literal
29578 asm-clobber-list , string-literal
29580 Returns a TREE_LIST, indicating the clobbers in the order that they
29581 appeared. The TREE_VALUE of each node is a STRING_CST. */
29583 static tree
29585 {
29589 {
29590 /* Look for the string literal. */
29594 /* Add it to the list. */
29596 /* If the next token is not a `,', then the list is
29597 complete. */
29600 /* Consume the `,' token. */
29602 }
29605 }
29607 /* Parse an asm-label-list.
29609 asm-label-list:
29610 identifier
29611 asm-label-list , identifier
29613 Returns a TREE_LIST, indicating the labels in the order that they
29614 appeared. The TREE_VALUE of each node is a label. */
29616 static tree
29618 {
29622 {
29625 /* Look for the identifier. */
29628 {
29631 {
29637 }
29638 }
29639 /* If the next token is not a `,', then the list is
29640 complete. */
29643 /* Consume the `,' token. */
29645 }
29648 }
29650 /* Return TRUE iff the next tokens in the stream are possibly the
29651 beginning of a GNU extension attribute. */
29653 static bool
29655 {
29657 }
29659 /* Return TRUE iff the next tokens in the stream are possibly the
29660 beginning of a standard C++-11 attribute specifier. */
29662 static bool
29664 {
29666 }
29668 /* Return TRUE iff the next Nth tokens in the stream are possibly the
29669 beginning of a standard C++-11 attribute specifier. */
29671 static bool
29673 {
29681 }
29683 /* Return TRUE iff the next Nth tokens in the stream are possibly the
29684 beginning of a GNU extension attribute. */
29686 static bool
29688 {
29692 }
29694 /* Return true iff the next tokens can be the beginning of either a
29695 GNU attribute list, or a standard C++11 attribute sequence. */
29697 static bool
29699 {
29702 }
29704 /* Return true iff the next Nth tokens can be the beginning of either
29705 a GNU attribute list, or a standard C++11 attribute sequence. */
29707 static bool
29709 {
29712 }
29714 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
29715 of GNU attributes, or return NULL. */
29717 static tree
29719 {
29722 {
29727 else
29729 }
29731 }
29733 /* Parse an (optional) series of attributes.
29735 attributes:
29736 attributes attribute
29738 attribute:
29739 __attribute__ (( attribute-list [opt] ))
29741 The return value is as for cp_parser_gnu_attribute_list. */
29743 static tree
29745 {
29752 {
29754 tree attribute_list;
29757 /* Peek at the next token. */
29759 /* If it's not `__attribute__', then we're done. */
29763 /* Consume the `__attribute__' keyword. */
29765 /* Look for the two `(' tokens. */
29766 matching_parens outer_parens;
29769 matching_parens inner_parens;
29773 /* Peek at the next token. */
29776 /* Parse the attribute-list. */
29778 else
29779 /* If the next token is a `)', then there is no attribute
29780 list. */
29783 /* Look for the two `)' tokens. */
29791 /* Add these new attributes to the list. */
29793 }
29796 }
29798 /* Parse a GNU attribute-list.
29800 attribute-list:
29801 attribute
29802 attribute-list , attribute
29804 attribute:
29805 identifier
29806 identifier ( identifier )
29807 identifier ( identifier , expression-list )
29808 identifier ( expression-list )
29810 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
29811 to an attribute. The TREE_PURPOSE of each node is the identifier
29812 indicating which attribute is in use. The TREE_VALUE represents
29813 the arguments, if any. */
29815 static tree
29817 {
29821 /* Don't create wrapper nodes within attributes: the
29822 handlers don't know how to handle them. */
29823 auto_suppress_location_wrappers sentinel;
29827 {
29829 tree identifier;
29830 tree attribute;
29832 /* Look for the identifier. We also allow keywords here; for
29833 example `__attribute__ ((const))' is legal. */
29837 {
29840 /* Consume the token, but save it since we need it for the
29841 SIMD enabled function parsing. */
29844 /* Save away the identifier that indicates which attribute
29845 this is. */
29847 /* For keywords, use the canonical spelling, not the
29848 parsed identifier. */
29855 /* Peek at the next token. */
29857 /* If it's an `(', then parse the attribute arguments. */
29859 {
29865 vec = cp_parser_parenthesized_expression_list
29871 else
29872 {
29875 }
29876 /* Save the arguments away. */
29878 }
29881 {
29882 /* Add this attribute to the list. */
29885 }
29888 }
29889 /* Unless EXACTLY_ONE is set look for more attributes.
29890 If the next token isn't a `,', we're done. */
29894 /* Consume the comma and keep going. */
29896 }
29899 /* We built up the list in reverse order. */
29901 }
29903 /* Parse arguments of omp::directive attribute.
29905 ( directive-name ,[opt] clause-list[opt] )
29907 For directive just remember the first/last tokens for subsequent
29908 parsing. */
29910 static void
29912 {
29915 {
29921 }
29924 {
29930 }
29941 }
29943 /* Parse arguments of omp::sequence attribute.
29945 ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
29947 static void
29949 {
29950 matching_parens parens;
29952 do
29953 {
29958 {
29962 }
29967 else
29972 {
29981 }
29985 UNKNOWN_LOCATION);
29988 else
29993 }
29998 }
30000 /* Parse a standard C++11 attribute.
30002 The returned representation is a TREE_LIST which TREE_PURPOSE is
30003 the scoped name of the attribute, and the TREE_VALUE is its
30004 arguments list.
30006 Note that the scoped name of the attribute is itself a TREE_LIST
30007 which TREE_PURPOSE is the namespace of the attribute, and
30008 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
30009 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
30010 and which TREE_PURPOSE is directly the attribute name.
30012 Clients of the attribute code should use get_attribute_namespace
30013 and get_attribute_name to get the actual namespace and name of
30014 attributes, regardless of their being GNU or C++11 attributes.
30016 attribute:
30017 attribute-token attribute-argument-clause [opt]
30019 attribute-token:
30020 identifier
30021 attribute-scoped-token
30023 attribute-scoped-token:
30024 attribute-namespace :: identifier
30026 attribute-namespace:
30027 identifier
30029 attribute-argument-clause:
30030 ( balanced-token-seq )
30032 balanced-token-seq:
30033 balanced-token [opt]
30034 balanced-token-seq balanced-token
30036 balanced-token:
30037 ( balanced-token-seq )
30038 [ balanced-token-seq ]
30039 { balanced-token-seq }. */
30041 static tree
30043 {
30050 /* First, parse name of the attribute, a.k.a attribute-token. */
30067 {
30068 /* We are seeing a scoped attribute token. */
30083 else
30084 {
30088 }
30094 NULL_TREE);
30096 }
30098 {
30102 NULL_TREE);
30103 }
30104 else
30105 {
30108 NULL_TREE);
30110 /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
30111 but no longer: we have to be able to tell [[noreturn]] and
30112 __attribute__((noreturn)) apart. */
30113 /* C++14 deprecated attribute is equivalent to GNU's. */
30116 /* C++17 fallthrough attribute is equivalent to GNU's. */
30119 /* C++23 assume attribute is equivalent to GNU's. */
30122 /* Transactional Memory TS optimize_for_synchronized attribute is
30123 equivalent to GNU transaction_callable. */
30127 /* Transactional Memory attributes are GNU attributes. */
30130 }
30132 /* Now parse the optional argument clause of the attribute. */
30135 {
30141 {
30143 attr_id);
30145 }
30147 }
30149 {
30153 /* Maybe we don't expect to see any arguments for this attribute. */
30157 {
30159 attr_id);
30165 }
30169 /* The assume attribute needs special handling of the argument. */
30173 /* A GNU attribute that takes an identifier in parameter. */
30181 /* If this is a fake attribute created to handle -Wno-attributes,
30182 we must skip parsing the arguments. */
30184 {
30186 {
30188 {
30191 }
30193 {
30198 }
30200 {
30206 }
30207 }
30209 /* For unknown attributes, just skip balanced tokens instead of
30210 trying to parse the arguments. Set TREE_VALUE (attribute) to
30211 error_mark_node to distinguish skipped arguments from attributes
30212 with no arguments. */
30217 }
30219 vec = cp_parser_parenthesized_expression_list
30225 else
30226 {
30228 /* e.g. [[attr()]]. */
30231 attr_id);
30234 }
30238 else
30240 }
30243 }
30245 /* Warn if the attribute ATTRIBUTE appears more than once in the
30246 attribute-list ATTRIBUTES. This used to be enforced for certain
30247 attributes, but the restriction was removed in P2156.
30248 LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
30249 found in ATTRIBUTES. */
30251 static bool
30253 {
30262 {
30267 }
30269 }
30271 /* Parse a list of standard C++-11 attributes.
30273 attribute-list:
30274 attribute [opt]
30275 attribute-list , attribute[opt]
30276 attribute ...
30277 attribute-list , attribute ...
30278 */
30280 static tree
30282 {
30287 {
30293 {
30295 {
30298 }
30299 }
30302 {
30308 {
30312 }
30314 {
30319 }
30321 }
30325 }
30328 }
30330 /* Optionally parse a C++20 contract role. A NULL return means that no
30331 contract role was specified.
30333 contract-role:
30334 % default
30335 % identifier
30337 If the identifier does not name a known contract role, it will
30338 be assumed to be default. Returns the identifier for the role
30339 token. */
30341 static tree
30343 {
30353 else
30354 {
30357 }
30360 /* FIXME: Warn about invalid/unknown roles? */
30362 }
30364 /* Parse an optional contract mode.
30366 contract-mode:
30367 contract-semantic
30368 [contract-level] [contract-role]
30370 contract-semantic:
30371 check_never_continue
30372 check_maybe_continue
30373 check_always_continue
30375 contract-level:
30376 default
30377 audit
30378 axiom
30380 contract-role:
30381 default
30382 identifier
30384 This grammar is taken from P1332R0. During parsing, this sets options
30385 on the MODE object to determine the configuration of the contract.
30387 Returns a tree containing the identifiers used in the configuration.
30388 This is either an IDENTIFIER with the literal semantic or a TREE_LIST
30389 whose TREE_VALUE is the contract-level and whose TREE_PURPOSE is the
30390 contract-role, if any. NULL_TREE is returned if no information is
30391 given (i.e., all defaults selected). */
30393 static tree
30396 {
30397 /* The mode is empty; the level and role are default. */
30401 /* There is only a role; the level is default. */
30403 {
30406 }
30408 /* Otherwise, match semantic or level. */
30412 tree config_id;
30414 {
30417 /* Either a named level, a concrete semantic, or an identifier
30418 for a postcondition. */
30423 /* The identifier is the return value for a postcondition. */
30427 }
30429 {
30432 }
30433 else
30434 {
30435 /* We got some other token other than a ':'. */
30438 }
30440 /* Consume the literal semantic or level token. */
30444 {
30446 "expected contract level: "
30449 }
30451 /* We matched an explicit semantic. */
30453 {
30455 {
30459 }
30461 }
30463 /* We matched a level, there may be a role; otherwise this is default. */
30465 {
30468 }
30471 }
30473 static tree
30475 {
30479 }
30481 static bool
30483 {
30485 }
30487 /* Parse a standard C++20 contract attribute specifier.
30489 contract-attribute-specifier:
30490 [ [ assert contract-level [opt] : conditional-expression ] ]
30491 [ [ pre contract-level [opt] : conditional-expression ] ]
30492 [ [ post contract-level [opt] identifier [opt] : conditional-expression ] ]
30494 For free functions, we cannot determine the type of the postcondition
30495 identifier because the we haven't called grokdeclarator yet. In those
30496 cases we parse the postcondition as if the identifier was declared as
30497 'auto <identifier>'. We then instantiate the postcondition once the
30498 return type is known.
30500 For member functions, contracts are in the complete-class context, so the
30501 parse is deferred. We also have the return type avaialable (unless it's
30502 deduced), so we don't need to parse the postcondition in terms of a
30503 placeholder. */
30505 static tree
30507 {
30515 /* Parse the optional mode. */
30518 /* Check for postcondition identifiers. */
30519 cp_expr identifier;
30527 /* Defer the parsing of pre/post contracts inside class definitions. */
30528 tree contract;
30530 current_class_type &&
30532 {
30533 /* Skip until we reach an unenclose ']'. If we ran into an unnested ']'
30534 that doesn't close the attribute, return an error and let the attribute
30535 handling code emit an error for missing ']]'. */
30539 CPP_CLOSE_SQUARE,
30546 /* Build a deferred-parse node. */
30551 /* And its corresponding contract. */
30553 }
30554 else
30555 {
30556 /* Enable location wrappers when parsing contracts. */
30559 /* Build a fake variable for the result identifier. */
30562 {
30566 }
30568 /* Parse the condition, ensuring that parameters or the return variable
30569 aren't flagged for use outside the body of a function. */
30574 /* Try to recover from errors by scanning up to the end of the
30575 attribute. Sometimes we get partially parsed expressions, so
30576 we need to search the condition for errors. */
30580 /* Build the contract. */
30583 /* Leave our temporary scope for the postcondition result. */
30585 {
30588 }
30589 }
30592 {
30595 }
30598 }
30600 /* Parse a contract condition for a deferred contract. */
30603 tree fn,
30604 tree attribute)
30605 {
30608 /* Make sure we've gotten something that hasn't been parsed yet or that
30609 we're not parsing an invalid contract. */
30618 /* Build a fake variable for the result identifier. */
30621 {
30622 /* TODO: Can we guarantee that the identifier has a location? */
30626 {
30629 }
30634 }
30636 /* 'this' is not allowed in preconditions of constructors or in postconditions
30637 of destructors. Note that the previous value of this variable is
30638 established by the calling function, so we need to save it here. */
30643 {
30646 }
30650 /* Push the saved tokens onto the parser's lexer stack. */
30654 /* Parse the condition, ensuring that parameters or the return variable
30655 aren't flagged for use outside the body of a function. */
30660 /* Revert to the main lexer. */
30663 /* Restore the queue. */
30669 /* Commit to changes. */
30672 /* Leave our temporary scope for the postcondition result. */
30674 {
30677 }
30678 }
30680 /* Parse a standard C++-11 attribute specifier.
30682 attribute-specifier:
30683 [ [ attribute-using-prefix [opt] attribute-list ] ]
30684 contract-attribute-specifier
30685 alignment-specifier
30687 attribute-using-prefix:
30688 using attribute-namespace :
30690 alignment-specifier:
30691 alignas ( type-id ... [opt] )
30692 alignas ( alignment-expression ... [opt] ).
30694 Extensions for contracts:
30696 contract-attribute-specifier:
30697 [ [ assert : contract-mode [opt] : conditional-expression ] ]
30698 [ [ pre : contract-mode [opt] : conditional-expression ] ]
30699 [ [ post : contract-mode [opt] identifier [opt] :
30700 conditional-expression ] ]
30702 Return void_list_node if the current token doesn't start an
30703 attribute-specifier to differentiate from NULL_TREE returned e.g.
30704 for [ [ ] ]. */
30706 static tree
30708 {
30714 {
30723 {
30726 }
30728 /* Handle contract-attribute-specs specially. */
30730 {
30735 }
30738 {
30749 {
30752 "attribute using prefix only available "
30758 }
30759 else
30761 }
30765 finish_attrs:
30769 else
30770 /* Warn about parsing c++11 attribute in non-c++11 mode, only
30771 when we are sure that we have actually parsed them. */
30773 }
30774 else
30775 {
30776 tree alignas_expr;
30778 /* Look for an alignment-specifier. */
30789 matching_parens parens;
30797 {
30804 }
30809 /* Handle alignas (pack...). */
30811 {
30814 }
30816 /* Something went wrong, so don't build the attribute. */
30820 /* Missing ')' means the code cannot possibly be valid; go ahead
30821 and commit to make sure we issue a hard error. */
30829 /* Build the C++-11 representation of an 'aligned'
30830 attribute. */
30831 attributes
30834 }
30837 }
30839 /* Parse a standard C++-11 attribute-specifier-seq.
30841 attribute-specifier-seq:
30842 attribute-specifier-seq [opt] attribute-specifier */
30844 static tree
30846 {
30850 /* Don't create wrapper nodes within attributes: the
30851 handlers don't know how to handle them. */
30852 auto_suppress_location_wrappers sentinel;
30855 {
30859 /* Accept [[]][[]]; for which cp_parser_std_attribute_spec
30860 returns NULL_TREE as there are no attributes. */
30868 else
30871 }
30874 }
30876 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
30877 return index of the first token after balanced-token, or N on failure. */
30879 static size_t
30881 {
30884 do
30886 {
30890 /* FALLTHRU */
30892 /* Ran out of tokens. */
30914 }
30917 }
30919 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
30920 return index of the first token after the GNU attribute tokens, or N on
30921 failure. */
30923 static size_t
30925 {
30927 {
30939 }
30941 }
30943 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
30944 next token), return index of the first token after the standard C++11
30945 attribute tokens, or N on failure. */
30947 static size_t
30949 {
30951 {
30954 {
30961 }
30964 {
30969 }
30970 else
30972 }
30974 }
30976 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
30977 as the next token), return index of the first token after the attribute
30978 tokens, or N on failure. */
30980 static size_t
30982 {
30986 }
30988 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
30989 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
30990 current value of the PEDANTIC flag, regardless of whether or not
30991 the `__extension__' keyword is present. The caller is responsible
30992 for restoring the value of the PEDANTIC flag. */
30994 static bool
30996 {
30997 /* Save the old value of the PEDANTIC flag. */
31001 {
31002 /* Consume the `__extension__' token. */
31004 /* We're not being pedantic while the `__extension__' keyword is
31005 in effect. */
31009 }
31012 }
31014 /* Parse a label declaration.
31016 label-declaration:
31017 __label__ label-declarator-seq ;
31019 label-declarator-seq:
31020 identifier , label-declarator-seq
31021 identifier */
31023 static void
31025 {
31026 /* Look for the `__label__' keyword. */
31030 {
31031 tree identifier;
31033 /* Look for an identifier. */
31035 /* If we failed, stop. */
31038 /* Declare it as a label. */
31040 /* If the next token is a `;', stop. */
31043 /* Look for the `,' separating the label declarations. */
31045 }
31047 /* Look for the final `;'. */
31049 }
31051 // -------------------------------------------------------------------------- //
31052 // Concept definitions
31054 static tree
31056 {
31057 /* A concept definition is an unevaluated context. */
31058 cp_unevaluated u;
31065 {
31069 }
31074 {
31078 }
31080 processing_constraint_expression_sentinel parsing_constraint;
31085 /* Consume the trailing ';'. Diagnose the problem if it isn't there,
31086 but continue as if it were. */
31090 }
31092 // -------------------------------------------------------------------------- //
31093 // Requires Clause
31095 /* Diagnose an expression that should appear in ()'s within a requires-clause
31096 and suggest where to place those parentheses. */
31098 static void
31100 {
31102 }
31104 static void
31106 {
31111 }
31113 /* Characterizes the likely kind of expression intended by a mis-written
31114 primary constraint. */
31115 enum primary_constraint_error
31116 {
31117 pce_ok,
31118 pce_maybe_operator,
31119 pce_maybe_postfix
31120 };
31122 /* Returns true if the token(s) following a primary-expression in a
31123 constraint-logical-* expression would require parentheses. */
31125 static primary_constraint_error
31127 {
31130 {
31135 {
31136 /* An equal sign may be part of the definition of a function,
31137 and not an assignment operator, when parsing the expression
31138 for a trailing requires-clause. For example:
31140 template<typename T>
31141 struct S {
31142 S() requires C<T> = default;
31143 };
31145 Don't try to reparse this a binary operator. */
31151 }
31153 /* Arithmetic operators. */
31159 /* Bitwise operators. */
31165 /* Relational operators. */
31173 /* Pointer-to-member. */
31176 /* Assignment operators. */
31187 /* Conditional operator */
31189 /* Unenclosed binary or conditional operator. */
31193 {
31194 /* A primary constraint that precedes the parameter-list of a
31195 lambda expression is followed by an open paren.
31197 []<typename T> requires C (T a, T b) { ... }
31199 Don't try to re-parse this as a postfix expression. */
31204 }
31206 {
31207 /* A primary-constraint-expression followed by a '[[' is not a
31208 postfix expression. */
31213 }
31217 /* Unenclosed postfix operator. */
31221 /* A primary constraint that precedes the lambda-declarator of a
31222 lambda expression is followed by trailing return type.
31224 []<typename T> requires C -> void {}
31226 Don't try to re-parse this as a postfix expression in
31227 C++23 and later. In C++20 ( needs to come in between but we
31228 allow it to be omitted with pedwarn. */
31231 /* Unenclosed postfix operator. */
31233 }
31234 }
31236 /* Returns true if the next token begins a unary expression, preceded by
31237 an operator or keyword. */
31239 static bool
31241 {
31244 {
31255 {
31257 {
31273 }
31274 }
31278 }
31281 }
31283 /* Parse a primary expression within a constraint. */
31285 static cp_expr
31287 {
31288 /* If this looks like a unary expression, parse it as such, but diagnose
31289 it as ill-formed; it requires parens. */
31291 {
31295 }
31298 cp_id_kind idk;
31309 {
31310 /* The primary-expression could be part of an unenclosed non-logical
31311 compound expression. */
31313 }
31315 {
31318 }
31320 /* Retry the parse at a lower precedence. If that succeeds, diagnose the
31321 error, but return the expression as if it were valid. */
31326 else
31329 {
31332 }
31334 /* Otherwise, something has gone very wrong, and we can't generate a more
31335 meaningful diagnostic or recover. */
31338 }
31340 /* Parse a constraint-logical-and-expression.
31342 constraint-logical-and-expression:
31343 primary-expression
31344 constraint-logical-and-expression '&&' primary-expression */
31346 static cp_expr
31348 {
31351 {
31355 }
31357 }
31359 /* Parse a constraint-logical-or-expression.
31361 constraint-logical-or-expression:
31362 constraint-logical-and-expression
31363 constraint-logical-or-expression '||' constraint-logical-and-expression */
31365 static cp_expr
31367 {
31370 {
31374 }
31376 }
31378 /* Parse the expression after a requires-clause. This has a different grammar
31379 than that in the concepts TS. */
31381 static tree
31383 {
31384 processing_constraint_expression_sentinel parsing_constraint;
31391 }
31393 /* Parse a expression after a requires clause.
31395 constraint-expression:
31396 logical-or-expression
31398 The required logical-or-expression must be a constant expression. Note
31399 that we don't check that the expression is constepxr here. We defer until
31400 we analyze constraints and then, we only check atomic constraints. */
31402 static tree
31404 {
31405 processing_constraint_expression_sentinel parsing_constraint;
31414 }
31416 /* Optionally parse a requires clause:
31418 requires-clause:
31419 `requires` constraint-logical-or-expression.
31420 [ConceptsTS]
31421 `requires constraint-expression.
31423 LAMBDA_P is true when the requires-clause is parsed before the
31424 parameter-list of a lambda-declarator. */
31426 static tree
31428 {
31429 /* A requires clause is an unevaluated context. */
31430 cp_unevaluated u;
31434 {
31437 {
31439 "%<requires%> only available with "
31441 /* Parse and discard the requires-clause. */
31444 }
31446 }
31450 {
31451 /* An opening brace following the start of a requires-clause is
31452 ill-formed; the user likely forgot the second `requires' that
31453 would start a requires-expression. */
31458 /* Don't consume the `requires', so that it's reused as the start of a
31459 requires-expression. */
31460 }
31461 else
31466 else
31468 }
31470 /*---------------------------------------------------------------------------
31471 Requires expressions
31472 ---------------------------------------------------------------------------*/
31474 /* Parse a requires expression
31476 requirement-expression:
31477 'requires' requirement-parameter-list [opt] requirement-body */
31479 static tree
31481 {
31485 /* Avoid committing to outer tentative parse. */
31488 /* This is definitely a requires-expression. */
31492 {
31493 /* Local parameters are delared as variables within the scope
31494 of the expression. They are not visible past the end of
31495 the expression. Expressions within the requires-expression
31496 are unevaluated. */
31497 struct scope_sentinel
31498 {
31500 {
31504 }
31507 {
31510 }
31513 /* Parse the optional parameter list. */
31515 {
31519 }
31520 else
31523 /* Parse the requirement body. */
31529 }
31531 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
31532 the parm chain. */
31537 {
31538 /* Perform semantic processing now to diagnose any invalid types and
31539 expressions. */
31544 }
31546 }
31548 /* Parse a parameterized requirement.
31550 requirement-parameter-list:
31551 '(' parameter-declaration-clause ')' */
31553 static tree
31555 {
31556 matching_parens parens;
31560 tree parms = (cp_parser_parameter_declaration_clause
31566 /* Modify the declared parameters by removing their context
31567 so they don't refer to the enclosing scope and explicitly
31568 indicating that they are constraint variables. */
31570 {
31575 {
31578 }
31579 }
31582 }
31584 /* Parse the body of a requirement.
31586 requirement-body:
31587 '{' requirement-list '}' */
31588 static tree
31590 {
31591 matching_braces braces;
31601 }
31603 /* Parse a sequence of requirements.
31605 requirement-seq:
31606 requirement
31607 requirement-seq requirement */
31609 static tree
31611 {
31613 do
31614 {
31618 }
31622 /* If there are no valid requirements, this is not a valid expression. */
31626 /* Reverse the order of requirements so they are analyzed in order. */
31628 }
31630 /* Parse a syntactic requirement or type requirement.
31632 requirement:
31633 simple-requirement
31634 compound-requirement
31635 type-requirement
31636 nested-requirement */
31638 static tree
31640 {
31644 {
31645 /* It's probably a type-requirement. */
31650 /* No, maybe it's something like typename T::type(); */
31655 /* Non-tentative for the error. */
31657 }
31660 else
31662 }
31664 /* Parse a simple requirement.
31666 simple-requirement:
31667 expression ';' */
31669 static tree
31671 {
31682 /* Sometimes we don't get locations, so use the cached token location
31683 as a reasonable approximation. */
31688 {
31691 {
31694 }
31696 {
31700 "if a concept-id is a valid expression; add "
31702 }
31704 }
31707 }
31709 /* Parse a type requirement
31711 type-requirement
31712 nested-name-specifier [opt] required-type-name ';'
31714 required-type-name:
31715 type-name
31716 'template' [opt] simple-template-id */
31718 static tree
31720 {
31724 // Save the scope before parsing name specifiers.
31735 tree type;
31737 {
31746 }
31747 else
31767 }
31769 /* Parse a compound requirement
31771 compound-requirement:
31772 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
31774 static tree
31776 {
31777 /* Parse an expression enclosed in '{ }'s. */
31778 matching_braces braces;
31789 {
31793 }
31795 /* If the expression was invalid, skip the remainder of the requirement. */
31797 {
31801 }
31803 /* Parse the optional noexcept. */
31806 {
31809 }
31811 /* Parse the optional trailing return type. */
31814 {
31820 /* C++20 allows either a type-id or a type-constraint. Parsing
31821 a type-id will subsume the parsing for a type-constraint but
31822 allow for more syntactic forms (e.g., const C<T>*). */
31831 /* Check that we haven't written something like 'const C<T>*'. */
31833 {
31835 {
31840 }
31841 }
31843 /* P1452R2 removed the trailing-return-type option. */
31846 }
31858 }
31860 /* Parse a nested requirement. This is the same as a requires clause.
31862 nested-requirement:
31863 requires-clause */
31865 static tree
31867 {
31879 }
31881 /* Support Functions */
31883 /* Return the appropriate prefer_type argument for lookup_name based on
31884 tag_type. */
31888 {
31890 {
31894 }
31895 }
31897 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
31898 NAME should have one of the representations used for an
31899 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
31900 is returned. If PARSER->SCOPE is a dependent type, then a
31901 SCOPE_REF is returned.
31903 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
31904 returned; the name was already resolved when the TEMPLATE_ID_EXPR
31905 was formed. Abstractly, such entities should not be passed to this
31906 function, because they do not need to be looked up, but it is
31907 simpler to check for this special case here, rather than at the
31908 call-sites.
31910 In cases not explicitly covered above, this function returns a
31911 DECL, OVERLOAD, or baselink representing the result of the lookup.
31912 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
31913 is returned.
31915 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
31916 (e.g., "struct") that was used. In that case bindings that do not
31917 refer to types are ignored.
31919 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
31920 ignored. If IS_TEMPLATE IS 2, the 'template' keyword was specified.
31922 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
31923 are ignored.
31925 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
31926 types.
31928 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
31929 TREE_LIST of candidates if name-lookup results in an ambiguity, and
31930 NULL_TREE otherwise. */
31932 static cp_expr
31939 location_t name_location)
31940 {
31941 tree decl;
31944 /* Assume that the lookup will be unambiguous. */
31948 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
31949 no longer valid. Note that if we are parsing tentatively, and
31950 the parse fails, OBJECT_TYPE will be automatically restored. */
31956 /* A template-id has already been resolved; there is no lookup to
31957 do. */
31961 {
31965 }
31967 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
31968 it should already have been checked to make sure that the name
31969 used matches the type being destroyed. */
31971 {
31972 tree type;
31974 /* Figure out to which type this destructor applies. */
31979 else
31981 /* If that's not a class type, there is no destructor. */
31985 /* In a non-static member function, check implicit this->. */
31988 tf_warning_or_error);
31997 }
31999 /* By this point, the NAME should be an ordinary identifier. If
32000 the id-expression was a qualified name, the qualifying scope is
32001 stored in PARSER->SCOPE at this point. */
32004 /* Perform the lookup. */
32006 {
32012 /* If the SCOPE is dependent, the lookup must be deferred until
32013 the template is instantiated -- unless we are explicitly
32014 looking up names in uninstantiated templates. Even then, we
32015 cannot look up the name if the scope is not a class type; it
32016 might, for example, be a template type parameter. */
32021 /* Defer lookup. */
32023 else
32024 {
32027 /* If PARSER->SCOPE is a dependent type, then it must be a
32028 class type, and we must not be checking dependencies;
32029 otherwise, we would have processed this lookup above. So
32030 that PARSER->SCOPE is not considered a dependent base by
32031 lookup_member, we must enter the scope here. */
32035 /* If the PARSER->SCOPE is a template specialization, it
32036 may be instantiated during name lookup. In that case,
32037 errors may be issued. Even if we rollback the current
32038 tentative parse, those errors are valid. */
32043 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
32044 lookup result and the nested-name-specifier nominates a class C:
32045 * if the name specified after the nested-name-specifier, when
32046 looked up in C, is the injected-class-name of C (Clause 9), or
32047 * if the name specified after the nested-name-specifier is the
32048 same as the identifier or the simple-template-id's template-
32049 name in the last component of the nested-name-specifier,
32050 the name is instead considered to name the constructor of
32051 class C. [ Note: for example, the constructor is not an
32052 acceptable lookup result in an elaborated-type-specifier so
32053 the constructor would not be used in place of the
32054 injected-class-name. --end note ] Such a constructor name
32055 shall be used only in the declarator-id of a declaration that
32056 names a constructor or in a using-declaration. */
32066 }
32068 /* If the scope is a dependent type and either we deferred lookup or
32069 we did lookup but didn't find the name, rememeber the name. */
32072 {
32074 {
32075 tree type;
32077 /* The resolution to Core Issue 180 says that `struct
32078 A::B' should be considered a type-name, even if `A'
32079 is dependent. */
32084 }
32088 CPP_CLOSE_PAREN)))
32092 else
32095 is_template);
32096 }
32099 }
32101 {
32104 /* Look up the name in the scope of the OBJECT_TYPE, unless the
32105 OBJECT_TYPE is not a class. */
32107 /* If the OBJECT_TYPE is a template specialization, it may
32108 be instantiated during name lookup. In that case, errors
32109 may be issued. Even if we rollback the current tentative
32110 parse, those errors are valid. */
32112 name,
32115 tf_warning_or_error);
32116 else
32119 /* If we didn't find a member and have dependent bases, the member lookup
32120 is now dependent. */
32127 /* Look it up in the enclosing context. DR 141: When looking for a
32128 template-name after -> or ., only consider class templates. */
32130 /* DR 141: When looking in the
32131 current enclosing context for a
32132 template-name after -> or ., only
32133 consider class templates. */
32137 /* If we did unqualified lookup of a dependent member-qualified name and
32138 found something, do we want to use it? P1787 clarified that we need
32139 to look in the object scope first even if it's dependent, but for now
32140 let's still use it in some cases.
32141 FIXME remember unqualified lookup result to use if member lookup fails
32142 at instantiation time. */
32144 {
32146 /* Only use the unqualified class template lookup if we're actually
32147 looking at a template arg list. */
32150 }
32152 /* If we know we're looking for a type (e.g. A in p->A::x),
32153 mock up a typename. */
32155 {
32157 typename_type);
32159 }
32163 }
32164 else
32165 {
32170 }
32172 /* If the lookup failed, let our caller know. */
32176 /* If we have resolved the name of a member declaration, check to
32177 see if the declaration is accessible. When the name resolves to
32178 set of overloaded functions, accessibility is checked when
32179 overload resolution is done. If we have a TREE_LIST, then the lookup
32180 is either ambiguous or it found multiple injected-class-names, the
32181 accessibility of which is trivially satisfied.
32183 During an explicit instantiation, access is not checked at all,
32184 as per [temp.explicit]. */
32187 tf_warning_or_error);
32189 /* Pull out the template from an injected-class-name (or multiple). */
32193 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
32195 {
32198 /* The error message we have to print is too complicated for
32199 cp_parser_error, so we incorporate its actions directly. */
32201 {
32203 name);
32205 }
32207 }
32218 }
32220 /* Like cp_parser_lookup_name, but for use in the typical case where
32221 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
32222 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
32224 static tree
32226 {
32228 none_type,
32233 location);
32234 }
32236 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
32237 the current context, return the TYPE_DECL. If TAG_NAME_P is
32238 true, the DECL indicates the class being defined in a class-head,
32239 or declared in an elaborated-type-specifier.
32241 Otherwise, return DECL. */
32243 static tree
32245 {
32246 /* If the TEMPLATE_DECL is being declared as part of a class-head,
32247 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
32249 struct A {
32250 template <typename T> struct B;
32251 };
32253 template <typename T> struct A::B {};
32255 Similarly, in an elaborated-type-specifier:
32257 namespace N { struct X{}; }
32259 struct A {
32260 template <typename T> friend struct N::X;
32261 };
32263 However, if the DECL refers to a class type, and we are in
32264 the scope of the class, then the name lookup automatically
32265 finds the TYPE_DECL created by build_self_reference rather
32266 than a TEMPLATE_DECL. For example, in:
32268 template <class T> struct S {
32269 S s;
32270 };
32272 there is no need to handle such case. */
32278 }
32280 /* If too many, or too few, template-parameter lists apply to the
32281 declarator, issue an error message. Returns TRUE if all went well,
32282 and FALSE otherwise. */
32284 static bool
32287 location_t declarator_location)
32288 {
32290 {
32292 {
32301 {
32302 /* If the DECLARATOR has the form `X<y>' then it uses one
32303 additional level of template parameters. */
32306 }
32308 return cp_parser_check_template_parameters
32310 declarator);
32311 }
32327 }
32329 }
32331 /* NUM_TEMPLATES were used in the current declaration. If that is
32332 invalid, return FALSE and issue an error messages. Otherwise,
32333 return TRUE. If DECLARATOR is non-NULL, then we are checking a
32334 declarator and we can print more accurate diagnostics. */
32336 static bool
32340 location_t location,
32342 {
32343 /* If there are the same number of template classes and parameter
32344 lists, that's OK. */
32347 /* If there are more, but only one more, and the name ends in an identifier,
32348 then we are declaring a primary template. That's OK too. */
32356 /* If there are more template classes than parameter lists, we have
32357 something like:
32359 template <class T> void S<T>::R<T>::f (); */
32361 {
32371 else
32374 }
32375 /* Otherwise, there are too many template parameter lists. We have
32376 something like:
32378 template <class T> template <class U> void S::f(); */
32381 }
32383 /* Parse an optional `::' token indicating that the following name is
32384 from the global namespace. If so, PARSER->SCOPE is set to the
32385 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
32386 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
32387 Returns the new value of PARSER->SCOPE, if the `::' token is
32388 present, and NULL_TREE otherwise. */
32390 static tree
32392 {
32395 /* Peek at the next token. */
32397 /* If we're looking at a `::' token then we're starting from the
32398 global namespace, not our current location. */
32400 {
32401 /* Consume the `::' token. */
32403 /* Set the SCOPE so that we know where to start the lookup. */
32409 }
32411 {
32415 }
32418 }
32420 /* Returns TRUE if the upcoming token sequence is the start of a
32421 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
32422 declarator is preceded by the `friend' specifier. The parser flags FLAGS
32423 is used to control type-specifier parsing. */
32425 static bool
32428 {
32431 tree nested_name_specifier;
32434 /* The common case is that this is not a constructor declarator, so
32435 try to avoid doing lots of work if at all possible. It's not
32436 valid declare a constructor at function scope. */
32439 /* And only certain tokens can begin a constructor declarator. */
32447 /* Parse tentatively; we are going to roll back all of the tokens
32448 consumed here. */
32450 /* Assume that we are looking at a constructor declarator. */
32453 /* Look for the optional `::' operator. */
32456 /* Look for the nested-name-specifier. */
32457 nested_name_specifier
32464 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
32467 {
32472 }
32478 /* Outside of a class-specifier, there must be a
32479 nested-name-specifier. Except in C++17 mode, where we
32480 might be declaring a guiding declaration. */
32487 /* If we have a class scope, this is easy; DR 147 says that S::S always
32488 names the constructor, and no other qualified name could. */
32491 {
32501 }
32502 /* If we still think that this might be a constructor-declarator,
32503 look for a class-name. */
32505 {
32506 /* If we have:
32508 template <typename T> struct S {
32509 S();
32510 };
32512 we must recognize that the nested `S' names a class. */
32516 tree type_decl;
32520 none_type,
32527 {
32533 none_type,
32538 else
32540 }
32542 /* If there was no class-name, then this is not a constructor.
32543 Otherwise, if we are in a class-specifier and we aren't
32544 handling a friend declaration, check that its type matches
32545 current_class_type (c++/38313). Note: error_mark_node
32546 is left alone for error recovery purposes. */
32548 && (outside_class_specifier_p
32554 /* If we're still considering a constructor, we have to see a `(',
32555 to begin the parameter-declaration-clause, followed by either a
32556 `)', an `...', or a decl-specifier. We need to check for a
32557 type-specifier to avoid being fooled into thinking that:
32559 S (f) (int);
32561 is a constructor. (It is actually a function named `f' that
32562 takes one parameter (of type `int') and returns a value of type
32563 `S'. */
32571 /* A parameter declaration begins with a decl-specifier,
32572 which is either the "attribute" keyword, a storage class
32573 specifier, or (usually) a type-specifier. */
32575 /* GNU attributes can actually appear both at the start of
32576 a parameter and parenthesized declarator.
32577 S (__attribute__((unused)) int);
32578 is a constructor, but
32579 S (__attribute__((unused)) foo) (int);
32580 is a function declaration. [[attribute]] can appear in the
32581 first form too, but not in the second form. */
32583 {
32584 tree type;
32590 {
32594 }
32596 /* Names appearing in the type-specifier should be looked up
32597 in the scope of the class. */
32601 {
32604 {
32608 {
32611 }
32612 }
32614 }
32616 /* Inside the constructor parameter list, surrounding
32617 template-parameter-lists do not apply. */
32618 saved_num_template_parameter_lists
32622 /* Look for the type-specifier. It's not optional, but its typename
32623 might be. Unless this is a friend declaration; we don't want to
32624 treat
32626 friend S (T::fn)(int);
32628 as a constructor, but with P0634, we might assume a type when
32629 looking for the type-specifier. It is actually a function named
32630 `T::fn' that takes one parameter (of type `int') and returns a
32631 value of type `S'. Constructors can be friends, but they must
32632 use a qualified name.
32634 Parse with an empty set of declaration specifiers since we're
32635 trying to match a decl-specifier-seq of the first parameter.
32636 This must be non-null so that cp_parser_simple_type_specifier
32637 will recognize a constrained placeholder type such as:
32638 'C<int> auto' where C is a type concept. */
32639 cp_decl_specifier_seq ctor_specs;
32649 parser->num_template_parameter_lists
32652 /* Leave the scope of the class. */
32657 }
32658 }
32660 /* We did not really want to consume any tokens. */
32663 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
32664 declarator-id of a constructor or destructor. */
32667 {
32668 auto_diagnostic_group d;
32673 }
32676 }
32678 /* Parse the definition of the function given by the DECL_SPECIFIERS,
32679 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
32680 they must be performed once we are in the scope of the function.
32682 Returns the function defined. */
32684 static tree
32685 cp_parser_function_definition_from_specifiers_and_declarator
32688 tree attributes,
32690 {
32691 tree fn;
32694 /* Begin the function-definition. */
32697 /* The things we're about to see are not directly qualified by any
32698 template headers we've seen thus far. */
32701 /* If there were names looked up in the decl-specifier-seq that we
32702 did not check, check them now. We must wait until we are in the
32703 scope of the function to perform the checks, since the function
32704 might be a friend. */
32708 {
32713 }
32716 {
32717 /* Skip the entire function. */
32720 }
32722 {
32723 /* Seen already, skip it. An error message has already been output. */
32727 /* If this is a function from a class, pop the nested class. */
32730 }
32731 else
32732 {
32737 }
32740 }
32742 /* Parse the part of a function-definition that follows the
32743 declarator. INLINE_P is TRUE iff this function is an inline
32744 function defined within a class-specifier.
32746 Returns the function defined. */
32748 static tree
32751 {
32752 tree fn;
32757 bool fully_implicit_function_template_p
32760 tree implicit_template_parms
32763 cp_binding_level* implicit_template_scope
32769 /* If the next token is `return', then the code may be trying to
32770 make use of the "named return value" extension that G++ used to
32771 support. */
32774 {
32775 /* Consume the `return' keyword. */
32777 /* Look for the identifier that indicates what value is to be
32778 returned. */
32780 /* Issue an error message. */
32783 /* Skip tokens until we reach the start of the function body. */
32785 {
32792 }
32793 }
32794 /* The `extern' in `extern "C" void f () { ... }' does not apply to
32795 anything declared inside `f'. */
32796 saved_in_unbraced_linkage_specification_p
32799 /* Inside the function, surrounding template-parameter-lists do not
32800 apply. */
32801 saved_num_template_parameter_lists
32805 /* If the next token is `try', `__transaction_atomic', or
32806 `__transaction_relaxed`, then we are looking at either function-try-block
32807 or function-transaction-block. Note that all of these include the
32808 function-body. */
32812 RID_TRANSACTION_RELAXED))
32816 else
32817 cp_parser_ctor_initializer_opt_and_function_body
32820 /* Finish the function. */
32824 && !inline_p
32830 /* Generate code for it, if necessary. */
32833 /* Restore the saved values. */
32834 parser->in_unbraced_linkage_specification_p
32836 parser->num_template_parameter_lists
32840 parser->fully_implicit_function_template_p
32842 parser->implicit_template_parms
32844 parser->implicit_template_scope
32851 }
32853 /* Parse a template-declaration body (following argument list). */
32855 static void
32857 tree parameter_list,
32859 {
32863 /* We just processed one more parameter list. */
32866 /* Get the deferred access checks from the parameter list. These
32867 will be checked once we know what is being declared, as for a
32868 member template the checks must be performed in the scope of the
32869 class containing the member. */
32872 /* Tentatively parse for a new template parameter list, which can either be
32873 the template keyword or a template introduction. */
32882 /* -fconcept-ts 'concept bool' syntax is handled below, in
32883 cp_parser_single_declaration. */
32885 else
32886 {
32889 checks,
32890 member_p,
32894 /* If this is a member template declaration, let the front
32895 end know. */
32897 {
32902 }
32907 }
32908 /* We are done with the current parameter list. */
32913 /* Finish up. */
32916 /* Check the template arguments for a literal operator template. */
32920 {
32924 else
32925 {
32928 {
32935 /* OK, C++20 string literal operator template. We don't need
32936 to warn in lower dialects here because we will have already
32941 }
32943 {
32952 else
32953 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
32955 "ISO C++ did not adopt string literal operator templa"
32957 }
32958 else
32960 }
32962 {
32965 "template %qD has invalid parameter list; expected "
32966 "non-type template parameter pack %<<char...>%> or "
32968 decl);
32969 else
32971 "template %qD has invalid parameter list; expected "
32973 decl);
32974 }
32975 }
32977 /* Register member declarations. */
32980 /* If DECL is a function template, we must return to parse it later.
32981 (Even though there is no definition, there might be default
32982 arguments that need handling.) */
32986 }
32988 /* Parse a template introduction header for a template-declaration. Returns
32989 false if tentative parse fails. */
32991 static bool
32993 {
33003 /* In classes don't parse valid unnamed bitfields as invalid
33004 template introductions. */
33008 /* Look for the optional `::' operator. */
33011 /* Look for the nested-name-specifier. */
33021 /* Look up the concept for which we will be matching
33022 template parameters. */
33034 /* Look for opening brace for introduction. */
33035 matching_braces braces;
33044 /* Build vector of placeholder parameters and grab
33045 matching identifiers. */
33048 /* Look for closing brace for introduction. */
33052 /* The introduction-list shall not be empty. */
33055 {
33056 /* In cp_parser_introduction_list we have already issued an error. */
33058 }
33061 {
33065 }
33067 /* Build and associate the constraint. */
33072 introduction_list,
33073 introduction_loc);
33075 {
33082 member_p);
33084 }
33090 }
33092 /* Parse a normal template-declaration following the template keyword. */
33094 static void
33096 {
33097 tree parameter_list;
33101 /* Look for the `<' token. */
33105 {
33106 /* 14.5.2.2 [temp.mem]
33108 A local class shall not have member templates. */
33113 }
33114 /* [temp]
33116 A template ... shall not have C linkage. */
33118 {
33121 /* Give it C++ linkage to avoid confusing other parts of the
33122 front end. */
33125 }
33126 else
33129 /* We cannot perform access checks on the template parameter
33130 declarations until we know what is being declared, just as we
33131 cannot check the decl-specifier list. */
33134 /* If the next token is `>', then we have an invalid
33135 specialization. Rather than complain about an invalid template
33136 parameter, issue an error message here. */
33138 {
33142 }
33143 else
33144 {
33145 /* Parse the template parameters. */
33147 }
33149 /* Look for the `>'. */
33152 /* Manage template requirements */
33154 {
33159 }
33162 member_p);
33164 /* For the erroneous case of a template with C linkage, we pushed an
33165 implicit C++ linkage scope; exit that scope now. */
33168 }
33170 /* Parse a template-declaration, assuming that the `export' (and
33171 `extern') keywords, if present, has already been scanned. MEMBER_P
33172 is as for cp_parser_template_declaration. */
33174 static bool
33176 {
33178 {
33182 }
33187 }
33189 /* Perform the deferred access checks from a template-parameter-list.
33190 CHECKS is a TREE_LIST of access checks, as returned by
33191 get_deferred_access_checks. */
33193 static void
33194 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
33195 {
33199 }
33201 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
33202 `function-definition' sequence that follows a template header.
33203 If MEMBER_P is true, this declaration appears in a class scope.
33205 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
33206 *FRIEND_P is set to TRUE iff the declaration is a friend. */
33208 static tree
33214 {
33217 cp_decl_specifier_seq decl_specifiers;
33221 /* This function is only used when processing a template
33222 declaration. */
33226 /* Defer access checks until we know what is being declared. */
33229 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
33230 alternative. */
33233 (CP_PARSER_FLAGS_OPTIONAL
33238 cp_omp_declare_simd_data odsd;
33247 /* There are no template typedefs. */
33249 {
33253 }
33255 /* Gather up the access checks that occurred the
33256 decl-specifier-seq. */
33259 /* Check for the declaration of a template class. */
33261 {
33264 {
33267 /* In this case:
33269 struct C {
33270 friend template <typename T> struct A<T>::B;
33271 };
33273 A<T>::B will be represented by a TYPENAME_TYPE, and
33274 therefore not recognized by shadow_tag. */
33276 && !decl
33283 else
33286 /* If this is a declaration, but not a definition, associate
33287 any constraints with the type declaration. Constraints
33288 are associated with definitions in cp_parser_class_specifier. */
33292 /* Perform access checks for template parameters. */
33295 /* Give a helpful diagnostic for
33296 template <class T> struct A { } a;
33297 if we aren't already recovering from an error. */
33300 {
33302 "a class template declaration must not declare "
33306 }
33307 }
33308 }
33310 /* Complain about missing 'typename' or other invalid type names. */
33313 {
33314 /* cp_parser_parse_and_diagnose_invalid_type_name calls
33315 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
33316 the rest of this declaration. */
33319 }
33321 /* If it's not a template class, try for a template function. If
33322 the next token is a `;', then this declaration does not declare
33323 anything. But, if there were errors in the decl-specifiers, then
33324 the error might well have come from an attempted class-specifier.
33325 In that case, there's no need to warn about a missing declarator. */
33329 {
33331 /* We don't delay parsing for friends, though CWG 2510 may change
33332 that. */
33336 flags,
33338 checks,
33340 member_p,
33341 declares_class_or_enum,
33345 /* 7.1.1-1 [dcl.stc]
33347 A storage-class-specifier shall not be specified in an explicit
33348 specialization... */
33350 && explicit_specialization_p
33352 {
33356 }
33360 }
33362 /* Look for a trailing `;' after the declaration. */
33368 out:
33371 /* Clear any current qualification; whatever comes next is the start
33372 of something new. */
33380 }
33382 /* Parse a cast-expression that is not the operand of a unary "&". */
33384 static cp_expr
33386 {
33389 }
33391 /* Parse a functional cast to TYPE. Returns an expression
33392 representing the cast. */
33394 static cp_expr
33396 {
33398 tree expression_list;
33399 cp_expr cast;
33414 /* auto(x) and auto{x} need to use a level-less auto. */
33418 {
33428 /* Create a location of the form:
33429 type_name{i, f}
33430 ^~~~~~~~~~~~~~~
33431 with caret == start at the start of the type name,
33432 finishing at the closing brace. */
33437 }
33446 else
33447 {
33450 }
33452 /* Create a location of the form:
33453 float(i)
33454 ^~~~~~~~
33455 with caret == start at the start of the type name,
33456 finishing at the closing paren. */
33460 tf_warning_or_error);
33462 /* [expr.const]/1: In an integral constant expression "only type
33463 conversions to integral or enumeration type can be used". */
33469 NIC_CONSTRUCTOR))
33473 }
33475 /* Save the tokens that make up the body of a member function defined
33476 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
33477 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
33478 specifiers applied to the declaration. Returns the FUNCTION_DECL
33479 for the member function. */
33481 static tree
33485 tree attributes)
33486 {
33489 tree fn;
33492 /* Create the FUNCTION_DECL. */
33496 /* If something went badly wrong, bail out now. */
33498 {
33499 /* If there's a function-body, skip it. */
33504 }
33506 /* Remember it, if there are default args to post process. */
33509 /* Save away the tokens that make up the body of the
33510 function. */
33516 RID_TRANSACTION_ATOMIC))
33517 {
33519 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
33526 {
33532 }
33533 else
33536 {
33540 }
33541 }
33543 /* Handle function try blocks. */
33545 {
33548 }
33549 /* We can have braced-init-list mem-initializers before the fn body. */
33551 {
33554 {
33555 /* cache_group will stop after an un-nested { } pair, too. */
33559 /* variadic mem-inits have ... after the ')'. */
33562 }
33563 }
33565 /* Handle function try blocks. */
33571 /* Save away the inline definition; we will process it when the
33572 class is complete. */
33576 /* We need to know that this was defined in the class, so that
33577 friend templates are handled correctly. */
33580 /* Add FN to the queue of functions to be parsed later. */
33584 }
33586 /* Save the tokens that make up the in-class initializer for a non-static
33587 data member. Returns a DEFERRED_PARSE. */
33589 static tree
33591 {
33593 }
33595 /* Parse a template-argument-list, as well as the trailing ">" (but
33596 not the opening "<"). See cp_parser_template_argument_list for the
33597 return value. */
33599 static tree
33601 {
33602 tree arguments;
33603 tree saved_scope;
33604 tree saved_qualifying_scope;
33605 tree saved_object_scope;
33608 /* [temp.names]
33610 When parsing a template-id, the first non-nested `>' is taken as
33611 the end of the template-argument-list rather than a greater-than
33612 operator. */
33613 saved_greater_than_is_operator_p
33616 /* Parsing the argument list may modify SCOPE, so we save it
33617 here. */
33621 /* We need to evaluate the template arguments, even though this
33622 template-id may be nested within a "sizeof". */
33623 cp_evaluated ev;
33624 /* Parse the template-argument-list itself. */
33629 {
33632 }
33633 else
33635 /* Look for the `>' that ends the template-argument-list. If we find
33636 a '>>' instead, it's probably just a typo. */
33638 {
33640 {
33641 /* In C++0x, a `>>' in a template argument list or cast
33642 expression is considered to be two separate `>'
33643 tokens. So, change the current token to a `>', but don't
33644 consume it: it will be consumed later when the outer
33645 template argument list (or cast expression) is parsed.
33646 Note that this replacement of `>' for `>>' is necessary
33647 even if we are parsing tentatively: in the tentative
33648 case, after calling
33649 cp_parser_enclosed_template_argument_list we will always
33650 throw away all of the template arguments and the first
33651 closing `>', either because the template argument list
33652 was erroneous or because we are replacing those tokens
33653 with a CPP_TEMPLATE_ID token. The second `>' (which will
33654 not have been thrown away) is needed either to close an
33655 outer template argument list or to complete a new-style
33656 cast. */
33659 }
33661 {
33662 /* If we're in a nested template argument list, the '>>' has
33663 to be a typo for '> >'. We emit the error message, but we
33664 continue parsing and we push a '>' as next token, so that
33665 the argument list will be parsed correctly. Note that the
33666 global source location is still on the token before the
33667 '>>', so we need to say explicitly where we want it. */
33675 }
33676 else
33677 {
33678 /* If this is not a nested template argument list, the '>>'
33679 is a typo for '>'. Emit an error message and continue.
33680 Same deal about the token location, but here we can get it
33681 right by consuming the '>>' before issuing the diagnostic. */
33684 "spurious %<>>%>, use %<>%> to terminate "
33686 }
33687 }
33688 /* Similarly for >>= and >=. */
33691 {
33697 {
33700 }
33702 {
33705 else
33708 }
33709 else
33710 {
33713 }
33719 }
33720 else
33722 /* The `>' token might be a greater-than operator again now. */
33723 parser->greater_than_is_operator_p
33725 /* Restore the SAVED_SCOPE. */
33731 }
33733 /* MEMBER_FUNCTION is a member function, or a friend. If default
33734 arguments, or the body of the function have not yet been parsed,
33735 parse them now. */
33737 static void
33739 {
33742 /* If this member is a template, get the underlying
33743 FUNCTION_DECL. */
33747 /* There should not be any class definitions in progress at this
33748 point; the bodies of members are only parsed outside of all class
33749 definitions. */
33751 /* While we're parsing the member functions we might encounter more
33752 classes. We want to handle them right away, but we don't want
33753 them getting mixed up with functions that are currently in the
33754 queue. */
33757 /* Make sure that any template parameters are in scope. */
33760 /* If the body of the function has not yet been parsed, parse it
33761 now. Except if the tokens have been purged (PR c++/39751). */
33764 {
33765 tree function_scope;
33768 /* The function is no longer pending; we are processing it. */
33773 /* If this is a local class, enter the scope of the containing
33774 function. */
33779 /* Push the body of the function onto the lexer stack. */
33782 /* Let the front end know that we going to be defining this
33783 function. */
33787 /* #pragma omp declare reduction needs special parsing. */
33789 {
33794 }
33795 else
33796 /* Now, parse the body of the function. */
33800 /* Leave the scope of the containing function. */
33804 }
33806 /* Remove any template parameters from the symbol table. */
33809 /* Restore the queue. */
33811 }
33813 /* If DECL contains any default args, remember it on the unparsed
33814 functions queue. */
33816 static void
33818 {
33819 tree probe;
33822 probe;
33825 {
33829 }
33831 /* Remember if there is a noexcept-specifier to post process. */
33836 /* Contracts are deferred. */
33839 {
33842 }
33843 }
33845 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
33846 which is either a FIELD_DECL or PARM_DECL. Parse it and return
33847 the result. For a PARM_DECL, PARMTYPE is the corresponding type
33848 from the parameter-type-list. */
33850 static tree
33853 {
33855 tree parsed_arg;
33860 /* Push the saved tokens for the default argument onto the parser's
33861 lexer stack. */
33867 /* Parse the default argument. */
33878 {
33879 /* In a non-template class, check conversions now. In a template,
33880 we'll wait and instantiate these as needed. */
33883 tf_warning_or_error);
33886 else
33888 }
33890 /* If the token stream has not been completely used up, then
33891 there was extra junk after the end of the default
33892 argument. */
33894 {
33897 else
33899 }
33901 /* Revert to the main lexer. */
33905 }
33907 /* FIELD is a non-static data member with an initializer which we saved for
33908 later; parse it now. */
33910 static void
33912 {
33913 tree def;
33920 NULL_TREE);
33926 }
33928 /* FN is a FUNCTION_DECL which may contains a parameter with an
33929 unparsed DEFERRED_PARSE. Parse the default args now. This function
33930 assumes that the current scope is the scope in which the default
33931 argument should be processed. */
33933 static void
33935 {
33938 /* While we're parsing the default args, we might (due to the
33939 statement expression extension) encounter more classes. We want
33940 to handle them right away, but we don't want them getting mixed
33941 up with default args that are currently in the queue. */
33944 /* Local variable names (and the `this' keyword) may not appear
33945 in a default argument. */
33953 /* Gather the PARM_DECLs into a vec so we can keep track of them when
33954 pushdecl clears DECL_CHAIN. */
33955 releasing_vec parms;
33965 {
33967 tree parsed_arg;
33976 /* This can happen for a friend declaration for a function
33977 already declared with default arguments. */
33980 parsed_arg
33982 default_arg,
33986 /* Update any instantiations we've already created. */
33989 }
33993 /* Restore DECL_CHAINs after clobbering by pushdecl. */
33996 {
33999 }
34003 /* Make sure no default arg is missing. */
34006 /* Restore the state of local_variables_forbidden_p. */
34009 /* Restore the queue. */
34011 }
34013 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
34015 sizeof ... ( identifier )
34017 where the 'sizeof' token has already been consumed. */
34019 static tree
34021 {
34022 /* Consume the `...'. */
34026 matching_parens parens;
34030 else
34038 /* The name is not qualified. */
34058 }
34060 /* Parse the operand of `sizeof' (or a similar operator). Returns
34061 either a TYPE or an expression, depending on the form of the
34062 input. The KEYWORD indicates which kind of expression we have
34063 encountered. */
34065 static tree
34067 {
34074 /* If it's a `...', then we are computing the length of a parameter
34075 pack. */
34080 /* Types cannot be defined in a `sizeof' expression. Save away the
34081 old message. */
34084 parser->type_definition_forbidden_message
34086 parser->type_definition_forbidden_message_arg
34089 /* The restrictions on constant-expressions do not apply inside
34090 sizeof expressions. */
34091 saved_integral_constant_expression_p
34093 saved_non_integral_constant_expression_p
34100 /* Do not actually evaluate the expression. */
34103 /* If it's a `(', then we might be looking at the type-id
34104 construction. */
34106 {
34111 /* We can't be sure yet whether we're looking at a type-id or an
34112 expression. */
34115 matching_parens parens;
34118 /* Note: as a GNU Extension, compound literals are considered
34119 postfix-expressions as they are in C99, so they are valid
34120 arguments to sizeof. See comment in cp_parser_cast_expression
34121 for details. */
34124 else
34125 {
34128 /* Look for the type-id. */
34130 /* Look for the closing `)'. */
34133 }
34135 /* If all went well, then we're done. */
34138 else
34139 {
34140 /* Commit to the tentative_firewall so we get syntax errors. */
34144 }
34145 }
34146 else
34149 /* Go back to evaluating expressions. */
34153 /* And restore the old one. */
34156 parser->integral_constant_expression_p
34158 parser->non_integral_constant_expression_p
34162 }
34164 /* If the current declaration has no declarator, return true. */
34166 static bool
34168 {
34169 /* If the next token is a `;' or a `,' then there is no
34170 declarator. */
34173 }
34175 /* Update the DECL_SPECS to reflect the storage class indicated by
34176 KEYWORD. */
34178 static void
34183 {
34184 cp_storage_class storage_class;
34187 {
34205 }
34208 {
34212 }
34214 {
34221 else
34228 }
34233 {
34236 }
34241 /* A storage class specifier cannot be applied alongside a typedef
34242 specifier. If there is a typedef specifier present then set
34243 conflicting_specifiers_p which will trigger an error later
34244 on in grokdeclarator. */
34247 {
34254 }
34255 }
34257 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
34258 is true, the type is a class or enum definition. */
34260 static void
34262 tree type_spec,
34265 {
34268 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
34269 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
34270 this is what happened. In system headers, we ignore these
34271 declarations so that G++ can work with system headers that are not
34272 C++-safe. */
34274 && !type_definition_p
34287 {
34290 ds_redefined_builtin_type_spec,
34291 token);
34293 {
34297 }
34298 }
34301 else
34302 {
34307 }
34308 }
34310 /* True iff TOKEN is the GNU keyword __thread. */
34312 static bool
34314 {
34317 }
34319 /* Set the location for a declarator specifier and check if it is
34320 duplicated.
34322 DECL_SPECS is the sequence of declarator specifiers onto which to
34323 set the location.
34325 DS is the single declarator specifier to set which location is to
34326 be set onto the existing sequence of declarators.
34328 LOCATION is the location for the declarator specifier to
34329 consider. */
34331 static void
34334 {
34343 {
34347 }
34348 else
34349 {
34351 {
34355 else
34356 {
34359 OPT_Wlong_long,
34361 }
34362 }
34364 {
34368 {
34372 }
34373 else
34374 {
34377 }
34378 }
34379 else
34380 {
34381 /* These correspond to cp-tree.h:cp_decl_spec,
34382 changes here should also be reflected there. */
34401 "this"
34402 };
34406 }
34407 }
34408 }
34410 /* Return true iff the declarator specifier DS is present in the
34411 sequence of declarator specifiers DECL_SPECS. */
34413 bool
34415 cp_decl_spec ds)
34416 {
34423 }
34425 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
34426 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
34428 static bool
34430 {
34432 }
34434 /* Issue an error message indicating that TOKEN_DESC was expected.
34435 If KEYWORD is true, it indicated this function is called by
34436 cp_parser_require_keword and the required token can only be
34437 a indicated keyword.
34439 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34440 within any error as the location of an "opening" token matching
34441 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34442 RT_CLOSE_PAREN). */
34444 static void
34446 required_token token_desc,
34448 location_t matching_location)
34449 {
34455 {
34530 }
34533 {
34535 {
34613 }
34614 }
34618 }
34621 /* If the next token is of the indicated TYPE, consume it. Otherwise,
34622 issue an error message indicating that TOKEN_DESC was expected.
34624 Returns the token consumed, if the token had the appropriate type.
34625 Otherwise, returns NULL.
34627 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
34628 within any error as the location of an "opening" token matching
34629 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
34630 RT_CLOSE_PAREN). */
34635 required_token token_desc,
34636 location_t matching_location)
34637 {
34640 else
34641 {
34642 /* Output the MESSAGE -- unless we're parsing tentatively. */
34645 matching_location);
34647 }
34648 }
34650 /* Skip an entire parameter list from start to finish. The next token must
34651 be the initial "<" of the parameter list. Returns true on success and
34652 false otherwise. */
34654 static bool
34656 {
34657 /* Consume the "<" because cp_parser_skip_to_end_of_template_parameter_list
34658 requires it. */
34661 }
34663 /* Ensure we are at the end of a template parameter list. If we are, return.
34664 If we are not, something has gone wrong, in which case issue an error and
34665 skip to end of the parameter list. */
34667 static void
34669 {
34670 /* Are we ready, yet? If not, issue error message. */
34675 }
34677 /* You should only call this function from inside a template parameter list
34678 (i.e. the current token should at least be the initial "<" of the
34679 parameter list). If you are skipping the entire list, it may be better to
34680 use cp_parser_skip_entire_template_parameter_list.
34682 Tokens are skipped until the final ">" is found, or if we see
34683 '{', '}', ';', or if we find an unbalanced ')' or ']'.
34685 Returns true if we successfully reached the end, and false if
34686 something unexpected happened (e.g. end of file). */
34688 static bool
34690 {
34691 /* Current level of '< ... >'. */
34693 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
34696 /* Skip tokens until the desired token is found. */
34698 {
34699 /* Peek at the next token. */
34701 {
34709 /* C++0x views the `>>' operator as two `>' tokens, but
34710 C++98 does not. */
34713 {
34714 /* We've hit a `>>' where the first `>' closes the
34715 template argument list, and the second `>' is
34716 spurious. Just consume the `>>' and stop; we've
34717 already produced at least one error. */
34720 }
34721 /* Fall through for C++0x, so we handle the second `>' in
34722 the `>>'. */
34727 {
34728 /* We've reached the token we want, consume it and stop. */
34731 }
34750 /* The '>' was probably forgotten, don't look further. */
34755 }
34757 /* Consume this token. */
34759 }
34760 }
34762 /* If the next token is the indicated keyword, consume it. Otherwise,
34763 issue an error message indicating that TOKEN_DESC was expected.
34765 Returns the token consumed, if the token had the appropriate type.
34766 Otherwise, returns NULL. */
34771 required_token token_desc)
34772 {
34776 {
34778 UNKNOWN_LOCATION);
34780 }
34783 }
34785 /* Returns TRUE iff TOKEN is a token that can begin the body of a
34786 function-definition. */
34788 static bool
34790 {
34793 /* A ctor-initializer begins with a `:'. */
34795 /* A function-try-block begins with `try'. */
34797 /* A function-transaction-block begins with `__transaction_atomic'
34798 or `__transaction_relaxed'. */
34801 /* The named return value extension begins with `return'. */
34803 }
34805 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
34806 definition. */
34808 static bool
34810 {
34817 }
34819 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
34820 C++0x) ending a template-argument. */
34822 static bool
34824 {
34832 /* For better diagnostics, treat >>= like that too, that
34833 shouldn't appear non-nested in template arguments. */
34835 }
34837 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
34838 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
34840 static bool
34843 {
34849 /* Check for the sequence `<::' in the original code. It would be lexed as
34850 `[:', where `[' is a digraph, and there is no whitespace before
34851 `:'. */
34853 {
34858 }
34860 }
34862 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
34863 or none_type otherwise. */
34865 static enum tag_types
34867 {
34869 {
34879 }
34880 }
34882 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
34883 or none_type otherwise or if the token is null. */
34885 static enum tag_types
34887 {
34892 {
34900 }
34901 }
34903 /* Diagnose redundant enum-keys. */
34905 static void
34908 {
34914 /* Look up the NAME to see if it unambiguously refers to the TYPE. */
34919 /* The enum-key is redundant for uses of the TYPE that are not
34920 declarations and for which name lookup returns just the type
34921 itself. */
34929 {
34930 /* Avoid issuing the diagnostic for apparently redundant (unscoped)
34931 enum tag in shared C/C++ code in files (such as headers) included
34932 in the main source file. */
34935 LRK_MACRO_DEFINITION_LOCATION,
34939 }
34947 }
34949 /* Describes the set of declarations of a struct, class, or class template
34950 or its specializations. Used for -Wmismatched-tags. */
34952 class class_decl_loc_t
34953 {
34958 {
34960 }
34962 /* Constructs an object for a single declaration of a class with
34963 CLASS_KEY at the current location in the current function (or
34964 at another scope). KEY_REDUNDANT is true if the class-key may
34965 be omitted in the current context without an ambiguity with
34966 another symbol with the same name.
34967 DEF_P is true for a class declaration that is a definition.
34968 CURLOC is the associated location. */
34972 {
34975 key_redundant);
34977 }
34979 /* Copy, assign, and destroy the object. Necessary because LOCVEC
34980 isn't safely copyable and assignable and doesn't release storage
34981 on its own. */
34985 { }
34988 {
34996 }
34999 {
35001 }
35003 /* Issues -Wmismatched-tags for a single class. */
35006 /* Issues -Wmismatched-tags for all classes. */
35009 /* Adds TYPE_DECL to the collection of class decls and diagnoses
35010 redundant tags (if -Wredundant-tags is enabled). */
35013 /* Either adds this decl to the collection of class decls
35014 or diagnoses it, whichever is appropriate. */
35020 {
35022 }
35025 {
35027 }
35030 {
35032 }
35035 {
35037 }
35039 /* True if a definition for the class has been seen. */
35041 {
35043 }
35045 /* The location of a single mention of a class type with the given
35046 class-key. */
35047 struct class_key_loc_t
35048 {
35051 { }
35053 /* The function the type is mentioned in. */
35054 tree func;
35055 /* The exact location. */
35056 location_t loc;
35057 /* The class-key used in the mention of the type. */
35058 tag_types class_key;
35059 /* True when the class-key could be omitted at this location
35060 without an ambiguity with another symbol of the same name. */
35062 };
35063 /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
35065 /* LOCVEC index of the definition or UINT_MAX if none exists. */
35067 /* The class-key the class was last declared with or none_type when
35068 it has been declared with a mismatched key. */
35069 tag_types def_class_key;
35071 /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
35072 description above. */
35075 };
35079 /* Issue an error message if the CLASS_KEY does not match the TYPE.
35080 DEF_P is expected to be set for a definition of class TYPE. DECL_P
35081 is set for a declaration of class TYPE and clear for a reference to
35082 it that is not a declaration of it. */
35084 static void
35088 {
35094 {
35098 type))
35102 }
35107 /* Only consider the true class-keys below and ignore typename_type,
35108 etc. that are not C++ class-keys. */
35115 }
35117 /* Returns the template or specialization of one to which the RECORD_TYPE
35118 TYPE corresponds. */
35120 static tree
35122 {
35125 /* Determine the template or its partial specialization to which TYPE
35126 corresponds. */
35135 }
35138 /* Adds the class TYPE to the collection of class decls and diagnoses
35139 redundant tags (if -Wredundant-tags is enabled).
35140 DEF_P is expected to be set for a definition of class TYPE. DECL_P
35141 is set for a (likely, based on syntactic context) declaration of class
35142 TYPE and clear for a reference to it that is not a declaration of it. */
35144 void
35147 {
35150 /* Look up the NAME to see if it unambiguously refers to the TYPE
35151 and set KEY_REDUNDANT if so. */
35156 /* The class-key is redundant for uses of the CLASS_TYPE that are
35157 neither definitions of it nor declarations, and for which name
35158 lookup returns just the type itself. */
35169 {
35170 /* Avoid issuing the diagnostic for apparently redundant struct
35171 and union class-keys in shared C/C++ code in files (such as
35172 headers) included in the main source file. */
35175 LRK_MACRO_DEFINITION_LOCATION,
35179 }
35181 /* Set if a declaration of TYPE has previously been seen or if it must
35182 exist in a precompiled header. */
35186 {
35189 {
35190 /* TYPE_DECL is the first declaration or definition of the type
35191 (outside precompiled headers -- see below). Just create
35192 a new entry for it and return unless it's a declaration
35193 involving a template that may need to be diagnosed by
35194 -Wredundant-tags. */
35198 }
35199 else
35200 {
35201 /* TYPE was previously defined in some unknown precompiled header.
35202 Simply add a record of its definition at an unknown location and
35203 proceed below to add a reference to it at the current location.
35204 (Declarations in precompiled headers that are not definitions
35205 are ignored.) */
35206 tag_types def_key
35211 }
35212 }
35214 /* A prior declaration of TYPE_DECL has been seen. */
35217 {
35224 type);
35225 }
35228 /* Do nothing if this is the first declaration of the type. */
35232 /* Do nothing if the class-key in this declaration matches
35233 the definition. */
35237 def_p);
35238 }
35240 /* Either adds this DECL corresponding to the TYPE_DECL to the collection
35241 of class decls or diagnoses it, whichever is appropriate. */
35243 void
35245 tag_types class_key,
35248 {
35249 /* Reset the CLASS_KEY associated with this type on mismatch.
35250 This is an optimization that lets the diagnostic code skip
35251 over classes that use the same class-key in all declarations. */
35255 /* Set IDXDEF to the index of the vector corresponding to
35256 the definition. */
35260 /* Append a record of this declaration to the vector. */
35262 redundant);
35268 /* As a space optimization diagnose declarations of a class
35269 whose definition has been seen and purge the LOCVEC of
35270 all entries except the definition. */
35273 {
35279 }
35280 else
35281 /* Pop the entry pushed above for this declaration. */
35283 }
35285 /* Issues -Wmismatched-tags for a single class. */
35287 void
35289 {
35293 /* Number of uses of the class. */
35296 /* The class (or template) declaration guiding the decisions about
35297 the diagnostic. For ordinary classes it's the same as THIS. For
35298 uses of instantiations of templates other than their declarations
35299 it points to the record for the declaration of the corresponding
35300 primary template or partial specialization. */
35305 {
35306 /* For implicit instantiations of a primary template look up
35307 the primary or partial specialization and use it as
35308 the expected class-key rather than using the class-key of
35309 the first reference to the instantiation. The primary must
35310 be (and inevitably is) at index zero. */
35313 /* It's possible that we didn't find SPEC. Consider:
35315 template<typename T> struct A {
35316 template<typename U> struct W { };
35317 };
35318 struct A<int>::W<int> w; // #1
35320 where while parsing A and #1 we've stashed
35321 A<T>
35322 A<T>::W<U>
35323 A<int>::W<int>
35324 into CLASS2LOC. If TYPE is A<int>::W<int>, specialization_of
35325 will yield A<int>::W<U> which may be in CLASS2LOC if we had
35326 an A<int> class specialization, but otherwise won't be in it.
35327 So try to look up A<T>::W<U>. */
35329 {
35332 }
35333 /* Now we really should have found something. */
35335 }
35336 /* Skip declarations that consistently use the same class-key. */
35340 /* Set if a definition for the class has been seen. */
35343 /* The index of the declaration whose class-key this declaration
35344 is expected to match. It's either the class-key of the class
35345 definition if one exists or the first declaration otherwise. */
35348 /* The class-key the class is expected to be declared with: it's
35349 either the key used in its definition or the first declaration
35350 if no definition has been provided.
35351 For implicit instantiations of a primary template it's
35352 the class-key used to declare the primary with. The primary
35353 must be at index zero. */
35357 /* Advance IDX to the first declaration that either is not
35358 a definition or that doesn't match the first declaration
35359 if no definition is provided. */
35364 /* Save the current function before changing it below. */
35366 /* Set the function declaration to print in diagnostic context. */
35374 auto_diagnostic_group d;
35375 /* Issue a warning for the first mismatched declaration.
35376 Avoid using "%#qT" since the class-key for the same type will
35377 be the same regardless of which one was used in the declaraion. */
35381 {
35382 /* Suggest how to avoid the warning for each instance since
35383 the guidance may be different depending on context. */
35385 (key_redundant_p
35388 xpectkstr);
35390 /* Also point to the first declaration or definition that guided
35391 the decision to issue the warning above. */
35393 (def_p
35397 }
35399 /* Issue warnings for the remaining inconsistent declarations. */
35401 {
35403 /* Skip over the declarations that match either the definition
35404 if one was provided or the first declaration. */
35410 /* Set the function declaration to print in diagnostic context. */
35415 /* Suggest how to avoid the warning for each instance since
35416 the guidance may be different depending on context. */
35418 (key_redundant_p
35421 xpectkstr);
35422 }
35424 /* Restore the current function in case it was replaced above. */
35426 }
35428 /* Issues -Wmismatched-tags for all classes. Called at the end
35429 of processing a translation unit, after declarations of all class
35430 types and their uses have been recorded. */
35432 void
35434 {
35435 /* CLASS2LOC should be empty if both -Wmismatched-tags and
35436 -Wredundant-tags are disabled. */
35438 || warn_redundant_tags
35441 /* Save the current function before changing on return. It should
35442 be null at this point. */
35446 {
35447 /* Iterate over the collected class/struct/template declarations. */
35450 {
35454 }
35455 }
35458 }
35460 /* Issue an error message if DECL is redeclared with different
35461 access than its original declaration [class.access.spec/3].
35462 This applies to nested classes, nested class templates and
35463 enumerations [class.mem/1]. */
35465 static void
35467 {
35479 }
35481 /* Look for the `template' keyword, as a syntactic disambiguator.
35482 Return TRUE iff it is present, in which case it will be
35483 consumed. */
35485 static bool
35487 {
35489 {
35490 /* In C++98 the `template' keyword can only be used within templates;
35491 outside templates the parser can always figure out what is a
35492 template and what is not. In C++11, per the resolution of DR 468,
35493 `template' is allowed in cases where it is not strictly necessary. */
35496 {
35499 "in C++98 %<template%> (as a disambiguator) is only "
35501 /* If this part of the token stream is rescanned, the same
35502 error message would be generated. So, we purge the token
35503 from the stream. */
35506 }
35507 else
35508 {
35509 /* Consume the `template' keyword. */
35512 }
35513 }
35515 }
35517 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
35518 set PARSER->SCOPE, and perform other related actions. */
35520 static void
35522 {
35525 /* Get the stored value. */
35527 /* Set the scope from the stored value. */
35532 }
35534 /* Consume tokens up through a non-nested END token. Returns TRUE if we
35535 encounter the end of a block before what we were looking for. */
35537 static bool
35541 {
35543 {
35546 /* Abort a parenthesized expression if we encounter a semicolon. */
35550 /* If we've reached the end of the file, stop. */
35556 /* We've hit the end of an enclosing block, so there's been some
35557 kind of syntax error. */
35560 /* Consume the token. */
35562 /* See if it starts a new group. */
35564 {
35566 /* In theory this should probably check end == '}', but
35567 cp_parser_save_member_function_body needs it to exit
35568 after either '}' or ')' when called with ')'. */
35571 }
35573 {
35577 }
35582 }
35583 }
35585 /* Like above, for caching a default argument or NSDMI. Both of these are
35586 terminated by a non-nested comma, but it can be unclear whether or not a
35587 comma is nested in a template argument list unless we do more parsing.
35588 In order to handle this ambiguity, when we encounter a ',' after a '<'
35589 we try to parse what follows as a parameter-declaration-list (in the
35590 case of a default argument) or a member-declarator (in the case of an
35591 NSDMI). If that succeeds, then we stop caching. */
35593 static tree
35595 {
35600 tree default_argument;
35602 /* Add tokens until we have processed the entire default
35603 argument. We add the range [first_token, token). */
35606 {
35607 /* For list-initialization, this is straightforward. */
35610 }
35612 {
35615 /* Peek at the next token. */
35617 /* What we do depends on what token we have. */
35619 {
35620 /* In valid code, a default argument must be
35621 immediately followed by a `,' `)', or `...'. */
35624 {
35625 /* If we've seen a '<', we might be in a
35626 template-argument-list. Until Core issue 325 is
35627 resolved, we don't know how this situation ought
35628 to be handled, so try to DTRT. We check whether
35629 what comes after the comma is a valid parameter
35630 declaration list. If it is, then the comma ends
35631 the default argument; otherwise the default
35632 argument continues. */
35636 /* Set ITALP so cp_parser_parameter_declaration_list
35637 doesn't decide to commit to this parse. */
35644 {
35645 /* Parse declarators until we reach a non-comma or
35646 somthing that cannot be an initializer.
35647 Just checking whether we're looking at a single
35648 declarator is insufficient. Consider:
35649 int var = tuple<T,U>::x;
35650 The template parameter 'U' looks exactly like a
35651 declarator. */
35652 do
35653 {
35657 CP_PARSER_FLAGS_NONE,
35666 }
35668 /* If we met an '=' or ';' then the original comma
35669 was the end of the NSDMI. Otherwise assume
35670 we're still in the NSDMI. */
35673 }
35674 else
35675 {
35678 tree t = cp_parser_parameter_declaration_list
35684 }
35691 }
35692 /* FALLTHRU */
35695 /* If we run into a non-nested `;', `}', or `]',
35696 then the code is invalid -- but the default
35697 argument is certainly over. */
35702 /* Handle correctly int n = sizeof ... ( p ); */
35705 /* Update DEPTH, if necessary. */
35720 /* This might be the comparison operator, or it might
35721 start a template argument list. */
35728 /* Fall through for C++0x, which treats the `>>'
35729 operator like two `>' tokens in certain
35730 cases. */
35735 {
35736 /* This might be an operator, or it might close a
35737 template argument list. But if a previous '<'
35738 started a template argument list, this will have
35739 closed it, so we can't be in one anymore. */
35743 }
35746 /* If we run out of tokens, issue an error message. */
35754 /* In these cases, we should look for template-ids.
35755 For example, if the default argument is
35756 `X<int, double>()', we need to do name lookup to
35757 figure out whether or not `X' is a template; if
35758 so, the `,' does not end the default argument.
35760 That is not yet done. */
35765 }
35767 /* If we've reached the end, stop. */
35771 /* Add the token to the token block. */
35773 }
35775 /* Create a DEFERRED_PARSE to represent the unparsed default
35776 argument. */
35783 }
35785 /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
35787 location_t
35789 {
35794 }
35796 /* Begin parsing tentatively. We always save tokens while parsing
35797 tentatively so that if the tentative parsing fails we can restore the
35798 tokens. */
35800 static void
35802 {
35803 /* Enter a new parsing context. */
35805 /* Begin saving tokens. */
35807 /* In order to avoid repetitive access control error messages,
35808 access checks are queued up until we are no longer parsing
35809 tentatively. */
35811 }
35813 /* Commit to the currently active tentative parse. */
35815 static void
35817 {
35821 /* Mark all of the levels as committed. */
35824 {
35831 }
35832 }
35834 /* Commit to the topmost currently active tentative parse.
35836 Note that this function shouldn't be called when there are
35837 irreversible side-effects while in a tentative state. For
35838 example, we shouldn't create a permanent entry in the symbol
35839 table, or issue an error message that might not apply if the
35840 tentative parse is aborted. */
35842 static void
35844 {
35849 {
35857 }
35858 }
35860 /* Abort the currently active tentative parse. All consumed tokens
35861 will be rolled back, and no diagnostics will be issued. */
35863 static void
35865 {
35869 /* Now, pretend that we want to see if the construct was
35870 successfully parsed. */
35872 }
35874 /* Stop parsing tentatively. If a parse error has occurred, restore the
35875 token stream. Otherwise, commit to the tokens we have consumed.
35876 Returns true if no error occurred; false otherwise. */
35878 static bool
35880 {
35884 /* Remember whether or not an error occurred, since we are about to
35885 destroy that information. */
35887 /* Remove the topmost context from the stack. */
35890 /* If no parse errors occurred, commit to the tentative parse. */
35892 {
35893 /* Commit to the tokens read tentatively, unless that was
35894 already done. */
35899 }
35900 /* Otherwise, if errors occurred, roll back our state so that things
35901 are just as they were before we began the tentative parse. */
35902 else
35903 {
35906 }
35907 /* Add the context to the front of the free list. */
35912 }
35914 /* Returns true if we are parsing tentatively and are not committed to
35915 this tentative parse. */
35917 static bool
35919 {
35922 }
35924 /* Returns nonzero iff an error has occurred during the most recent
35925 tentative parse. */
35927 static bool
35929 {
35932 }
35934 /* Returns nonzero if GNU extensions are allowed. */
35936 static bool
35938 {
35940 }
35941 \f
35942 /* Objective-C++ Productions */
35945 /* Parse an Objective-C expression, which feeds into a primary-expression
35946 above.
35948 objc-expression:
35949 objc-message-expression
35950 objc-string-literal
35951 objc-encode-expression
35952 objc-protocol-expression
35953 objc-selector-expression
35955 Returns a tree representation of the expression. */
35957 static cp_expr
35959 {
35960 /* Try to figure out what kind of declaration is present. */
35964 {
35974 {
35986 }
35987 /* FALLTHRU */
35993 }
35996 }
35998 /* Parse an Objective-C message expression.
36000 objc-message-expression:
36001 [ objc-message-receiver objc-message-args ]
36003 Returns a representation of an Objective-C message. */
36005 static tree
36007 {
36020 /* Construct a location e.g.
36021 [self func1:5]
36022 ^~~~~~~~~~~~~~
36023 ranging from the '[' to the ']', with the caret at the start. */
36029 }
36031 /* Parse an objc-message-receiver.
36033 objc-message-receiver:
36034 expression
36035 simple-type-specifier
36037 Returns a representation of the type or expression. */
36039 static tree
36041 {
36042 tree rcv;
36044 /* An Objective-C message receiver may be either (1) a type
36045 or (2) an expression. */
36049 /* If that worked out, fine. */
36056 CP_PARSER_FLAGS_NONE);
36063 }
36065 /* Parse the arguments and selectors comprising an Objective-C message.
36067 objc-message-args:
36068 objc-selector
36069 objc-selector-args
36070 objc-selector-args , objc-comma-args
36072 objc-selector-args:
36073 objc-selector [opt] : assignment-expression
36074 objc-selector-args objc-selector [opt] : assignment-expression
36076 objc-comma-args:
36077 assignment-expression
36078 objc-comma-args , assignment-expression
36080 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
36081 selector arguments and TREE_VALUE containing a list of comma
36082 arguments. */
36084 static tree
36086 {
36092 {
36098 /* Detect if we have a unary selector. */
36107 sel_args
36112 }
36114 /* Handle non-selector arguments, if any. */
36116 {
36117 tree arg;
36122 addl_args
36127 }
36130 {
36133 }
36136 }
36138 /* Parse an Objective-C encode expression.
36140 objc-encode-expression:
36141 @encode objc-typename
36143 Returns an encoded representation of the type argument. */
36145 static cp_expr
36147 {
36148 tree type;
36153 matching_parens parens;
36160 {
36164 }
36166 /* This happens if we find @encode(T) (where T is a template
36167 typename or something dependent on a template typename) when
36168 parsing a template. In that case, we can't compile it
36169 immediately, but we rather create an AT_ENCODE_EXPR which will
36170 need to be instantiated when the template is used.
36171 */
36173 {
36177 }
36180 /* Build a location of the form:
36181 @encode(int)
36182 ^~~~~~~~~~~~
36183 with caret==start at the @ token, finishing at the close paren. */
36187 }
36189 /* Parse an Objective-C @defs expression. */
36191 static tree
36193 {
36194 tree name;
36197 matching_parens parens;
36203 }
36205 /* Parse an Objective-C protocol expression.
36207 objc-protocol-expression:
36208 @protocol ( identifier )
36210 Returns a representation of the protocol expression. */
36212 static tree
36214 {
36215 tree proto;
36219 matching_parens parens;
36224 /* Build a location of the form:
36225 @protocol(prot)
36226 ^~~~~~~~~~~~~~~
36227 with caret==start at the @ token, finishing at the close paren. */
36232 }
36234 /* Parse an Objective-C selector expression.
36236 objc-selector-expression:
36237 @selector ( objc-method-signature )
36239 objc-method-signature:
36240 objc-selector
36241 objc-selector-seq
36243 objc-selector-seq:
36244 objc-selector :
36245 objc-selector-seq objc-selector :
36247 Returns a representation of the method selector. */
36249 static tree
36251 {
36258 matching_parens parens;
36264 {
36273 {
36274 /* Detect if we have a unary selector. */
36276 {
36279 }
36280 else
36281 {
36283 }
36284 }
36289 {
36290 sel_seq
36293 sel_seq
36296 }
36297 else
36298 sel_seq
36303 }
36305 finish_selector:
36309 /* Build a location of the form:
36310 @selector(func)
36311 ^~~~~~~~~~~~~~~
36312 with caret==start at the @ token, finishing at the close paren. */
36315 /* TODO: objc_build_selector_expr doesn't always honor the location. */
36318 }
36320 /* Parse a list of identifiers.
36322 objc-identifier-list:
36323 identifier
36324 objc-identifier-list , identifier
36326 Returns a TREE_LIST of identifier nodes. */
36328 static tree
36330 {
36331 tree identifier;
36332 tree list;
36343 {
36350 identifier));
36352 }
36355 }
36357 /* Parse an Objective-C alias declaration.
36359 objc-alias-declaration:
36360 @compatibility_alias identifier identifier ;
36362 This function registers the alias mapping with the Objective-C front end.
36363 It returns nothing. */
36365 static void
36367 {
36375 }
36377 /* Parse an Objective-C class forward-declaration.
36379 objc-class-declaration:
36380 @class objc-identifier-list ;
36382 The function registers the forward declarations with the Objective-C
36383 front end. It returns nothing. */
36385 static void
36387 {
36390 {
36391 tree id;
36401 else
36403 }
36405 }
36407 /* Parse a list of Objective-C protocol references.
36409 objc-protocol-refs-opt:
36410 objc-protocol-refs [opt]
36412 objc-protocol-refs:
36413 < objc-identifier-list >
36415 Returns a TREE_LIST of identifiers, if any. */
36417 static tree
36419 {
36423 {
36427 }
36430 }
36432 /* Parse a Objective-C visibility specification. */
36434 static void
36436 {
36440 {
36455 }
36457 /* Eat '@private'/'@protected'/'@public'. */
36459 }
36461 /* Parse an Objective-C method type. Return 'true' if it is a class
36462 (+) method, and 'false' if it is an instance (-) method. */
36466 {
36469 else
36471 }
36473 /* Parse an Objective-C protocol qualifier. */
36475 static tree
36477 {
36490 {
36495 }
36498 }
36500 /* Parse an Objective-C typename. */
36502 static tree
36504 {
36508 {
36511 matching_parens parens;
36515 /* An ObjC type name may consist of just protocol qualifiers, in which
36516 case the type shall default to 'id'. */
36518 {
36521 /* If the type could not be parsed, an error has already
36522 been produced. For error recovery, behave as if it had
36523 not been specified, which will use the default type
36524 'id'. */
36526 {
36528 /* We need to skip to the closing parenthesis as
36529 cp_parser_type_id() does not seem to do it for
36530 us. */
36535 }
36536 }
36540 }
36543 }
36545 /* Check to see if TYPE refers to an Objective-C selector name. */
36547 static bool
36549 {
36555 }
36557 /* Parse an Objective-C selector. */
36559 static tree
36561 {
36565 {
36568 }
36570 /* C++ operator names are allowed to appear in ObjC selectors. */
36572 {
36585 }
36586 }
36588 /* Parse an Objective-C params list. */
36590 static tree
36592 {
36598 {
36608 /* Detect if we have a unary selector. */
36611 {
36614 }
36618 {
36619 /* Something went quite wrong. There should be a colon
36620 here, but there is not. Stop parsing parameters. */
36622 }
36624 /* New ObjC allows attributes on parameters too. */
36629 params
36632 type_name,
36633 identifier,
36634 parm_attr));
36637 }
36640 {
36643 }
36645 /* We allow tail attributes for the method. */
36647 {
36655 }
36658 {
36661 }
36663 }
36665 /* Parse the non-keyword Objective-C params. */
36667 static tree
36670 {
36676 {
36678 tree parm;
36684 {
36689 }
36691 /* TODO: parse attributes for tail parameters. */
36701 }
36703 /* We allow tail attributes for the method. */
36705 {
36707 {
36712 }
36713 else
36714 /* We have an error, but parse the attributes, so that we can
36715 carry on. */
36721 }
36724 }
36726 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
36728 static void
36730 {
36733 /* If the next token is `extern' and the following token is a string
36734 literal, then we have a linkage specification. */
36736 && cp_parser_is_pure_string_literal
36739 /* Handle #pragma, if any. */
36742 /* Allow stray semicolons. */
36745 /* Mark methods as optional or required, when building protocols. */
36747 {
36750 }
36752 {
36755 }
36758 /* Other stray characters must generate errors. */
36760 {
36764 }
36765 /* Finally, try to parse a block-declaration, or a function-definition. */
36766 else
36768 }
36770 /* Parse a method signature. */
36772 static tree
36774 {
36790 }
36792 static bool
36794 {
36795 tree tattr;
36800 /* If the attributes are followed by a method introducer, this is not allowed.
36801 Dump the attributes and flag the situation. */
36806 /* Otherwise, the attributes introduce some interstitial code, possibly so
36807 rewind to allow that check. */
36810 }
36812 /* Parse an Objective-C method prototype list. */
36814 static void
36816 {
36820 {
36822 {
36827 else
36831 {
36835 }
36838 }
36844 OPT_Wattributes,
36846 else
36847 /* Allow for interspersed non-ObjC++ code. */
36851 }
36855 else
36859 }
36861 /* Parse an Objective-C method definition list. */
36863 static void
36865 {
36867 {
36871 {
36874 }
36876 {
36879 }
36881 {
36885 tree attribute;
36889 else
36890 {
36894 /* For historical reasons, we accept an optional semicolon. */
36900 tree meth
36904 }
36905 }
36906 /* The following case will be removed once @synthesize is
36907 completely implemented. */
36918 else
36919 /* Allow for interspersed non-ObjC++ code. */
36921 }
36924 }
36926 /* Parse Objective-C ivars. */
36928 static void
36930 {
36941 {
36942 cp_decl_specifier_seq declspecs;
36944 tree prefix_attributes;
36952 CP_PARSER_FLAGS_OPTIONAL,
36956 /* auto, register, static, extern, mutable. */
36958 {
36961 }
36963 /* thread_local. */
36965 {
36968 }
36970 /* typedef. */
36972 {
36975 }
36980 /* Keep going until we hit the `;' at the end of the
36981 declaration. */
36983 {
36988 /* Check for a (possibly unnamed) bitfield declaration. */
36996 {
36997 /* Get the name of the bitfield. */
37002 eat_colon:
37004 /* Get the width of the bitfield. */
37005 width
37007 }
37008 else
37009 {
37010 /* Parse the declarator. */
37011 declarator
37013 CP_PARSER_FLAGS_NONE,
37019 }
37021 /* Look for attributes that apply to the ivar. */
37023 /* Remember which attributes are prefix attributes and
37024 which are not. */
37026 /* Combine the attributes. */
37030 /* Create the bitfield declaration. */
37033 else
37038 /* Add the instance variable. */
37042 /* Reset PREFIX_ATTRIBUTES. */
37044 {
37049 }
37054 {
37057 }
37059 }
37063 }
37068 /* Do not consume the RID_AT_END, so it will be read again as terminating
37069 the @interface of @implementation. */
37073 /* For historical reasons, we accept an optional semicolon. */
37076 }
37078 /* Parse an Objective-C protocol declaration. */
37080 static void
37082 {
37088 {
37093 }
37095 /* See if we have a forward declaration or a definition. */
37098 /* Try a forward declaration first. */
37100 {
37102 {
37103 tree id;
37113 else
37115 }
37117 }
37119 /* Ok, we got a full-fledged definition (or at least should). */
37120 else
37121 {
37126 }
37127 }
37129 /* Parse an Objective-C superclass or category. */
37131 static void
37136 {
37142 {
37145 }
37147 {
37148 matching_parens parens;
37151 /* If there is no category name, and this is an @interface, we
37152 have a class extension. */
37154 {
37157 }
37158 else
37162 }
37163 }
37165 /* Parse an Objective-C class interface. */
37167 static void
37169 {
37177 {
37178 /* It's hard to recover because even if valid @interface stuff
37179 is to follow, we can't compile it (or validate it) if we
37180 don't even know which class it refers to. Let's assume this
37181 was a stray '@interface' token in the stream and skip it.
37182 */
37184 }
37189 /* We have either a class or a category on our hands. */
37192 else
37193 {
37195 /* Handle instance variable declarations, if any. */
37198 }
37201 }
37203 /* Parse an Objective-C class implementation. */
37205 static void
37207 {
37214 {
37215 /* It's hard to recover because even if valid @implementation
37216 stuff is to follow, we can't compile it (or validate it) if
37217 we don't even know which class it refers to. Let's assume
37218 this was a stray '@implementation' token in the stream and
37219 skip it.
37220 */
37222 }
37226 /* We have either a class or a category on our hands. */
37229 else
37230 {
37232 /* Handle instance variable declarations, if any. */
37235 }
37238 }
37240 /* Consume the @end token and finish off the implementation. */
37242 static void
37244 {
37247 }
37249 /* Parse an Objective-C declaration. */
37251 static void
37253 {
37254 /* Try to figure out what kind of declaration is present. */
37259 {
37275 }
37278 {
37301 }
37302 }
37304 /* Parse an Objective-C try-catch-finally statement.
37306 objc-try-catch-finally-stmt:
37307 @try compound-statement objc-catch-clause-seq [opt]
37308 objc-finally-clause [opt]
37310 objc-catch-clause-seq:
37311 objc-catch-clause objc-catch-clause-seq [opt]
37313 objc-catch-clause:
37314 @catch ( objc-exception-declaration ) compound-statement
37316 objc-finally-clause:
37317 @finally compound-statement
37319 objc-exception-declaration:
37320 parameter-declaration
37321 '...'
37323 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
37325 Returns NULL_TREE.
37327 PS: This function is identical to c_parser_objc_try_catch_finally_statement
37328 for C. Keep them in sync. */
37330 static tree
37332 {
37333 location_t location;
37334 tree stmt;
37339 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
37340 node, lest it get absorbed into the surrounding block. */
37346 {
37350 matching_parens parens;
37356 {
37357 /* We have "@catch (...)" (where the '...' are literally
37358 what is in the code). Skip the '...'.
37359 parameter_declaration is set to NULL_TREE, and
37360 objc_being_catch_clauses() knows that that means
37361 '...'. */
37364 }
37365 else
37366 {
37367 /* We have "@catch (NSException *exception)" or something
37368 like that. Parse the parameter declaration. */
37373 else
37378 }
37381 else
37382 {
37383 /* If there was no open parenthesis, we are recovering from
37384 an error, and we are trying to figure out what mistake
37385 the user has made. */
37387 /* If there is an immediate closing parenthesis, the user
37388 probably forgot the opening one (ie, they typed "@catch
37389 NSException *e)". Parse the closing parenthesis and keep
37390 going. */
37394 /* If these is no immediate closing parenthesis, the user
37395 probably doesn't know that parenthesis are required at
37396 all (ie, they typed "@catch NSException *e"). So, just
37397 forget about the closing parenthesis and keep going. */
37398 }
37402 }
37404 {
37407 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
37408 node, lest it get absorbed into the surrounding block. */
37412 }
37415 }
37417 /* Parse an Objective-C synchronized statement.
37419 objc-synchronized-stmt:
37420 @synchronized ( expression ) compound-statement
37422 Returns NULL_TREE. */
37424 static tree
37426 {
37427 location_t location;
37434 matching_parens parens;
37439 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
37440 node, lest it get absorbed into the surrounding block. */
37445 }
37447 /* Parse an Objective-C throw statement.
37449 objc-throw-stmt:
37450 @throw assignment-expression [opt] ;
37452 Returns a constructed '@throw' statement. */
37454 static tree
37456 {
37468 }
37470 /* Parse an Objective-C statement. */
37472 static tree
37474 {
37475 /* Try to figure out what kind of declaration is present. */
37479 {
37490 }
37493 }
37495 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
37496 look ahead to see if an objc keyword follows the attributes. This
37497 is to detect the use of prefix attributes on ObjC @interface and
37498 @protocol. */
37500 static bool
37502 {
37507 {
37511 else
37514 }
37517 }
37519 /* This routine is a minimal replacement for
37520 c_parser_struct_declaration () used when parsing the list of
37521 types/names or ObjC++ properties. For example, when parsing the
37522 code
37524 @property (readonly) int a, b, c;
37526 this function is responsible for parsing "int a, int b, int c" and
37527 returning the declarations as CHAIN of DECLs.
37529 TODO: Share this code with cp_parser_objc_class_ivars. It's very
37530 similar parsing. */
37531 static tree
37533 {
37535 cp_decl_specifier_seq declspecs;
37537 tree prefix_attributes;
37540 CP_PARSER_FLAGS_NONE,
37547 /* auto, register, static, extern, mutable. */
37549 {
37552 }
37554 /* thread_local. */
37556 {
37559 }
37561 /* typedef. */
37563 {
37566 }
37571 /* Keep going until we hit the `;' at the end of the declaration. */
37573 {
37578 /* Parse the declarator. */
37580 CP_PARSER_FLAGS_NONE,
37583 /* Look for attributes that apply to the ivar. */
37585 /* Remember which attributes are prefix attributes and
37586 which are not. */
37588 /* Combine the attributes. */
37598 /* Reset PREFIX_ATTRIBUTES. */
37600 {
37605 }
37612 {
37615 }
37616 else
37618 }
37620 }
37622 /* Parse an Objective-C @property declaration. The syntax is:
37624 objc-property-declaration:
37625 '@property' objc-property-attributes[opt] struct-declaration ;
37627 objc-property-attributes:
37628 '(' objc-property-attribute-list ')'
37630 objc-property-attribute-list:
37631 objc-property-attribute
37632 objc-property-attribute-list, objc-property-attribute
37634 objc-property-attribute
37635 'getter' = identifier
37636 'setter' = identifier
37637 'readonly'
37638 'readwrite'
37639 'assign'
37640 'retain'
37641 'copy'
37642 'nonatomic'
37644 For example:
37645 @property NSString *name;
37646 @property (readonly) id object;
37647 @property (retain, nonatomic, getter=getTheName) id name;
37648 @property int a, b, c;
37650 PS: This function is identical to
37651 c_parser_objc_at_property_declaration for C. Keep them in sync. */
37652 static void
37654 {
37655 /* Parse the optional attribute list.
37657 A list of parsed, but not verified, attributes. */
37663 /* Parse the optional attribute list... */
37665 {
37666 /* Eat the '('. */
37667 matching_parens parens;
37672 /* Allow empty @property attribute lists, but with a warning. */
37674 location_t attr_comb;
37676 {
37680 }
37681 else
37683 {
37690 {
37697 }
37708 /* Account for accepting the 'class' keyword in this context. */
37710 else
37714 enum objc_property_attribute_kind prop_kind
37716 property_attribute_info *prop
37720 tree meth_name;
37722 {
37727 attr_name);
37728 else
37736 {
37739 attr_name);
37742 }
37750 {
37753 attr_name);
37756 }
37758 /* Get the end of the method name, and consume the name. */
37761 /* Because method names may contain C++ keywords, we have a
37762 routine to fetch them (this also consumes the token). */
37766 {
37768 {
37770 attr_end);
37774 }
37775 else
37776 {
37780 }
37782 attr_end);
37783 }
37784 else
37786 attr_end);
37788 /* Updated location including all that was successfully
37789 parsed. */
37792 }
37794 /* If we see a comma here, then keep going - even if we already
37795 saw a syntax error. For simple mistakes e.g. (asign, getter=x)
37796 this makes a more useful output and avoid spurious warnings
37797 about missing attributes that are, in fact, specified after the
37798 one with the syntax error. */
37801 else
37803 }
37809 }
37811 /* 'properties' is the list of properties that we read. Usually a
37812 single one, but maybe more (eg, in "@property int a, b, c;" there
37813 are three).
37814 TODO: Update this parsing so that it accepts (erroneous) bitfields so
37815 that we can issue a meaningful and consistent (between C/C++) error
37816 message from objc_add_property_declaration (). */
37823 else
37824 {
37825 /* Comma-separated properties are chained together in reverse order;
37826 add them one by one. */
37830 prop_attr_list);
37831 }
37834 }
37836 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
37838 objc-synthesize-declaration:
37839 @synthesize objc-synthesize-identifier-list ;
37841 objc-synthesize-identifier-list:
37842 objc-synthesize-identifier
37843 objc-synthesize-identifier-list, objc-synthesize-identifier
37845 objc-synthesize-identifier
37846 identifier
37847 identifier = identifier
37849 For example:
37850 @synthesize MyProperty;
37851 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
37853 PS: This function is identical to c_parser_objc_at_synthesize_declaration
37854 for C. Keep them in sync.
37855 */
37856 static void
37858 {
37860 location_t loc;
37865 {
37869 {
37872 }
37874 {
37878 {
37881 }
37882 }
37883 else
37888 else
37890 }
37893 }
37895 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
37897 objc-dynamic-declaration:
37898 @dynamic identifier-list ;
37900 For example:
37901 @dynamic MyProperty;
37902 @dynamic MyProperty, AnotherProperty;
37904 PS: This function is identical to c_parser_objc_at_dynamic_declaration
37905 for C. Keep them in sync.
37906 */
37907 static void
37909 {
37911 location_t loc;
37916 {
37917 tree property;
37920 {
37923 }
37927 else
37929 }
37932 }
37934 \f
37935 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
37937 /* Returns name of the next clause.
37938 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
37939 the token is not consumed. Otherwise appropriate pragma_omp_clause is
37940 returned and the token is consumed. */
37942 static pragma_omp_clause
37944 {
37960 {
37965 {
38186 }
38187 }
38193 }
38195 /* Validate that a clause of the given type does not already exist. */
38197 static void
38200 {
38203 }
38205 /* OpenMP 2.5:
38206 variable-list:
38207 identifier
38208 variable-list , identifier
38210 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
38211 colon). An opening parenthesis will have been consumed by the caller.
38213 If KIND is nonzero, create the appropriate node and install the decl
38214 in OMP_CLAUSE_DECL and add the node to the head of the list.
38216 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
38217 return the list created.
38219 COLON can be NULL if only closing parenthesis should end the list,
38220 or pointer to bool which will receive false if the list is terminated
38221 by closing parenthesis or true if the list is terminated by colon.
38223 The optional ALLOW_DEREF argument is true if list items can use the deref
38224 (->) operator. */
38226 struct omp_dim
38227 {
38229 location_t loc;
38233 };
38235 static tree
38239 {
38245 {
38248 }
38250 {
38255 /* This condition doesn't include OMP_CLAUSE_DEPEND or
38256 OMP_CLAUSE_AFFINITY since lvalue ("locator list") parsing for those is
38257 handled further down the function. */
38262 {
38268 /* This code rewrites a parsed expression containing various tree
38269 codes used to represent array accesses into a more uniform nest of
38270 OMP_ARRAY_SECTION nodes before it is processed by
38271 semantics.cc:handle_omp_array_sections_1. It might be more
38272 efficient to move this logic to that function instead, analysing
38273 the parsed expression directly rather than this preprocessed
38274 form. */
38277 {
38279 {
38284 }
38289 {
38294 {
38297 }
38299 {
38303 }
38305 {
38310 }
38311 }
38313 /* Bare references have their own special handling, so remove
38314 the explicit dereference added by convert_from_reference. */
38321 }
38323 {
38326 /* If we have "*foo" and
38327 - it's an indirection of a reference, "unconvert" it, i.e.
38328 strip the indirection (to just "foo").
38329 - it's an indirection of a pointer, turn it into
38330 "foo[0:1]". */
38336 integer_one_node);
38337 }
38339 {
38346 }
38352 }
38356 {
38362 }
38366 {
38367 cp_id_kind idk;
38370 }
38375 CPP_CLOSE_PAREN)))
38376 {
38379 }
38380 else
38381 {
38388 {
38393 }
38397 else
38400 {
38406 }
38407 }
38411 ;
38413 {
38415 {
38417 /* The OpenACC cache directive explicitly only allows "array
38418 elements or subarrays". */
38420 {
38424 }
38425 /* FALLTHROUGH. */
38429 start_component_ref:
38432 {
38433 cpp_ttype ttype
38436 location_t loc
38441 decl = (cp_parser_postfix_dot_deref_expression
38444 }
38445 /* FALLTHROUGH. */
38455 {
38463 {
38466 /* Later handling is not prepared to see through these. */
38468 }
38470 parser->colon_corrects_to_scope_p
38473 {
38476 }
38477 else
38478 {
38479 /* Look for `:'. */
38481 {
38486 }
38489 else
38492 CPP_CLOSE_SQUARE))
38493 {
38495 /* Later handling is not prepared to see through these. */
38497 }
38498 }
38499 /* Look for the closing `]'. */
38501 RT_CLOSE_SQUARE))
38502 {
38507 }
38510 }
38515 && !array_section_p
38518 {
38520 {
38524 }
38526 }
38527 else
38535 }
38538 {
38542 {
38543 depend_lvalue:
38547 }
38548 else
38550 }
38552 build_clause:
38557 }
38558 else
38561 get_comma:
38565 }
38571 {
38575 }
38578 {
38581 /* Try to resync to an unnested comma. Copied from
38582 cp_parser_parenthesized_expression_list. */
38583 skip_comma:
38592 }
38595 }
38597 /* Similarly, but expect leading and trailing parenthesis. This is a very
38598 common case for omp clauses. */
38600 static tree
38603 {
38605 {
38607 {
38613 }
38614 else
38616 list);
38617 }
38621 map_lvalue);
38623 }
38625 /* OpenACC 2.0:
38626 copy ( variable-list )
38627 copyin ( variable-list )
38628 copyout ( variable-list )
38629 create ( variable-list )
38630 delete ( variable-list )
38631 present ( variable-list )
38633 OpenACC 2.6:
38634 no_create ( variable-list )
38635 attach ( variable-list )
38636 detach ( variable-list )
38638 OpenACC 2.7:
38639 copyin (readonly : variable-list )
38640 */
38642 static tree
38644 tree list)
38645 {
38648 {
38686 /* "The 'host' clause is a synonym for the 'self' clause." */
38692 }
38697 {
38698 /* Turn on readonly modifier parsing for copyin clause. */
38700 {
38705 {
38709 }
38710 }
38713 }
38716 {
38720 }
38723 }
38725 /* OpenACC 2.0:
38726 deviceptr ( variable-list ) */
38728 static tree
38730 {
38734 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
38735 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
38736 variable-list must only allow for pointer variables. */
38739 {
38746 }
38749 }
38751 /* OpenACC 2.5:
38752 auto
38753 finalize
38754 independent
38755 nohost
38756 seq */
38758 static tree
38760 tree list)
38761 {
38768 }
38770 /* OpenACC:
38771 num_gangs ( expression )
38772 num_workers ( expression )
38773 vector_length ( expression ) */
38775 static tree
38778 {
38781 matching_parens parens;
38789 {
38794 }
38802 }
38804 /* OpenACC:
38806 gang [( gang-arg-list )]
38807 worker [( [num:] int-expr )]
38808 vector [( [length:] int-expr )]
38810 where gang-arg is one of:
38812 [num:] int-expr
38813 static: size-expr
38815 and size-expr may be:
38817 *
38818 int-expr
38819 */
38821 static tree
38823 omp_clause_code kind,
38825 {
38834 {
38835 matching_parens parens;
38838 do
38839 {
38843 /* Gang static argument. */
38846 {
38854 {
38857 }
38859 /* Check for the '*' argument. */
38863 CPP_CLOSE_PAREN)))
38864 {
38869 {
38872 }
38874 }
38875 }
38876 /* Worker num: argument and vector length: arguments. */
38880 {
38883 }
38885 /* Now collect the actual argument. */
38887 {
38890 }
38902 {
38905 }
38907 }
38912 }
38926 cleanup_error:
38929 }
38931 /* OpenACC 2.0:
38932 tile ( size-expr-list ) */
38934 static tree
38936 {
38940 /* Collapse and tile are mutually exclusive. (The spec doesn't say
38941 so, but the spec authors never considered such a case and have
38942 differing opinions on what it might mean, including 'not
38943 allowed'.) */
38946 clause_loc);
38951 do
38952 {
38959 {
38962 }
38963 else
38967 }
38970 /* Consume the trailing ')'. */
38978 }
38980 /* OpenACC 2.0
38981 Parse wait clause or directive parameters. */
38983 static tree
38985 {
38995 {
38997 {
39000 }
39002 }
39009 {
39013 {
39016 else
39017 {
39024 }
39025 }
39026 }
39029 }
39031 /* OpenACC:
39032 wait [( int-expr-list )] */
39034 static tree
39036 {
39041 else
39042 {
39048 }
39051 }
39053 /* OpenMP 3.0:
39054 collapse ( constant-expression ) */
39056 static tree
39058 {
39060 location_t loc;
39061 HOST_WIDE_INT n;
39064 matching_parens parens;
39082 {
39085 }
39094 }
39096 /* OpenMP 2.5:
39097 default ( none | shared )
39099 OpenMP 5.1:
39100 default ( private | firstprivate )
39102 OpenACC:
39103 default ( none | present ) */
39105 static tree
39108 {
39110 tree c;
39112 matching_parens parens;
39116 {
39119 }
39121 {
39126 {
39153 }
39156 }
39157 else
39158 {
39159 invalid_kind:
39162 else
39165 }
39182 }
39184 /* OpenMP 3.1:
39185 final ( expression ) */
39187 static tree
39189 {
39192 matching_parens parens;
39211 }
39213 /* OpenMP 5.1:
39214 indirect [( expression )]
39215 */
39217 static tree
39219 location_t location)
39220 {
39221 tree t;
39224 {
39225 matching_parens parens;
39240 }
39241 else
39251 }
39253 /* OpenMP 2.5:
39254 if ( expression )
39256 OpenMP 4.5:
39257 if ( directive-name-modifier : expression )
39259 directive-name-modifier:
39260 parallel | task | taskloop | target data | target | target update
39261 | target enter data | target exit data
39263 OpenMP 5.0:
39264 directive-name-modifier:
39265 ... | simd | cancel */
39267 static tree
39270 {
39274 matching_parens parens;
39279 {
39295 {
39298 {
39311 else
39312 {
39313 location_t loc
39318 }
39321 {
39323 {
39328 }
39330 {
39331 location_t loc
39335 }
39336 }
39337 }
39338 }
39340 {
39342 {
39345 }
39346 else
39347 {
39349 {
39350 location_t loc
39353 }
39355 }
39356 }
39357 }
39369 {
39372 {
39375 {
39387 }
39389 p);
39391 }
39393 {
39396 else
39399 }
39402 {
39406 }
39407 }
39415 }
39417 /* OpenMP 3.1:
39418 mergeable */
39420 static tree
39423 {
39424 tree c;
39427 location);
39432 }
39434 /* OpenMP 2.5:
39435 nowait */
39437 static tree
39440 {
39441 tree c;
39448 }
39450 /* OpenMP 2.5:
39451 num_threads ( expression ) */
39453 static tree
39455 location_t location)
39456 {
39459 matching_parens parens;
39479 }
39481 /* OpenMP 4.5:
39482 num_tasks ( expression )
39484 OpenMP 5.1:
39485 num_tasks ( strict : expression ) */
39487 static tree
39489 location_t location)
39490 {
39493 matching_parens parens;
39500 {
39503 {
39507 }
39508 }
39527 }
39529 /* OpenMP 4.5:
39530 grainsize ( expression )
39532 OpenMP 5.1:
39533 grainsize ( strict : expression ) */
39535 static tree
39537 location_t location)
39538 {
39541 matching_parens parens;
39548 {
39551 {
39555 }
39556 }
39575 }
39577 /* OpenMP 4.5:
39578 priority ( expression ) */
39580 static tree
39582 location_t location)
39583 {
39586 matching_parens parens;
39606 }
39608 /* OpenMP 4.5:
39609 hint ( expression ) */
39611 static tree
39613 {
39616 matching_parens parens;
39623 {
39631 }
39644 }
39646 /* OpenMP 5.1:
39647 filter ( integer-expression ) */
39649 static tree
39651 {
39654 matching_parens parens;
39672 }
39674 /* OpenMP 4.5:
39675 defaultmap ( tofrom : scalar )
39677 OpenMP 5.0:
39678 defaultmap ( implicit-behavior [ : variable-category ] ) */
39680 static tree
39682 location_t location)
39683 {
39687 enum omp_clause_defaultmap_kind category
39690 matching_parens parens;
39697 {
39698 invalid_behavior:
39700 "%<tofrom%>, %<firstprivate%>, %<none%> "
39703 }
39704 else
39705 {
39708 }
39711 {
39715 else
39722 else
39731 else
39738 else
39745 else
39754 else
39760 }
39764 {
39769 {
39770 invalid_category:
39774 }
39779 {
39785 else
39792 else
39799 else
39805 }
39808 }
39821 {
39831 {
39849 }
39852 p);
39853 else
39857 }
39864 out_err:
39869 }
39871 /* OpenMP 5.0:
39872 order ( concurrent )
39874 OpenMP 5.1:
39875 order ( order-modifier : concurrent )
39877 order-modifier:
39878 reproducible
39879 unconstrained */
39881 static tree
39883 {
39889 matching_parens parens;
39895 {
39902 else
39903 {
39907 }
39910 }
39912 {
39915 }
39916 else
39917 {
39920 }
39922 {
39925 }
39937 out_err:
39942 }
39944 /* OpenMP 5.0:
39945 bind ( teams | parallel | thread ) */
39947 static tree
39949 location_t location)
39950 {
39951 tree c;
39955 matching_parens parens;
39960 {
39961 invalid:
39965 }
39966 else
39967 {
39970 }
39981 /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
39987 out_err:
39992 }
39994 /* OpenMP 2.5:
39995 ordered
39997 OpenMP 4.5:
39998 ordered ( constant-expression ) */
40000 static tree
40003 {
40005 HOST_WIDE_INT n;
40011 {
40012 matching_parens parens;
40029 {
40031 "ordered argument needs positive constant integer "
40034 }
40035 }
40041 }
40043 /* OpenMP 2.5:
40044 reduction ( reduction-operator : variable-list )
40046 reduction-operator:
40047 One of: + * - & ^ | && ||
40049 OpenMP 3.1:
40051 reduction-operator:
40052 One of: + * - & ^ | && || min max
40054 OpenMP 4.0:
40056 reduction-operator:
40057 One of: + * - & ^ | && ||
40058 id-expression
40060 OpenMP 5.0:
40061 reduction ( reduction-modifier, reduction-operator : variable-list )
40062 in_reduction ( reduction-operator : variable-list )
40063 task_reduction ( reduction-operator : variable-list ) */
40065 static tree
40068 {
40078 {
40081 {
40084 }
40087 {
40095 {
40098 }
40099 }
40100 }
40103 {
40113 }
40117 else
40118 {
40129 {
40159 }
40160 else
40161 {
40163 resync_fail:
40168 }
40169 }
40175 NULL);
40177 {
40184 }
40187 }
40189 /* OpenMP 2.5:
40190 schedule ( schedule-kind )
40191 schedule ( schedule-kind , expression )
40193 schedule-kind:
40194 static | dynamic | guided | runtime | auto
40196 OpenMP 4.5:
40197 schedule ( schedule-modifier : schedule-kind )
40198 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
40200 schedule-modifier:
40201 simd
40202 monotonic
40203 nonmonotonic */
40205 static tree
40207 {
40211 matching_parens parens;
40219 {
40228 else
40234 {
40237 }
40238 else
40239 {
40242 }
40243 }
40248 {
40253 {
40274 }
40275 }
40280 else
40286 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
40288 {
40292 }
40295 {
40310 else
40315 }
40327 invalid_kind:
40329 resync_fail:
40334 }
40336 /* OpenMP 3.0:
40337 untied */
40339 static tree
40342 {
40343 tree c;
40350 }
40352 /* OpenMP 4.0:
40353 inbranch
40354 notinbranch */
40356 static tree
40359 {
40364 }
40366 /* OpenMP 4.0:
40367 parallel
40368 for
40369 sections
40370 taskgroup */
40372 static tree
40376 {
40380 }
40382 /* OpenMP 4.5:
40383 nogroup */
40385 static tree
40388 {
40393 }
40395 /* OpenMP 4.5:
40396 simd
40397 threads */
40399 static tree
40403 {
40408 }
40410 /* OpenMP 4.0:
40411 num_teams ( expression )
40413 OpenMP 5.1:
40414 num_teams ( expression : expression ) */
40416 static tree
40418 location_t location)
40419 {
40422 matching_parens parens;
40433 {
40437 }
40454 }
40456 /* OpenMP 4.0:
40457 thread_limit ( expression ) */
40459 static tree
40461 location_t location)
40462 {
40465 matching_parens parens;
40485 }
40487 /* OpenMP 4.0:
40488 aligned ( variable-list )
40489 aligned ( variable-list : constant-expression ) */
40491 static tree
40493 {
40497 matching_parens parens;
40505 {
40515 }
40521 }
40523 /* OpenMP 5.0:
40524 allocate ( variable-list )
40525 allocate ( expression : variable-list )
40527 OpenMP 5.1:
40528 allocate ( allocator-modifier : variable-list )
40529 allocate ( allocator-modifier , allocator-modifier : variable-list )
40531 allocator-modifier:
40532 allocator ( expression )
40533 align ( expression ) */
40535 static tree
40537 {
40541 matching_parens parens;
40551 {
40557 matching_parens parens2;
40561 {
40565 }
40566 else
40567 {
40571 }
40575 {
40578 }
40582 }
40583 else
40586 {
40592 }
40595 {
40602 }
40603 else
40604 {
40608 }
40615 {
40618 }
40621 }
40623 /* OpenMP 2.5:
40624 lastprivate ( variable-list )
40626 OpenMP 5.0:
40627 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
40629 static tree
40631 {
40639 {
40644 {
40648 }
40649 }
40658 }
40660 /* OpenMP 4.0:
40661 linear ( variable-list )
40662 linear ( variable-list : expression )
40664 OpenMP 4.5:
40665 linear ( modifier ( variable-list ) )
40666 linear ( modifier ( variable-list ) : expression )
40668 modifier:
40669 val
40670 ref
40671 uval
40673 OpenMP 5.2:
40674 linear ( variable-list : modifiers-list )
40676 modifiers:
40677 val
40678 ref
40679 uval
40680 step ( expression ) */
40682 static tree
40685 {
40691 matching_parens parens;
40696 {
40707 {
40710 }
40711 else
40713 }
40718 else
40719 {
40728 }
40731 {
40735 {
40745 {
40749 }
40753 CPP_CLOSE_PAREN)))
40755 }
40759 {
40761 {
40772 {
40778 }
40780 {
40781 location_t step_loc
40784 matching_parens parens2;
40786 {
40792 CPP_CLOSE_PAREN))
40793 {
40794 cp_token *token
40802 tok_loc);
40804 {
40807 }
40810 }
40816 }
40817 else
40819 }
40820 else
40823 {
40826 }
40828 }
40831 }
40835 {
40846 {
40849 }
40852 }
40863 }
40866 {
40870 }
40873 }
40875 /* OpenMP 4.0:
40876 safelen ( constant-expression ) */
40878 static tree
40880 location_t location)
40881 {
40884 matching_parens parens;
40903 }
40905 /* OpenMP 4.0:
40906 simdlen ( constant-expression ) */
40908 static tree
40910 location_t location)
40911 {
40914 matching_parens parens;
40933 }
40935 /* OpenMP 4.5:
40936 vec:
40937 identifier [+/- integer]
40938 vec , identifier [+/- integer]
40939 */
40941 static tree
40944 {
40948 {
40951 }
40954 {
40960 {
40963 {
40971 }
40972 }
40973 }
40976 {
40983 else
40984 {
40985 t = cp_parser_lookup_name_simple
40990 id_loc);
40991 }
40997 {
41000 }
41004 {
41007 }
41011 {
41014 }
41017 add_to_vector:
41019 {
41023 }
41030 }
41033 {
41040 }
41042 }
41044 /* OpenMP 5.0:
41045 detach ( event-handle ) */
41047 static tree
41049 {
41050 matching_parens parens;
41066 else
41067 {
41070 else
41075 }
41088 }
41090 /* OpenMP 5.0:
41091 iterators ( iterators-definition )
41093 iterators-definition:
41094 iterator-specifier
41095 iterator-specifier , iterators-definition
41097 iterator-specifier:
41098 identifier = range-specification
41099 iterator-type identifier = range-specification
41101 range-specification:
41102 begin : end
41103 begin : end : step */
41105 static tree
41107 {
41111 matching_parens parens;
41115 bool saved_colon_corrects_to_scope_p
41117 bool saved_colon_doesnt_start_class_def_p
41120 do
41121 {
41122 tree iter_type;
41126 else
41127 {
41130 parser->type_definition_forbidden_message
41136 }
41140 {
41143 }
41163 {
41166 }
41181 {
41184 }
41186 }
41190 parser->colon_doesnt_start_class_def_p
41200 }
41202 /* OpenMP 5.0:
41203 affinity ( [aff-modifier :] variable-list )
41204 aff-modifier:
41205 iterator ( iterators-definition ) */
41207 static tree
41209 {
41212 matching_parens parens;
41217 {
41222 CPP_OPEN_PAREN)));
41224 {
41227 }
41229 {
41233 {
41241 }
41242 }
41243 }
41247 {
41250 {
41255 }
41256 }
41258 }
41260 /* OpenMP 4.0:
41261 depend ( depend-kind : variable-list )
41263 depend-kind:
41264 in | out | inout
41266 OpenMP 4.5:
41267 depend ( source )
41269 depend ( sink : vec )
41271 OpenMP 5.0:
41272 depend ( depend-modifier , depend-kind: variable-list )
41274 depend-kind:
41275 in | out | inout | mutexinoutset | depobj
41277 depend-modifier:
41278 iterator ( iterators-definition ) */
41280 static tree
41282 {
41287 matching_parens parens;
41291 do
41292 {
41300 {
41305 }
41322 else
41325 }
41333 {
41338 }
41341 {
41352 }
41358 {
41364 }
41365 else
41366 {
41371 {
41375 else
41377 }
41380 {
41385 }
41386 }
41389 invalid_kind:
41391 resync_fail:
41398 }
41400 /* OpenMP 5.2:
41401 doacross ( source : )
41402 doacross ( source : omp_cur_iteration )
41404 doacross ( sink : vec )
41405 doacross ( sink : omp_cur_iteration - logical_iteration ) */
41407 static tree
41409 {
41410 tree nlist;
41413 matching_parens parens;
41418 {
41419 invalid_kind:
41421 resync_fail:
41426 }
41435 else
41444 {
41446 {
41451 }
41456 }
41457 else
41465 }
41467 /* OpenMP 4.0:
41468 from ( variable-list )
41469 to ( variable-list )
41471 OpenMP 5.1:
41472 from ( [present :] variable-list )
41473 to ( [present :] variable-list ) */
41475 static tree
41477 tree list)
41478 {
41488 {
41492 }
41500 }
41502 /* OpenMP 4.0:
41503 map ( map-kind : variable-list )
41504 map ( variable-list )
41506 map-kind:
41507 alloc | to | from | tofrom
41509 OpenMP 4.5:
41510 map-kind:
41511 alloc | to | from | tofrom | release | delete
41513 map ( always [,] map-kind: variable-list )
41515 OpenMP 5.0:
41516 map ( [map-type-modifier[,] ...] map-kind: variable-list )
41518 map-type-modifier:
41519 always | close */
41521 static tree
41523 {
41534 {
41536 {
41539 }
41542 pos++;
41543 pos++;
41544 }
41550 {
41553 {
41556 }
41560 {
41562 {
41569 }
41571 }
41573 {
41575 {
41582 }
41584 }
41586 {
41588 {
41595 }
41597 }
41598 else
41599 {
41607 }
41610 }
41614 {
41638 else
41639 {
41645 }
41648 }
41651 {
41655 }
41657 /* We introduce a scope here so that errors parsing e.g. "always", "close"
41658 tokens do not propagate to later directives that might use them
41659 legally. */
41669 }
41671 /* OpenMP 4.0:
41672 device ( expression )
41674 OpenMP 5.0:
41675 device ( [device-modifier :] integer-expression )
41677 device-modifier:
41678 ancestor | device_num */
41680 static tree
41682 location_t location)
41683 {
41687 matching_parens parens;
41693 {
41697 {
41700 /* A requires directive with the reverse_offload clause must be
41701 specified. */
41703 {
41705 "preceded by %<requires%> directive "
41709 }
41710 }
41712 ;
41713 else
41714 {
41718 }
41721 }
41740 }
41742 /* OpenMP 4.0:
41743 dist_schedule ( static )
41744 dist_schedule ( static , expression ) */
41746 static tree
41748 location_t location)
41749 {
41752 matching_parens parens;
41763 {
41774 }
41778 /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
41779 "dist_schedule", location); */
41785 invalid_kind:
41787 resync_fail:
41792 }
41794 /* OpenMP 4.0:
41795 proc_bind ( proc-bind-kind )
41797 proc-bind-kind:
41798 primary | master | close | spread
41799 where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
41801 static tree
41803 location_t location)
41804 {
41805 tree c;
41812 {
41824 else
41826 }
41827 else
41836 location);
41841 invalid_kind:
41843 resync_fail:
41848 }
41850 /* OpenMP 5.0:
41851 device_type ( host | nohost | any ) */
41853 static tree
41855 location_t location)
41856 {
41857 tree c;
41864 {
41874 else
41876 }
41877 else
41886 location);
41891 invalid_kind:
41893 resync_fail:
41898 }
41900 /* OpenACC:
41901 async [( int-expr )] */
41903 static tree
41905 {
41912 {
41913 matching_parens parens;
41922 }
41932 }
41934 /* OpenACC 2.7:
41935 self [( expression )] */
41937 static tree
41939 {
41940 tree t;
41943 {
41944 matching_parens parens;
41949 {
41954 }
41955 }
41956 else
41961 {
41964 }
41970 }
41972 /* Parse all OpenACC clauses. The set clauses allowed by the directive
41973 is a bitmask in MASK. Return the list of clauses found. */
41975 static tree
41979 {
41983 /* Don't create location wrapper nodes within OpenACC clauses. */
41984 auto_suppress_location_wrappers sentinel;
41987 {
41988 location_t here;
41989 pragma_omp_clause c_kind;
41990 omp_clause_code code;
42001 {
42008 clauses);
42061 clauses);
42066 clauses);
42084 clauses);
42089 clauses);
42102 clauses);
42109 clauses);
42115 clauses);
42123 clauses);
42127 clauses
42134 /* OpenACC compute construct */
42136 else
42137 /* OpenACC 'update' directive */
42143 clauses);
42152 clauses);
42158 OMP_CLAUSE_VECTOR,
42165 clauses);
42174 OMP_CLAUSE_WORKER,
42180 }
42185 {
42186 /* Remove the invalid clause(s) from the list to avoid
42187 confusing the rest of the compiler. */
42190 }
42191 }
42193 saw_error:
42201 }
42203 /* Parse all OpenMP clauses. The set clauses allowed by the directive
42204 is a bitmask in MASK. Return the list of clauses found.
42205 FINISH_P set if finish_omp_clauses should be called.
42206 NESTED non-zero if clauses should be terminated by closing paren instead
42207 of end of pragma. If it is 2, additionally commas are required in between
42208 the clauses. */
42210 static tree
42214 {
42219 /* Don't create location wrapper nodes within OpenMP clauses. */
42220 auto_suppress_location_wrappers sentinel;
42223 {
42224 pragma_omp_clause c_kind;
42232 {
42237 "clauses in %<simd%> trait should be separated "
42239 }
42245 {
42262 clauses);
42281 clauses);
42301 clauses);
42306 clauses);
42311 clauses);
42316 clauses);
42325 clauses
42376 clauses);
42380 clauses
42392 clauses);
42396 clauses
42398 OMP_CLAUSE_TASK_REDUCTION,
42414 clauses);
42419 OMP_CLAUSE_NOTINBRANCH,
42428 {
42429 clause_not_first:
42433 }
42462 {
42464 clauses);
42468 }
42469 else
42471 clauses);
42476 clauses);
42481 clauses);
42503 {
42508 }
42569 clauses
42575 clauses
42582 clauses);
42588 }
42593 {
42594 /* Remove the invalid clause(s) from the list to avoid
42595 confusing the rest of the compiler. */
42598 }
42599 }
42600 saw_error:
42604 {
42607 else
42609 }
42611 }
42613 /* OpenMP 2.5:
42614 structured-block:
42615 statement
42617 In practice, we're also interested in adding the statement to an
42618 outer node. So it is convenient if we work around the fact that
42619 cp_parser_statement calls add_stmt. */
42621 static unsigned
42623 {
42626 /* Only move the values to IN_OMP_BLOCK if they weren't false.
42627 This preserves the "not within loop or switch" style error messages
42628 for nonsense cases like
42629 void foo() {
42630 #pragma omp single
42631 break;
42632 }
42633 */
42638 }
42640 static void
42642 {
42644 }
42646 static tree
42648 {
42657 }
42659 /* OpenMP 5.x:
42660 # pragma omp allocate (list) clauses
42662 OpenMP 5.0 clause:
42663 allocator (omp_allocator_handle_t expression)
42665 OpenMP 5.1 additional clause:
42666 align (constant-expression)] */
42668 static void
42670 {
42676 do
42677 {
42684 matching_parens parens;
42690 {
42693 }
42698 {
42701 }
42703 {
42706 /* FIXME: Remove when adding check to semantics.cc; cf FIXME below. */
42710 {
42712 "positive constant power of two integer "
42715 }
42717 {
42720 {
42725 {
42727 "positive constant power of two integer "
42730 }
42731 }
42732 }
42733 }
42735 {
42738 }
42739 else
42740 {
42743 }
42750 {
42753 }
42755 /* FIXME: When implementing properly, delete the align/allocate expr error
42756 check above and add one in semantics.cc (to properly handle templates).
42757 Base this on the allocator/align modifiers check for the 'allocate' clause
42758 in semantics.cc's finish_omp_clauses. */
42760 }
42762 /* OpenMP 2.5:
42763 # pragma omp atomic new-line
42764 expression-stmt
42766 expression-stmt:
42767 x binop= expr | x++ | ++x | x-- | --x
42768 binop:
42769 +, *, -, /, &, ^, |, <<, >>
42771 where x is an lvalue expression with scalar type.
42773 OpenMP 3.1:
42774 # pragma omp atomic new-line
42775 update-stmt
42777 # pragma omp atomic read new-line
42778 read-stmt
42780 # pragma omp atomic write new-line
42781 write-stmt
42783 # pragma omp atomic update new-line
42784 update-stmt
42786 # pragma omp atomic capture new-line
42787 capture-stmt
42789 # pragma omp atomic capture new-line
42790 capture-block
42792 read-stmt:
42793 v = x
42794 write-stmt:
42795 x = expr
42796 update-stmt:
42797 expression-stmt | x = x binop expr
42798 capture-stmt:
42799 v = expression-stmt
42800 capture-block:
42801 { v = x; update-stmt; } | { update-stmt; v = x; }
42803 OpenMP 4.0:
42804 update-stmt:
42805 expression-stmt | x = x binop expr | x = expr binop x
42806 capture-stmt:
42807 v = update-stmt
42808 capture-block:
42809 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
42811 OpenMP 5.1:
42812 # pragma omp atomic compare new-line
42813 conditional-update-atomic
42815 # pragma omp atomic compare capture new-line
42816 conditional-update-capture-atomic
42818 conditional-update-atomic:
42819 cond-expr-stmt | cond-update-stmt
42820 cond-expr-stmt:
42821 x = expr ordop x ? expr : x;
42822 x = x ordop expr ? expr : x;
42823 x = x == e ? d : x;
42824 cond-update-stmt:
42825 if (expr ordop x) { x = expr; }
42826 if (x ordop expr) { x = expr; }
42827 if (x == e) { x = d; }
42828 ordop:
42829 <, >
42830 conditional-update-capture-atomic:
42831 v = cond-expr-stmt
42832 { v = x; cond-expr-stmt }
42833 { cond-expr-stmt v = x; }
42834 { v = x; cond-update-stmt }
42835 { cond-update-stmt v = x; }
42836 if (x == e) { x = d; } else { v = x; }
42837 { r = x == e; if (r) { x = d; } }
42838 { r = x == e; if (r) { x = d; } else { v = x; } }
42840 where x, r and v are lvalue expressions with scalar type,
42841 expr, e and d are expressions with scalar type and e might be
42842 the same as v. */
42844 static void
42846 {
42862 {
42868 {
42873 enum omp_memory_order new_memory_order
42889 {
42893 }
42901 {
42902 matching_parens parens;
42909 {
42919 }
42922 {
42926 else
42928 }
42929 else
42939 }
42951 {
42955 }
42956 else
42957 {
42960 "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
42961 "%<seq_cst%>, %<acq_rel%>, %<release%>, "
42963 }
42965 {
42967 {
42968 /* OpenACC permits 'update capture'. */
42975 else
42977 }
42979 {
42982 else
42984 }
42986 {
42989 else
42991 }
42993 {
42996 else
42998 }
43000 {
43003 else
43005 }
43008 }
43009 }
43011 }
43017 {
43021 else
43023 }
43025 {
43029 }
43031 {
43034 }
43036 {
43039 }
43043 {
43044 omp_requires_mask
43049 {
43059 {
43061 "%<acquire%> clause implicitly provided by a "
43064 }
43065 else
43070 {
43072 "%<release%> clause implicitly provided by a "
43075 }
43076 else
43081 {
43091 }
43095 }
43096 }
43097 else
43099 {
43102 {
43106 }
43112 {
43116 }
43122 }
43124 memory_order
43129 {
43139 else
43144 {
43145 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
43146 opcode. */
43151 }
43155 {
43158 }
43162 else
43163 {
43171 {
43175 }
43176 }
43179 }
43181 restart:
43183 {
43186 matching_parens parens;
43190 tree cmp_expr;
43193 else
43201 {
43207 }
43209 ;
43211 {
43215 }
43218 {
43220 "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
43223 }
43234 {
43237 }
43242 else
43255 {
43257 {
43260 }
43262 {
43267 }
43268 else
43270 }
43275 {
43280 }
43281 else
43282 {
43283 bad_if:
43287 }
43290 {
43294 {
43298 }
43326 /* Signal to c_finish_omp_atomic that in
43327 if (x == e) { x = d; } else { v = x; }
43328 case the store to v should be conditional. */
43330 }
43332 {
43335 }
43341 }
43345 {
43352 /* FALLTHROUGH */
43364 /* FALLTHROUGH */
43381 /* Undo effects of boolean_increment for post {in,de}crement. */
43383 /* FALLTHRU */
43387 {
43388 /* Undo effects of boolean_increment. */
43390 {
43391 /* This is pre or post increment. */
43396 && !structured_block
43402 }
43403 }
43404 /* FALLTHRU */
43407 {
43410 }
43412 {
43447 {
43451 }
43456 {
43462 {
43467 }
43469 {
43483 {
43485 {
43490 }
43491 else
43493 }
43498 || !structured_block
43499 || v
43505 {
43507 {
43513 }
43514 }
43522 {
43526 cond_expr:
43528 bool saved_colon_corrects_to_scope_p
43532 parser->colon_corrects_to_scope_p
43537 {
43539 {
43541 {
43545 }
43547 {
43548 opcode
43552 }
43553 }
43554 else
43555 {
43558 {
43559 opcode
43564 }
43565 }
43566 }
43568 "invalid form of "
43571 }
43575 }
43580 {
43587 }
43591 }
43595 {
43598 {
43606 }
43608 {
43613 }
43657 }
43660 {
43662 "invalid form of "
43665 }
43676 {
43678 {
43680 "invalid form of "
43683 }
43685 }
43691 }
43698 }
43699 stmt_done:
43701 {
43714 }
43716 {
43720 }
43721 done:
43723 {
43726 }
43734 invalid_compare:
43736 /* FALLTHRU */
43737 saw_error:
43742 {
43746 {
43750 }
43751 }
43752 }
43755 /* OpenMP 2.5:
43756 # pragma omp barrier new-line */
43758 static void
43760 {
43763 }
43765 /* OpenMP 2.5:
43766 # pragma omp critical [(name)] new-line
43767 structured-block
43769 OpenMP 4.5:
43770 # pragma omp critical [(name) [hint(expression)]] new-line
43771 structured-block */
43773 #define OMP_CRITICAL_CLAUSE_MASK \
43774 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
43776 static tree
43778 {
43782 {
43783 matching_parens parens;
43799 }
43806 }
43808 /* OpenMP 5.0:
43809 # pragma omp depobj ( depobj ) depobj-clause new-line
43811 depobj-clause:
43812 depend (dependence-type : locator)
43813 destroy
43814 update (dependence-type)
43816 OpenMP 5.2 additionally:
43817 destroy ( depobj )
43819 dependence-type:
43820 in
43821 out
43822 inout
43823 mutexinout */
43825 static void
43827 {
43829 matching_parens parens;
43831 {
43834 }
43849 {
43855 {
43856 /* Don't create location wrapper nodes within the depend clause. */
43857 auto_suppress_location_wrappers sentinel;
43863 }
43865 {
43867 matching_parens c_parens;
43870 {
43877 "the %<destroy%> expression %qE should be the same "
43884 }
43885 }
43887 {
43888 matching_parens c_parens;
43890 {
43891 location_t c2_loc
43894 {
43909 }
43911 {
43915 }
43921 }
43922 else
43924 }
43925 }
43927 {
43930 }
43934 }
43937 /* OpenMP 2.5:
43938 # pragma omp flush flush-vars[opt] new-line
43940 flush-vars:
43941 ( variable-list )
43943 OpenMP 5.0:
43944 # pragma omp flush memory-order-clause new-line */
43946 static void
43948 {
43954 {
43965 else
43967 "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
43970 }
43972 {
43975 "%<flush%> list specified together with memory order "
43978 }
43982 }
43984 /* Helper function, to parse omp for increment expression. */
43986 static tree
43988 {
43993 {
43996 }
43999 {
44011 }
44013 /* If decl is an iterator, preserve LHS and RHS of the relational
44014 expr until finish_omp_for. */
44025 }
44027 /* Helper function, to parse omp for increment expression. */
44029 static tree
44031 {
44035 cp_id_kind idk;
44039 {
44048 }
44057 {
44062 }
44069 {
44073 }
44086 do
44087 {
44094 {
44096 {
44099 else
44102 }
44103 else
44108 }
44109 }
44113 {
44119 }
44120 else
44124 }
44126 /* Parse the initialization statement of an OpenMP for loop. Range-for
44127 is handled separately in cp_convert_omp_range_for.
44129 On entry SL is the current statement list. Parsing of some forms
44130 of initialization pops this list and stores its contents in either INIT
44131 or THIS_PRE_BODY, and sets SL to null. Initialization for class
44132 iterators is added directly to SL and it is not popped until later.
44134 On return, DECL is set if the initialization is by binding the
44135 iteration variable. If the initialization is by assignment, REAL_DECL
44136 is set to point to a variable in an outer scope. ORIG_INIT is set
44137 if the iteration variable is of class type; this is a copy saved for
44138 error checking in finish_omp_for.
44140 Return true if the resulting construct should have an
44141 OMP_CLAUSE_PRIVATE added to it. */
44143 static tree
44151 {
44157 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
44159 init-expr:
44160 var = lb
44161 integer-type var = lb
44162 random-access-iterator-type var = lb
44163 pointer-type var = lb
44164 */
44165 cp_decl_specifier_seq type_specifiers;
44167 /* First, try to parse as an initialized declaration. See
44168 cp_parser_condition, from whence the bulk of this is copied. */
44176 {
44177 /* If parsing a type specifier seq succeeded, then this
44178 MUST be a initialized declaration. */
44183 CP_PARSER_DECLARATOR_NAMED,
44184 CP_PARSER_FLAGS_NONE,
44196 else
44197 {
44207 {
44209 CPP_OPEN_PAREN))
44212 else
44213 /* Trigger an error. */
44218 }
44222 {
44230 {
44233 auto_node);
44238 }
44241 asm_specification,
44242 LOOKUP_ONLYCONVERTING);
44245 /* In the case of a class iterator, do not pop sl here.
44246 Both class initialization and finalization must happen in
44247 the enclosing init block scope. For now set the init
44248 expression to null; it'll be filled in properly in
44249 finish_omp_for before stuffing it in the OMP_FOR. */
44253 {
44257 {
44259 /* Move lambda DECL_EXPRs to the enclosing block. */
44261 {
44265 {
44269 }
44271 }
44273 {
44278 }
44279 }
44280 }
44281 }
44282 else
44283 /* This is an initialized declaration of non-class,
44284 non-parameterized type iteration variable. */
44285 {
44286 /* Consume '='. */
44290 non_class:
44293 else
44296 asm_specification,
44297 LOOKUP_ONLYCONVERTING);
44300 }
44304 }
44305 }
44306 else
44307 {
44308 cp_id_kind idk;
44309 /* If parsing a type specifier sequence failed, then
44310 this MUST be a simple expression. */
44316 && decl
44319 {
44330 {
44335 }
44340 }
44342 && decl
44345 {
44346 tree rhs;
44355 tf_warning_or_error));
44358 }
44359 else
44360 {
44365 {
44369 }
44370 }
44373 }
44375 }
44377 /* Helper for cp_parser_omp_loop_nest, handle one range-for loop
44378 including introducing new temporaries for the range start and end,
44379 doing auto deduction, and processing decomposition variables.
44381 This function is also called from pt.cc during template instantiation.
44382 In that case SL is NULL_TREE, otherwise it is the current statement
44383 list. */
44384 void
44388 {
44394 {
44398 /* do_auto_deduction doesn't mess with template init-lists. */
44400 {
44404 {
44409 {
44414 }
44415 }
44417 }
44422 {
44425 }
44427 }
44432 /* If an error happened previously do nothing or else a lot of
44433 unhelpful errors would be issued. */
44435 else
44436 {
44437 tree range_temp;
44441 /* Can't bind a reference to an array of runtime bound. */
44443 else
44444 {
44450 LOOKUP_ONLYCONVERTING);
44453 }
44456 }
44467 LOOKUP_ONLYCONVERTING);
44469 /* The new for initialization statement. */
44477 else
44478 {
44481 }
44484 LOOKUP_ONLYCONVERTING);
44486 /* The new for condition. */
44489 else
44495 /* The new increment expression. */
44498 else
44501 tf_warning_or_error);
44505 /* Defer popping sl here. */
44509 {
44514 {
44520 }
44521 }
44525 {
44529 {
44533 {
44539 }
44540 }
44541 }
44543 /* The output ORIG_DECL is not a decl. Instead, it is a tree structure
44544 that holds decls for variables implementing the iterator, represented
44545 as a TREE_LIST whose TREE_CHAIN is a vector. The first two elements
44546 of the vector are decls of scratch variables for the range start and
44547 end that will eventually be bound in the implicit scope surrounding
44548 the whole loop nest. The remaining elements are decls of derived
44549 decomposition variables that are bound inside the loop body. This
44550 structure is further mangled by finish_omp_for into the form required
44551 for the OMP_FOR_ORIG_DECLS field of the OMP_FOR tree node. */\
44560 {
44562 {
44563 /* If cp_finish_decomp was called with processing_template_decl
44564 temporarily set to 1, then decomp names will have deduced
44565 name but the DECL_VALUE_EXPR will be dependent. Hide those
44566 from folding of other loop initializers e.g. for warning
44567 purposes until cp_finish_omp_range_for. */
44572 }
44575 }
44577 }
44579 /* Helper for cp_parser_omp_for_loop, finalize part of range for
44580 inside of the collapsed body. */
44582 void
44584 {
44591 {
44596 {
44597 /* Undo temporary clearing of DECL_HAS_VALUE_EXPR_P done
44598 by cp_convert_omp_range_for above. */
44602 {
44606 }
44607 }
44608 }
44610 /* The declaration is initialized with *__begin inside the loop body. */
44618 }
44620 /* Return true if next tokens contain a standard attribute that contains
44621 omp::directive (DIRECTIVE). */
44623 static bool
44626 {
44634 {
44642 }
44647 location_t last_loc
44656 {
44658 {
44662 cnt++;
44666 {
44670 }
44671 }
44672 }
44674 {
44677 }
44679 {
44681 "%<[[omp::directive(%s)]]%> must be the only specified "
44685 }
44690 }
44692 /* Parse an OpenMP structured block sequence. KIND is the corresponding
44693 separating directive. */
44695 static tree
44698 {
44704 {
44717 kind == PRAGMA_OMP_SCAN
44722 }
44726 }
44729 /* OpenMP 5.0:
44731 scan-loop-body:
44732 { structured-block scan-directive structured-block } */
44734 static void
44736 {
44740 matching_braces braces;
44747 else
44748 {
44750 "%<#pragma omp scan%> with zero preceding executable "
44753 }
44759 {
44769 {
44776 }
44778 {
44781 }
44782 else
44787 }
44788 else
44794 else
44795 {
44798 "%<#pragma omp scan%> with zero succeeding executable "
44801 }
44803 clauses);
44807 }
44810 /* This function parses a single level of a loop nest, invoking itself
44811 recursively if necessary.
44813 loop-nest :: for (...) loop-body
44814 loop-body :: loop-nest
44815 | { [intervening-code] loop-body [intervening-code] }
44816 | final-loop-body
44817 intervening-code :: structured-block-sequence
44818 final-loop-body :: structured-block
44820 For a collapsed loop nest, only a single OMP_FOR is built, pulling out
44821 all the iterator information from the inner loops into vectors in the
44822 parser->omp_for_parse_state structure.
44824 In the "range for" case, it is transformed into a regular "for" iterator
44825 by introducing some temporary variables for the begin/end,
44826 as well as bindings of the actual iteration variables which are
44827 injected into the body of the loop.
44829 Initialization code for iterator variables may end up either in the
44830 init vector (simple assignments), in omp_for_parse_state->pre_body
44831 (decl_exprs for iterators bound in the for statement), or in the
44832 scope surrounding this level of loop initialization.
44834 The scopes of class iterator variables and their finalizers need to
44835 be adjusted after parsing so that all of the initialization happens
44836 in a scope surrounding all of the intervening and body code. For
44837 this reason we separately store the initialization and body blocks
44838 for each level of loops in the omp_for_parse_state structure and
44839 reassemble/reorder them in cp_parser_omp_for. See additional
44840 comments there about the use of placeholders, etc. */
44842 static tree
44844 {
44849 tree init_scope;
44854 location_t loc;
44862 /* We have already matched the FOR token but not consumed it yet. */
44866 /* Forbid break/continue in the loop initializer, condition, and
44867 increment expressions. */
44871 /* We are not in intervening code now. */
44874 /* Don't create location wrapper nodes within an OpenMP "for"
44875 statement. */
44876 auto_suppress_location_wrappers sentinel;
44878 matching_parens parens;
44885 integer_zero_node);
44888 /* The init_block acts as a container for this level of loop goo. */
44892 /* Wrap a scope around this entire level of loop to hold bindings
44893 of loop iteration variables. We can't insert them directly
44894 in the containing scope because that would cause their visibility to
44895 be incorrect with respect to intervening code after this loop.
44896 We will combine the nested init_scopes in postprocessing after the
44897 entire loop is parsed. */
44900 /* Now we need another level of statement list container to capture the
44901 initialization (and possible finalization) bits. In some cases this
44902 container may be popped off during initializer parsing to store code in
44903 INIT or THIS_PRE_BODY, depending on the form of initialization. If
44904 we have a class iterator we will pop it at the end of parsing this
44905 level, so the cleanups are handled correctly. */
44909 {
44910 /* Save tokens so that we can put them back. */
44913 /* Look for ':' that is not nested in () or {}. */
44914 is_range_for
44917 CPP_COLON,
44918 /*consume_paren=*/
44921 /* Roll back the tokens we skipped. */
44925 {
44926 bool saved_colon_corrects_to_scope_p
44929 /* A colon is used in range-based for. */
44932 /* Parse the declaration. */
44934 /*function_definition_allowed_p=*/
44936 parser->colon_corrects_to_scope_p
44950 "%<ordered%> clause with parameter on "
44954 }
44955 }
44957 add_private_clause
44963 /* If the iteration variable was introduced via a declaration in the
44964 for statement, DECL points at it. Otherwise DECL is null and
44965 REAL_DECL is a variable previously declared in an outer scope.
44966 Make REAL_DECL point at the iteration variable no matter where it
44967 was introduced. */
44971 /* Some clauses treat iterator variables specially. */
44976 {
44982 {
44986 }
44989 {
44990 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
44994 {
44998 }
44999 else
45000 {
45003 }
45005 }
45006 else
45007 {
45012 }
45013 }
45016 {
45017 tree c;
45019 {
45028 decl);
45033 decl);
45034 }
45036 {
45043 else
45048 {
45051 /* For linear, signal that we need to fill up
45052 the so far unknown linear step. */
45055 }
45056 }
45057 }
45066 {
45067 /* If decl is an iterator, preserve the operator on decl
45068 until finish_omp_for. */
45070 && ((processing_template_decl
45075 else
45078 }
45080 parse_close_paren:
45086 /* We've parsed all the for (...) stuff now. Store the bits. */
45092 {
45095 }
45097 {
45099 omp_for_parse_state->orig_declv
45102 }
45109 /* Start a nested block for the loop body. */
45111 integer_zero_node);
45119 {
45123 }
45126 {
45127 /* This is the open brace in the loop-body grammar production. Rather
45128 than trying to special-case braces, just parse it as a compound
45129 statement and handle the nested loop-body case there. Note that
45130 when we see a further open brace inside the compound statement
45131 loop-body, we don't know whether it is the start of intervening
45132 code that is a compound statement, or a level of braces
45133 surrounding a nested loop-body. Use the WANT_NESTED_LOOP state
45134 bit to ensure we have only one nested loop at each level. */
45141 {
45142 /* We have already parsed the whole loop body and not found a
45143 nested loop. */
45147 }
45149 }
45150 else
45151 {
45152 /* This is the final-loop-body case in the grammar: we have something
45153 that is not a FOR and not an open brace. */
45155 {
45156 /* If we were expecting a nested loop, give an error and mark
45157 that parsing has failed, and try to recover by parsing the
45158 body as regular code without further collapsing. */
45162 }
45165 /* Generate the parts of range for that belong in the loop body,
45166 to be executed on every iteration. This includes setting the
45167 user-declared decomposition variables from the compiler-generated
45168 temporaries that are the real iteration variables for OMP_FOR.
45169 FIXME: Not sure if this is correct with respect to visibility
45170 of the variables from intervening code. However, putting this
45171 code in each level of loop instead of all around the innermost
45172 body also makes the decomposition variables visible to the
45173 inner for init/bound/step exressions, which is not supposed to
45174 happen and causes test failures. */
45177 {
45182 }
45184 /* Now parse the final-loop-body for the innermost loop. */
45188 else
45191 }
45196 /* Pop and remember the body block. Add the body placeholder
45197 to the surrounding statement list instead. This is just a unique
45198 token that will be replaced when we reassemble the generated
45199 code for the entire omp for statement. */
45204 /* Pop and remember the init block. */
45211 /* Return the init placeholder rather than the remembered init block.
45212 Again, this is just a unique cookie that will be used to reassemble
45213 code pieces when the entire omp for statement has been parsed. */
45215 }
45217 /* Worker for find_structured_blocks. *TP points to a STATEMENT_LIST
45218 and ITER is the element that is or contains a nested loop. This
45219 function moves the statements before and after ITER into
45220 OMP_STRUCTURED_BLOCKs and modifies *TP. */
45221 static void
45223 {
45227 {
45232 TSI_SAME_STMT);
45233 i++;
45235 }
45236 else
45237 {
45241 }
45246 TSI_SAME_STMT);
45247 }
45249 /* Helper to find and mark structured blocks in intervening code for a
45250 single loop level with markers for later error checking. *TP is the
45251 piece of code to be marked and INNER is the inner loop placeholder.
45252 Returns true if INNER was found (recursively) in *TP. */
45253 static bool
45255 {
45261 {
45263 {
45265 /* The normal case is that there is no intervening code and we
45266 do not have to insert any OMP_STRUCTURED_BLOCK markers. */
45268 {
45272 }
45273 }
45275 }
45280 else
45282 }
45284 /* Helpers used for relinking tree structures: In tree rooted at
45285 CONTEXT, replace ORIG with REPLACEMENT. If FLATTEN is true, try to combine
45286 nested BIND_EXPRs. Gives an assertion if it fails to find ORIG. */
45289 tree orig;
45290 tree repl;
45292 };
45294 static tree
45297 {
45300 {
45303 }
45304 /* Remove redundant BIND_EXPRs with no bindings even when not specifically
45305 trying to flatten. */
45310 {
45313 }
45317 {
45319 {
45320 /* Merge binding lists for two directly nested BIND_EXPRs,
45321 keeping the outer one. */
45326 }
45328 /* There might be a statement list containing cleanup_points
45329 etc between the two levels of BIND_EXPR. We can still merge
45330 them, again keeping the outer BIND_EXPR. */
45333 {
45336 {
45341 }
45342 }
45343 }
45345 }
45347 static void
45349 {
45362 }
45364 /* Walker to patch up the BLOCK_NODE hierarchy after the above surgery.
45365 *DP is the parent block. */
45367 static tree
45369 {
45372 /* BIND_EXPR_BLOCK may be null if the expression is not a
45373 full-expression; if there's no block, no patching is necessary
45374 for this node. */
45376 {
45379 {
45383 }
45388 }
45391 }
45393 /* Parse the restricted form of the for statement allowed by OpenMP. */
45395 static tree
45398 {
45399 tree ret;
45407 tree result;
45414 {
45417 }
45420 {
45423 }
45430 {
45436 }
45442 {
45445 }
45447 /* Initialize parse state for recursive descent. */
45472 /* Bomb out early if there was an error (not enough loops, etc). */
45474 {
45477 }
45479 /* Relink the init and body blocks that were built during parsing. At
45480 this point we have a structure nested like
45481 init 0
45482 body 0
45483 init 1
45484 body 1
45485 init 2
45486 body 2
45487 and we want to turn it into
45488 init 0
45489 init 1
45490 init 2
45491 omp_for
45492 body 0
45493 body 1
45494 body 2
45495 We also need to flatten the init blocks, as some code for later
45496 processing of combined directives gets confused otherwise. */
45503 /* First insert markers for structured blocks for intervening code in
45504 the loop bodies. */
45506 {
45510 }
45512 /* Do the substitution from the inside out. */
45514 {
45521 }
45523 /* Generate the OMP_FOR. Note finish_omp_for adds the OMP_FOR
45524 (and possibly other stuff) to the current statement list but
45525 returns a pointer to the OMP_FOR itself, or null in case of error. */
45533 /* Check for errors involving lb/ub/incr expressions referencing
45534 variables declared in intervening code. */
45540 {
45541 /* Splice the omp_for into the nest of init blocks. */
45546 /* Some later processing for combined directives assumes
45547 that the BIND_EXPR containing range for variables appears
45548 at top level in the OMP_FOR body. Fix that up if it's
45549 not the case, e.g. because there is intervening code. */
45553 /* Clean up the block subblock/superblock links. Per comment in
45554 begin_compound_stmt, "we don't build BLOCK nodes when processing
45555 templates", so skip this step in that case. */
45557 {
45561 }
45563 /* Finally record the result. */
45565 }
45569 }
45571 /* Helper function for OpenMP parsing, split clauses and call
45572 finish_omp_clauses on each of the set of clauses afterwards. */
45574 static void
45577 {
45583 i == C_OMP_CLAUSE_SPLIT_TARGET
45585 }
45587 /* OpenMP 5.0:
45588 #pragma omp loop loop-clause[optseq] new-line
45589 for-loop */
45591 #define OMP_LOOP_CLAUSE_MASK \
45592 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45593 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45594 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45595 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45596 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
45597 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45599 static tree
45603 {
45614 {
45617 }
45629 }
45631 /* OpenMP 4.0:
45632 #pragma omp simd simd-clause[optseq] new-line
45633 for-loop */
45635 #define OMP_SIMD_CLAUSE_MASK \
45636 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
45637 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
45638 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45639 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
45640 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45641 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45642 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45643 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45644 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
45645 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
45646 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45648 static tree
45652 {
45663 {
45666 }
45678 }
45680 /* OpenMP 2.5:
45681 #pragma omp for for-clause[optseq] new-line
45682 for-loop
45684 OpenMP 4.0:
45685 #pragma omp for simd for-simd-clause[optseq] new-line
45686 for-loop */
45688 #define OMP_FOR_CLAUSE_MASK \
45689 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
45690 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
45691 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
45692 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45693 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
45694 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
45695 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
45696 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
45697 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
45698 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
45699 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
45701 static tree
45705 {
45712 /* parallel for{, simd} disallows nowait clause, but for
45713 target {teams distribute ,}parallel for{, simd} it should be accepted. */
45716 /* Composite distribute parallel for{, simd} disallows ordered clause. */
45721 {
45726 {
45750 }
45751 }
45753 {
45756 }
45758 /* Composite distribute parallel for disallows linear clause. */
45765 {
45768 }
45780 }
45785 /* OpenMP 2.5:
45786 # pragma omp master new-line
45787 structured-block */
45789 static tree
45793 {
45801 {
45806 {
45826 }
45827 }
45829 {
45832 }
45835 {
45839 }
45840 else
45845 }
45847 /* OpenMP 5.1:
45848 # pragma omp masked masked-clauses new-line
45849 structured-block */
45851 #define OMP_MASKED_CLAUSE_MASK \
45852 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
45854 static tree
45858 {
45867 {
45872 {
45893 }
45894 }
45896 {
45899 }
45904 {
45907 }
45911 clauses);
45912 }
45914 /* OpenMP 2.5:
45915 # pragma omp ordered new-line
45916 structured-block
45918 OpenMP 4.5:
45919 # pragma omp ordered ordered-clauses new-line
45920 structured-block */
45922 #define OMP_ORDERED_CLAUSE_MASK \
45923 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
45924 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
45926 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
45927 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
45928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DOACROSS))
45930 static bool
45933 {
45941 {
45946 {
45948 {
45951 }
45953 {
45955 "%qs clause may only be used in compound "
45959 }
45960 tree clauses
45962 OMP_ORDERED_DEPEND_CLAUSE_MASK,
45966 }
45967 }
45969 tree clauses
45980 }
45982 /* OpenMP 2.5:
45984 section-scope:
45985 { section-sequence }
45987 section-sequence:
45988 section-directive[opt] structured-block
45989 section-sequence section-directive structured-block */
45991 static tree
45993 {
45998 matching_braces braces;
46005 != PRAGMA_OMP_SECTION
46007 {
46009 PRAGMA_OMP_SECTION);
46012 }
46015 {
46025 {
46029 }
46031 {
46034 }
46037 PRAGMA_OMP_SECTION);
46040 }
46051 }
46053 /* OpenMP 2.5:
46054 # pragma omp sections sections-clause[optseq] newline
46055 sections-scope */
46057 #define OMP_SECTIONS_CLAUSE_MASK \
46058 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46059 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46060 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46061 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46062 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46063 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46065 static tree
46068 {
46080 {
46083 }
46090 }
46092 /* OpenMP 2.5:
46093 # pragma omp parallel parallel-clause[optseq] new-line
46094 structured-block
46095 # pragma omp parallel for parallel-for-clause[optseq] new-line
46096 structured-block
46097 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
46098 structured-block
46100 OpenMP 4.0:
46101 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
46102 structured-block */
46104 #define OMP_PARALLEL_CLAUSE_MASK \
46105 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46106 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46107 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46108 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
46109 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46110 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
46111 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46112 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
46113 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46114 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
46116 static tree
46120 {
46127 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
46133 {
46141 if_p);
46145 if_p);
46148 block);
46153 }
46154 /* When combined with distribute, parallel has to be followed by for.
46155 #pragma omp target parallel is allowed though. */
46159 {
46163 }
46165 {
46169 {
46183 block);
46186 /* masked does have just filter clause, but during gimplification
46187 isn't represented by a gimplification omp context, so for
46188 #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
46189 so that
46190 #pragma omp parallel masked
46191 #pragma omp taskloop simd lastprivate (x)
46192 isn't confused with
46193 #pragma omp parallel masked taskloop simd lastprivate (x) */
46197 }
46199 {
46213 block);
46216 /* master doesn't have any clauses and during gimplification
46217 isn't represented by a gimplification omp context, so for
46218 #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
46219 so that
46220 #pragma omp parallel master
46221 #pragma omp taskloop simd lastprivate (x)
46222 isn't confused with
46223 #pragma omp parallel master taskloop simd lastprivate (x) */
46227 }
46229 {
46244 block);
46249 }
46251 {
46254 }
46256 {
46266 block);
46269 }
46270 }
46272 {
46275 }
46280 {
46283 }
46292 }
46294 /* OpenMP 2.5:
46295 # pragma omp single single-clause[optseq] new-line
46296 structured-block */
46298 #define OMP_SINGLE_CLAUSE_MASK \
46299 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46300 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46301 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
46302 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46303 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46305 static tree
46307 {
46318 }
46320 /* OpenMP 5.1:
46321 # pragma omp scope scope-clause[optseq] new-line
46322 structured-block */
46324 #define OMP_SCOPE_CLAUSE_MASK \
46325 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46326 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46327 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46328 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46329 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46331 static tree
46333 {
46344 }
46346 /* OpenMP 3.0:
46347 # pragma omp task task-clause[optseq] new-line
46348 structured-block */
46350 #define OMP_TASK_CLAUSE_MASK \
46351 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
46353 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
46354 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46355 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46356 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46357 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
46358 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
46359 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46360 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
46361 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46362 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
46363 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
46364 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
46366 static tree
46368 {
46380 }
46382 /* OpenMP 3.0:
46383 # pragma omp taskwait new-line
46385 OpenMP 5.0:
46386 # pragma omp taskwait taskwait-clause[opt] new-line */
46388 #define OMP_TASKWAIT_CLAUSE_MASK \
46389 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46390 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46392 static void
46394 {
46395 tree clauses
46400 {
46407 }
46408 else
46410 }
46412 /* OpenMP 3.1:
46413 # pragma omp taskyield new-line */
46415 static void
46417 {
46420 }
46422 /* OpenMP 4.0:
46423 # pragma omp taskgroup new-line
46424 structured-block
46426 OpenMP 5.0:
46427 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
46429 #define OMP_TASKGROUP_CLAUSE_MASK \
46430 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46431 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
46433 static tree
46435 {
46436 tree clauses
46441 if_p),
46442 clauses);
46443 }
46446 /* OpenMP 2.5:
46447 # pragma omp threadprivate (variable-list) */
46449 static void
46451 {
46452 tree vars;
46458 }
46460 /* OpenMP 4.0:
46461 # pragma omp cancel cancel-clause[optseq] new-line */
46463 #define OMP_CANCEL_CLAUSE_MASK \
46464 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
46465 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
46466 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
46467 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
46468 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
46470 static void
46472 {
46476 }
46478 /* OpenMP 4.0:
46479 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
46481 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
46482 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
46483 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
46484 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
46485 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
46487 static bool
46490 {
46491 tree clauses;
46495 {
46500 {
46503 }
46504 }
46506 {
46510 }
46513 {
46518 else
46522 }
46525 OMP_CANCELLATION_POINT_CLAUSE_MASK,
46527 pragma_tok);
46530 }
46532 /* OpenMP 4.0:
46533 #pragma omp distribute distribute-clause[optseq] new-line
46534 for-loop */
46536 #define OMP_DISTRIBUTE_CLAUSE_MASK \
46537 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46538 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46539 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
46540 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
46541 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46542 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
46543 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
46545 static tree
46549 {
46558 {
46566 else
46569 {
46575 {
46579 else
46582 }
46588 else
46602 }
46603 }
46605 {
46608 }
46613 {
46616 }
46628 }
46630 /* OpenMP 4.0:
46631 # pragma omp teams teams-clause[optseq] new-line
46632 structured-block */
46634 #define OMP_TEAMS_CLAUSE_MASK \
46635 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
46636 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
46637 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
46638 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
46639 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
46640 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
46641 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
46642 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
46644 static tree
46648 {
46657 {
46661 {
46687 }
46689 {
46715 }
46716 }
46718 {
46721 }
46726 {
46729 }
46739 }
46741 /* OpenMP 4.0:
46742 # pragma omp target data target-data-clause[optseq] new-line
46743 structured-block */
46745 #define OMP_TARGET_DATA_CLAUSE_MASK \
46746 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
46750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
46752 static tree
46754 {
46756 omp_requires_mask
46759 tree clauses
46765 {
46768 {
46794 "%<#pragma omp target data%> with map-type other "
46795 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
46799 }
46804 }
46807 {
46810 "%<#pragma omp target data%> must contain at least "
46811 "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
46814 }
46825 }
46827 /* OpenMP 4.5:
46828 # pragma omp target enter data target-enter-data-clause[optseq] new-line
46829 structured-block */
46831 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
46832 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46833 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46834 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46835 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46836 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46838 static bool
46841 {
46844 {
46849 {
46852 }
46853 }
46855 {
46859 }
46862 {
46868 }
46871 omp_requires_mask
46874 tree clauses
46880 {
46883 {
46917 "%<#pragma omp target enter data%> with map-type other "
46921 }
46923 }
46926 {
46929 "%<#pragma omp target enter data%> must contain at least "
46932 }
46940 }
46942 /* OpenMP 4.5:
46943 # pragma omp target exit data target-enter-data-clause[optseq] new-line
46944 structured-block */
46946 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
46947 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
46948 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
46949 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
46950 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
46951 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
46953 static bool
46956 {
46959 {
46964 {
46967 }
46968 }
46970 {
46974 }
46977 {
46983 }
46986 omp_requires_mask
46989 tree clauses
46997 {
47000 {
47034 "%<#pragma omp target exit data%> with map-type other "
47035 "than %<from%>, %<tofrom%>, %<release%> or %<delete%> "
47039 }
47041 }
47044 {
47047 "%<#pragma omp target exit data%> must contain at least "
47050 }
47058 }
47060 /* OpenMP 4.0:
47061 # pragma omp target update target-update-clause[optseq] new-line */
47063 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
47064 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
47065 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
47066 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
47067 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
47068 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
47069 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
47071 static bool
47074 {
47076 {
47082 }
47084 tree clauses
47089 {
47091 "%<#pragma omp target update%> must contain at least one "
47094 }
47097 omp_requires_mask
47106 }
47108 /* OpenMP 4.0:
47109 # pragma omp target target-clause[optseq] new-line
47110 structured-block */
47112 #define OMP_TARGET_CLAUSE_MASK \
47113 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
47114 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
47115 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
47116 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
47117 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
47118 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47119 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47120 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
47121 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47122 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
47123 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
47124 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR)\
47125 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR))
47127 static bool
47130 {
47132 omp_requires_mask
47136 {
47148 {
47156 {
47157 tree stmt;
47159 {
47162 OMP_TARGET_CLAUSE_MASK,
47167 OMP_TARGET_CLAUSE_MASK,
47172 OMP_TARGET_CLAUSE_MASK,
47177 }
47179 }
47184 {
47188 if_p);
47193 if_p);
47198 if_p);
47202 }
47208 /* For combined target teams, ensure the num_teams and
47209 thread_limit clause expressions are evaluated on the host,
47210 before entering the target construct. */
47219 {
47222 tf_none);
47229 OMP_CLAUSE_FIRSTPRIVATE);
47234 }
47239 }
47241 {
47244 }
47246 {
47250 }
47252 {
47255 }
47257 {
47260 }
47262 {
47265 }
47266 }
47268 {
47271 }
47278 {
47284 }
47293 }
47295 /* OpenACC 2.0:
47296 # pragma acc cache (variable-list) new-line
47298 OpenACC 2.7:
47299 # pragma acc cache (readonly: variable-list) new-line
47300 */
47302 static tree
47304 {
47305 /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
47306 clauses. */
47307 auto_suppress_location_wrappers sentinel;
47313 {
47318 {
47322 }
47325 }
47342 }
47344 /* OpenACC 2.0:
47345 # pragma acc data oacc-data-clause[optseq] new-line
47346 structured-block */
47348 #define OACC_DATA_CLAUSE_MASK \
47349 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47353 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47354 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47355 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
47356 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47357 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47358 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47359 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
47361 static tree
47363 {
47376 }
47378 /* OpenACC 2.0:
47379 # pragma acc host_data <clauses> new-line
47380 structured-block */
47382 #define OACC_HOST_DATA_CLAUSE_MASK \
47383 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
47384 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47385 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
47387 static tree
47389 {
47397 {
47401 }
47409 }
47411 /* OpenACC 2.0:
47412 # pragma acc declare oacc-data-clause[optseq] new-line
47413 */
47415 #define OACC_DECLARE_CLAUSE_MASK \
47416 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47417 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47418 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47419 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47420 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47421 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
47422 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
47423 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
47425 static tree
47427 {
47437 {
47441 }
47444 {
47448 {
47452 }
47455 {
47467 {
47469 "%qD must be a global variable in "
47471 decl);
47474 }
47479 {
47483 }
47485 {
47487 "invalid use of %<extern%> variable %qD "
47491 }
47493 {
47495 "invalid use of %<global%> variable %qD "
47499 }
47501 }
47504 /* This seems to ignore the existence of cleanup scopes?
47505 What is the meaning for local extern decls? The local
47506 extern is in this scope, but it is referring to a decl that
47507 is namespace scope. */
47510 {
47513 }
47515 {
47517 "%qD must be a variable declared in the same scope as "
47521 }
47524 {
47526 /* We need to mark the aliased decl, as that is the entity
47527 that is being referred to. This won't work for
47528 dependent variables, but it didn't work for them before
47529 DECL_LOCAL_DECL_P was a thing either. But then
47530 dependent local extern variable decls are as rare as
47531 hen's teeth. */
47539 {
47544 }
47546 tree id;
47549 else
47555 {
47558 {
47561 {
47565 }
47566 }
47567 }
47568 }
47569 }
47582 }
47584 /* OpenACC 2.0:
47585 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
47587 or
47589 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
47591 LOC is the location of the #pragma token.
47592 */
47594 #define OACC_ENTER_DATA_CLAUSE_MASK \
47595 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47596 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47597 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47598 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47599 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47600 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47602 #define OACC_EXIT_DATA_CLAUSE_MASK \
47603 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47604 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47605 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47606 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
47607 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
47608 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
47609 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47611 static tree
47614 {
47623 {
47628 }
47635 else
47640 {
47644 }
47652 }
47654 /* OpenACC 2.0:
47655 # pragma acc loop oacc-loop-clause[optseq] new-line
47656 structured-block */
47658 #define OACC_LOOP_CLAUSE_MASK \
47659 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
47660 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47661 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47662 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
47663 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
47664 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
47665 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
47666 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
47667 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
47668 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
47670 static tree
47673 {
47683 {
47689 }
47696 /* Later processing of combined acc loop constructs gets confused
47697 by an extra level of empty nested BIND_EXPRs, so flatten them. */
47706 }
47708 /* OpenACC 2.0:
47709 # pragma acc kernels oacc-kernels-clause[optseq] new-line
47710 structured-block
47712 or
47714 # pragma acc parallel oacc-parallel-clause[optseq] new-line
47715 structured-block
47717 OpenACC 2.6:
47719 # pragma acc serial oacc-serial-clause[optseq] new-line
47720 */
47722 #define OACC_KERNELS_CLAUSE_MASK \
47723 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47724 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47725 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47726 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47727 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47728 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47729 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47730 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47731 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47732 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47733 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
47734 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
47735 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47736 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47737 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
47738 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47740 #define OACC_PARALLEL_CLAUSE_MASK \
47741 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
47750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47751 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47752 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
47753 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
47754 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47755 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47756 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47757 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47758 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
47759 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47761 #define OACC_SERIAL_CLAUSE_MASK \
47762 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47763 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
47764 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
47765 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
47766 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
47767 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
47768 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
47769 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
47770 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47771 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
47772 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
47773 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
47774 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
47775 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
47776 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47777 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
47779 static tree
47782 {
47783 omp_clause_mask mask;
47786 {
47804 }
47807 {
47811 {
47814 tree clauses;
47819 }
47820 }
47831 }
47833 /* OpenACC 2.0:
47834 # pragma acc update oacc-update-clause[optseq] new-line
47835 */
47837 #define OACC_UPDATE_CLAUSE_MASK \
47838 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
47839 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
47840 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
47841 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
47842 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
47843 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SELF) \
47844 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
47846 static tree
47848 {
47855 {
47857 "%<#pragma acc update%> must contain at least one "
47860 }
47868 }
47870 /* OpenACC 2.0:
47871 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
47873 LOC is the location of the #pragma token.
47874 */
47876 #define OACC_WAIT_CLAUSE_MASK \
47877 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
47879 static tree
47881 {
47895 }
47897 /* OpenMP 4.0:
47898 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
47900 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
47901 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
47902 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
47903 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
47904 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
47905 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
47906 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
47908 static void
47912 {
47914 cp_omp_declare_simd_data data;
47916 {
47924 /* It is safe to take the address of a local variable; it will only be
47925 used while this scope is live. */
47927 }
47929 {
47931 "%<#pragma omp declare %s%> followed by "
47936 }
47938 /* Store away all pragma tokens. */
47947 {
47951 {
47964 }
47969 "%<#pragma omp declare %s%> not immediately followed by "
47974 }
47975 }
47977 /* OpenMP 5.0:
47979 trait-selector:
47980 trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
47982 trait-score:
47983 score(score-expression)
47985 Note that this function returns a list of trait selectors for the
47986 trait-selector-set SET. */
47988 static tree
47991 {
47993 do
47994 {
47995 tree selector;
47999 else
48000 {
48003 }
48005 enum omp_ts_code sel
48009 {
48010 /* Per the spec, "Implementations can ignore specified selectors
48011 that are not those described in this section"; however, we
48012 must record such selectors because they cause match failures. */
48014 OPT_Wopenmp,
48024 {
48027 }
48028 else
48030 }
48038 tree t;
48041 {
48043 {
48047 }
48049 matching_parens parens;
48056 {
48063 {
48067 matching_parens parens2;
48076 "%<score%> cannot be specified in traits "
48080 {
48091 else
48093 }
48094 }
48095 else
48099 }
48102 {
48106 {
48110 properties);
48111 }
48112 else
48113 {
48116 }
48119 do
48120 {
48125 {
48128 }
48133 else
48134 {
48138 }
48144 else
48146 }
48151 /* FIXME: this is bogus, the expression need
48152 not be constant. */
48155 {
48162 else
48164 properties);
48165 }
48166 else
48171 {
48173 {
48175 "selector may not be specified in "
48178 }
48179 properties
48181 OMP_DECLARE_SIMD_CLAUSE_MASK,
48183 }
48185 {
48186 /* FIXME: The "requires" selector was added in OpenMP 5.1.
48187 Currently only the now-deprecated syntax
48188 from OpenMP 5.0 is supported. */
48192 }
48193 else
48198 }
48204 }
48208 {
48211 }
48217 else
48219 }
48223 }
48225 /* OpenMP 5.0:
48227 trait-set-selector[,trait-set-selector[,...]]
48229 trait-set-selector:
48230 trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
48232 trait-set-selector-name:
48233 constructor
48234 device
48235 implementation
48236 user */
48238 static tree
48241 {
48243 do
48244 {
48247 setp
48252 {
48255 }
48262 matching_braces braces;
48266 tree selectors
48269 {
48272 }
48280 else
48282 }
48288 }
48290 /* Assumption clauses:
48291 OpenMP 5.1
48292 absent (directive-name-list)
48293 contains (directive-name-list)
48294 holds (expression)
48295 no_openmp
48296 no_openmp_routines
48297 no_parallelism */
48299 static void
48302 {
48317 {
48330 {
48335 }
48337 {
48342 }
48344 {
48349 }
48351 {
48353 matching_parens parens;
48355 {
48367 }
48368 }
48370 {
48372 matching_parens parens;
48374 {
48375 do
48376 {
48379 location_t dloc
48382 {
48383 tree id;
48388 CPP_KEYWORD))
48389 {
48390 enum rid rid
48394 }
48395 else
48398 }
48401 else
48402 {
48415 else
48416 {
48421 "mentioned in both %<absent%> and "
48429 ? &absent_head
48432 "mentioned multiple times in %qs "
48439 }
48442 }
48445 else
48447 }
48454 }
48455 }
48457 {
48464 }
48465 else
48466 {
48470 }
48471 }
48473 }
48475 /* OpenMP 5.1
48476 # pragma omp assume clauses[optseq] new-line */
48478 static void
48480 {
48483 }
48485 /* OpenMP 5.1
48486 # pragma omp assumes clauses[optseq] new-line */
48488 static bool
48490 {
48493 }
48495 /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
48496 that into "omp declare variant base" attribute. */
48498 static tree
48500 tree attrs)
48501 {
48502 matching_parens parens;
48504 {
48505 fail:
48508 }
48513 cp_expr varid
48521 tree variant;
48528 else
48529 {
48530 tree ambiguous_decls;
48538 }
48542 {
48544 variant
48552 }
48567 {
48570 }
48582 {
48584 match_loc);
48593 }
48598 }
48601 /* Finalize #pragma omp declare simd clauses after direct declarator has
48602 been parsed, and put that into "omp declare simd" attribute. */
48604 static tree
48606 {
48612 {
48617 }
48622 {
48633 {
48636 pragma_tok);
48644 }
48645 else
48646 {
48648 attrs
48650 }
48652 }
48656 {
48662 {
48664 {
48671 {
48679 else
48682 }
48688 {
48690 "unknown OpenMP directive name in "
48695 }
48699 {
48701 "OpenMP directive other than %<declare simd%> "
48702 "or %<declare variant%> appertains to a "
48705 }
48708 {
48710 "mixing OpenMP directives with attribute and "
48713 }
48718 {
48721 }
48723 cp_token tok = {};
48731 tok = {};
48736 tok = {};
48748 /* Move the current source position to that of the first token
48749 in the new lexer. */
48759 {
48767 pragma_tok);
48771 cl);
48776 }
48777 else
48778 {
48780 attrs
48782 attrs);
48783 }
48786 }
48788 }
48789 else
48791 }
48797 }
48799 /* D should be DEFERRED_PARSE from omp::decl attribute. If it contains
48800 a threadprivate, groupprivate, allocate or declare target directive,
48801 return true and parse it for DECL. */
48803 bool
48805 {
48811 {
48819 else
48822 }
48828 {
48830 "unknown OpenMP directive name in "
48833 }
48835 /* && dir->id != PRAGMA_OMP_GROUPPRIVATE */
48849 cp_token tok = {};
48857 tok = {};
48862 tok = {};
48874 /* Move the current source position to that of the first token in the
48875 new lexer. */
48880 }
48882 /* Helper for cp_parser_omp_declare_target, handle one to or link clause
48883 on #pragma omp declare target. Return false if errors were reported. */
48885 static bool
48888 {
48891 tree id;
48893 {
48896 }
48897 else
48900 {
48903 "%qD specified both in declare target %<link%> and %qs"
48905 else
48907 "%qD specified both in declare target %<link%> and "
48910 }
48912 {
48919 {
48922 {
48926 }
48927 }
48928 }
48932 {
48936 {
48939 }
48940 }
48942 {
48946 {
48949 }
48950 }
48952 {
48956 {
48960 }
48961 }
48963 }
48965 /* OpenMP 4.0:
48966 # pragma omp declare target new-line
48967 declarations and definitions
48968 # pragma omp end declare target new-line
48970 OpenMP 4.5:
48971 # pragma omp declare target ( extended-list ) new-line
48973 # pragma omp declare target declare-target-clauses[seq] new-line */
48975 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
48976 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
48977 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \
48978 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
48979 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
48980 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
48982 static void
48984 {
48992 clauses
48997 {
48999 clauses);
49002 }
49003 else
49004 {
49005 cp_omp_declare_target_attr a
49010 }
49012 {
49017 }
49019 {
49034 }
49040 "%<device_type%> clause must specify 'any' when used with "
49042 }
49044 /* OpenMP 5.1
49045 # pragma omp begin assumes clauses[optseq] new-line
49047 # pragma omp begin declare target clauses[optseq] new-line */
49049 #define OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK \
49050 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \
49051 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT))
49053 static void
49055 {
49059 {
49062 }
49064 {
49068 {
49071 }
49073 {
49075 tree clauses
49077 OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK,
49079 pragma_tok);
49083 {
49088 }
49089 cp_omp_declare_target_attr a
49092 }
49093 else
49094 {
49097 }
49098 }
49100 {
49105 }
49106 else
49107 {
49110 }
49111 }
49113 /* OpenMP 4.0:
49114 # pragma omp end declare target new-line
49116 OpenMP 5.1:
49117 # pragma omp end assumes new-line */
49119 static void
49121 {
49125 {
49128 }
49130 {
49134 {
49137 }
49140 else
49141 {
49145 }
49149 "%<#pragma omp end declare target%> without corresponding "
49150 "%<#pragma omp declare target%> or "
49152 else
49153 {
49154 cp_omp_declare_target_attr
49157 {
49160 "%qs in attribute syntax terminated "
49165 else
49167 "%qs in pragma syntax terminated "
49172 }
49173 }
49174 }
49176 {
49183 else
49184 {
49185 cp_omp_begin_assumes_data
49188 {
49191 "%qs in attribute syntax terminated "
49194 else
49196 "%qs in pragma syntax terminated "
49199 }
49200 }
49201 }
49202 else
49203 {
49207 }
49208 }
49210 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
49211 expression and optional initializer clause of
49212 #pragma omp declare reduction. We store the expression(s) as
49213 either 3, 6 or 7 special statements inside of the artificial function's
49214 body. The first two statements are DECL_EXPRs for the artificial
49215 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
49216 expression that uses those variables.
49217 If there was any INITIALIZER clause, this is followed by further statements,
49218 the fourth and fifth statements are DECL_EXPRs for the artificial
49219 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
49220 constructor variant (first token after open paren is not omp_priv),
49221 then the sixth statement is a statement with the function call expression
49222 that uses the OMP_PRIV and optionally OMP_ORIG variable.
49223 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
49224 to initialize the OMP_PRIV artificial variable and there is seventh
49225 statement, a DECL_EXPR of the OMP_PRIV statement again. */
49227 static bool
49229 {
49241 tree combiner;
49262 {
49265 }
49268 {
49270 matching_parens parens;
49276 {
49279 }
49295 {
49299 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
49303 == CPP_CLOSE_PAREN
49306 {
49310 }
49316 }
49317 else
49318 {
49320 /* Don't create location wrapper nodes here. */
49321 auto_suppress_location_wrappers sentinel;
49336 {
49341 }
49343 tree arg;
49356 }
49369 }
49373 UNKNOWN_LOCATION);
49376 }
49378 /* OpenMP 4.0
49379 #pragma omp declare reduction (reduction-id : typename-list : expression) \
49380 initializer-clause[opt] new-line
49382 initializer-clause:
49383 initializer (omp_priv initializer)
49384 initializer (function-name (argument-list)) */
49386 static void
49389 {
49399 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
49406 {
49438 }
49450 /* Types may not be defined in declare reduction type list. */
49453 parser->type_definition_forbidden_message
49459 saved_colon_doesnt_start_class_def_p
49464 {
49468 ;
49486 else
49491 else
49493 }
49495 /* Restore the saved message. */
49498 parser->colon_doesnt_start_class_def_p
49503 {
49504 fail:
49507 }
49513 {
49514 tree fntype
49517 NULL_TREE);
49534 {
49538 }
49544 {
49547 }
49549 {
49551 {
49557 }
49564 }
49565 else
49566 {
49569 /* We should never meet a matched duplicate decl. */
49571 }
49576 else
49579 {
49582 }
49590 else
49591 {
49595 }
49600 {
49608 }
49616 }
49620 done:
49621 /* Free any declarators allocated. */
49623 }
49625 /* OpenMP 4.0
49626 #pragma omp declare simd declare-simd-clauses[optseq] new-line
49627 #pragma omp declare reduction (reduction-id : typename-list : expression) \
49628 initializer-clause[opt] new-line
49629 #pragma omp declare target new-line
49631 OpenMP 5.0
49632 #pragma omp declare variant (identifier) match (context-selector) */
49634 static bool
49637 {
49639 {
49644 {
49649 }
49651 {
49656 }
49659 {
49662 context);
49664 }
49666 {
49669 }
49671 {
49675 }
49676 }
49681 }
49683 /* OpenMP 5.0
49684 #pragma omp requires clauses[optseq] new-line */
49686 static bool
49688 {
49693 {
49699 {
49714 {
49717 matching_parens parens;
49719 {
49721 {
49726 this_req
49729 this_req
49732 this_req
49735 this_req
49738 this_req
49740 }
49742 {
49744 "expected %<acq_rel%>, %<acquire%>, "
49747 {
49754 CPP_CLOSE_PAREN))
49757 }
49758 }
49759 else
49766 /*consume_paren=*/
49770 {
49773 }
49774 }
49776 }
49777 else
49778 {
49780 "%<unified_shared_memory%>, "
49781 "%<dynamic_allocators%>, "
49782 "%<reverse_offload%> "
49786 }
49790 {
49792 {
49799 }
49801 {
49805 }
49808 {
49811 this_req
49813 (omp_requires_mask
49815 }
49819 "lexically after first %<atomic%> construct "
49822 omp_requires_mask
49825 }
49826 }
49828 }
49834 }
49837 /* OpenMP 5.1:
49838 #pragma omp nothing new-line */
49840 static void
49842 {
49844 }
49847 /* OpenMP 5.1
49848 #pragma omp error clauses[optseq] new-line */
49850 static bool
49853 {
49861 {
49874 };
49882 {
49885 }
49887 {
49892 }
49896 matching_parens parens;
49898 {
49900 {
49904 else
49906 tf_warning_or_error,
49907 LOOKUP_NORMAL);
49908 }
49909 else
49910 {
49912 {
49920 }
49922 {
49927 {
49934 CPP_CLOSE_PAREN))
49937 }
49938 }
49939 else
49941 }
49947 /*consume_paren=*/
49951 {
49953 {
49956 }
49957 else
49959 }
49961 {
49963 {
49966 }
49967 else
49969 }
49970 }
49971 else
49973 }
49983 {
49985 {
49989 }
49990 tree fndecl
49999 }
50006 {
50010 }
50014 else
50018 }
50020 /* OpenMP 4.5:
50021 #pragma omp taskloop taskloop-clause[optseq] new-line
50022 for-loop
50024 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
50025 for-loop */
50027 #define OMP_TASKLOOP_CLAUSE_MASK \
50028 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
50029 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
50030 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
50031 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
50032 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
50033 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
50034 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
50035 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
50036 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
50037 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
50038 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
50039 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
50040 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
50041 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
50042 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
50043 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
50044 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
50046 static tree
50050 {
50057 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
50058 clause. */
50063 {
50068 {
50092 }
50093 }
50095 {
50098 }
50103 {
50106 }
50113 if_p);
50119 }
50122 /* OpenACC 2.0:
50123 # pragma acc routine oacc-routine-clause[optseq] new-line
50124 function-definition
50126 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
50127 */
50129 #define OACC_ROUTINE_CLAUSE_MASK \
50130 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
50131 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
50132 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
50133 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
50134 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
50136 /* Parse the OpenACC routine pragma. This has an optional '( name )'
50137 component, which must resolve to a declared namespace-scope
50138 function. The clauses are either processed directly (for a named
50139 function), or defered until the immediatley following declaration
50140 is parsed. */
50142 static void
50145 {
50147 /* The checking for "another pragma following this one" in the "no optional
50148 '( name )'" case makes sure that we dont re-enter. */
50151 cp_oacc_routine_data data;
50157 /* It is safe to take the address of a local variable; it will only be
50158 used while this scope is live. */
50161 /* Look for optional '( name )'. */
50163 {
50164 matching_parens parens;
50167 /* We parse the name as an id-expression. If it resolves to
50168 anything other than a non-overloaded function at namespace
50169 scope, it's an error. */
50185 {
50189 }
50191 data.clauses
50195 /* The clauses are in reverse order; fix that to make later diagnostic
50196 emission easier. */
50202 {
50207 }
50209 /* Perhaps we should use the same rule as declarations in different
50210 namespaces? */
50212 {
50217 }
50220 {
50224 }
50228 }
50230 {
50231 /* Store away all pragma tokens. */
50239 /* Emit a helpful diagnostic if there's another pragma following this
50240 one. */
50242 {
50245 /* ..., and then just keep going. */
50247 }
50249 /* We only have to consider the pragma_external case here. */
50254 else
50257 }
50258 }
50260 /* Finalize #pragma acc routine clauses after direct declarator has
50261 been parsed. */
50263 static tree
50265 {
50270 {
50272 "%<#pragma acc routine%> not immediately followed by "
50275 }
50291 /* The clauses are in reverse order; fix that to make later diagnostic
50292 emission easier. */
50295 /* Later, cp_finalize_oacc_routine will process the clauses. */
50299 }
50301 /* Apply any saved OpenACC routine clauses to a just-parsed
50302 declaration. */
50304 static void
50306 {
50308 {
50309 /* Keep going if we're in error reporting mode. */
50315 {
50317 {
50319 "%<#pragma acc routine%> not immediately followed by"
50323 }
50327 }
50329 int compatible
50334 {
50337 }
50339 {
50340 }
50341 else
50342 {
50344 {
50353 }
50355 /* Set the routine's level of parallelism. */
50359 /* Add an "omp declare target" attribute. */
50364 }
50365 }
50366 }
50368 /* Main entry point to OpenMP statement pragmas. */
50370 static void
50372 {
50373 tree stmt;
50378 {
50406 if_p);
50426 if_p);
50431 if_p);
50436 if_p);
50441 if_p);
50446 if_p);
50451 if_p);
50463 if_p);
50477 if_p);
50482 if_p);
50489 }
50492 }
50493 \f
50494 /* Transactional Memory parsing routines. */
50496 /* Parse a transaction attribute.
50498 txn-attribute:
50499 attribute
50500 [ [ identifier ] ]
50502 We use this instead of cp_parser_attributes_opt for transactions to avoid
50503 the pedwarn in C++98 mode. */
50505 static tree
50507 {
50522 {
50526 /* For keywords, use the canonical spelling,
50527 not the parsed identifier. */
50531 }
50532 else
50536 error1:
50539 }
50541 /* Parse a __transaction_atomic or __transaction_relaxed statement.
50543 transaction-statement:
50544 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
50545 compound-statement
50546 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
50547 */
50549 static tree
50551 {
50562 else
50563 {
50567 }
50569 /* Parse a noexcept specification. */
50573 {
50574 /* cancel-and-throw is unimplemented. */
50577 }
50578 else
50580 CP_PARSER_FLAGS_NONE,
50585 /* Keep track if we're in the lexical scope of an outer transaction. */
50597 }
50599 /* Parse a __transaction_atomic or __transaction_relaxed expression.
50601 transaction-expression:
50602 __transaction_atomic txn-noexcept-spec[opt] ( expression )
50603 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
50604 */
50606 static tree
50608 {
50621 keyword == RID_TRANSACTION_RELAXED
50635 /* Set this early. This might mean that we allow transaction_cancel in
50636 an expression that we find out later actually has to be a constexpr.
50637 However, we expect that cxx_constant_value will be able to deal with
50638 this; also, if the noexcept has no constexpr, then what we parse next
50639 really is a transaction's body. */
50642 /* Parse a noexcept specification. */
50644 CP_PARSER_FLAGS_NONE,
50651 {
50652 matching_parens parens;
50659 }
50660 else
50661 {
50662 /* The only expression that is available got parsed for the noexcept
50663 already. noexcept is true then. */
50666 }
50675 }
50677 /* Parse a function-transaction-block.
50679 function-transaction-block:
50680 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
50681 function-body
50682 __transaction_atomic txn-attribute[opt] function-try-block
50683 __transaction_relaxed ctor-initializer[opt] function-body
50684 __transaction_relaxed function-try-block
50685 */
50687 static void
50689 {
50704 else
50705 {
50709 }
50717 else
50718 cp_parser_ctor_initializer_opt_and_function_body
50724 }
50726 /* Parse a __transaction_cancel statement.
50728 cancel-statement:
50729 __transaction_cancel txn-attribute[opt] ;
50730 __transaction_cancel txn-attribute[opt] throw-expression ;
50732 ??? Cancel and throw is not yet implemented. */
50734 static tree
50736 {
50742 RT_TRANSACTION_CANCEL);
50749 /* ??? Parse cancel-and-throw here. */
50754 {
50758 }
50760 {
50764 }
50766 {
50769 {
50775 }
50776 }
50778 {
50782 }
50788 }
50789 \f
50791 /* Special handling for the first token or line in the file. The first
50792 thing in the file might be #pragma GCC pch_preprocess, which loads a
50793 PCH file, which is a GC collection point. So we need to handle this
50794 first pragma without benefit of an existing lexer structure.
50796 Always returns one token to the caller in *FIRST_TOKEN. This is
50797 either the true first token of the file, or the first token after
50798 the initial pragma. */
50800 static void
50802 {
50810 {
50814 }
50816 /* Skip to the end of the pragma. */
50818 {
50821 do
50824 }
50826 /* Now actually load the PCH file. */
50830 /* Read one more token to return to our caller. We have to do this
50831 after reading the PCH file in, since its pointers have to be
50832 live. */
50834 }
50836 /* Parse a pragma GCC ivdep. */
50838 static bool
50840 {
50843 }
50845 /* Parse a pragma GCC unroll. */
50847 static tree
50849 {
50855 }
50857 /* Parse a pragma GCC novector. */
50859 static bool
50861 {
50864 }
50866 /* Normal parsing of a pragma token. Here we can (and must) use the
50867 regular lexer. */
50869 static bool
50871 {
50874 tree stmt;
50886 {
50892 }
50896 {
50904 {
50915 }
50920 {
50931 }
50936 {
50947 }
50952 {
50964 }
50969 {
50981 }
50986 {
50998 }
51017 {
51023 }
51031 {
51037 }
51045 {
51050 }
51056 {
51062 }
51070 {
51076 }
51118 {
51120 "%<#pragma omp requires%> may only be used at file or "
51124 }
51129 {
51131 "%<#pragma omp assumes%> may only be used at file or "
51135 }
51171 "%<#pragma omp scan%> may only be used in "
51177 "%<#pragma omp section%> may only be used in "
51184 {
51191 {
51203 }
51206 {
51209 pragma_str);
51211 }
51215 do
51216 {
51218 {
51220 {
51225 }
51227 {
51232 }
51234 {
51239 }
51243 }
51246 }
51253 {
51256 }
51259 }
51266 bad_stmt:
51269 }
51273 }
51275 /* Helper for pragma_lex in preprocess-only mode; in this mode, we have not
51276 populated the lexer with any tokens (the tokens rather being read by
51277 c-ppoutput.c's machinery), so we need to read enough tokens now to handle
51278 a pragma. */
51279 static void
51281 {
51286 /* Read the rest of the tokens comprising the pragma line. */
51288 do
51289 {
51296 }
51298 /* The interface the pragma parsers have to the lexer. */
51300 enum cpp_ttype
51302 {
51318 else
51319 {
51323 }
51326 }
51328 void
51330 {
51331 /* We have already read all the tokens, so we just need to discard
51332 them here. */
51336 }
51338 \f
51339 /* External interface. */
51341 /* Parse one entire translation unit. */
51343 void
51345 {
51353 /* cp_lexer_new_main is called before doing any GC allocation
51354 because tokenization might load a PCH file. */
51363 }
51365 /* Create an identifier for a generic parameter type (a synthesized
51366 template parameter implied by `auto' or a concept identifier). */
51369 static tree
51371 {
51375 }
51377 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
51378 (creating a new template parameter list if necessary). Returns the newly
51379 created template type parm. */
51381 static tree
51383 {
51384 /* A requires-clause is not a function and cannot have placeholders. */
51386 {
51389 }
51393 /* We are either continuing a function template that already contains implicit
51394 template parameters, creating a new fully-implicit function template, or
51395 extending an existing explicit function template with implicit template
51396 parameters. */
51404 {
51408 }
51409 else
51410 {
51411 /* Roll back to the existing template parameter scope (in the case of
51412 extending an explicit function template) or introduce a new template
51413 parameter scope ahead of the function parameter scope (or class scope
51414 in the case of out-of-line member definitions). The function scope is
51415 added back after template parameter synthesis below. */
51420 {
51423 }
51425 {
51426 /* If not defining a class, then any class scope is a scope level in
51427 an out-of-line member definition. In this case simply wind back
51428 beyond the first such scope to inject the template parameter list.
51429 Otherwise wind back to the class being defined. The latter can
51430 occur in class member friend declarations such as:
51432 class A {
51433 void foo (auto);
51434 };
51435 class B {
51436 friend void A::foo (auto);
51437 };
51439 The template parameter list synthesized for the friend declaration
51440 must be injected in the scope of 'B'. This can also occur in
51441 erroneous cases such as:
51443 struct A {
51444 struct B {
51445 void foo (auto);
51446 };
51447 void B::foo (auto) {}
51448 };
51450 Here the attempted definition of 'B::foo' within 'A' is ill-formed
51451 but, nevertheless, the template parameter list synthesized for the
51452 declarator should be injected into the scope of 'A' as if the
51453 ill-formed template was specified explicitly. */
51456 {
51459 }
51460 }
51466 {
51467 /* Introduce a new template parameter list for implicit template
51468 parameters. */
51472 parser->implicit_template_scope
51479 }
51480 else
51481 {
51482 /* Synthesize implicit template parameters at the end of the explicit
51483 template parameter list. */
51490 parser->implicit_template_parms
51492 }
51493 }
51495 /* Synthesize a new template parameter and track the current template
51496 parameter chain with implicit_template_parms. */
51502 /* Synthesize the type template parameter. */
51510 /* Attach the constraint to the parm before processing. */
51513 tree new_parm
51515 input_location,
51516 node,
51519 // Process_template_parm returns the list of parms, and
51520 // parser->implicit_template_parms holds the final node of the parm
51521 // list. We really want to manipulate the newly appended element.
51528 // Record the last implicit parm node
51531 /* Mark the synthetic declaration "virtual". This is used when
51532 comparing template-heads to determine if whether an abbreviated
51533 function template is equivalent to an explicit template.
51535 Note that DECL_ARTIFICIAL is used elsewhere for template
51536 parameters. */
51542 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
51545 /* If creating a fully implicit function template, start the new implicit
51546 template parameter list with this synthesized type, otherwise grow the
51547 current template parameter list. */
51550 {
51556 }
51557 else
51558 {
51563 }
51565 /* If the new parameter was constrained, we need to add that to the
51566 constraints in the template parameter list. */
51568 {
51572 }
51577 }
51579 /* Finish the declaration of a fully implicit function template. Such a
51580 template has no explicit template parameter list so has not been through the
51581 normal template head and tail processing. synthesize_implicit_template_parm
51582 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
51583 provided if the declaration is a class member such that its template
51584 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
51585 form is returned. Otherwise NULL_TREE is returned. */
51587 static tree
51589 {
51594 {
51598 }
51610 }
51612 /* Like finish_fully_implicit_template, but to be used in error
51613 recovery, rearranging scopes so that we restore the state we had
51614 before synthesize_implicit_template_parm inserted the implement
51615 template parms scope. */
51617 static void
51619 {
51624 {
51633 }
51634 else
51640 }
51642 /* Helper function for diagnostics that have complained about things
51643 being used with 'extern "C"' linkage.
51645 Attempt to issue a note showing where the 'extern "C"' linkage began. */
51647 void
51649 {
51653 }