| blob | 10d303884fbacc43d7fc8d6ffa3723821b41a945 |
1 /* -*- C++ -*- Parser.
2 Copyright (C) 2000-2022 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
51 \f
52 /* The lexer. */
54 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
55 and c-lex.cc) and the C++ parser. */
57 /* The various kinds of non integral constant we encounter. */
59 NIC_NONE,
60 /* floating-point literal */
61 NIC_FLOAT,
62 /* %<this%> */
63 NIC_THIS,
64 /* %<__FUNCTION__%> */
65 NIC_FUNC_NAME,
66 /* %<__PRETTY_FUNCTION__%> */
67 NIC_PRETTY_FUNC,
68 /* %<__func__%> */
69 NIC_C99_FUNC,
70 /* "%<va_arg%> */
71 NIC_VA_ARG,
72 /* a cast */
73 NIC_CAST,
74 /* %<typeid%> operator */
75 NIC_TYPEID,
76 /* non-constant compound literals */
77 NIC_NCC,
78 /* a function call */
79 NIC_FUNC_CALL,
80 /* an increment */
81 NIC_INC,
82 /* an decrement */
83 NIC_DEC,
84 /* an array reference */
85 NIC_ARRAY_REF,
86 /* %<->%> */
87 NIC_ARROW,
88 /* %<.%> */
89 NIC_POINT,
90 /* the address of a label */
91 NIC_ADDR_LABEL,
92 /* %<*%> */
93 NIC_STAR,
94 /* %<&%> */
95 NIC_ADDR,
96 /* %<++%> */
97 NIC_PREINCREMENT,
98 /* %<--%> */
99 NIC_PREDECREMENT,
100 /* %<new%> */
101 NIC_NEW,
102 /* %<delete%> */
103 NIC_DEL,
104 /* calls to overloaded operators */
105 NIC_OVERLOADED,
106 /* an assignment */
107 NIC_ASSIGNMENT,
108 /* a comma operator */
109 NIC_COMMA,
110 /* a call to a constructor */
111 NIC_CONSTRUCTOR,
112 /* a transaction expression */
113 NIC_TRANSACTION
114 };
116 /* The various kinds of errors about name-lookup failing. */
118 /* NULL */
119 NLE_NULL,
120 /* is not a type */
121 NLE_TYPE,
122 /* is not a class or namespace */
123 NLE_CXX98,
124 /* is not a class, namespace, or enumeration */
125 NLE_NOT_CXX98
126 };
128 /* The various kinds of required token */
130 RT_NONE,
152 /* The type is CPP_KEYWORD */
184 RT_CO_YIELD /* co_yield */
185 };
187 /* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
188 reverting it on destruction. */
190 class type_id_in_expr_sentinel
191 {
201 };
203 /* Prototypes. */
209 static void cp_lexer_destroy
211 static int cp_lexer_saving_tokens
215 static void cp_lexer_get_preprocessor_token
223 static bool cp_lexer_next_token_is_not
225 static bool cp_lexer_next_token_is_keyword
229 static void cp_lexer_purge_token
231 static void cp_lexer_purge_tokens_after
233 static void cp_lexer_save_tokens
235 static void cp_lexer_commit_tokens
237 static void cp_lexer_rollback_tokens
239 static void cp_lexer_print_token
243 static void cp_lexer_start_debugging
245 static void cp_lexer_stop_debugging
250 static tree cp_parser_late_noexcept_specifier
252 static void noexcept_override_late_checks
255 static void cp_parser_initial_pragma
258 static bool cp_parser_omp_declare_reduction_exprs
260 static void cp_finalize_oacc_routine
263 /* Manifest constants. */
264 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
265 #define CP_SAVED_TOKEN_STACK 5
267 /* Variables. */
269 /* The stream to which debugging output should be written. */
272 /* Nonzero if we are parsing an unevaluated operand: an operand to
273 sizeof, typeof, or alignof. */
276 /* Dump up to NUM tokens in BUFFER to FILE starting with token
277 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
278 first token in BUFFER. If NUM is 0, dump all the tokens. If
279 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
280 highlighted by surrounding it in [[ ]]. */
282 static void
286 {
303 {
306 }
311 {
318 nprinted++;
328 {
338 }
339 }
342 {
345 }
348 }
351 /* Dump all tokens in BUFFER to stderr. */
353 void
355 {
357 }
359 DEBUG_FUNCTION void
361 {
363 }
365 DEBUG_FUNCTION void
367 {
370 else
372 }
375 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
376 description for T. */
378 static void
380 {
382 {
385 }
386 }
389 /* Dump parser context C to FILE. */
391 static void
393 {
398 }
401 /* Print the stack of parsing contexts to FILE starting with FIRST. */
403 static void
405 {
411 {
414 }
415 }
418 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
420 static void
422 {
425 }
428 /* Print an unparsed function entry UF to FILE. */
430 static void
432 {
435 tree fn;
440 i++)
441 {
447 }
452 {
455 }
461 {
464 }
466 }
469 /* Print the stack of unparsed member functions S to FILE. */
471 static void
474 {
480 {
483 }
484 }
487 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
488 the given PARSER. If FILE is NULL, the output is printed on stderr. */
490 static void
492 {
504 next_token);
505 }
508 /* Dump debugging information for the given PARSER. If FILE is NULL,
509 the output is printed on stderr. */
511 void
513 {
516 expanded_location eloc;
581 parser->type_definition_forbidden_message_arg
597 }
599 DEBUG_FUNCTION void
601 {
603 }
605 DEBUG_FUNCTION void
607 {
610 else
612 }
614 /* Allocate memory for a new lexer object and return it. */
618 {
619 /* Allocate the memory. */
622 /* Initially we are not debugging. */
627 /* Create the buffer. */
631 }
633 /* Return TRUE if token is the start of a module declaration that will be
634 terminated by a CPP_PRAGMA_EOL token. */
637 {
641 }
643 /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
644 PRAGMA_NONE. */
646 static enum pragma_kind
648 {
651 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
653 }
655 /* Handle early pragmas such as #pragma GCC diagnostic, which needs to be done
656 during preprocessing for the case of preprocessing-related diagnostics. This
657 is called immediately after pushing the CPP_PRAGMA_EOL token onto
658 lexer->buffer. */
660 static void
662 {
666 /* Back up to the start of the pragma so pragma_lex () can parse it when
667 c-pragma lib asks it to. */
671 {
676 }
682 /* Dispatch it. */
683 const unsigned int id
688 /* Reset to normal state. */
690 }
692 /* The parser. */
696 /* Create a new main C++ lexer, the lexer that gets tokens from the
697 preprocessor, and also create the main parser. */
701 {
702 cp_token token;
704 /* It's possible that parsing the first pragma will load a PCH file,
705 which is a GC collection point. So we have to do that before
706 allocating any memory. */
712 /* Put the first token in the buffer. */
719 /* Create the parser now, so we can use it to handle early pragmas. */
723 /* Get the remaining tokens from the preprocessor. */
725 {
727 /* Process the previous token. */
731 /* Check for early pragmas that need to be handled now. */
737 }
745 {
746 /* Set the EOF token's location to be the just after the previous
747 token's range. That way 'at-eof' diagnostics point at something
748 meaninful. */
752 }
757 /* Subsequent preprocessor diagnostics should use compiler
758 diagnostic functions to get the compiler source location. */
765 }
767 /* Create a new lexer whose token stream is primed with the tokens in
768 CACHE. When these tokens are exhausted, no new tokens will be read. */
772 {
777 /* We do not own the buffer. */
780 /* Insert an EOF token. */
791 /* Initially we are not debugging. */
797 }
799 /* Frees all resources associated with LEXER. */
801 static void
803 {
806 else
807 {
808 /* Restore the token we overwrite with EOF. */
811 }
814 }
816 /* This needs to be set to TRUE before the lexer-debugging infrastructure can
817 be used. The point of this flag is to help the compiler to fold away calls
818 to cp_lexer_debugging_p within this source file at compile time, when the
819 lexer is not being debugged. */
821 #define LEXER_DEBUGGING_ENABLED_P false
823 /* Returns nonzero if debugging information should be output. */
827 {
832 }
837 {
839 }
843 {
845 }
849 {
851 }
855 {
857 }
861 {
864 /* Skip past purged tokens. */
866 {
868 tp--;
869 }
872 }
874 /* Same as above, but return NULL when the lexer doesn't own the token
875 buffer or if the next_token is at the start of the token
876 vector or if all previous tokens are purged. */
880 {
883 {
886 /* Skip past purged tokens. */
888 {
891 tp--;
892 }
894 }
897 }
899 /* Overload for make_location, taking the lexer to mean the location of the
900 previous token. */
904 {
907 }
909 /* Overload for make_location taking tokens instead of locations. */
913 {
915 }
917 /* nonzero if we are presently saving tokens. */
921 {
923 }
925 /* Store the next token from the preprocessor in *TOKEN. Return true
926 if we reach EOF. If LEXER is NULL, assume we are handling an
927 initial #pragma pch_preprocess, and thus want the lexer to return
928 processed strings.
930 Diagnostics issued from this function must have their controlling option (if
931 any) in c.opt annotated as a libcpp option via the CppReason property. */
933 static void
935 {
938 /* Get a new token from the preprocessor. */
939 token->type
941 flags);
946 /* Usually never see a zero, but just in case ... */
949 /* On some systems, some header files are surrounded by an
950 implicit extern "C" block. Set a flag in the token if it
951 comes from such a header. */
956 /* Check to see if this token is a keyword. */
958 {
960 {
961 /* Mark this token as a keyword. */
963 /* Record which keyword. */
965 }
966 else
967 {
971 /* These are outside the CXX11 range. */
975 {
976 /* Warn about the C++11 keyword (but still treat it as
977 an identifier). */
982 /* Clear out the C_RID_CODE so we don't warn about this
983 particular identifier-turned-keyword again. */
985 }
989 {
990 /* Warn about the C++20 keyword (but still treat it as
991 an identifier). */
996 /* Clear out the C_RID_CODE so we don't warn about this
997 particular identifier-turned-keyword again. */
999 }
1002 }
1003 }
1005 {
1006 /* This only happens in Objective-C++; it must be a keyword. */
1009 {
1010 /* Replace 'class' with '@class', 'private' with '@private',
1011 etc. This prevents confusion with the C++ keyword
1012 'class', and makes the tokens consistent with other
1013 Objective-C 'AT' keywords. For example '@class' is
1014 reported as RID_AT_CLASS which is consistent with
1015 '@synchronized', which is reported as
1016 RID_AT_SYNCHRONIZED.
1017 */
1027 }
1028 }
1029 }
1031 /* Update the globals input_location and the input file stack from TOKEN. */
1034 {
1036 }
1038 /* Update the globals input_location and the input file stack from LEXER. */
1041 {
1044 }
1046 /* Return a pointer to the next token in the token stream, but do not
1047 consume it. */
1051 {
1053 {
1057 }
1059 }
1061 /* Return true if the next token has the indicated TYPE. */
1065 {
1067 }
1069 /* Return true if the next token does not have the indicated TYPE. */
1073 {
1075 }
1077 /* Return true if the next token is the indicated KEYWORD. */
1081 {
1083 }
1087 {
1089 }
1093 {
1095 }
1097 /* Return true if KEYWORD can start a decl-specifier. */
1099 bool
1101 {
1103 {
1104 /* auto specifier: storage-class-specifier in C++,
1105 simple-type-specifier in C++0x. */
1107 /* Storage classes. */
1113 /* Elaborated type specifiers. */
1119 /* Simple type specifiers. */
1133 CASE_RID_FLOATN_NX:
1135 /* CV qualifiers. */
1138 /* Function specifiers. */
1141 /* friend/typdef/inline specifiers. */
1145 /* GNU extensions. */
1147 /* C++11 extensions. */
1150 /* C++20 extensions. */
1155 #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
1156 case RID_##CODE:
1158 #undef DEFTRAIT_TYPE
1167 }
1168 }
1170 /* Return true if the next token is a keyword for a decl-specifier. */
1172 static bool
1174 {
1179 }
1181 /* Returns TRUE iff the token T begins a decltype type. */
1183 static bool
1185 {
1188 }
1190 /* Returns TRUE iff the next token begins a decltype type. */
1192 static bool
1194 {
1197 }
1199 /* Called when processing a token with tree_check_value; perform or defer the
1200 associated checks and return the value. */
1202 static tree
1204 {
1205 /* Perform any access checks that were deferred. */
1210 {
1216 }
1217 /* Return the stored value. */
1219 }
1221 /* Return a pointer to the Nth token in the token stream. If N is 1,
1222 then this is precisely equivalent to cp_lexer_peek_token (except
1223 that it is not inline). One would like to disallow that case, but
1224 there is one case (cp_parser_nth_token_starts_template_id) where
1225 the caller passes a variable for N and it might be 1. */
1229 {
1232 /* N is 1-based, not zero-based. */
1242 {
1246 }
1249 {
1252 }
1255 }
1257 /* Return the next token, and advance the lexer's next_token pointer
1258 to point to the next non-purged token. */
1262 {
1265 do
1266 {
1269 }
1274 /* Provide debugging output. */
1276 {
1280 }
1283 }
1285 /* Permanently remove the next token from the token stream, and
1286 advance the next_token pointer to refer to the next non-purged
1287 token. */
1289 static void
1291 {
1300 do
1301 tok++;
1304 }
1306 /* Permanently remove all tokens after TOK, up to, but not
1307 including, the token that will be returned next by
1308 cp_lexer_peek_token. */
1310 static void
1312 {
1318 {
1323 }
1324 }
1326 /* Begin saving tokens. All tokens consumed after this point will be
1327 preserved. */
1329 static void
1331 {
1332 /* Provide debugging output. */
1337 }
1339 /* Commit to the portion of the token stream most recently saved. */
1341 static void
1343 {
1344 /* Provide debugging output. */
1349 }
1351 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1352 to the token stream. Stop saving tokens. */
1354 static void
1356 {
1357 /* Provide debugging output. */
1362 }
1364 /* Determines what saved_token_sentinel does when going out of scope. */
1367 STS_COMMIT,
1368 STS_ROLLBACK,
1369 STS_DONOTHING
1370 };
1372 /* RAII wrapper around the above functions, with sanity checking (the token
1373 stream should be the same at the point of instantiation as it is at the
1374 point of destruction).
1376 Creating a variable saves tokens. MODE determines what happens when the
1377 object is destroyed. STS_COMMIT commits tokens (default),
1378 STS_ROLLBACK rolls-back and STS_DONOTHING does nothing. Calling
1379 rollback() will immediately roll-back tokens and set MODE to
1380 STS_DONOTHING. */
1382 struct saved_token_sentinel
1383 {
1386 saved_token_sentinel_mode mode;
1390 {
1393 }
1395 {
1397 cp_lexer_set_source_position_from_token
1400 }
1402 {
1409 }
1410 };
1412 /* Print a representation of the TOKEN on the STREAM. */
1414 static void
1416 {
1417 /* We don't use cpp_type2name here because the parser defines
1418 a few tokens of its own. */
1420 /* cpplib-defined token types */
1421 #define OP(e, s) #e,
1422 #define TK(e, s) #e,
1423 TTYPE_TABLE
1424 #undef OP
1425 #undef TK
1426 /* C++ parser token types - see "Manifest constants", above. */
1430 };
1432 /* For some tokens, print the associated data. */
1434 {
1436 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1437 For example, `struct' is mapped to an INTEGER_CST. */
1440 /* fall through */
1458 /* If we have a name for the token, print it out. Otherwise, we
1459 simply give the numeric code. */
1462 else
1465 }
1466 }
1468 DEBUG_FUNCTION void
1470 {
1473 }
1475 DEBUG_FUNCTION void
1477 {
1480 else
1482 }
1485 /* Start emitting debugging information. */
1487 static void
1489 {
1496 }
1498 /* Stop emitting debugging information. */
1500 static void
1502 {
1509 }
1511 /* Create a new cp_token_cache, representing a range of tokens. */
1515 {
1520 }
1522 /* Diagnose if #pragma omp declare simd isn't followed immediately
1523 by function declaration or definition. */
1527 {
1529 {
1534 }
1535 }
1537 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1538 and put that into "omp declare simd" attribute. */
1542 {
1544 {
1546 {
1549 }
1551 {
1554 }
1555 }
1556 }
1558 /* Similarly, but for use in declaration parsing functions
1559 which call cp_parser_handle_directive_omp_attributes. */
1563 {
1570 "%<declare %s%> directive not immediately followed by "
1574 }
1576 /* Diagnose if #pragma acc routine isn't followed immediately by function
1577 declaration or definition. */
1581 {
1583 {
1585 "%<#pragma acc routine%> not immediately followed by "
1588 }
1589 }
1590 \f
1591 /* Decl-specifiers. */
1593 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1595 static void
1597 {
1599 }
1601 /* Declarators. */
1603 /* Nothing other than the parser should be creating declarators;
1604 declarators are a semi-syntactic representation of C++ entities.
1605 Other parts of the front end that need to create entities (like
1606 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1620 /* An erroneous declarator. */
1623 /* The obstack on which declarators and related data structures are
1624 allocated. */
1627 /* Alloc BYTES from the declarator memory pool. */
1631 {
1633 }
1635 /* Allocate a declarator of the indicated KIND. Clear fields that are
1636 common to all declarators. */
1640 {
1654 }
1656 /* Make a declarator for a generalized identifier. If
1657 QUALIFYING_SCOPE is non-NULL, the identifier is
1658 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1659 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1660 is, if any. */
1665 {
1668 /* It is valid to write:
1670 class C { void f(); };
1671 typedef C D;
1672 void D::f();
1674 The standard is not clear about whether `typedef const C D' is
1675 legal; as of 2002-09-15 the committee is considering that
1676 question. EDG 3.0 allows that syntax. Therefore, we do as
1677 well. */
1692 }
1694 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1695 of modifiers such as const or volatile to apply to the pointer
1696 type, represented as identifiers. ATTRIBUTES represent the attributes that
1697 appertain to the pointer or reference. */
1699 cp_declarator *
1701 tree attributes)
1702 {
1710 {
1714 }
1715 else
1721 }
1723 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1724 represent the attributes that appertain to the pointer or
1725 reference. */
1727 cp_declarator *
1730 {
1738 {
1742 }
1743 else
1749 }
1751 /* Like make_pointer_declarator -- but for a pointer to a non-static
1752 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1753 appertain to the pointer or reference. */
1755 cp_declarator *
1758 tree attributes)
1759 {
1768 {
1771 }
1772 else
1778 }
1780 /* Make a declarator for the function given by TARGET, with the
1781 indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1782 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1783 indicates what exceptions can be thrown. */
1785 cp_declarator *
1787 tree parms,
1788 cp_cv_quals cv_qualifiers,
1789 cp_virt_specifiers virt_specifiers,
1790 cp_ref_qualifier ref_qualifier,
1791 tree tx_qualifier,
1792 tree exception_specification,
1793 tree late_return_type,
1794 tree requires_clause,
1795 location_t parens_loc)
1796 {
1811 {
1815 }
1816 else
1820 }
1822 /* Make a declarator for an array of BOUNDS elements, each of which is
1823 defined by ELEMENT. */
1825 cp_declarator *
1827 {
1834 {
1838 }
1839 else
1843 }
1845 /* Determine whether the declarator we've seen so far can be a
1846 parameter pack, when followed by an ellipsis. */
1847 static bool
1849 {
1851 /* We already saw an ellipsis. */
1854 /* Search for a declarator name, or any other declarator that goes
1855 after the point where the ellipsis could appear in a parameter
1856 pack. If we find any of these, then this declarator cannot be
1857 made into a parameter pack. */
1860 {
1862 {
1875 }
1876 }
1879 }
1883 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1884 DECLARATOR and DEFAULT_ARGUMENT. */
1886 cp_parameter_declarator *
1889 tree default_argument,
1890 location_t loc,
1892 {
1900 else
1908 }
1910 /* Returns true iff DECLARATOR is a declaration for a function. */
1912 static bool
1914 {
1916 {
1925 }
1927 }
1929 /* The parser. */
1931 /* Overview
1932 --------
1934 A cp_parser parses the token stream as specified by the C++
1935 grammar. Its job is purely parsing, not semantic analysis. For
1936 example, the parser breaks the token stream into declarators,
1937 expressions, statements, and other similar syntactic constructs.
1938 It does not check that the types of the expressions on either side
1939 of an assignment-statement are compatible, or that a function is
1940 not declared with a parameter of type `void'.
1942 The parser invokes routines elsewhere in the compiler to perform
1943 semantic analysis and to build up the abstract syntax tree for the
1944 code processed.
1946 The parser (and the template instantiation code, which is, in a
1947 way, a close relative of parsing) are the only parts of the
1948 compiler that should be calling push_scope and pop_scope, or
1949 related functions. The parser (and template instantiation code)
1950 keeps track of what scope is presently active; everything else
1951 should simply honor that. (The code that generates static
1952 initializers may also need to set the scope, in order to check
1953 access control correctly when emitting the initializers.)
1955 Methodology
1956 -----------
1958 The parser is of the standard recursive-descent variety. Upcoming
1959 tokens in the token stream are examined in order to determine which
1960 production to use when parsing a non-terminal. Some C++ constructs
1961 require arbitrary look ahead to disambiguate. For example, it is
1962 impossible, in the general case, to tell whether a statement is an
1963 expression or declaration without scanning the entire statement.
1964 Therefore, the parser is capable of "parsing tentatively." When the
1965 parser is not sure what construct comes next, it enters this mode.
1966 Then, while we attempt to parse the construct, the parser queues up
1967 error messages, rather than issuing them immediately, and saves the
1968 tokens it consumes. If the construct is parsed successfully, the
1969 parser "commits", i.e., it issues any queued error messages and
1970 the tokens that were being preserved are permanently discarded.
1971 If, however, the construct is not parsed successfully, the parser
1972 rolls back its state completely so that it can resume parsing using
1973 a different alternative.
1975 Future Improvements
1976 -------------------
1978 The performance of the parser could probably be improved substantially.
1979 We could often eliminate the need to parse tentatively by looking ahead
1980 a little bit. In some places, this approach might not entirely eliminate
1981 the need to parse tentatively, but it might still speed up the average
1982 case. */
1984 /* Flags that are passed to some parsing functions. These values can
1985 be bitwise-ored together. */
1987 enum
1988 {
1989 /* No flags. */
1991 /* The construct is optional. If it is not present, then no error
1992 should be issued. */
1994 /* When parsing a type-specifier, treat user-defined type-names
1995 as non-type identifiers. */
1997 /* When parsing a type-specifier, do not try to parse a class-specifier
1998 or enum-specifier. */
2000 /* When parsing a decl-specifier-seq, only allow type-specifier or
2001 constexpr. */
2003 /* When parsing a decl-specifier-seq, only allow mutable, constexpr or
2004 for C++20 consteval or for C++23 static. */
2006 /* When parsing a decl-specifier-seq, allow missing typename. */
2008 /* When parsing of the noexcept-specifier should be delayed. */
2010 /* When parsing a consteval declarator. */
2012 };
2014 /* This type is used for parameters and variables which hold
2015 combinations of the above flags. */
2018 /* The different kinds of declarators we want to parse. */
2020 enum cp_parser_declarator_kind
2021 {
2022 /* We want an abstract declarator. */
2023 CP_PARSER_DECLARATOR_ABSTRACT,
2024 /* We want a named declarator. */
2025 CP_PARSER_DECLARATOR_NAMED,
2026 /* We don't mind, but the name must be an unqualified-id. */
2027 CP_PARSER_DECLARATOR_EITHER
2028 };
2030 /* The precedence values used to parse binary expressions. The minimum value
2031 of PREC must be 1, because zero is reserved to quickly discriminate
2032 binary operators from other tokens. */
2034 enum cp_parser_prec
2035 {
2036 PREC_NOT_OPERATOR,
2037 PREC_LOGICAL_OR_EXPRESSION,
2038 PREC_LOGICAL_AND_EXPRESSION,
2039 PREC_INCLUSIVE_OR_EXPRESSION,
2040 PREC_EXCLUSIVE_OR_EXPRESSION,
2041 PREC_AND_EXPRESSION,
2042 PREC_EQUALITY_EXPRESSION,
2043 PREC_RELATIONAL_EXPRESSION,
2044 PREC_SPACESHIP_EXPRESSION,
2045 PREC_SHIFT_EXPRESSION,
2046 PREC_ADDITIVE_EXPRESSION,
2047 PREC_MULTIPLICATIVE_EXPRESSION,
2048 PREC_PM_EXPRESSION,
2049 NUM_PREC_VALUES = PREC_PM_EXPRESSION
2050 };
2052 /* A mapping from a token type to a corresponding tree node type, with a
2053 precedence value. */
2055 struct cp_parser_binary_operations_map_node
2056 {
2057 /* The token type. */
2059 /* The corresponding tree code. */
2061 /* The precedence of this operator. */
2063 };
2065 struct cp_parser_expression_stack_entry
2066 {
2067 /* Left hand side of the binary operation we are currently
2068 parsing. */
2069 cp_expr lhs;
2070 /* Original tree code for left hand side, if it was a binary
2071 expression itself (used for -Wparentheses). */
2073 /* Tree code for the binary operation we are parsing. */
2075 /* Precedence of the binary operation we are parsing. */
2077 /* Location of the binary operation we are parsing. */
2078 location_t loc;
2079 /* Flags from the operator token. */
2081 };
2083 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
2084 entries because precedence levels on the stack are monotonically
2085 increasing. */
2089 /* Prototypes. */
2091 /* Constructors and destructors. */
2096 /* Class variables. */
2100 /* The operator-precedence table used by cp_parser_binary_expression.
2101 Transformed into an associative array (binops_by_token) by
2102 cp_parser_new. */
2137 };
2139 /* The same as binops, but initialized by cp_parser_new so that
2140 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
2141 for speed. */
2144 /* Constructors and destructors. */
2146 /* Construct a new context. The context below this one on the stack
2147 is given by NEXT. */
2151 {
2154 /* Allocate the storage. */
2156 {
2157 /* Pull the first entry from the free list. */
2161 }
2162 else
2165 /* No errors have occurred yet in this context. */
2167 /* If this is not the bottommost context, copy information that we
2168 need from the previous context. */
2170 {
2171 /* If, in the NEXT context, we are parsing an `x->' or `x.'
2172 expression, then we are parsing one in this context, too. */
2174 /* Thread the stack. */
2176 }
2179 }
2181 /* Managing the unparsed function queues. */
2183 #define unparsed_funs_with_default_args \
2184 parser->unparsed_queues->last ().funs_with_default_args
2185 #define unparsed_funs_with_definitions \
2186 parser->unparsed_queues->last ().funs_with_definitions
2187 #define unparsed_nsdmis \
2188 parser->unparsed_queues->last ().nsdmis
2189 #define unparsed_noexcepts \
2190 parser->unparsed_queues->last ().noexcepts
2192 static void
2194 {
2197 }
2199 static void
2201 {
2204 }
2206 /* Prototypes. */
2208 /* Routines to parse various constructs.
2210 Those that return `tree' will return the error_mark_node (rather
2211 than NULL_TREE) if a parse error occurs, unless otherwise noted.
2212 Sometimes, they will return an ordinary node if error-recovery was
2213 attempted, even though a parse error occurred. So, to check
2214 whether or not a parse error occurred, you should always use
2215 cp_parser_error_occurred. If the construct is optional (indicated
2216 either by an `_opt' in the name of the function that does the
2217 parsing or via a FLAGS parameter), then NULL_TREE is returned if
2218 the construct is not present. */
2220 /* Lexical conventions [gram.lex] */
2222 static cp_expr cp_parser_identifier
2224 static cp_expr cp_parser_string_literal
2226 static cp_expr cp_parser_userdef_char_literal
2228 static tree cp_parser_userdef_string_literal
2230 static cp_expr cp_parser_userdef_numeric_literal
2233 /* Basic concepts [gram.basic] */
2237 /* Expressions [gram.expr] */
2239 static cp_expr cp_parser_primary_expression
2241 static cp_expr cp_parser_id_expression
2243 static cp_expr cp_parser_unqualified_id
2245 static tree cp_parser_nested_name_specifier_opt
2247 static tree cp_parser_nested_name_specifier
2249 static tree cp_parser_qualifying_entity
2251 static cp_expr cp_parser_postfix_expression
2253 static tree cp_parser_postfix_open_square_expression
2255 static tree cp_parser_postfix_dot_deref_expression
2260 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2262 static void cp_parser_pseudo_destructor_name
2264 static cp_expr cp_parser_unary_expression
2266 static enum tree_code cp_parser_unary_operator
2268 static tree cp_parser_has_attribute_expression
2270 static tree cp_parser_new_expression
2274 static tree cp_parser_new_type_id
2282 static tree cp_parser_delete_expression
2284 static cp_expr cp_parser_cast_expression
2286 static cp_expr cp_parser_binary_expression
2288 static tree cp_parser_question_colon_clause
2291 static cp_expr cp_parser_assignment_expression
2293 static enum tree_code cp_parser_assignment_operator_opt
2295 static cp_expr cp_parser_expression
2297 static cp_expr cp_parser_constant_expression
2299 static cp_expr cp_parser_builtin_offsetof
2301 static cp_expr cp_parser_lambda_expression
2303 static void cp_parser_lambda_introducer
2305 static bool cp_parser_lambda_declarator_opt
2307 static void cp_parser_lambda_body
2310 /* Statements [gram.stmt.stmt] */
2312 static void cp_parser_statement
2314 static void cp_parser_label_for_labeled_statement
2316 static tree cp_parser_expression_statement
2318 static tree cp_parser_compound_statement
2320 static void cp_parser_statement_seq_opt
2322 static tree cp_parser_selection_statement
2324 static tree cp_parser_condition
2326 static tree cp_parser_iteration_statement
2328 static bool cp_parser_init_statement
2330 static tree cp_parser_for
2332 static tree cp_parser_c_for
2334 static tree cp_parser_range_for
2336 static void do_range_for_auto_deduction
2338 static tree cp_parser_perform_range_for_lookup
2340 static tree cp_parser_range_for_member_function
2342 static tree cp_parser_jump_statement
2344 static void cp_parser_declaration_statement
2347 static tree cp_parser_implicitly_scoped_statement
2349 static void cp_parser_already_scoped_statement
2352 /* State of module-declaration parsing. */
2353 enum module_parse
2354 {
2357 _MP_UNUSED,
2367 };
2369 static module_parse cp_parser_module_declaration
2371 static void cp_parser_import_declaration
2374 /* Declarations [gram.dcl.dcl] */
2376 static void cp_parser_declaration_seq_opt
2378 static void cp_parser_declaration
2380 static void cp_parser_toplevel_declaration
2382 static void cp_parser_block_declaration
2384 static void cp_parser_simple_declaration
2386 static void cp_parser_decl_specifier_seq
2388 static tree cp_parser_storage_class_specifier_opt
2390 static tree cp_parser_function_specifier_opt
2392 static tree cp_parser_type_specifier
2395 static tree cp_parser_simple_type_specifier
2397 static tree cp_parser_placeholder_type_specifier
2399 static tree cp_parser_type_name
2401 static tree cp_parser_nonclass_name
2403 static tree cp_parser_elaborated_type_specifier
2405 static tree cp_parser_enum_specifier
2407 static void cp_parser_enumerator_list
2409 static void cp_parser_enumerator_definition
2411 static tree cp_parser_namespace_name
2413 static void cp_parser_namespace_definition
2415 static void cp_parser_namespace_body
2417 static tree cp_parser_qualified_namespace_specifier
2419 static void cp_parser_namespace_alias_definition
2421 static bool cp_parser_using_declaration
2423 static void cp_parser_using_directive
2425 static void cp_parser_using_enum
2427 static tree cp_parser_alias_declaration
2429 static void cp_parser_asm_definition
2431 static void cp_parser_linkage_specification
2433 static void cp_parser_static_assert
2435 static tree cp_parser_decltype
2437 static tree cp_parser_decomposition_declaration
2440 /* Declarators [gram.dcl.decl] */
2442 static tree cp_parser_init_declarator
2452 static enum tree_code cp_parser_ptr_operator
2454 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2456 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2458 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2460 static tree cp_parser_tx_qualifier_opt
2462 static tree cp_parser_late_return_type_opt
2464 static tree cp_parser_declarator_id
2466 static tree cp_parser_type_id
2468 static tree cp_parser_template_type_arg
2471 static tree cp_parser_type_id_1
2473 static void cp_parser_type_specifier_seq
2475 static tree cp_parser_parameter_declaration_clause
2477 static tree cp_parser_parameter_declaration_list
2481 static tree cp_parser_default_argument
2483 static void cp_parser_function_body
2485 static tree cp_parser_initializer
2487 static cp_expr cp_parser_initializer_clause
2489 static cp_expr cp_parser_braced_list
2494 static void cp_parser_ctor_initializer_opt_and_function_body
2497 static tree cp_parser_late_parsing_omp_declare_simd
2500 static tree cp_parser_late_parsing_oacc_routine
2503 static tree synthesize_implicit_template_parm
2505 static tree finish_fully_implicit_template
2507 static void abort_fully_implicit_template
2510 /* Classes [gram.class] */
2512 static tree cp_parser_class_name
2514 static tree cp_parser_class_specifier
2516 static tree cp_parser_class_head
2518 static enum tag_types cp_parser_class_key
2520 static void cp_parser_type_parameter_key
2522 static void cp_parser_member_specification_opt
2524 static void cp_parser_member_declaration
2526 static tree cp_parser_pure_specifier
2528 static tree cp_parser_constant_initializer
2531 /* Derived classes [gram.class.derived] */
2533 static tree cp_parser_base_clause
2535 static tree cp_parser_base_specifier
2538 /* Special member functions [gram.special] */
2540 static tree cp_parser_conversion_function_id
2542 static tree cp_parser_conversion_type_id
2546 static void cp_parser_ctor_initializer_opt
2548 static void cp_parser_mem_initializer_list
2550 static tree cp_parser_mem_initializer
2552 static tree cp_parser_mem_initializer_id
2555 /* Overloading [gram.over] */
2557 static cp_expr cp_parser_operator_function_id
2559 static cp_expr cp_parser_operator
2562 /* Templates [gram.temp] */
2564 static void cp_parser_template_declaration
2566 static tree cp_parser_template_parameter_list
2568 static tree cp_parser_template_parameter
2570 static tree cp_parser_type_parameter
2572 static tree cp_parser_template_id
2574 static tree cp_parser_template_id_expr
2576 static tree cp_parser_template_name
2578 static tree cp_parser_template_argument_list
2580 static tree cp_parser_template_argument
2582 static void cp_parser_explicit_instantiation
2584 static void cp_parser_explicit_specialization
2587 /* Exception handling [gram.except] */
2589 static tree cp_parser_try_block
2591 static void cp_parser_function_try_block
2593 static void cp_parser_handler_seq
2595 static void cp_parser_handler
2597 static tree cp_parser_exception_declaration
2599 static tree cp_parser_throw_expression
2601 static tree cp_parser_exception_specification_opt
2603 static tree cp_parser_type_id_list
2605 static tree cp_parser_noexcept_specification_opt
2608 /* GNU Extensions */
2610 static tree cp_parser_asm_specification_opt
2612 static tree cp_parser_asm_operand_list
2614 static tree cp_parser_asm_clobber_list
2616 static tree cp_parser_asm_label_list
2618 static bool cp_next_tokens_can_be_attribute_p
2620 static bool cp_next_tokens_can_be_gnu_attribute_p
2622 static bool cp_next_tokens_can_be_std_attribute_p
2624 static bool cp_nth_tokens_can_be_std_attribute_p
2626 static bool cp_nth_tokens_can_be_gnu_attribute_p
2628 static bool cp_nth_tokens_can_be_attribute_p
2630 static tree cp_parser_attributes_opt
2632 static tree cp_parser_gnu_attributes_opt
2634 static tree cp_parser_gnu_attribute_list
2636 static tree cp_parser_std_attribute
2638 static tree cp_parser_std_attribute_spec
2640 static tree cp_parser_std_attribute_spec_seq
2642 static size_t cp_parser_skip_std_attribute_spec_seq
2644 static size_t cp_parser_skip_attributes_opt
2646 static bool cp_parser_extension_opt
2648 static void cp_parser_label_declaration
2651 /* Concept Extensions */
2653 static tree cp_parser_concept_definition
2655 static tree cp_parser_constraint_expression
2657 static tree cp_parser_requires_clause_opt
2659 static tree cp_parser_requires_expression
2661 static tree cp_parser_requirement_parameter_list
2663 static tree cp_parser_requirement_body
2665 static tree cp_parser_requirement_seq
2667 static tree cp_parser_requirement
2669 static tree cp_parser_simple_requirement
2671 static tree cp_parser_compound_requirement
2673 static tree cp_parser_type_requirement
2675 static tree cp_parser_nested_requirement
2678 /* Transactional Memory Extensions */
2680 static tree cp_parser_transaction
2682 static tree cp_parser_transaction_expression
2684 static void cp_parser_function_transaction
2686 static tree cp_parser_transaction_cancel
2689 /* Coroutine extensions. */
2691 static tree cp_parser_yield_expression
2696 pragma_external,
2697 pragma_member,
2698 pragma_objc_icode,
2699 pragma_stmt,
2700 pragma_compound
2701 };
2702 static bool cp_parser_pragma
2705 /* Objective-C++ Productions */
2707 static tree cp_parser_objc_message_receiver
2709 static tree cp_parser_objc_message_args
2711 static tree cp_parser_objc_message_expression
2713 static cp_expr cp_parser_objc_encode_expression
2715 static tree cp_parser_objc_defs_expression
2717 static tree cp_parser_objc_protocol_expression
2719 static tree cp_parser_objc_selector_expression
2721 static cp_expr cp_parser_objc_expression
2723 static bool cp_parser_objc_selector_p
2725 static tree cp_parser_objc_selector
2727 static tree cp_parser_objc_protocol_refs_opt
2729 static void cp_parser_objc_declaration
2731 static tree cp_parser_objc_statement
2733 static bool cp_parser_objc_valid_prefix_attributes
2735 static void cp_parser_objc_at_property_declaration
2737 static void cp_parser_objc_at_synthesize_declaration
2739 static void cp_parser_objc_at_dynamic_declaration
2741 static tree cp_parser_objc_struct_declaration
2744 /* Utility Routines */
2746 static cp_expr cp_parser_lookup_name
2748 static tree cp_parser_lookup_name_simple
2750 static tree cp_parser_maybe_treat_template_as_class
2752 static bool cp_parser_check_declarator_template_parameters
2754 static bool cp_parser_check_template_parameters
2756 static cp_expr cp_parser_simple_cast_expression
2758 static tree cp_parser_global_scope_opt
2760 static bool cp_parser_constructor_declarator_p
2762 static tree cp_parser_function_definition_from_specifiers_and_declarator
2764 static tree cp_parser_function_definition_after_declarator
2766 static bool cp_parser_template_declaration_after_export
2768 static void cp_parser_perform_template_parameter_access_checks
2770 static tree cp_parser_single_declaration
2772 static cp_expr cp_parser_functional_cast
2774 static tree cp_parser_save_member_function_body
2776 static tree cp_parser_save_nsdmi
2778 static tree cp_parser_enclosed_template_argument_list
2780 static void cp_parser_save_default_args
2782 static void cp_parser_late_parsing_for_member
2784 static tree cp_parser_late_parse_one_default_arg
2786 static void cp_parser_late_parsing_nsdmi
2788 static void cp_parser_late_parsing_default_args
2790 static tree cp_parser_sizeof_operand
2792 static cp_expr cp_parser_trait
2794 static bool cp_parser_declares_only_class_p
2796 static void cp_parser_set_storage_class
2798 static void cp_parser_set_decl_spec_type
2800 static void set_and_check_decl_spec_loc
2803 static bool cp_parser_friend_p
2805 static void cp_parser_required_error
2811 static bool cp_parser_token_starts_function_definition_p
2813 static bool cp_parser_next_token_starts_class_definition_p
2815 static bool cp_parser_next_token_ends_template_argument_p
2817 static bool cp_parser_nth_token_starts_template_argument_list_p
2819 static enum tag_types cp_parser_token_is_class_key
2821 static enum tag_types cp_parser_token_is_type_parameter_key
2824 static void cp_parser_check_class_key
2826 static void cp_parser_check_access_in_redeclaration
2828 static bool cp_parser_optional_template_keyword
2830 static void cp_parser_pre_parsed_nested_name_specifier
2832 static bool cp_parser_cache_group
2834 static tree cp_parser_cache_defarg
2836 static void cp_parser_parse_tentatively
2838 static void cp_parser_commit_to_tentative_parse
2840 static void cp_parser_commit_to_topmost_tentative_parse
2842 static void cp_parser_abort_tentative_parse
2844 static bool cp_parser_parse_definitely
2848 static bool cp_parser_uncommitted_to_tentative_parse_p
2850 static void cp_parser_error
2852 static void cp_parser_name_lookup_error
2854 static bool cp_parser_simulate_error
2856 static bool cp_parser_check_type_definition
2858 static void cp_parser_check_for_definition_in_return_type
2860 static void cp_parser_check_for_invalid_template_id
2862 static bool cp_parser_non_integral_constant_expression
2864 static void cp_parser_diagnose_invalid_type_name
2866 static bool cp_parser_parse_and_diagnose_invalid_type_name
2868 static int cp_parser_skip_to_closing_parenthesis
2870 static void cp_parser_skip_to_end_of_statement
2872 static void cp_parser_consume_semicolon_at_end_of_statement
2874 static void cp_parser_skip_to_end_of_block_or_statement
2876 static bool cp_parser_skip_to_closing_brace
2878 static bool cp_parser_skip_entire_template_parameter_list
2880 static void cp_parser_require_end_of_template_parameter_list
2882 static bool cp_parser_skip_to_end_of_template_parameter_list
2884 static void cp_parser_skip_to_pragma_eol
2886 static bool cp_parser_error_occurred
2888 static bool cp_parser_allow_gnu_extensions_p
2890 static bool cp_parser_is_pure_string_literal
2892 static bool cp_parser_is_string_literal
2894 static bool cp_parser_is_keyword
2896 static tree cp_parser_make_typename_type
2900 static bool cp_parser_compound_literal_p
2902 static bool cp_parser_array_designator_p
2904 static bool cp_parser_init_statement_p
2906 static bool cp_parser_skip_to_closing_square_bracket
2910 // -------------------------------------------------------------------------- //
2911 // Unevaluated Operand Guard
2912 //
2913 // Implementation of an RAII helper for unevaluated operand parsing.
2915 {
2918 }
2921 {
2924 }
2926 // -------------------------------------------------------------------------- //
2927 // Tentative Parsing
2929 /* Returns nonzero if we are parsing tentatively. */
2933 {
2935 }
2937 /* Returns nonzero if TOKEN is a string literal. */
2939 static bool
2941 {
2947 }
2949 /* Returns nonzero if TOKEN is a string literal
2950 of a user-defined string literal. */
2952 static bool
2954 {
2961 }
2963 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2965 static bool
2967 {
2969 }
2971 /* Helper function for cp_parser_error.
2972 Having peeked a token of kind TOK1_KIND that might signify
2973 a conflict marker, peek successor tokens to determine
2974 if we actually do have a conflict marker.
2975 Specifically, we consider a run of 7 '<', '=' or '>' characters
2976 at the start of a line as a conflict marker.
2977 These come through the lexer as three pairs and a single,
2978 e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
2979 If it returns true, *OUT_LOC is written to with the location/range
2980 of the marker. */
2982 static bool
2985 {
2996 /* It must be at the start of the line. */
3001 /* We have a conflict marker. Construct a location of the form:
3002 <<<<<<<
3003 ^~~~~~~
3004 with start == caret, finishing at the end of the marker. */
3009 }
3011 /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
3012 RT_CLOSE_PAREN. */
3016 {
3018 {
3026 }
3027 }
3029 /* Attempt to convert TOKEN_DESC from a required_token to an
3030 enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
3032 static enum cpp_ttype
3034 {
3036 {
3057 /* Use CPP_EOF as a "no completions possible" code. */
3059 }
3060 }
3063 /* Subroutine of cp_parser_error and cp_parser_required_error.
3065 Issue a diagnostic of the form
3066 FILE:LINE: MESSAGE before TOKEN
3067 where TOKEN is the next token in the input stream. MESSAGE
3068 (specified by the caller) is usually of the form "expected
3069 OTHER-TOKEN".
3071 This bypasses the check for tentative passing, and potentially
3072 adds material needed by cp_parser_required_error.
3074 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
3075 suggesting insertion of the missing token.
3077 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
3078 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
3079 location. */
3081 static void
3083 required_token missing_token_desc,
3084 location_t matching_location)
3085 {
3087 /* This diagnostic makes more sense if it is tagged to the line
3088 of the token we just peeked at. */
3092 {
3097 }
3099 /* If this is actually a conflict marker, report it as such. */
3103 {
3104 location_t loc;
3106 {
3109 /* Consume tokens until the end of the source line. */
3111 {
3125 }
3127 }
3128 }
3130 auto_diagnostic_group d;
3137 {
3138 /* Potentially supply a fix-it hint, suggesting to add the
3139 missing token immediately after the *previous* token.
3140 This may move the primary location within richloc. */
3144 prev_token_loc);
3146 /* If matching_location != UNKNOWN_LOCATION, highlight it.
3147 Attempt to consolidate diagnostics by printing it as a
3148 secondary range within the main diagnostic. */
3150 added_matching_location
3152 }
3154 /* If we were parsing a string-literal and there is an unknown name
3155 token right after, then check to see if that could also have been
3156 a literal string by checking the name against a list of known
3157 standard string literal constants defined in header files. If
3158 there is one, then add that as an hint to the error message. */
3159 name_hint h;
3163 {
3170 token_name,
3171 header_hint));
3172 }
3174 /* Actually emit the error. */
3176 /* Because c_parser_error does not understand
3177 CPP_KEYWORD, keywords are treated like
3178 identifiers. */
3183 {
3184 /* If we weren't able to consolidate matching_location, then
3185 print it as a secondary diagnostic. */
3190 }
3191 }
3193 /* If not parsing tentatively, issue a diagnostic of the form
3194 FILE:LINE: MESSAGE before TOKEN
3195 where TOKEN is the next token in the input stream. MESSAGE
3196 (specified by the caller) is usually of the form "expected
3197 OTHER-TOKEN". */
3199 static void
3201 {
3204 }
3206 /* Issue an error about name-lookup failing. NAME is the
3207 IDENTIFIER_NODE DECL is the result of
3208 the lookup (as returned from cp_parser_lookup_name). DESIRED is
3209 the thing that we hoped to find. */
3211 static void
3213 tree name,
3214 tree decl,
3215 name_lookup_error desired,
3216 location_t location)
3217 {
3218 /* If name lookup completely failed, tell the user that NAME was not
3219 declared. */
3221 {
3234 else
3236 }
3238 {
3240 {
3257 }
3258 }
3260 {
3262 {
3272 name);
3276 }
3277 }
3278 else
3279 {
3281 {
3294 }
3295 }
3296 }
3298 /* If we are parsing tentatively, remember that an error has occurred
3299 during this tentative parse. Returns true if the error was
3300 simulated; false if a message should be issued by the caller. */
3302 static bool
3304 {
3306 {
3309 }
3311 }
3313 /* This function is called when a type is defined. If type
3314 definitions are forbidden at this point, an error message is
3315 issued. */
3317 static bool
3319 {
3320 /* If types are forbidden here, issue a message. */
3322 {
3323 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3324 or %qs in the message need to be interpreted. */
3328 }
3330 }
3332 /* This function is called when the DECLARATOR is processed. The TYPE
3333 was a type defined in the decl-specifiers. If it is invalid to
3334 define a type in the decl-specifiers for DECLARATOR, an error is
3335 issued. TYPE_LOCATION is the location of TYPE and is used
3336 for error reporting. */
3338 static void
3341 {
3342 /* [dcl.fct] forbids type definitions in return types.
3343 Unfortunately, it's not easy to know whether or not we are
3344 processing a return type until after the fact. */
3352 {
3357 type);
3358 }
3359 }
3361 /* A type-specifier (TYPE) has been parsed which cannot be followed by
3362 "<" in any valid C++ program. If the next token is indeed "<",
3363 issue a message warning the user about what appears to be an
3364 invalid attempt to form a template-id. LOCATION is the location
3365 of the type-specifier (TYPE) */
3367 static void
3369 tree type,
3371 location_t location)
3372 {
3376 {
3382 {
3385 else
3387 }
3388 else
3390 /* Remember the location of the invalid "<". */
3393 /* Consume the "<". */
3395 /* Parse the template arguments. */
3397 /* Permanently remove the invalid template arguments so that
3398 this error message is not issued again. */
3401 }
3402 }
3404 /* If parsing an integral constant-expression, issue an error message
3405 about the fact that THING appeared and return true. Otherwise,
3406 return false. In either case, set
3407 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3409 static bool
3411 non_integral_constant thing)
3412 {
3415 {
3417 {
3420 {
3423 "ISO C++ forbids using a floating-point literal "
3428 "enumeration type cannot appear in a "
3519 }
3523 }
3524 }
3526 }
3528 /* Emit a diagnostic for an invalid type name. This function commits
3529 to the current active tentative parse, if any. (Otherwise, the
3530 problematic construct might be encountered again later, resulting
3531 in duplicate error messages.) LOCATION is the location of ID. */
3533 static void
3535 location_t location)
3536 {
3539 /* Try to lookup the identifier. */
3546 /* If the lookup was ambiguous, an error will already have
3547 been issued. */
3549 /* If the lookup found a template-name, it means that the user forgot
3550 to specify an argument list. Emit a useful error message. */
3552 {
3553 auto_diagnostic_group d;
3556 decl);
3561 }
3565 /* Something like 'unsigned A a;' */
3568 {
3569 /* Issue an error message. */
3570 auto_diagnostic_group d;
3571 name_hint hint;
3575 {
3581 }
3582 else
3584 /* If we're in a template class, it's possible that the user was
3585 referring to a type from a base class. For example:
3587 template <typename T> struct A { typedef T X; };
3588 template <typename T> struct B : public A<T> { X x; };
3590 The user should have said "typename A<T>::X". */
3599 {
3602 id);
3605 id);
3606 else
3609 }
3626 {
3629 {
3633 {
3634 /* Go from a particular instantiation of the
3635 template (which will have an empty TYPE_FIELDs),
3636 to the main version. */
3642 {
3647 }
3648 }
3649 }
3650 found:;
3651 }
3652 }
3653 /* Here we diagnose qualified-ids where the scope is actually correct,
3654 but the identifier does not resolve to a valid type name. */
3656 {
3658 {
3659 auto_diagnostic_group d;
3660 name_hint hint;
3669 {
3672 "%qE in namespace %qE does not name a template"
3675 else
3679 }
3681 {
3684 "%qE in namespace %qE does not name a template"
3687 else
3689 "%qE in namespace %qE does not name a template"
3692 }
3693 else
3694 {
3697 "%qE in namespace %qE does not name a type"
3700 else
3704 }
3707 }
3710 {
3711 /* A<T>::A<T>() */
3712 auto_diagnostic_group d;
3718 }
3721 {
3726 "need %<typename%> before %<%T::%D::%E%> because "
3730 id,
3733 else
3737 }
3739 {
3740 auto_diagnostic_group d;
3752 else
3758 }
3759 else
3761 }
3762 }
3764 /* Check for a common situation where a type-name should be present,
3765 but is not, and issue a sensible error message. Returns true if an
3766 invalid type-name was detected.
3768 The situation handled by this function are variable declarations of the
3769 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3770 Usually, `ID' should name a type, but if we got here it means that it
3771 does not. We try to emit the best possible error message depending on
3772 how exactly the id-expression looks like. */
3774 static bool
3776 {
3777 tree id;
3780 /* Avoid duplicate error about ambiguous lookup. */
3782 {
3786 }
3795 /* If the next token is a (, this is a function with no explicit return
3796 type, i.e. constructor, destructor or conversion op. */
3799 {
3802 }
3806 /* Emit a diagnostic for the invalid type. */
3808 out:
3809 /* If we aren't in the middle of a declarator (i.e. in a
3810 parameter-declaration-clause), skip to the end of the declaration;
3811 there's no point in trying to process it. */
3815 }
3817 /* Consume tokens up to, and including, the next non-nested closing `)'.
3818 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3819 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3820 found an unnested token of that type. */
3822 static int
3825 cpp_ttype or_ttype,
3827 {
3838 {
3841 /* Have we found what we're looking for before the closing paren? */
3847 {
3851 /* FALLTHRU */
3853 /* If we've run out of tokens, then there is no closing `)'. */
3856 /* This is good for lambda expression capture-lists. */
3866 /* This matches the processing in skip_to_end_of_statement. */
3886 {
3890 }
3900 condop_depth--;
3906 /* FALLTHROUGH */
3909 /* We fell into a pragma. Skip it, and continue. */
3915 }
3917 /* Consume the token. */
3919 }
3920 }
3922 /* Consume tokens up to, and including, the next non-nested closing `)'.
3923 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3924 are doing error recovery. Returns -1 if OR_COMMA is true and we
3925 found an unnested token of that type. */
3927 static int
3932 {
3936 }
3938 /* Consume tokens until we reach the end of the current statement.
3939 Normally, that will be just before consuming a `;'. However, if a
3940 non-nested `}' comes first, then we stop before consuming that. */
3942 static void
3944 {
3947 /* Unwind generic function template scope if necessary. */
3952 {
3956 {
3960 /* FALLTHRU */
3962 /* If we've run out of tokens, stop. */
3966 /* If the next token is a `;', we have reached the end of the
3967 statement. */
3973 /* If this is a non-nested '}', stop before consuming it.
3974 That way, when confronted with something like:
3976 { 3 + }
3978 we stop before consuming the closing '}', even though we
3979 have not yet reached a `;'. */
3983 /* If it is the closing '}' for a block that we have
3984 scanned, stop -- but only after consuming the token.
3985 That way given:
3987 void f g () { ... }
3988 typedef int I;
3990 we will stop after the body of the erroneously declared
3991 function, but before consuming the following `typedef'
3992 declaration. */
3994 {
3997 }
4007 /* FALLTHROUGH */
4010 /* We fell into a pragma. Skip it, and continue or return. */
4018 }
4020 /* Consume the token. */
4022 }
4023 }
4025 /* This function is called at the end of a statement or declaration.
4026 If the next token is a semicolon, it is consumed; otherwise, error
4027 recovery is attempted. */
4029 static void
4031 {
4032 /* Look for the trailing `;'. */
4034 {
4035 /* If there is additional (erroneous) input, skip to the end of
4036 the statement. */
4038 /* If the next token is now a `;', consume it. */
4041 }
4042 }
4044 /* Skip tokens until we have consumed an entire block, or until we
4045 have consumed a non-nested `;'. */
4047 static void
4049 {
4052 /* Unwind generic function template scope if necessary. */
4057 {
4061 {
4065 /* FALLTHRU */
4067 /* If we've run out of tokens, stop. */
4071 /* Stop if this is an unnested ';'. */
4077 /* Stop if this is an unnested '}', or closes the outermost
4078 nesting level. */
4079 nesting_depth--;
4087 /* Nest. */
4088 nesting_depth++;
4094 /* FALLTHROUGH */
4097 /* Skip it, and continue or return. */
4105 }
4107 /* Consume the token. */
4109 }
4110 }
4112 /* Skip tokens until a non-nested closing curly brace is the next
4113 token, or there are no more tokens. Return true in the first case,
4114 false otherwise. */
4116 static bool
4118 {
4122 {
4126 {
4130 /* FALLTHRU */
4132 /* If we've run out of tokens, stop. */
4136 /* If the next token is a non-nested `}', then we have reached
4137 the end of the current block. */
4143 /* If it the next token is a `{', then we are entering a new
4144 block. Consume the entire block. */
4150 }
4152 /* Consume the token. */
4154 }
4155 }
4157 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
4158 parameter is the PRAGMA token, allowing us to purge the entire pragma
4159 sequence. PRAGMA_TOK can be NULL, if we're speculatively scanning
4160 forwards (not error recovery). */
4162 static void
4164 {
4167 do
4168 {
4169 /* The preprocessor makes sure that a PRAGMA_EOL token appears
4170 before an EOF token, even when the EOF is on the pragma line.
4171 We should never get here without being inside a deferred
4172 pragma. */
4175 }
4179 {
4183 {
4185 /* Put the current source position back where it was before this
4186 lexer was pushed. */
4188 }
4189 }
4190 }
4192 /* Require pragma end of line, resyncing with it as necessary. The
4193 arguments are as for cp_parser_skip_to_pragma_eol. */
4195 static void
4197 {
4203 {
4205 /* Put the current source position back where it was before this
4206 lexer was pushed. */
4208 }
4209 }
4211 /* This is a simple wrapper around make_typename_type. When the id is
4212 an unresolved identifier node, we can provide a superior diagnostic
4213 using cp_parser_diagnose_invalid_type_name. */
4215 static tree
4217 location_t id_location)
4218 {
4219 tree result;
4221 {
4227 }
4229 }
4231 /* This is a wrapper around the
4232 make_{pointer,ptrmem,reference}_declarator functions that decides
4233 which one to call based on the CODE and CLASS_TYPE arguments. The
4234 CODE argument should be one of the values returned by
4235 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
4236 appertain to the pointer or reference. */
4240 cp_cv_quals cv_qualifiers,
4242 tree attributes)
4243 {
4250 else
4260 }
4262 /* Create a new C++ parser. */
4266 {
4267 /* Initialize the binops_by_token so that we can get the tree
4268 directly from the token. */
4276 /* For now, we always accept GNU extensions. */
4279 /* The `>' token is a greater-than operator, not the end of a
4280 template-id. */
4285 /* We are not parsing a constant-expression. */
4290 /* Local variable names are not forbidden. */
4293 /* We are not processing an `extern "C"' declaration. */
4296 /* We are not processing a declarator. */
4299 /* We are not processing a template-argument-list. */
4302 /* We are not in an iteration statement. */
4305 /* We are not in a switch statement. */
4308 /* We are not parsing a type-id inside an expression. */
4311 /* String literals should be translated to the execution character set. */
4314 /* We are not parsing a function body. */
4317 /* We can correct until told otherwise. */
4320 /* The unparsed function queue is empty. */
4323 /* There are no classes being defined. */
4326 /* No template parameters apply. */
4329 /* Special parsing data structures. */
4333 /* Not declaring an implicit function template. */
4339 /* Allow constrained-type-specifiers. */
4342 /* We haven't yet seen an 'extern "C"'. */
4346 }
4348 /* Create a cp_lexer structure which will emit the tokens in CACHE
4349 and push it onto the parser's lexer stack. This is used for delayed
4350 parsing of in-class method bodies and default arguments, and should
4351 not be confused with tentative parsing. */
4352 static void
4354 {
4359 /* Move the current source position to that of the first token in the
4360 new lexer. */
4362 }
4364 /* Pop the top lexer off the parser stack. This is never used for the
4365 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4366 static void
4368 {
4373 /* Put the current source position back where it was before this
4374 lexer was pushed. */
4376 }
4378 /* Lexical conventions [gram.lex] */
4380 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4381 identifier. */
4383 static cp_expr
4385 {
4388 /* Look for the identifier. */
4390 /* Return the value. */
4393 else
4395 }
4397 /* Parse a sequence of adjacent string constants. Returns a
4398 TREE_STRING representing the combined, nul-terminated string
4399 constant. If TRANSLATE is true, translate the string to the
4400 execution character set. If WIDE_OK is true, a wide string is
4401 invalid here.
4403 C++98 [lex.string] says that if a narrow string literal token is
4404 adjacent to a wide string literal token, the behavior is undefined.
4405 However, C99 6.4.5p4 says that this results in a wide string literal.
4406 We follow C99 here, for consistency with the C front end.
4408 This code is largely lifted from lex_string() in c-lex.cc.
4410 FUTURE: ObjC++ will need to handle @-strings here. */
4411 static cp_expr
4414 {
4415 tree value;
4423 tree string_tree;
4429 {
4432 }
4437 {
4441 }
4442 else
4443 {
4446 }
4449 /* Try to avoid the overhead of creating and destroying an obstack
4450 for the common case of just one string. */
4453 {
4461 {
4465 }
4466 else
4470 }
4471 else
4472 {
4478 do
4479 {
4481 count++;
4486 {
4489 {
4492 }
4495 {
4500 }
4502 }
4503 else
4507 {
4511 {
4515 "concatenation of string literals with "
4517 }
4518 }
4527 {
4531 }
4532 else
4533 {
4537 }
4538 }
4541 /* A string literal built by concatenation has its caret=start at
4542 the start of the initial string, and its finish at the finish of
4543 the final string literal. */
4547 }
4550 {
4553 }
4557 {
4561 {
4565 }
4568 {
4576 else
4588 }
4593 {
4598 else
4600 }
4601 }
4602 else
4603 /* cpp_interpret_string has issued an error. */
4607 {
4610 }
4613 }
4615 /* Look up a literal operator with the name and the exact arguments. */
4617 static tree
4619 {
4625 {
4629 {
4636 {
4646 }
4650 /* May be this should be sufficient_parms_p instead,
4651 depending on how exactly should user-defined literals
4652 work in presence of default arguments on the literal
4653 operator parameters. */
4656 }
4657 }
4660 }
4662 /* Parse a user-defined char constant. Returns a call to a user-defined
4663 literal operator taking the character as an argument. */
4665 static cp_expr
4667 {
4675 /* Build up a call to the user-defined operator */
4676 /* Lookup the name we got back from the id-expression. */
4677 releasing_vec args;
4681 {
4685 }
4688 }
4690 /* A subroutine of cp_parser_userdef_numeric_literal to
4691 create a char... template parameter pack from a string node. */
4693 static tree
4695 {
4696 tree charvec;
4703 /* Fill in CHARVEC with all of the parameters. */
4706 {
4715 }
4717 /* Build the argument packs. */
4723 }
4725 /* A subroutine of cp_parser_userdef_numeric_literal to
4726 create a char... template parameter pack from a string node. */
4728 static tree
4730 {
4731 tree charvec;
4742 /* First template parm is character type. */
4745 /* Fill in CHARVEC with all of the parameters. */
4752 /* Build the argument packs. */
4758 }
4760 /* Parse a user-defined numeric constant. returns a call to a user-defined
4761 literal operator. */
4763 static cp_expr
4765 {
4775 /* Look for a literal operator taking the exact type of numeric argument
4776 as the literal value. */
4777 releasing_vec args;
4781 {
4783 tf_warning_or_error);
4786 {
4789 long_long_unsigned_type_node);
4790 }
4791 else
4792 {
4796 long_double_type_node);
4800 }
4803 }
4805 /* If the numeric argument didn't work, look for a raw literal
4806 operator taking a const char* argument consisting of the number
4807 in string format. */
4812 {
4814 tf_warning_or_error);
4816 }
4818 /* If the raw literal didn't work, look for a non-type template
4819 function with parameter pack char.... Call the function with
4820 template parameter characters representing the number. */
4824 {
4827 {
4829 num_string);
4831 }
4834 tf_warning_or_error);
4836 }
4838 /* In C++14 the standard library defines complex number suffixes that
4839 conflict with GNU extensions. Prefer them if <complex> is #included. */
4849 {
4853 {
4854 /* No <complex>, so pedwarn and use GNU semantics. */
4857 }
4858 }
4860 bool complained
4867 {
4869 "(from %<<complex>%>) to enable the C++14 user-defined literal "
4874 }
4881 else
4882 {
4883 /* Use the built-in semantics. */
4884 tree type;
4886 {
4889 else
4891 }
4899 }
4902 /* Avoid repeated diagnostics. */
4905 }
4907 /* Parse a user-defined string constant. Returns a call to a user-defined
4908 literal operator taking a character pointer and the length of the string
4909 as arguments. */
4911 static tree
4913 {
4919 tree decl;
4921 /* Build up a call to the user-defined operator. */
4922 /* Lookup the name we got back from the id-expression. */
4923 releasing_vec args;
4930 tf_warning_or_error);
4932 /* Look for a suitable template function, either (C++20) with a single
4933 parameter of class type, or (N3599) with typename parameter CharT and
4934 parameter pack CharT... */
4938 {
4939 /* Use resolve_nondeduced_context to try to choose one form of template
4940 or the other. */
4947 else
4948 {
4953 }
4957 tf_warning_or_error);
4958 }
4963 }
4966 /* Basic concepts [gram.basic] */
4968 /* Parse a translation-unit.
4970 translation-unit:
4971 declaration-seq [opt] */
4973 static void
4975 {
4978 /* Create the declarator obstack. */
4980 /* Create the error declarator. */
4982 /* Create the empty parameter list. */
4984 UNKNOWN_LOCATION);
4985 /* Remember where the base of the declarator obstack lies. */
4997 /* Parse until EOF. */
4999 {
5002 /* If we're entering or exiting a region that's implicitly
5003 extern "C", modify the lang context appropriately. This is
5004 so horrible. Please die. */
5007 {
5011 else
5013 }
5019 {
5020 /* Top-level module declarations are ok, and change the
5021 portion of file we're in. Top-level import declarations
5022 are significant for the import portions. */
5027 {
5030 }
5032 {
5033 mp_state
5036 }
5038 {
5043 }
5044 else
5048 {
5051 {
5054 "global module fragment contents must be"
5056 }
5057 }
5058 }
5060 /* This relies on the ordering of module_parse values. */
5062 /* We're no longer in the import portion of a named module. */
5068 {
5071 /* If the next token is now a `;', consume it. */
5074 }
5075 else
5077 }
5079 /* Get rid of the token array; we don't need it any more. */
5083 /* The EOF should have reset this. */
5086 /* Make sure the declarator obstack was fully cleaned up. */
5089 }
5091 /* Return the appropriate tsubst flags for parsing, possibly in N3276
5092 decltype context. */
5096 {
5101 }
5103 /* We're about to parse a collection of statements. If we're currently
5104 parsing tentatively, set up a firewall so that any nested
5105 cp_parser_commit_to_tentative_parse won't affect the current context. */
5107 static cp_token_position
5109 {
5116 }
5118 /* We've finished parsing the collection of statements. Wrap up the
5119 firewall and replace the relevant tokens with the parsed form. */
5121 static void
5123 tree expr)
5124 {
5128 /* Finish the firewall level. */
5130 /* And remember the result of the parse for when we try again. */
5136 }
5138 /* Like the above functions, but let the user modify the tokens. Used by
5139 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
5140 later parses, so it makes sense to localize the effects of
5141 cp_parser_commit_to_tentative_parse. */
5143 struct tentative_firewall
5144 {
5149 {
5150 /* If we're currently parsing tentatively, start a committed level as a
5151 firewall and then an inner tentative parse. */
5153 {
5157 }
5158 }
5161 {
5163 {
5164 /* Finish the inner tentative parse and the firewall, propagating any
5165 uncommitted error state to the outer tentative parse. */
5171 }
5172 }
5173 };
5175 /* Some tokens naturally come in pairs e.g.'(' and ')'.
5176 This class is for tracking such a matching pair of symbols.
5177 In particular, it tracks the location of the first token,
5178 so that if the second token is missing, we can highlight the
5179 location of the first token when notifying the user about the
5180 problem. */
5183 class token_pair
5184 {
5186 /* token_pair's ctor. */
5189 /* If the next token is the opening symbol for this pair, consume it and
5190 return true.
5191 Otherwise, issue an error and return false.
5192 In either case, record the location of the opening token. */
5195 {
5199 }
5201 /* Consume the next token from PARSER, recording its location as
5202 that of the opening token within the pair. */
5205 {
5210 }
5212 /* If the next token is the closing symbol for this pair, consume it
5213 and return it.
5214 Otherwise, issue an error, highlighting the location of the
5215 corresponding opening token, and return NULL. */
5218 {
5221 m_open_loc);
5222 }
5227 location_t m_open_loc;
5228 };
5230 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
5232 struct matching_paren_traits
5233 {
5238 };
5240 /* "matching_parens" is a token_pair<T> class for tracking matching
5241 pairs of parentheses. */
5245 /* Traits for token_pair<T> for tracking matching pairs of braces. */
5247 struct matching_brace_traits
5248 {
5253 };
5255 /* "matching_braces" is a token_pair<T> class for tracking matching
5256 pairs of braces. */
5261 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
5262 enclosing parentheses. */
5264 static cp_expr
5266 {
5269 /* Consume the '('. */
5271 matching_parens parens;
5273 /* Start the statement-expression. */
5275 /* Parse the compound-statement. */
5277 /* Finish up. */
5279 /* Consume the ')'. */
5287 }
5289 /* Expressions [gram.expr] */
5291 /* Parse a fold-operator.
5293 fold-operator:
5294 - * / % ^ & | = < > << >>
5295 = -= *= /= %= ^= &= |= <<= >>=
5296 == != <= >= && || , .* ->*
5298 This returns the tree code corresponding to the matched operator
5299 as an int. When the current token matches a compound assignment
5300 operator, the resulting tree code is the negative value of the
5301 non-assignment operator. */
5303 static int
5305 {
5307 {
5347 }
5348 }
5350 /* Returns true if CODE indicates a binary expression, which is not allowed in
5351 the LHS of a fold-expression. More codes will need to be added to use this
5352 function in other contexts. */
5354 static bool
5356 {
5358 {
5391 }
5392 }
5394 /* If the next token is a suitable fold operator, consume it and return as
5395 the function above. */
5397 static int
5399 {
5405 }
5407 /* Parse a fold-expression.
5409 fold-expression:
5410 ( ... folding-operator cast-expression)
5411 ( cast-expression folding-operator ... )
5412 ( cast-expression folding operator ... folding-operator cast-expression)
5414 Note that the '(' and ')' are matched in primary expression. */
5416 static cp_expr
5418 {
5419 cp_id_kind pidk;
5421 // Left fold.
5423 {
5429 {
5432 }
5439 }
5444 {
5447 }
5450 {
5453 }
5456 /* The operands of a fold-expression are cast-expressions, so binary or
5457 conditional expressions are not allowed. We check this here to avoid
5458 tentative parsing. */
5470 // Right fold.
5475 {
5478 }
5481 // Binary left or right fold.
5486 }
5488 /* Parse a primary-expression.
5490 primary-expression:
5491 literal
5492 this
5493 ( expression )
5494 id-expression
5495 lambda-expression (C++11)
5497 GNU Extensions:
5499 primary-expression:
5500 ( compound-statement )
5501 __builtin_va_arg ( assignment-expression , type-id )
5502 __builtin_offsetof ( type-id , offsetof-expression )
5504 C++ Extensions:
5505 __has_nothrow_assign ( type-id )
5506 __has_nothrow_constructor ( type-id )
5507 __has_nothrow_copy ( type-id )
5508 __has_trivial_assign ( type-id )
5509 __has_trivial_constructor ( type-id )
5510 __has_trivial_copy ( type-id )
5511 __has_trivial_destructor ( type-id )
5512 __has_virtual_destructor ( type-id )
5513 __is_abstract ( type-id )
5514 __is_base_of ( type-id , type-id )
5515 __is_class ( type-id )
5516 __is_empty ( type-id )
5517 __is_enum ( type-id )
5518 __is_final ( type-id )
5519 __is_literal_type ( type-id )
5520 __is_pod ( type-id )
5521 __is_polymorphic ( type-id )
5522 __is_std_layout ( type-id )
5523 __is_trivial ( type-id )
5524 __is_union ( type-id )
5526 Objective-C++ Extension:
5528 primary-expression:
5529 objc-expression
5531 literal:
5532 __null
5534 ADDRESS_P is true iff this expression was immediately preceded by
5535 "&" and therefore might denote a pointer-to-member. CAST_P is true
5536 iff this expression is the target of a cast. TEMPLATE_ARG_P is
5537 true iff this expression is a template argument.
5539 Returns a representation of the expression. Upon return, *IDK
5540 indicates what kind of id-expression (if any) was present. */
5542 static cp_expr
5549 {
5552 /* Assume the primary expression is not an id-expression. */
5555 /* Peek at the next token. */
5558 {
5559 /* literal:
5560 integer-literal
5561 character-literal
5562 floating-literal
5563 string-literal
5564 boolean-literal
5565 pointer-literal
5566 user-defined-literal */
5578 {
5582 }
5583 /* Floating-point literals are only allowed in an integral
5584 constant expression if they are cast to an integral or
5585 enumeration type. */
5589 {
5590 /* CAST_P will be set even in invalid code like "int(2.7 +
5591 ...)". Therefore, we have to check that the next token
5592 is sure to end the cast. */
5594 {
5599 enumerator-definition. */
5601 /* The curly brace at the end of an enum-specifier. */
5603 /* The end of a statement. */
5605 /* The end of the cast-expression. */
5607 /* The end of an array bound. */
5609 /* The closing ">" in a template-argument-list. */
5612 /* C++0x only: A ">>" treated like two ">" tokens,
5613 in a template-argument-list. */
5618 }
5620 /* If we are within a cast, then the constraint that the
5621 cast is to an integral or enumeration type will be
5622 checked at that point. If we are not within a cast, then
5623 this code is invalid. */
5626 }
5647 /* ??? Should wide strings be allowed when parser->translate_strings_p
5648 is false (i.e. in attributes)? If not, we can kill the third
5649 argument to cp_parser_string_literal. */
5656 /* If we see `( { ' then we are looking at the beginning of
5657 a GNU statement-expression. */
5660 {
5661 /* Statement-expressions are not allowed by the standard. */
5665 /* And they're not allowed outside of a function-body; you
5666 cannot, for example, write:
5668 int i = ({ int j = 3; j + 1; });
5670 at class or namespace scope. */
5673 {
5675 "statement-expressions are not allowed outside "
5681 }
5682 else
5684 }
5685 /* Otherwise it's a normal parenthesized expression. */
5686 {
5687 cp_expr expr;
5692 /* Consume the `('. */
5693 matching_parens parens;
5695 /* Within a parenthesized expression, a `>' token is always
5696 the greater-than operator. */
5697 saved_greater_than_is_operator_p
5702 /* Left fold expression. */
5704 else
5705 /* Parse the parenthesized expression. */
5710 {
5715 "fold-expressions only available with %<-std=c++17%> "
5717 }
5718 else
5719 /* Let the front end know that this expression was
5720 enclosed in parentheses. This matters in case, for
5721 example, the expression is of the form `A::B', since
5722 `&A::B' might be a pointer-to-member, but `&(A::B)' is
5723 not. */
5726 /* DR 705: Wrapping an unqualified name in parentheses
5727 suppresses arg-dependent lookup. We want to pass back
5728 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5729 (c++/37862), but none of the others. */
5733 /* The `>' token might be the end of a template-id or
5734 template-parameter-list now. */
5735 parser->greater_than_is_operator_p
5738 /* Consume the `)'. */
5750 }
5753 {
5755 {
5756 /* We might have an Objective-C++ message. */
5759 /* If that works out, we're done ... */
5762 /* ... else, fall though to see if it's a lambda. */
5763 }
5765 /* Don't warn about a failed tentative parse. */
5770 }
5774 /* We have an Objective-C++ string literal. */
5781 {
5782 /* These two are the boolean literals. */
5790 /* The `__null' literal. */
5795 /* The `nullptr' literal. */
5800 /* Recognize the `this' keyword. */
5804 {
5808 }
5809 /* Pointers cannot appear in constant-expressions. */
5814 /* The `operator' keyword can be the beginning of an
5815 id-expression. */
5822 {
5823 non_integral_constant name;
5825 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
5826 __func__ are the names of variables -- but they are
5827 treated specially. Therefore, they are handled here,
5828 rather than relying on the generic id-expression logic
5829 below. Grammatically, these names are id-expressions.
5831 Consume the token. */
5835 {
5847 }
5852 /* Look up the name. */
5854 }
5857 {
5858 tree expression;
5859 tree type;
5860 location_t type_location;
5861 location_t start_loc
5863 /* The `__builtin_va_arg' construct is used to handle
5864 `va_arg'. Consume the `__builtin_va_arg' token. */
5866 /* Look for the opening `('. */
5867 matching_parens parens;
5869 /* Now, parse the assignment-expression. */
5871 /* Look for the `,'. */
5874 /* Parse the type-id. */
5875 {
5878 }
5879 /* Look for the closing `)'. */
5880 location_t finish_loc
5883 /* Using `va_arg' in a constant-expression is not
5884 allowed. */
5886 NIC_VA_ARG))
5888 /* Construct a location of the form:
5889 __builtin_va_arg (v, int)
5890 ~~~~~~~~~~~~~~~~~~~~~^~~~
5891 with the caret at the type, ranging from the start of the
5892 "__builtin_va_arg" token to the close paren. */
5893 location_t combined_loc
5896 }
5901 #define DEFTRAIT_EXPR(CODE, NAME, ARITY) \
5902 case RID_##CODE:
5904 #undef DEFTRAIT_EXPR
5907 // C++ concepts
5911 /* Objective-C++ expressions. */
5921 "%<omp_all_memory%> may only be used in OpenMP "
5929 {
5934 }
5935 /* FALLTHRU */
5939 }
5941 /* An id-expression can start with either an identifier, a
5942 `::' as the beginning of a qualified-id, or the "operator"
5943 keyword. */
5948 {
5949 id_expression:
5950 cp_expr id_expression;
5951 cp_expr decl;
5957 /* Parse the id-expression. */
5958 id_expression
5975 /* If we have a template-id, then no further lookup is
5976 required. If the template-id was for a template-class, we
5977 will sometimes have a TYPE_DECL at this point. */
5981 /* Look up the name. */
5982 else
5983 {
5984 tree ambiguous_decls;
5986 /* If we already know that this lookup is ambiguous, then
5987 we've already issued an error message; there's no reason
5988 to check again. */
5991 {
5994 }
5997 none_type,
5998 template_p,
6003 /* If the lookup was ambiguous, an error will already have
6004 been issued. */
6008 /* In Objective-C++, we may have an Objective-C 2.0
6009 dot-syntax for classes here. */
6014 {
6015 tree component;
6022 component);
6023 /* Build a location of the form:
6024 expr.component
6025 ~~~~~^~~~~~~~~
6026 with caret at the start of the component name (at
6027 input_location), ranging from the start of the id_expression
6028 to the end of the component name. */
6029 location_t combined_loc
6034 }
6036 /* In Objective-C++, an instance variable (ivar) may be preferred
6037 to whatever cp_parser_lookup_name() found.
6038 Call objc_lookup_ivar. To avoid exposing cp_expr to the
6039 rest of c-family, we have to do a little extra work to preserve
6040 any location information in cp_expr "decl". Given that
6041 objc_lookup_ivar is implemented in "c-family" and "objc", we
6042 have a trip through the pure "tree" type, rather than cp_expr.
6043 Naively copying it back to "decl" would implicitly give the
6044 new cp_expr value an UNKNOWN_LOCATION for nodes that don't
6045 store an EXPR_LOCATION. Hence we only update "decl" (and
6046 hence its location_t) if we get back a different tree node. */
6048 id_expression);
6052 /* If name lookup gives us a SCOPE_REF, then the
6053 qualifying scope was dependent. */
6055 {
6056 /* At this point, we do not know if DECL is a valid
6057 integral constant expression. We assume that it is
6058 in fact such an expression, so that code like:
6060 template <int N> struct A {
6061 int a[B<N>::i];
6062 };
6064 is accepted. At template-instantiation time, we
6065 will check that B<N>::i is actually a constant. */
6067 }
6068 /* Check to see if DECL is a local variable in a context
6069 where that is forbidden. */
6072 /* DR 2082 permits local variables in unevaluated contexts
6073 within a default argument. */
6075 {
6083 }
6084 }
6086 decl = (finish_id_expression
6088 idk,
6093 template_arg_p,
6098 /* Build a location for an id-expression of the form:
6099 ::ns::id
6100 ~~~~~~^~
6101 or:
6102 id
6103 ^~
6104 i.e. from the start of the first token to the end of the final
6105 token, with the caret at the start of the unqualified-id. */
6109 location_t combined_loc
6114 }
6116 /* Anything else is an error. */
6120 }
6121 }
6129 {
6132 }
6134 /* Complain about missing template keyword when naming a dependent
6135 member template. */
6137 static void
6139 {
6146 "expected %qs keyword before dependent "
6149 }
6151 /* Parse an id-expression.
6153 id-expression:
6154 unqualified-id
6155 qualified-id
6157 qualified-id:
6158 :: [opt] nested-name-specifier template [opt] unqualified-id
6159 :: identifier
6160 :: operator-function-id
6161 :: template-id
6163 Return a representation of the unqualified portion of the
6164 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
6165 a `::' or nested-name-specifier.
6167 Often, if the id-expression was a qualified-id, the caller will
6168 want to make a SCOPE_REF to represent the qualified-id. This
6169 function does not do this in order to avoid wastefully creating
6170 SCOPE_REFs when they are not required.
6172 If TEMPLATE_KEYWORD_P is true, then we have just seen the
6173 `template' keyword.
6175 If CHECK_DEPENDENCY_P is false, then names are looked up inside
6176 uninstantiated templates.
6178 If *TEMPLATE_P is non-NULL, it is set to true iff the
6179 `template' keyword is used to explicitly indicate that the entity
6180 named is a template.
6182 If DECLARATOR_P is true, the id-expression is appearing as part of
6183 a declarator, rather than as part of an expression. */
6185 static cp_expr
6192 {
6196 /* Assume the `template' keyword was not used. */
6200 /* Look for the optional `::' operator. */
6201 global_scope_p
6202 = (!template_keyword_p
6207 /* Look for the optional nested-name-specifier. */
6208 nested_name_specifier_p
6211 check_dependency_p,
6213 declarator_p,
6214 template_keyword_p)
6220 /* Peek at the next token. */
6223 /* If there is a nested-name-specifier, then we are looking at
6224 the first qualified-id production. */
6226 {
6227 tree saved_object_scope;
6228 tree saved_qualifying_scope;
6230 /* See if the next token is the `template' keyword. */
6234 /* Name lookup we do during the processing of the
6235 unqualified-id might obliterate SCOPE. */
6238 /* Process the final unqualified-id. */
6240 check_dependency_p,
6241 declarator_p,
6243 /* Restore the SAVED_SCOPE for our caller. */
6247 }
6248 /* Otherwise, if we are in global scope, then we are looking at one
6249 of the other qualified-id productions. */
6251 {
6252 /* If it's an identifier, and the next token is not a "<", then
6253 we can avoid the template-id case. This is an optimization
6254 for this common case. */
6256 && !cp_parser_nth_token_starts_template_argument_list_p
6261 /* Try a template-id. */
6265 declarator_p);
6266 /* If that worked, we're done. */
6270 /* Peek at the next token. (Changes in the token buffer may
6271 have invalidated the pointer obtained above.) */
6275 {
6282 {
6285 }
6286 /* Fall through. */
6291 }
6292 }
6293 else
6294 {
6299 declarator_p,
6300 optional_p);
6301 }
6304 && warn_missing_template_keyword
6305 && !template_keyword_p
6306 /* Don't warn if we're looking inside templates. */
6307 && check_dependency_p
6308 /* In a template argument list a > could be closing
6309 the enclosing targs. */
6312 /* Don't confuse an ill-formed constructor declarator for a missing
6313 template keyword in a return type. */
6317 OPT_Wmissing_template_keyword))
6318 {
6321 /* An operator after the > suggests that the > ends a
6322 template-id; a name or literal suggests that the > is an
6323 operator. */
6327 }
6330 }
6332 /* Parse an unqualified-id.
6334 unqualified-id:
6335 identifier
6336 operator-function-id
6337 conversion-function-id
6338 ~ class-name
6339 template-id
6341 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
6342 keyword, in a construct like `A::template ...'.
6344 Returns a representation of unqualified-id. For the `identifier'
6345 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
6346 production a BIT_NOT_EXPR is returned; the operand of the
6347 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
6348 other productions, see the documentation accompanying the
6349 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
6350 names are looked up in uninstantiated templates. If DECLARATOR_P
6351 is true, the unqualified-id is appearing as part of a declarator,
6352 rather than as part of an expression. */
6354 static cp_expr
6360 {
6363 /* Peek at the next token. */
6367 {
6369 {
6370 tree id;
6372 /* We don't know yet whether or not this will be a
6373 template-id. */
6375 /* Try a template-id. */
6377 check_dependency_p,
6378 declarator_p);
6379 /* If it worked, we're done. */
6382 /* Otherwise, it's an ordinary identifier. */
6384 }
6388 check_dependency_p,
6389 declarator_p);
6392 {
6393 tree type_decl;
6394 tree qualifying_scope;
6395 tree object_scope;
6396 tree scope;
6400 /* Consume the `~' token. */
6402 /* Parse the class-name. The standard, as written, seems to
6403 say that:
6405 template <typename T> struct S { ~S (); };
6406 template <typename T> S<T>::~S() {}
6408 is invalid, since `~' must be followed by a class-name, but
6409 `S<T>' is dependent, and so not known to be a class.
6410 That's not right; we need to look in uninstantiated
6411 templates. A further complication arises from:
6413 template <typename T> void f(T t) {
6414 t.T::~T();
6415 }
6417 Here, it is not possible to look up `T' in the scope of `T'
6418 itself. We must look in both the current scope, and the
6419 scope of the containing complete expression.
6421 Yet another issue is:
6423 struct S {
6424 int S;
6425 ~S();
6426 };
6428 S::~S() {}
6430 The standard does not seem to say that the `S' in `~S'
6431 should refer to the type `S' and not the data member
6432 `S::S'. */
6434 /* DR 244 says that we look up the name after the "~" in the
6435 same scope as we looked up the qualifying name. That idea
6436 isn't fully worked out; it's more complicated than that. */
6441 /* Check for invalid scopes. */
6443 {
6447 }
6449 {
6453 scope);
6458 }
6460 {
6466 }
6472 /* Create a location with caret == start at the tilde,
6473 finishing at the end of the peeked token, e.g:
6474 ~token
6475 ^~~~~~. */
6476 location_t loc
6479 /* If the name is of the form "X::~X" it's OK even if X is a
6480 typedef. */
6489 {
6492 }
6494 /* ~auto means the destructor of whatever the object is. */
6496 {
6499 "%<~auto%> only available with "
6503 }
6505 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
6506 declarator-id of a constructor or destructor. */
6509 {
6513 }
6515 /* If there was an explicit qualification (S::~T), first look
6516 in the scope given by the qualification (i.e., S).
6518 Note: in the calls to cp_parser_class_name below we pass
6519 typename_type so that lookup finds the injected-class-name
6520 rather than the constructor. */
6524 {
6529 typename_type,
6532 declarator_p);
6535 }
6536 /* In "N::S::~S", look in "N" as well. */
6538 {
6543 type_decl
6547 typename_type,
6550 declarator_p);
6553 }
6554 /* In "p->S::~T", look in the scope given by "*p" as well. */
6556 {
6561 type_decl
6565 typename_type,
6568 declarator_p);
6571 }
6572 /* Look in the surrounding context. */
6574 {
6580 type_decl
6584 typename_type,
6587 declarator_p);
6590 {
6591 /* We couldn't find a type with this name. If we're parsing
6592 tentatively, fail and try something else. */
6594 {
6597 }
6598 /* Otherwise, accept it and check for a match at instantiation
6599 time. */
6604 }
6605 }
6606 /* If an error occurred, assume that the name of the
6607 destructor is the same as the name of the qualifying
6608 class. That allows us to keep parsing after running
6609 into ill-formed destructor names. */
6615 /* Check that destructor name and scope match. */
6617 {
6624 }
6626 /* [class.dtor]
6628 A typedef-name that names a class shall not be used as the
6629 identifier in the declarator for a destructor declaration. */
6636 type_decl);
6639 }
6643 {
6644 cp_expr id;
6646 /* This could be a template-id, so we try that first. */
6648 /* Try a template-id. */
6651 declarator_p);
6652 /* If that worked, we're done. */
6655 /* We still don't know whether we're looking at an
6656 operator-function-id or a conversion-function-id. */
6658 /* Try an operator-function-id. */
6660 /* If that didn't work, try a conversion-function-id. */
6665 }
6666 /* Fall through. */
6673 }
6674 }
6676 /* Check [temp.names]/5: A name prefixed by the keyword template shall
6677 be a template-id or the name shall refer to a class template or an
6678 alias template. */
6680 static void
6682 {
6692 /* Alias templates are also OK. */
6699 name);
6700 }
6702 /* Parse an (optional) nested-name-specifier.
6704 nested-name-specifier: [C++98]
6705 class-or-namespace-name :: nested-name-specifier [opt]
6706 class-or-namespace-name :: template nested-name-specifier [opt]
6708 nested-name-specifier: [C++0x]
6709 type-name ::
6710 namespace-name ::
6711 nested-name-specifier identifier ::
6712 nested-name-specifier template [opt] simple-template-id ::
6714 PARSER->SCOPE should be set appropriately before this function is
6715 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6716 effect. TYPE_P is TRUE if we non-type bindings should be ignored
6717 in name lookups.
6719 Sets PARSER->SCOPE to the class (TYPE) or namespace
6720 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6721 it unchanged if there is no nested-name-specifier. Returns the new
6722 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6724 If CHECK_DEPENDENCY_P is FALSE, names are looked up in dependent scopes.
6726 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6727 part of a declaration and/or decl-specifier. */
6729 static tree
6736 {
6741 /* Remember where the nested-name-specifier starts. */
6744 {
6747 }
6750 {
6751 tree new_scope;
6752 tree old_scope;
6753 tree saved_qualifying_scope;
6755 /* Spot cases that cannot be the beginning of a
6756 nested-name-specifier. */
6759 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
6760 the already parsed nested-name-specifier. */
6762 {
6763 /* Grab the nested-name-specifier and continue the loop. */
6765 /* If we originally encountered this nested-name-specifier
6766 with CHECK_DEPENDENCY_P set to true, we will not have
6767 resolved TYPENAME_TYPEs, so we must do so here. */
6769 && !check_dependency_p
6771 {
6776 }
6779 }
6781 /* Spot cases that cannot be the beginning of a
6782 nested-name-specifier. On the second and subsequent times
6783 through the loop, we look for the `template' keyword. */
6785 ;
6786 /* A template-id can start a nested-name-specifier. */
6788 ;
6789 /* DR 743: decltype can be used in a nested-name-specifier. */
6791 ;
6792 else
6793 {
6794 /* If the next token is not an identifier, then it is
6795 definitely not a type-name or namespace-name. */
6798 /* If the following token is neither a `<' (to begin a
6799 template-id), nor a `::', then we are not looking at a
6800 nested-name-specifier. */
6806 /* name:name is a valid sequence in an Objective C message. */
6808 {
6812 "found %<:%> in nested-name-specifier, "
6815 }
6818 && !cp_parser_nth_token_starts_template_argument_list_p
6821 }
6823 /* The nested-name-specifier is optional, so we parse
6824 tentatively. */
6827 /* Look for the optional `template' keyword, if this isn't the
6828 first time through the loop. */
6830 {
6832 /* DR1710: "In a qualified-id used as the name in
6833 a typename-specifier, elaborated-type-specifier, using-declaration,
6834 or class-or-decltype, an optional keyword template appearing at
6835 the top level is ignored." */
6837 && typename_keyword_p
6840 }
6842 /* Save the old scope since the name lookup we are about to do
6843 might destroy it. */
6846 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
6847 look up names in "X<T>::I" in order to determine that "Y" is
6848 a template. So, if we have a typename at this point, we make
6849 an effort to look through it. */
6851 && !check_dependency_p
6852 && !typename_keyword_p
6857 /* Parse the qualifying entity. */
6858 new_scope
6860 typename_keyword_p,
6861 template_keyword_p,
6862 check_dependency_p,
6863 type_p,
6864 is_declaration);
6865 /* Look for the `::' token. */
6868 /* If we found what we wanted, we keep going; otherwise, we're
6869 done. */
6871 {
6874 /* Restore the OLD_SCOPE since it was valid before the
6875 failed attempt at finding the last
6876 class-or-namespace-name. */
6880 /* If the next token is a decltype, and the one after that is a
6881 `::', then the decltype has failed to resolve to a class or
6882 enumeration type. Give this error even when parsing
6883 tentatively since it can't possibly be valid--and we're going
6884 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
6885 won't get another chance.*/
6889 {
6895 dtype);
6898 /* As below. */
6901 }
6905 {
6906 /* If we have a non-type template-id followed by ::, it can't
6907 possibly be valid. */
6912 {
6915 {
6922 else
6925 }
6926 else
6927 {
6933 else
6934 {
6935 /* Variable template. */
6939 }
6940 }
6947 /* As below. */
6951 }
6952 }
6956 /* If the next token is an identifier, and the one after
6957 that is a `::', then any valid interpretation would have
6958 found a class-or-namespace-name. */
6964 {
6967 {
6969 {
6970 tree decl;
6971 tree ambiguous_decls;
6974 none_type,
6983 decl);
6985 {
6986 // cp_parser_lookup_name has the same diagnostic,
6987 // thus make sure to emit it at most once.
6990 {
6995 }
6997 }
6998 else
6999 {
7001 cp_parser_name_lookup_error
7004 else
7005 cp_parser_name_lookup_error
7008 }
7009 }
7012 /* Treat this as a successful nested-name-specifier
7013 due to:
7015 [basic.lookup.qual]
7017 If the name found is not a class-name (clause
7018 _class_) or namespace-name (_namespace.def_), the
7019 program is ill-formed. */
7021 }
7023 }
7025 }
7026 /* We've found one valid nested-name-specifier. */
7028 /* Name lookup always gives us a DECL. */
7031 /* Uses of "template" must be followed by actual templates. */
7034 /* If it is a class scope, try to complete it; we are about to
7035 be looking up names inside the class. */
7037 /* Since checking types for dependency can be expensive,
7038 avoid doing it if the type is already complete. */
7040 /* Do not try to complete dependent types. */
7042 {
7044 /* If it is a typedef to current class, use the current
7045 class instead, as the typedef won't have any names inside
7046 it yet. */
7050 }
7051 /* Make sure we look in the right scope the next time through
7052 the loop. */
7054 }
7056 /* If parsing tentatively, replace the sequence of tokens that makes
7057 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
7058 token. That way, should we re-parse the token stream, we will
7059 not have to repeat the effort required to do the parse, nor will
7060 we issue duplicate error messages. */
7062 {
7066 /* Reset the contents of the START token. */
7068 /* Retrieve any deferred checks. Do not pop this access checks yet
7069 so the memory will not be reclaimed during token replacing below. */
7078 /* Purge all subsequent tokens. */
7080 }
7086 }
7088 /* Parse a nested-name-specifier. See
7089 cp_parser_nested_name_specifier_opt for details. This function
7090 behaves identically, except that it will an issue an error if no
7091 nested-name-specifier is present. */
7093 static tree
7099 {
7100 tree scope;
7102 /* Look for the nested-name-specifier. */
7104 typename_keyword_p,
7105 check_dependency_p,
7106 type_p,
7107 is_declaration);
7108 /* If it was not present, issue an error message. */
7110 {
7113 }
7116 }
7118 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
7119 this is either a class-name or a namespace-name (which corresponds
7120 to the class-or-namespace-name production in the grammar). For
7121 C++0x, it can also be a type-name that refers to an enumeration
7122 type or a simple-template-id.
7124 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
7125 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
7126 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
7127 TYPE_P is TRUE iff the next name should be taken as a class-name,
7128 even the same name is declared to be another entity in the same
7129 scope.
7131 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
7132 specified by the class-or-namespace-name. If neither is found the
7133 ERROR_MARK_NODE is returned. */
7135 static tree
7142 {
7143 tree saved_scope;
7144 tree saved_qualifying_scope;
7145 tree saved_object_scope;
7146 tree scope;
7150 /* DR 743: decltype can appear in a nested-name-specifier. */
7152 {
7156 {
7159 }
7163 }
7165 /* Before we try to parse the class-name, we must save away the
7166 current PARSER->SCOPE since cp_parser_class_name will destroy
7167 it. */
7171 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
7172 there is no need to look for a namespace-name. */
7173 only_class_p = template_keyword_p
7178 typename_keyword_p,
7179 template_keyword_p,
7181 check_dependency_p,
7183 is_declaration,
7186 /* If that didn't work, try for a namespace-name. */
7188 {
7189 /* Restore the saved scope. */
7193 /* If we are not looking at an identifier followed by the scope
7194 resolution operator, then this is not part of a
7195 nested-name-specifier. (Note that this function is only used
7196 to parse the components of a nested-name-specifier.) */
7201 }
7204 }
7206 /* Return true if we are looking at a compound-literal, false otherwise. */
7208 static bool
7210 {
7213 /* Skip tokens until the next token is a closing parenthesis.
7214 If we find the closing `)', and the next token is a `{', then
7215 we are looking at a compound-literal. */
7216 bool compound_literal_p
7221 /* Roll back the tokens we skipped. */
7225 }
7227 /* Return true if EXPR is the integer constant zero or a complex constant
7228 of zero, without any folding, but ignoring location wrappers. */
7230 bool
7232 {
7235 }
7237 /* Parse a postfix-expression.
7239 postfix-expression:
7240 primary-expression
7241 postfix-expression [ expression ]
7242 postfix-expression ( expression-list [opt] )
7243 simple-type-specifier ( expression-list [opt] )
7244 typename :: [opt] nested-name-specifier identifier
7245 ( expression-list [opt] )
7246 typename :: [opt] nested-name-specifier template [opt] template-id
7247 ( expression-list [opt] )
7248 postfix-expression . template [opt] id-expression
7249 postfix-expression -> template [opt] id-expression
7250 postfix-expression . pseudo-destructor-name
7251 postfix-expression -> pseudo-destructor-name
7252 postfix-expression ++
7253 postfix-expression --
7254 dynamic_cast < type-id > ( expression )
7255 static_cast < type-id > ( expression )
7256 reinterpret_cast < type-id > ( expression )
7257 const_cast < type-id > ( expression )
7258 typeid ( expression )
7259 typeid ( type-id )
7261 GNU Extension:
7263 postfix-expression:
7264 ( type-id ) { initializer-list , [opt] }
7266 This extension is a GNU version of the C99 compound-literal
7267 construct. (The C99 grammar uses `type-name' instead of `type-id',
7268 but they are essentially the same concept.)
7270 If ADDRESS_P is true, the postfix expression is the operand of the
7271 `&' operator. CAST_P is true if this expression is the target of a
7272 cast.
7274 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
7275 class member access expressions [expr.ref].
7277 Returns a representation of the expression. */
7279 static cp_expr
7283 {
7285 location_t loc;
7291 /* Peek at the next token. */
7296 /* Some of the productions are determined by keywords. */
7299 {
7304 {
7305 tree type;
7306 cp_expr expression;
7310 /* All of these can be handled in the same way from the point
7311 of view of parsing. Begin by consuming the token
7312 identifying the cast. */
7315 /* New types cannot be defined in the cast. */
7317 parser->type_definition_forbidden_message
7320 /* Look for the opening `<'. */
7322 /* Parse the type to which we are casting. */
7326 NULL);
7328 /* Look for the closing `>'. */
7330 /* Restore the old message. */
7333 bool saved_greater_than_is_operator_p
7337 /* And the expression which is being cast. */
7338 matching_parens parens;
7342 RT_CLOSE_PAREN);
7346 parser->greater_than_is_operator_p
7349 /* Only type conversions to integral or enumeration types
7350 can be used in constant-expressions. */
7353 {
7356 }
7358 /* Construct a location e.g. :
7359 reinterpret_cast <int *> (expr)
7360 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
7361 ranging from the start of the "*_cast" token to the final closing
7362 paren, with the caret at the start. */
7366 {
7368 postfix_expression
7370 tf_warning_or_error);
7373 postfix_expression
7375 tf_warning_or_error);
7378 postfix_expression
7380 tf_warning_or_error);
7383 postfix_expression
7385 tf_warning_or_error);
7389 }
7390 }
7394 {
7395 tree type;
7399 /* Consume the `typeid' token. */
7401 /* Look for the `(' token. */
7402 matching_parens parens;
7404 /* Types cannot be defined in a `typeid' expression. */
7406 parser->type_definition_forbidden_message
7408 /* We can't be sure yet whether we're looking at a type-id or an
7409 expression. */
7411 /* Try a type-id first. */
7416 /* Look for the `)' token. Otherwise, we can't be sure that
7417 we're not looking at an expression: consider `typeid (int
7418 (3))', for example. */
7420 /* If all went well, simply lookup the type-id. */
7423 /* Otherwise, fall back to the expression variant. */
7424 else
7425 {
7426 tree expression;
7428 /* Look for an expression. */
7430 /* Compute its typeid. */
7432 /* Look for the `)' token. */
7434 }
7435 /* Restore the saved message. */
7437 /* `typeid' may not appear in an integral constant expression. */
7441 /* Construct a location e.g. :
7442 typeid (expr)
7443 ^~~~~~~~~~~~~
7444 ranging from the start of the "typeid" token to the final closing
7445 paren, with the caret at the start. */
7447 {
7448 location_t typeid_loc
7452 }
7453 }
7457 {
7458 tree type;
7459 /* The syntax permitted here is the same permitted for an
7460 elaborated-type-specifier. */
7467 }
7475 {
7483 {
7486 }
7492 {
7495 postfix_expression
7497 else
7498 {
7502 }
7508 tf_warning_or_error);
7509 else
7510 {
7514 }
7522 else
7523 {
7527 }
7532 postfix_expression
7536 postfix_expression
7539 else
7540 {
7544 }
7549 {
7553 }
7554 else
7555 {
7556 postfix_expression
7558 }
7563 }
7565 }
7568 {
7569 tree expression;
7570 tree type;
7571 /* Consume the `__builtin_convertvector' token. */
7573 /* Look for the opening `('. */
7574 matching_parens parens;
7576 /* Now, parse the assignment-expression. */
7578 /* Look for the `,'. */
7580 location_t type_location
7582 /* Parse the type-id. */
7583 {
7586 }
7587 /* Look for the closing `)'. */
7589 postfix_expression
7591 tf_warning_or_error);
7593 }
7596 {
7597 tree expression;
7598 tree type;
7599 /* Consume the `__builtin_bit_cast' token. */
7601 /* Look for the opening `('. */
7602 matching_parens parens;
7604 location_t type_location
7606 /* Parse the type-id. */
7607 {
7610 }
7611 /* Look for the `,'. */
7613 /* Now, parse the assignment-expression. */
7615 /* Look for the closing `)'. */
7617 postfix_expression
7619 tf_warning_or_error);
7621 }
7624 {
7625 tree type;
7627 /* If the next thing is a simple-type-specifier, we may be
7628 looking at a functional cast. We could also be looking at
7629 an id-expression. So, we try the functional cast, and if
7630 that doesn't work we fall back to the primary-expression. */
7632 /* Look for the simple-type-specifier. */
7636 CP_PARSER_FLAGS_NONE);
7638 /* Parse the cast itself. */
7640 postfix_expression
7642 /* If that worked, we're done. */
7646 /* If the functional-cast didn't work out, try a
7647 compound-literal. */
7650 {
7655 matching_parens parens;
7658 /* Avoid calling cp_parser_type_id pointlessly, see comment
7659 in cp_parser_cast_expression about c++/29234. */
7662 else
7663 {
7664 /* Parse the type. */
7670 }
7672 /* If things aren't going well, there's no need to
7673 keep going. */
7675 {
7677 /* Parse the brace-enclosed initializer list. */
7680 }
7681 /* If that worked, we're definitely looking at a
7682 compound-literal expression. */
7684 {
7685 /* Warn the user that a compound literal is not
7686 allowed in standard C++. */
7689 /* For simplicity, we disallow compound literals in
7690 constant-expressions. We could
7691 allow compound literals of integer type, whose
7692 initializer was a constant, in constant
7693 expressions. Permitting that usage, as a further
7694 extension, would not change the meaning of any
7695 currently accepted programs. (Of course, as
7696 compound literals are not part of ISO C++, the
7697 standard has nothing to say.) */
7699 NIC_NCC))
7700 {
7703 }
7704 /* Form the representation of the compound-literal. */
7705 postfix_expression
7710 }
7711 }
7713 /* It must be a primary-expression. */
7714 postfix_expression
7717 decltype_p,
7719 }
7721 }
7723 /* Note that we don't need to worry about calling build_cplus_new on a
7724 class-valued CALL_EXPR in decltype when it isn't the end of the
7725 postfix-expression; unary_complex_lvalue will take care of that for
7726 all these cases. */
7728 /* Keep looping until the postfix-expression is complete. */
7730 {
7734 /* It is not a Koenig lookup function call. */
7735 postfix_expression
7738 /* Peek at the next token. */
7742 {
7745 {
7747 "two consecutive %<[%> shall "
7750 }
7751 postfix_expression
7753 postfix_expression,
7755 decltype_p);
7764 /* postfix-expression ( expression-list [opt] ) */
7765 {
7777 tree stripped_expression
7779 is_builtin_constant_p
7782 {
7783 /* The whole point of __builtin_constant_p is to allow
7784 non-constant expressions to appear as arguments. */
7785 saved_integral_constant_expression_p
7787 saved_non_integral_constant_expression_p
7790 }
7791 args = (cp_parser_parenthesized_expression_list
7798 {
7799 parser->integral_constant_expression_p
7801 parser->non_integral_constant_expression_p
7803 }
7806 {
7809 }
7811 /* Function calls are not permitted in
7812 constant-expressions. */
7815 NIC_FUNC_CALL))
7816 {
7820 }
7825 {
7827 /* In C++20, we may need to perform ADL for a template
7828 name. */
7831 {
7833 {
7836 postfix_expression
7838 complain);
7839 }
7840 else
7841 postfix_expression
7843 }
7844 /* We do not perform argument-dependent lookup if
7845 normal lookup finds a non-function, in accordance
7846 with the expected resolution of DR 218. */
7849 {
7850 /* Do not do argument dependent lookup if regular
7851 lookup finds a member function or a block-scope
7852 function declaration. [basic.lookup.argdep]/3 */
7856 {
7862 {
7865 }
7866 }
7869 {
7872 postfix_expression
7874 complain);
7875 }
7876 }
7877 }
7879 /* Temporarily set input_location to the combined location
7880 with call expression range, as e.g. build_out_target_exprs
7881 called from convert_default_arg relies on input_location,
7882 so updating it only when the call is fully built results
7883 in inconsistencies between location handling in templates
7884 and outside of templates. */
7887 close_paren_loc);
7891 {
7901 {
7903 postfix_expression
7905 }
7907 {
7908 postfix_expression
7909 = (build_new_method_call
7915 complain));
7916 }
7917 else
7918 postfix_expression
7922 complain);
7923 }
7927 postfix_expression = (build_offset_ref_call_from_tree
7929 complain));
7931 /* A call to a static class member, or a namespace-scope
7932 function. */
7933 postfix_expression
7936 koenig_p,
7937 complain);
7938 else
7939 /* All other function calls. */
7940 postfix_expression
7943 koenig_p,
7944 complain);
7949 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
7953 }
7958 /* postfix-expression . template [opt] id-expression
7959 postfix-expression . pseudo-destructor-name
7960 postfix-expression -> template [opt] id-expression
7961 postfix-expression -> pseudo-destructor-name */
7963 /* Consume the `.' or `->' operator. */
7966 postfix_expression
7968 postfix_expression,
7975 /* postfix-expression ++ */
7976 /* Consume the `++' token. */
7978 /* Generate a representation for the complete expression. */
7979 postfix_expression
7981 POSTINCREMENT_EXPR);
7982 /* Increments may not appear in constant-expressions. */
7990 /* postfix-expression -- */
7991 /* Consume the `--' token. */
7993 /* Generate a representation for the complete expression. */
7994 postfix_expression
7996 POSTDECREMENT_EXPR);
7997 /* Decrements may not appear in constant-expressions. */
8008 return is_member_access
8009 ? postfix_expression
8011 else
8013 }
8014 }
8015 }
8017 /* Helper function for cp_parser_parenthesized_expression_list and
8018 cp_parser_postfix_open_square_expression. Parse a single element
8019 of parenthesized expression list. */
8021 static cp_expr
8025 {
8029 /* Parse the next assignment-expression. */
8031 {
8032 /* A braced-init-list. */
8038 }
8040 {
8046 }
8047 else
8050 /* If we have an ellipsis, then this is an expression expansion. */
8053 {
8054 /* Consume the `...'. */
8057 /* Build the argument pack. */
8059 }
8061 }
8063 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8064 by cp_parser_builtin_offsetof. We're looking for
8066 postfix-expression [ expression ]
8067 postfix-expression [ braced-init-list ] (C++11)
8068 postfix-expression [ expression-list[opt] ] (C++23)
8070 FOR_OFFSETOF is set if we're being called in that context, which
8071 changes how we deal with integer constant expressions. */
8073 static tree
8075 tree postfix_expression,
8078 {
8084 /* Consume the `[' token. */
8090 /* Parse the index expression. */
8091 /* ??? For offsetof, there is a question of what to allow here. If
8092 offsetof is not being used in an integral constant expression context,
8093 then we *could* get the right answer by computing the value at runtime.
8094 If we are in an integral constant expression context, then we might
8095 could accept any constant expression; hard to say without analysis.
8096 Rather than open the barn door too wide right away, allow only integer
8097 constant expressions here. */
8100 else
8101 {
8106 {
8108 {
8109 cp_expr expr
8111 /*cast_p=*/
8113 /*allow_exp_p=*/
8115 /*non_cst_p=*/
8116 NULL);
8123 else
8126 /* If the next token isn't a `,', then we are done. */
8131 {
8134 }
8136 /* Otherwise, consume the `,' and keep going. */
8138 }
8141 }
8143 {
8148 }
8149 else
8153 }
8157 /* Look for the closing `]'. */
8160 /* Build the ARRAY_REF. */
8163 tf_warning_or_error
8166 /* When not doing offsetof, array references are not permitted in
8167 constant-expressions. */
8173 }
8175 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
8176 dereference of incomplete type, returns true if error_mark_node should
8177 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
8178 and *DEPENDENT_P. */
8180 bool
8183 {
8184 /* In a template, be permissive by treating an object expression
8185 of incomplete type as dependent (after a pedwarn). */
8186 diagnostic_t kind = (processing_template_decl
8190 {
8202 /* Don't emit any diagnostic for OVERLOADs. */
8206 /* Avoid clobbering e.g. DECLs. */
8210 }
8222 {
8225 }
8227 }
8229 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
8230 by cp_parser_builtin_offsetof. We're looking for
8232 postfix-expression . template [opt] id-expression
8233 postfix-expression . pseudo-destructor-name
8234 postfix-expression -> template [opt] id-expression
8235 postfix-expression -> pseudo-destructor-name
8237 FOR_OFFSETOF is set if we're being called in that context. That sorta
8238 limits what of the above we'll actually accept, but nevermind.
8239 TOKEN_TYPE is the "." or "->" token, which will already have been
8240 removed from the stream. */
8242 static tree
8245 cp_expr postfix_expression,
8247 location_t location)
8248 {
8249 tree name;
8255 /* If this is a `->' operator, dereference the pointer. */
8258 tf_warning_or_error);
8259 /* Check to see whether or not the expression is type-dependent and
8260 not the current instantiation. */
8262 /* The identifier following the `->' or `.' is not qualified. */
8268 /* Enter the scope corresponding to the type of the object
8269 given by the POSTFIX_EXPRESSION. */
8271 {
8273 /* According to the standard, no expression should ever have
8274 reference type. Unfortunately, we do not currently match
8275 the standard in this respect in that our internal representation
8276 of an expression may have reference type even when the standard
8277 says it does not. Therefore, we have to manually obtain the
8278 underlying type here. */
8280 /* The type of the POSTFIX_EXPRESSION must be complete. */
8281 /* Unlike the object expression in other contexts, *this is not
8282 required to be of complete type for purposes of class member
8283 access (5.2.5) outside the member function body. */
8287 {
8293 }
8296 {
8297 /* Let the name lookup machinery know that we are processing a
8298 class member access expression. */
8300 /* If something went wrong, we want to be able to discern that case,
8301 as opposed to the case where there was no SCOPE due to the type
8302 of expression being dependent. */
8305 /* If the SCOPE was erroneous, make the various semantic analysis
8306 functions exit quickly -- and without issuing additional error
8307 messages. */
8310 }
8311 }
8314 {
8316 /* If we don't have a (type-dependent) object of class type, use
8317 typeof to figure out the type of the object. */
8321 }
8323 /* Assume this expression is not a pseudo-destructor access. */
8326 /* If the SCOPE is a scalar type, then, if this is a valid program,
8327 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
8328 is type dependent, it can be pseudo-destructor-name or something else.
8329 Try to parse it as pseudo-destructor-name first. */
8331 {
8332 tree s;
8333 tree type;
8336 /* Parse the pseudo-destructor-name. */
8345 {
8347 postfix_expression
8350 }
8351 }
8354 {
8355 /* If the SCOPE is not a scalar type, we are looking at an
8356 ordinary class member access expression, rather than a
8357 pseudo-destructor-name. */
8360 /* Parse the id-expression. */
8361 name = (cp_parser_id_expression
8368 /* In general, build a SCOPE_REF if the member name is qualified.
8369 However, if the name was not dependent and has already been
8370 resolved; there is no need to build the SCOPE_REF. For example;
8372 struct X { void f(); };
8373 template <typename T> void f(T* t) { t->X::f(); }
8375 Even though "t" is dependent, "X::f" is not and has been resolved
8376 to a BASELINK; there is no need to include scope information. */
8378 /* But we do need to remember that there was an explicit scope for
8379 virtual function calls. */
8383 /* If the name is a template-id that names a type, we will get a
8384 TYPE_DECL here. That is invalid code. */
8386 {
8389 }
8390 else
8391 {
8393 {
8395 {
8399 }
8400 else
8403 name,
8404 template_p);
8408 }
8410 adjust_result_of_qualified_name_lookup
8412 postfix_expression
8414 template_p,
8415 tf_warning_or_error);
8416 /* Build a location e.g.:
8417 ptr->access_expr
8418 ~~~^~~~~~~~~~~~~
8419 where the caret is at the deref token, ranging from
8420 the start of postfix_expression to the end of the access expr. */
8421 location_t combined_loc
8424 }
8425 }
8427 /* We no longer need to look up names in the scope of the object on
8428 the left-hand side of the `.' or `->' operator. */
8431 /* Outside of offsetof, these operators may not appear in
8432 constant-expressions. */
8434 && (cp_parser_non_integral_constant_expression
8439 }
8441 /* Parse a parenthesized expression-list.
8443 expression-list:
8444 assignment-expression
8445 expression-list, assignment-expression
8447 attribute-list:
8448 expression-list
8449 identifier
8450 identifier, expression-list
8452 CAST_P is true if this expression is the target of a cast.
8454 ALLOW_EXPANSION_P is true if this expression allows expansion of an
8455 argument pack.
8457 WRAP_LOCATIONS_P is true if expressions within this list for which
8458 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
8459 their source locations.
8461 Returns a vector of trees. Each element is a representation of an
8462 assignment-expression. NULL is returned if the ( and or ) are
8463 missing. An empty, but allocated, vector is returned on no
8464 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
8465 if we are parsing an attribute list for an attribute that wants a
8466 plain identifier argument, normal_attr for an attribute that wants
8467 an expression, or non_attr if we aren't parsing an attribute list. If
8468 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
8469 not all of the expressions in the list were constant.
8470 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
8471 will be written to with the location of the closing parenthesis. If
8472 an error occurs, it may or may not be written to. */
8482 {
8486 /* Assume all the expressions will be constant. */
8490 matching_parens parens;
8496 /* Within a parenthesized expression, a `>' token is always
8497 the greater-than operator. */
8498 saved_greater_than_is_operator_p
8504 /* Consume expressions until there are no more. */
8507 {
8508 /* At the beginning of attribute lists, check to see if the
8509 next token is an identifier. */
8515 else
8516 expr
8518 allow_expansion_p,
8519 non_constant_p);
8524 /* Add it to the list. We add error_mark_node
8525 expressions to the list, so that we can still tell if
8526 the correct form for a parenthesized expression-list
8527 is found. That gives better errors. */
8533 /* After the first item, attribute lists look the same as
8534 expression lists. */
8537 get_comma:;
8538 /* If the next token isn't a `,', then we are done. */
8542 /* Otherwise, consume the `,' and keep going. */
8544 }
8550 {
8553 skip_comma:;
8554 /* We try and resync to an unnested comma, as that will give the
8555 user better diagnostics. */
8563 {
8564 parser->greater_than_is_operator_p
8567 }
8568 }
8570 parser->greater_than_is_operator_p
8574 }
8576 /* Parse a pseudo-destructor-name.
8578 pseudo-destructor-name:
8579 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
8580 :: [opt] nested-name-specifier template template-id :: ~ type-name
8581 :: [opt] nested-name-specifier [opt] ~ type-name
8583 If either of the first two productions is used, sets *SCOPE to the
8584 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
8585 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
8586 or ERROR_MARK_NODE if the parse fails. */
8588 static void
8590 tree object,
8593 {
8596 /* Handle ~auto. */
8600 {
8603 "%<~auto%> only available with "
8610 }
8612 /* Assume that things will not work out. */
8615 /* Look for the optional `::' operator. */
8617 /* Look for the optional nested-name-specifier. */
8618 nested_name_specifier_p
8625 /* Now, if we saw a nested-name-specifier, we might be doing the
8626 second production. */
8629 {
8630 /* Consume the `template' keyword. */
8632 /* Parse the template-id. */
8636 class_type,
8638 /* Look for the `::' token. */
8640 }
8641 /* If the next token is not a `~', then there might be some
8642 additional qualification. */
8644 {
8645 /* At this point, we're looking for "type-name :: ~". The type-name
8646 must not be a class-name, since this is a pseudo-destructor. So,
8647 it must be either an enum-name, or a typedef-name -- both of which
8648 are just identifiers. So, we peek ahead to check that the "::"
8649 and "~" tokens are present; if they are not, then we can avoid
8650 calling type_name. */
8654 {
8657 }
8659 /* Look for the type-name. */
8664 /* Look for the `::' token. */
8666 }
8667 else
8670 /* Look for the `~'. */
8673 /* Once we see the ~, this has to be a pseudo-destructor. */
8677 /* Look for the type-name again. We are not responsible for
8678 checking that it matches the first type-name. */
8680 }
8682 /* Parse a unary-expression.
8684 unary-expression:
8685 postfix-expression
8686 ++ cast-expression
8687 -- cast-expression
8688 await-expression
8689 unary-operator cast-expression
8690 sizeof unary-expression
8691 sizeof ( type-id )
8692 alignof ( type-id ) [C++0x]
8693 new-expression
8694 delete-expression
8696 GNU Extensions:
8698 unary-expression:
8699 __extension__ cast-expression
8700 __alignof__ unary-expression
8701 __alignof__ ( type-id )
8702 alignof unary-expression [C++0x]
8703 __real__ cast-expression
8704 __imag__ cast-expression
8705 && identifier
8706 sizeof ( type-id ) { initializer-list , [opt] }
8707 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
8708 __alignof__ ( type-id ) { initializer-list , [opt] }
8710 ADDRESS_P is true iff the unary-expression is appearing as the
8711 operand of the `&' operator. CAST_P is true if this expression is
8712 the target of a cast.
8714 Returns a representation of the expression. */
8716 static cp_expr
8719 {
8723 /* Peek at the next token. */
8725 /* Some keywords give away the kind of expression. */
8727 {
8731 {
8734 {
8742 /* Consume the token. */
8744 /* Parse the operand. */
8747 /* Construct a location e.g. :
8748 alignof (expr)
8749 ^~~~~~~~~~~~~~
8750 with start == caret at the start of the "alignof"/"sizeof"
8751 token, with the endpoint at the final closing paren. */
8752 location_t compound_loc
8758 else
8759 {
8760 /* ISO C++ defines alignof only with types, not with
8761 expressions. So pedwarn if alignof is used with a non-
8762 type expression. However, __alignof__ is ok. */
8765 "ISO C++ does not allow %<alignof%> "
8770 }
8771 /* For SIZEOF_EXPR, just issue diagnostics, but keep
8772 SIZEOF_EXPR with the original operand. */
8774 {
8776 {
8778 {
8781 error_mark_node));
8783 }
8784 else
8789 }
8790 }
8795 }
8807 {
8808 /* The saved value of the PEDANTIC flag. */
8810 tree expr;
8812 /* Save away the PEDANTIC flag. */
8814 /* Parse the cast-expression. */
8816 /* Restore the PEDANTIC flag. */
8820 }
8824 {
8825 tree expression;
8827 /* Consume the `__real__' or `__imag__' token. */
8829 /* Parse the cast-expression. */
8831 /* Create the complete representation. */
8836 tf_warning_or_error);
8837 }
8845 {
8846 tree expr;
8855 matching_parens parens;
8859 parser->type_definition_forbidden_message
8862 saved_integral_constant_expression_p
8864 saved_non_integral_constant_expression_p
8868 saved_greater_than_is_operator_p
8880 parser->greater_than_is_operator_p
8883 parser->integral_constant_expression_p
8885 parser->non_integral_constant_expression_p
8892 /* Construct a location of the form:
8893 noexcept (expr)
8894 ^~~~~~~~~~~~~~~
8895 with start == caret, finishing at the close-paren. */
8896 location_t noexcept_loc
8900 noexcept_loc);
8901 }
8904 {
8905 tree expr;
8908 /* Consume the `co_await' token. */
8910 /* Parse its cast-expression. */
8915 /* Handle [expr.await]. */
8917 }
8921 }
8922 }
8924 /* Look for the `:: new' and `:: delete', which also signal the
8925 beginning of a new-expression, or delete-expression,
8926 respectively. If the next token is `::', then it might be one of
8927 these. */
8929 {
8932 /* See if the token after the `::' is one of the keywords in
8933 which we're interested. */
8935 /* If it's `new', we have a new-expression. */
8938 /* Similarly, for `delete'. */
8941 }
8943 /* Look for a unary operator. */
8945 /* The `++' and `--' operators can be handled similarly, even though
8946 they are not technically unary-operators in the grammar. */
8948 {
8953 /* Handle the GNU address-of-label extension. */
8956 {
8957 tree identifier;
8958 tree expression;
8961 /* Consume the '&&' token. */
8963 /* Look for the identifier. */
8965 /* Construct a location of the form:
8966 &&label
8967 ^~~~~~~
8968 with caret==start at the "&&", finish at the end of the label. */
8969 location_t combined_loc
8971 /* Create an expression representing the address. */
8974 NIC_ADDR_LABEL))
8977 }
8978 }
8980 {
8981 cp_expr cast_expression;
8987 /* Consume the operator token. */
8991 /* Parse the cast-expression. */
8992 cast_expression
8997 pidk);
8999 /* Make a location:
9000 OP_TOKEN CAST_EXPRESSION
9001 ^~~~~~~~~~~~~~~~~~~~~~~~~
9002 with start==caret at the operator token, and
9003 extending to the end of the cast_expression. */
9006 /* Now, build an appropriate representation. */
9008 {
9013 complain);
9014 /* TODO: build_x_indirect_ref does not always honor the
9015 location, so ensure it is set. */
9021 /* Fall through. */
9024 cast_expression,
9026 /* TODO: build_x_unary_op does not always honor the location,
9027 so ensure it is set. */
9035 /* Fall through. */
9037 /* Immediately fold negation of a constant, unless the constant is 0
9038 (since -0 == 0) or it would overflow. */
9040 {
9041 tree stripped_expr
9046 {
9049 stripped_expr);
9051 {
9054 }
9055 }
9056 }
9057 /* Fall through. */
9066 }
9070 non_constant_p))
9074 }
9078 decltype_p,
9079 pidk);
9080 }
9082 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
9083 unary-operator, the corresponding tree code is returned. */
9085 static enum tree_code
9087 {
9089 {
9110 }
9111 }
9113 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
9114 Returns a representation of the expression. */
9116 static tree
9118 {
9121 /* Consume the __builtin_has_attribute token. */
9124 matching_parens parens;
9128 /* Types cannot be defined in a `sizeof' expression. Save away the
9129 old message. */
9133 parser->type_definition_forbidden_message
9135 parser->type_definition_forbidden_message_arg
9138 /* The restrictions on constant-expressions do not apply inside
9139 sizeof expressions. */
9140 bool saved_integral_constant_expression_p
9142 bool saved_non_integral_constant_expression_p
9146 /* Do not actually evaluate the expression. */
9152 /* We can't be sure yet whether we're looking at a type-id or an
9153 expression. */
9158 /* Look for the type-id. */
9164 /* If the type-id production did not work out, then we must be
9165 looking at an expression. */
9171 /* Go back to evaluating expressions. */
9175 /* And restore the old one. */
9178 parser->integral_constant_expression_p
9180 parser->non_integral_constant_expression_p
9183 /* Consume the comma if it's there. */
9185 {
9189 }
9191 /* Parse the attribute specification. */
9195 {
9201 else
9202 {
9203 /* Fold constant expressions used in attributes first. */
9206 /* Finally, see if OPER has been declared with ATTR. */
9208 }
9211 }
9212 else
9213 {
9216 }
9218 /* Construct a location e.g. :
9219 __builtin_has_attribute (oper, attr)
9220 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9221 with start == caret at the start of the built-in token,
9222 and with the endpoint at the final closing paren. */
9223 location_t compound_loc
9230 }
9232 /* Parse a new-expression.
9234 new-expression:
9235 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
9236 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
9238 Returns a representation of the expression. */
9240 static tree
9242 {
9245 tree type;
9248 tree ret;
9252 /* Look for the optional `::' operator. */
9253 global_scope_p
9257 /* Look for the `new' operator. */
9259 /* There's no easy way to tell a new-placement from the
9260 `( type-id )' construct. */
9262 /* Look for a new-placement. */
9264 /* If that didn't work out, there's no new-placement. */
9266 {
9270 }
9272 /* If the next token is a `(', then we have a parenthesized
9273 type-id. */
9275 {
9279 /* Consume the `('. */
9280 matching_parens parens;
9283 /* Parse the type-id. */
9284 parser->type_definition_forbidden_message
9286 {
9289 }
9292 /* Look for the closing `)'. */
9295 /* There should not be a direct-new-declarator in this production,
9296 but GCC used to allowed this, so we check and emit a sensible error
9297 message for this case. */
9299 {
9305 }
9306 }
9307 /* Otherwise, there must be a new-type-id. */
9308 else
9311 /* If the next token is a `(' or '{', then we have a new-initializer. */
9316 else
9319 /* A new-expression may not appear in an integral constant
9320 expression. */
9323 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
9324 of a new-type-id or type-id of a new-expression, the new-expression shall
9325 contain a new-initializer of the form ( assignment-expression )".
9326 Additionally, consistently with the spirit of DR 1467, we want to accept
9327 'new auto { 2 }' too. */
9333 {
9335 "initialization of new-expression for type %<auto%> "
9338 }
9339 else
9340 {
9341 /* Construct a location e.g.:
9342 ptr = new int[100]
9343 ^~~~~~~~~~~~
9344 with caret == start at the start of the "new" token, and the end
9345 at the end of the final token we consumed. */
9348 /* Create a representation of the new-expression. */
9351 }
9359 }
9361 /* Parse a new-placement.
9363 new-placement:
9364 ( expression-list )
9366 Returns the same representation as for an expression-list. */
9370 {
9373 /* Parse the expression-list. */
9374 expression_list = (cp_parser_parenthesized_expression_list
9383 }
9385 /* Parse a new-type-id.
9387 new-type-id:
9388 type-specifier-seq new-declarator [opt]
9390 Returns the TYPE allocated. If the new-type-id indicates an array
9391 type, *NELTS is set to the number of elements in the last array
9392 bound; the TYPE will not include the last array bound. */
9394 static tree
9396 {
9397 cp_decl_specifier_seq type_specifier_seq;
9403 /* The type-specifier sequence must not contain type definitions.
9404 (It cannot contain declarations of new types either, but if they
9405 are not definitions we will catch that because they are not
9406 complete.) */
9408 parser->type_definition_forbidden_message
9410 /* Parse the type-specifier-seq. */
9415 /* Restore the old message. */
9421 /* Parse the new-declarator. */
9424 /* Determine the number of elements in the last array dimension, if
9425 any. */
9427 /* Skip down to the last array dimension. */
9432 {
9435 }
9440 {
9443 }
9446 {
9455 else
9457 }
9460 }
9462 /* Parse an (optional) new-declarator.
9464 new-declarator:
9465 ptr-operator new-declarator [opt]
9466 direct-new-declarator
9468 Returns the declarator. */
9472 {
9475 cp_cv_quals cv_quals;
9477 /* We don't know if there's a ptr-operator next, or not. */
9479 /* Look for a ptr-operator. */
9481 /* If that worked, look for more new-declarators. */
9483 {
9486 /* Parse another optional declarator. */
9489 declarator = cp_parser_make_indirect_declarator
9493 }
9495 /* If the next token is a `[', there is a direct-new-declarator. */
9500 }
9502 /* Parse a direct-new-declarator.
9504 direct-new-declarator:
9505 [ expression ]
9506 direct-new-declarator [constant-expression]
9508 */
9512 {
9517 {
9518 tree expression;
9521 /* Look for the opening `['. */
9527 else
9529 /* The standard requires that the expression have integral
9530 type. DR 74 adds enumeration types. We believe that the
9531 real intent is that these expressions be handled like the
9532 expression in a `switch' condition, which also allows
9533 classes with a single conversion to integral or
9534 enumeration type. */
9536 {
9537 expression
9539 expression,
9542 {
9544 "expression in new-declarator must have integral "
9547 }
9548 }
9550 /* Look for the closing `]'. */
9553 /* Add this bound to the declarator. */
9556 /* If the next token is not a `[', then there are no more
9557 bounds. */
9561 }
9564 }
9566 /* Parse a new-initializer.
9568 new-initializer:
9569 ( expression-list [opt] )
9570 braced-init-list
9572 Returns a representation of the expression-list. */
9576 {
9580 {
9581 tree t;
9588 }
9589 else
9590 expression_list = (cp_parser_parenthesized_expression_list
9596 }
9598 /* Parse a delete-expression.
9600 delete-expression:
9601 :: [opt] delete cast-expression
9602 :: [opt] delete [ ] cast-expression
9604 Returns a representation of the expression. */
9606 static tree
9608 {
9611 tree expression;
9614 /* Look for the optional `::' operator. */
9615 global_scope_p
9619 /* Look for the `delete' keyword. */
9621 /* See if the array syntax is in use. */
9623 {
9624 /* Consume the `[' token. */
9626 /* Look for the `]' token. */
9628 /* Remember that this is the `[]' construct. */
9630 }
9631 else
9634 /* Parse the cast-expression. */
9637 /* A delete-expression may not appear in an integral constant
9638 expression. */
9642 /* Construct a location e.g.:
9643 delete [ ] ptr
9644 ^~~~~~~~~~~~~~
9645 with caret == start at the start of the "delete" token, and
9646 the end at the end of the final token we consumed. */
9653 }
9655 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9656 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9657 0 otherwise. */
9659 static int
9661 {
9664 {
9706 /* In ((type ()) () the last () isn't a valid cast-expression,
9707 so the whole must be parsed as postfix-expression. */
9712 /* '[' may start a primary-expression in obj-c++ and in C++11,
9713 as a lambda-expression, eg, '(void)[]{}'. */
9720 /* '++' and '--' may or may not start a cast-expression:
9722 struct T { void operator++(int); };
9723 void f() { (T())++; }
9725 vs
9727 int a;
9728 (int)++a; */
9733 }
9734 }
9736 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
9737 in the order: const_cast, static_cast, reinterpret_cast.
9739 Don't suggest dynamic_cast.
9741 Return the first legal cast kind found, or NULL otherwise. */
9745 {
9746 tree trial;
9748 /* Reuse the parser logic by attempting to build the various kinds of
9749 cast, with "complain" disabled.
9750 Identify the first such cast that is valid. */
9752 /* Don't attempt to run such logic within template processing. */
9756 /* First try const_cast. */
9761 /* If that fails, try static_cast. */
9766 /* Finally, try reinterpret_cast. */
9768 tf_none);
9772 /* No such cast possible. */
9774 }
9776 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
9777 suggesting how to convert a C-style cast of the form:
9779 (DST_TYPE)ORIG_EXPR
9781 to a C++-style cast.
9783 The primary range of RICHLOC is asssumed to be that of the original
9784 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
9785 of the parens in the C-style cast. */
9787 static void
9790 tree dst_type)
9791 {
9792 /* This function is non-trivial, so bail out now if the warning isn't
9793 going to be emitted. */
9797 /* Try to find a legal C++ cast, trying them in order:
9798 const_cast, static_cast, reinterpret_cast. */
9803 /* Replace the open paren with "CAST_SUGGESTION<". */
9804 pretty_printer pp;
9809 /* Replace the close paren with "> (". */
9812 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
9814 }
9817 /* Parse a cast-expression.
9819 cast-expression:
9820 unary-expression
9821 ( type-id ) cast-expression
9823 ADDRESS_P is true iff the unary-expression is appearing as the
9824 operand of the `&' operator. CAST_P is true if this expression is
9825 the target of a cast.
9827 Returns a representation of the expression. */
9829 static cp_expr
9832 {
9833 /* If it's a `(', then we might be looking at a cast. */
9835 {
9841 /* There's no way to know yet whether or not this is a cast.
9842 For example, `(int (3))' is a unary-expression, while `(int)
9843 3' is a cast. So, we resort to parsing tentatively. */
9845 /* Types may not be defined in a cast. */
9847 parser->type_definition_forbidden_message
9849 /* Consume the `('. */
9850 matching_parens parens;
9855 /* A very tricky bit is that `(struct S) { 3 }' is a
9856 compound-literal (which we permit in C++ as an extension).
9857 But, that construct is not a cast-expression -- it is a
9858 postfix-expression. (The reason is that `(struct S) { 3 }.i'
9859 is legal; if the compound-literal were a cast-expression,
9860 you'd need an extra set of parentheses.) But, if we parse
9861 the type-id, and it happens to be a class-specifier, then we
9862 will commit to the parse at that point, because we cannot
9863 undo the action that is done when creating a new class. So,
9864 then we cannot back up and do a postfix-expression.
9866 Another tricky case is the following (c++/29234):
9868 struct S { void operator () (); };
9870 void foo ()
9871 {
9872 ( S()() );
9873 }
9875 As a type-id we parse the parenthesized S()() as a function
9876 returning a function, groktypename complains and we cannot
9877 back up in this case either.
9879 Therefore, we scan ahead to the closing `)', and check to see
9880 if the tokens after the `)' can start a cast-expression. Otherwise
9881 we are dealing with an unary-expression, a postfix-expression
9882 or something else.
9884 Yet another tricky case, in C++11, is the following (c++/54891):
9886 (void)[]{};
9888 The issue is that usually, besides the case of lambda-expressions,
9889 the parenthesized type-id cannot be followed by '[', and, eg, we
9890 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
9891 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
9892 we don't commit, we try a cast-expression, then an unary-expression.
9894 Save tokens so that we can put them back. */
9897 /* We may be looking at a cast-expression. */
9900 cast_expression
9903 /* Roll back the tokens we skipped. */
9905 /* If we aren't looking at a cast-expression, simulate an error so
9906 that the call to cp_parser_error_occurred below returns true. */
9909 else
9910 {
9913 /* Look for the type-id. */
9915 /* Look for the closing `)'. */
9920 }
9922 /* Restore the saved message. */
9925 /* At this point this can only be either a cast or a
9926 parenthesized ctor such as `(T ())' that looks like a cast to
9927 function returning T. */
9929 {
9930 /* Only commit if the cast-expression doesn't start with
9931 '++', '--', or '[' in C++11. */
9939 pidk);
9942 {
9943 /* Warn about old-style casts, if so requested. */
9948 {
9954 }
9956 /* Only type conversions to integral or enumeration types
9957 can be used in constant-expressions. */
9960 NIC_CAST))
9963 /* Perform the cast. */
9964 /* Make a location:
9965 (TYPE) EXPR
9966 ^~~~~~~~~~~
9967 with start==caret at the open paren, extending to the
9968 end of "expr". */
9970 open_paren_loc,
9974 }
9975 }
9976 else
9978 }
9980 /* If we get here, then it's not a cast, so it must be a
9981 unary-expression. */
9984 }
9986 /* Parse a binary expression of the general form:
9988 pm-expression:
9989 cast-expression
9990 pm-expression .* cast-expression
9991 pm-expression ->* cast-expression
9993 multiplicative-expression:
9994 pm-expression
9995 multiplicative-expression * pm-expression
9996 multiplicative-expression / pm-expression
9997 multiplicative-expression % pm-expression
9999 additive-expression:
10000 multiplicative-expression
10001 additive-expression + multiplicative-expression
10002 additive-expression - multiplicative-expression
10004 shift-expression:
10005 additive-expression
10006 shift-expression << additive-expression
10007 shift-expression >> additive-expression
10009 relational-expression:
10010 shift-expression
10011 relational-expression < shift-expression
10012 relational-expression > shift-expression
10013 relational-expression <= shift-expression
10014 relational-expression >= shift-expression
10016 GNU Extension:
10018 relational-expression:
10019 relational-expression <? shift-expression
10020 relational-expression >? shift-expression
10022 equality-expression:
10023 relational-expression
10024 equality-expression == relational-expression
10025 equality-expression != relational-expression
10027 and-expression:
10028 equality-expression
10029 and-expression & equality-expression
10031 exclusive-or-expression:
10032 and-expression
10033 exclusive-or-expression ^ and-expression
10035 inclusive-or-expression:
10036 exclusive-or-expression
10037 inclusive-or-expression | exclusive-or-expression
10039 logical-and-expression:
10040 inclusive-or-expression
10041 logical-and-expression && inclusive-or-expression
10043 logical-or-expression:
10044 logical-and-expression
10045 logical-or-expression || logical-and-expression
10047 All these are implemented with a single function like:
10049 binary-expression:
10050 simple-cast-expression
10051 binary-expression <token> binary-expression
10053 CAST_P is true if this expression is the target of a cast.
10055 The binops_by_token map is used to get the tree codes for each <token> type.
10056 binary-expressions are associated according to a precedence table. */
10058 #define TOKEN_PRECEDENCE(token) \
10059 (((token->type == CPP_GREATER \
10060 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
10061 && !parser->greater_than_is_operator_p) \
10062 ? PREC_NOT_OPERATOR \
10063 : binops_by_token[token->type].prec)
10065 static cp_expr
10071 {
10072 cp_parser_expression_stack stack;
10075 cp_parser_expression_stack_entry current;
10076 cp_expr rhs;
10080 tree overload;
10082 /* Parse the first expression. */
10093 {
10094 /* Get an operator token. */
10100 {
10102 "%<>>%> operator is treated"
10106 }
10111 /* This is a fold-expression; handle it later. */
10114 /* Popping an entry off the stack means we completed a subexpression:
10115 - either we found a token which is not an operator (`>' where it is not
10116 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
10117 will happen repeatedly;
10118 - or, we found an operator which has lower priority. This is the case
10119 where the recursive descent *ascends*, as in `3 * 4 + 5' after
10120 parsing `3 * 4'. */
10122 {
10125 else
10127 }
10129 get_rhs:
10134 /* We used the operator token. */
10137 /* For "false && x" or "true || x", x will never be executed;
10138 disable warnings while evaluating it. */
10143 {
10146 }
10148 /* Extract another operand. It may be the RHS of this expression
10149 or the LHS of a new, higher priority expression. */
10154 /* Get another operator token. Look up its precedence to avoid
10155 building a useless (immediately popped) stack entry for common
10156 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
10163 {
10164 /* ... and prepare to parse the RHS of the new, higher priority
10165 expression. Since precedence levels on the stack are
10166 monotonically increasing, we do not have to care about
10167 stack overflows. */
10176 pop:
10178 /* If the stack is not empty, we have parsed into LHS the right side
10179 (`4' in the example above) of an expression we had suspended.
10180 We can use the information on the stack to recover the LHS (`3')
10181 from the stack together with the tree code (`MULT_EXPR'), and
10182 the precedence of the higher level subexpression
10183 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
10184 which will be used to actually build the additive expression. */
10189 }
10191 /* Undo the disabling of warnings done above. */
10193 {
10196 }
10201 /* Avoid warning for !!x == y. */
10206 /* Avoid warning for !b == y where b is boolean. */
10210 /* Avoid warning for !!b == y where b is boolean. */
10219 /* Don't warn for named "xor" (as opposed to '^'). */
10223 check_for_xor_used_as_pow
10235 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
10236 ERROR_MARK for everything that is not a binary expression.
10237 This makes warn_about_parentheses miss some warnings that
10238 involve unary operators. For unary expressions we should
10239 pass the correct tree_code unless the unary expression was
10240 surrounded by parentheses.
10241 */
10245 {
10248 else
10249 {
10252 current.lhs
10255 == tcc_comparison
10259 }
10260 }
10261 else
10262 {
10268 /* TODO: build_x_binary_op doesn't always honor the location. */
10270 }
10273 /* If the binary operator required the use of an overloaded operator,
10274 then this expression cannot be an integral constant-expression.
10275 An overloaded operator can be used even if both operands are
10276 otherwise permissible in an integral constant-expression if at
10277 least one of the operands is of enumeration type. */
10281 NIC_OVERLOADED))
10283 }
10286 }
10288 static cp_expr
10293 {
10296 }
10298 /* Parse the `? expression : assignment-expression' part of a
10299 conditional-expression. The LOGICAL_OR_EXPR is the
10300 logical-or-expression that started the conditional-expression.
10301 Returns a representation of the entire conditional-expression.
10303 This routine is used by cp_parser_assignment_expression
10304 and cp_parser_conditional_expression.
10306 ? expression : assignment-expression
10308 GNU Extensions:
10310 ? : assignment-expression */
10312 static tree
10314 {
10316 cp_expr assignment_expr;
10320 /* Consume the `?' token. */
10325 {
10328 /* Implicit true clause. */
10330 c_inhibit_evaluation_warnings +=
10333 }
10334 else
10335 {
10338 /* Parse the expression. */
10339 c_inhibit_evaluation_warnings +=
10342 c_inhibit_evaluation_warnings +=
10346 }
10348 /* The next token should be a `:'. */
10350 /* Parse the assignment-expression. */
10352 c_inhibit_evaluation_warnings -=
10355 /* Make a location:
10356 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
10357 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
10358 with the caret at the "?", ranging from the start of
10359 the logical_or_expr to the end of the assignment_expr. */
10364 /* Build the conditional-expression. */
10366 expr,
10367 assignment_expr,
10368 tf_warning_or_error);
10369 }
10371 /* Parse a conditional-expression.
10373 conditional-expression:
10374 logical-or-expression
10375 logical-or-expression ? expression : assignment-expression
10377 GNU Extensions:
10379 logical-or-expression ? : assignment-expression */
10381 static cp_expr
10383 {
10386 /* If the next token is a `?' then we're actually looking at
10387 a conditional-expression; otherwise we're done. */
10391 }
10393 /* Parse an assignment-expression.
10395 assignment-expression:
10396 conditional-expression
10397 logical-or-expression assignment-operator assignment_expression
10398 throw-expression
10399 yield-expression
10401 CAST_P is true if this expression is the target of a cast.
10402 DECLTYPE_P is true if this expression is the operand of decltype.
10404 Returns a representation for the expression. */
10406 static cp_expr
10409 {
10410 cp_expr expr;
10412 /* If the next token is the `throw' keyword, then we're looking at
10413 a throw-expression. */
10416 /* If the next token is the `co_yield' keyword, then we're looking at
10417 a yield-expression. */
10420 /* Otherwise, it must be that we are looking at a
10421 logical-or-expression. */
10422 else
10423 {
10424 /* Parse the binary expressions (logical-or-expression). */
10426 decltype_p,
10428 /* If the next token is a `?' then we're actually looking at a
10429 conditional-expression. */
10432 else
10433 {
10436 /* If it's an assignment-operator, we're using the second
10437 production. */
10438 enum tree_code assignment_operator
10441 {
10444 /* Parse the right-hand side of the assignment. */
10451 /* An assignment may not appear in a
10452 constant-expression. */
10454 NIC_ASSIGNMENT))
10456 /* Build the assignment expression. Its default
10457 location:
10458 LHS = RHS
10459 ~~~~^~~~~
10460 is the location of the '=' token as the
10461 caret, ranging from the start of the lhs to the
10462 end of the rhs. */
10467 assignment_operator,
10470 /* TODO: build_x_modify_expr doesn't honor the location,
10471 so we must set it here. */
10473 }
10474 }
10475 }
10478 }
10480 /* Parse an (optional) assignment-operator.
10482 assignment-operator: one of
10483 = *= /= %= += -= >>= <<= &= ^= |=
10485 GNU Extension:
10487 assignment-operator: one of
10488 <?= >?=
10490 If the next token is an assignment operator, the corresponding tree
10491 code is returned, and the token is consumed. For example, for
10492 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
10493 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
10494 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
10495 operator, ERROR_MARK is returned. */
10497 static enum tree_code
10499 {
10503 /* Peek at the next token. */
10507 {
10553 /* Nothing else is an assignment operator. */
10555 }
10557 /* An operator followed by ... is a fold-expression, handled elsewhere. */
10562 /* If it was an assignment operator, consume it. */
10567 }
10569 /* Parse an expression.
10571 expression:
10572 assignment-expression
10573 expression , assignment-expression
10575 CAST_P is true if this expression is the target of a cast.
10576 DECLTYPE_P is true if this expression is the immediate operand of decltype,
10577 except possibly parenthesized or on the RHS of a comma (N3276).
10578 WARN_COMMA_P is true if a comma should be diagnosed.
10580 Returns a representation of the expression. */
10582 static cp_expr
10585 {
10590 {
10591 cp_expr assignment_expression;
10593 /* Parse the next assignment-expression. */
10594 assignment_expression
10597 /* We don't create a temporary for a call that is the immediate operand
10598 of decltype or on the RHS of a comma. But when we see a comma, we
10599 need to create a temporary for a call on the LHS. */
10604 assignment_expression
10608 /* If this is the first assignment-expression, we can just
10609 save it away. */
10612 else
10613 {
10614 /* Create a location with caret at the comma, ranging
10615 from the start of the LHS to the end of the RHS. */
10623 }
10624 /* If the next token is not a comma, or we're in a fold-expression, then
10625 we are done with the expression. */
10629 /* Consume the `,'. */
10632 {
10633 /* [depr.comma.subscript]: A comma expression appearing as
10634 the expr-or-braced-init-list of a subscripting expression
10635 is deprecated. A parenthesized comma expression is not
10636 deprecated. */
10638 "top-level comma expression in array subscript "
10641 }
10643 /* A comma operator cannot appear in a constant-expression. */
10646 }
10649 }
10651 /* Parse a constant-expression.
10653 constant-expression:
10654 conditional-expression
10656 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
10657 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
10658 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
10659 is false, NON_CONSTANT_P should be NULL. If ALLOW_NON_CONSTANT_P is
10660 greater than 1, this isn't really a constant-expression, only a
10661 potentially constant-evaluated expression. If STRICT_P is true,
10662 only parse a conditional-expression, otherwise parse an
10663 assignment-expression. See below for rationale. */
10665 static cp_expr
10670 {
10674 cp_expr expression;
10676 /* It might seem that we could simply parse the
10677 conditional-expression, and then check to see if it were
10678 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
10679 one that the compiler can figure out is constant, possibly after
10680 doing some simplifications or optimizations. The standard has a
10681 precise definition of constant-expression, and we must honor
10682 that, even though it is somewhat more restrictive.
10684 For example:
10686 int i[(2, 3)];
10688 is not a legal declaration, because `(2, 3)' is not a
10689 constant-expression. The `,' operator is forbidden in a
10690 constant-expression. However, GCC's constant-folding machinery
10691 will fold this operation to an INTEGER_CST for `3'. */
10693 /* Save the old settings. */
10695 saved_allow_non_integral_constant_expression_p
10698 /* We are now parsing a constant-expression. */
10700 parser->allow_non_integral_constant_expression_p
10704 /* A manifestly constant-evaluated expression is evaluated even in an
10705 unevaluated operand. */
10708 /* Although the grammar says "conditional-expression", when not STRICT_P,
10709 we parse an "assignment-expression", which also permits
10710 "throw-expression" and the use of assignment operators. In the case
10711 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
10712 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
10713 actually essential that we look for an assignment-expression.
10714 For example, cp_parser_initializer_clauses uses this function to
10715 determine whether a particular assignment-expression is in fact
10716 constant. */
10719 else
10721 /* Restore the old settings. */
10722 parser->integral_constant_expression_p
10724 parser->allow_non_integral_constant_expression_p
10727 {
10728 /* Require an rvalue constant expression here; that's what our
10729 callers expect. Reference constant expressions are handled
10730 separately in e.g. cp_parser_template_argument. */
10739 }
10742 parser->non_integral_constant_expression_p
10746 }
10748 /* Parse __builtin_offsetof.
10750 offsetof-expression:
10751 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
10753 offsetof-member-designator:
10754 id-expression
10755 | offsetof-member-designator "." id-expression
10756 | offsetof-member-designator "[" expression "]"
10757 | offsetof-member-designator "->" id-expression */
10759 static cp_expr
10761 {
10763 tree type;
10764 cp_expr expr;
10765 cp_id_kind dummy;
10767 location_t finish_loc;
10769 /* We're about to accept non-integral-constant things, but will
10770 definitely yield an integral constant expression. Save and
10771 restore these values around our local parsing. */
10777 /* Consume the "__builtin_offsetof" token. */
10779 /* Consume the opening `('. */
10780 matching_parens parens;
10782 /* Parse the type-id. */
10784 {
10786 parser->type_definition_forbidden_message
10790 }
10791 /* Look for the `,'. */
10795 /* Build the (type *)null that begins the traditional offsetof macro. */
10796 tree object_ptr
10800 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
10804 {
10807 {
10809 /* offsetof-member-designator "[" expression "]" */
10815 /* offsetof-member-designator "->" identifier */
10818 /* FALLTHRU */
10821 /* offsetof-member-designator "." identifier */
10829 /* Consume the ")" token. */
10835 /* Error. We know the following require will fail, but
10836 that gives the proper error message. */
10841 }
10842 }
10844 success:
10845 /* Make a location of the form:
10846 __builtin_offsetof (struct s, f)
10847 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
10848 with caret at the type-id, ranging from the start of the
10849 "_builtin_offsetof" token to the close paren. */
10851 /* The result will be an INTEGER_CST, so we need to explicitly
10852 preserve the location. */
10855 failure:
10861 }
10863 /* Parse a builtin trait expression or type. */
10865 static cp_expr
10867 {
10868 cp_trait_kind kind;
10875 {
10876 #define DEFTRAIT(TCC, CODE, NAME, ARITY) \
10877 case RID_##CODE: \
10878 kind = CPTK_##CODE; \
10879 binary = (ARITY == 2); \
10880 variadic = (ARITY == -1); \
10881 type = (TCC == tcc_type); \
10882 break;
10884 #undef DEFTRAIT
10887 }
10889 /* Get location of initial token. */
10892 /* Consume the token. */
10895 matching_parens parens;
10898 {
10901 }
10907 {
10910 {
10913 }
10917 }
10919 {
10921 {
10925 {
10928 }
10932 }
10934 }
10939 /* Construct a location of the form:
10940 __is_trivially_copyable(_Tp)
10941 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
10942 with start == caret, finishing at the close-paren. */
10945 /* Complete the trait expression, which may mean either processing
10946 the trait expr now or saving it for template instantiation. */
10948 {
10956 else
10958 }
10959 }
10961 /* Parse a lambda expression.
10963 lambda-expression:
10964 lambda-introducer lambda-declarator [opt] compound-statement
10965 lambda-introducer < template-parameter-list > requires-clause [opt]
10966 lambda-declarator [opt] compound-statement
10968 Returns a representation of the expression. */
10970 static cp_expr
10972 {
10974 tree type;
10982 {
10983 /* C++20 allows lambdas in unevaluated context, but one in the type of a
10984 non-type parameter is nonsensical.
10986 Distinguish a lambda in the parameter type from a lambda in the
10987 default argument by looking at local_variables_forbidden_p, which is
10988 only set in default arguments. */
10990 {
10995 }
10996 }
10998 {
11000 {
11002 "lambda-expression in unevaluated context"
11005 }
11007 }
11009 {
11011 {
11015 }
11017 }
11019 /* We may be in the middle of deferred access check. Disable
11020 it now. */
11033 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
11036 /* Now that we've started the type, add the capture fields for any
11037 explicit captures. */
11040 {
11041 /* Inside the class, surrounding template-parameter-lists do not apply. */
11042 unsigned int saved_num_template_parameter_lists
11046 bool fully_implicit_function_template_p
11050 bool auto_is_implicit_function_template_parm_p
11061 /* The body of a lambda in a discarded statement is not discarded. */
11065 /* Similarly the body of a lambda in immediate function context is not
11066 in immediate function context. */
11070 /* By virtue of defining a local class, a lambda expression has access to
11071 the private variables of enclosing classes. */
11082 {
11084 }
11086 {
11089 }
11091 /* The capture list was built up in reverse order; fix that now. */
11106 parser->fully_implicit_function_template_p
11110 parser->auto_is_implicit_function_template_parm_p
11112 }
11114 /* This field is only used during parsing of the lambda. */
11117 /* This lambda shouldn't have any proxies left at this point. */
11119 /* And now that we're done, push proxies for an enclosing lambda. */
11122 /* Update the lambda expression to a range. */
11129 else
11137 }
11139 /* Parse the beginning of a lambda expression.
11141 lambda-introducer:
11142 [ lambda-capture [opt] ]
11144 LAMBDA_EXPR is the current representation of the lambda expression. */
11146 static void
11148 {
11149 /* Need commas after the first capture. */
11152 /* Eat the leading `['. */
11155 /* Record default capture mode. "[&" "[=" "[&," "[=," */
11165 {
11171 }
11176 {
11178 tree capture_id;
11179 tree capture_init_expr;
11183 enum capture_kind_type
11184 {
11185 BY_COPY,
11186 BY_REFERENCE
11187 };
11191 {
11194 }
11198 else
11201 /* Possibly capture `this'. */
11203 {
11208 "explicit by-copy capture of %<this%> "
11209 "with by-copy capture default only available with "
11215 this_identifier);
11216 else
11221 }
11223 /* Possibly capture `*this'. */
11226 {
11230 "%<*this%> capture only available with "
11237 this_identifier);
11238 else
11243 }
11245 /* But reject `&this'. */
11248 {
11254 }
11256 /* Remember whether we want to capture as a reference or not. */
11258 {
11261 }
11266 {
11270 "pack init-capture only available with "
11274 }
11276 /* Early C++20 drafts had ...& instead of &...; be forgiving. */
11279 {
11284 }
11286 /* Get the identifier. */
11291 /* Would be nice to have a cp_parser_skip_to_closing_x for general
11292 delimiters, but I modified this to stop on unnested ']' as well. It
11293 was already changed to stop on unnested '}', so the
11294 "closing_parenthesis" name is no more misleading with my change. */
11295 {
11301 }
11303 /* Find the initializer for this capture. */
11307 {
11309 /* An explicit initializer exists. */
11312 "lambda capture initializers "
11318 {
11321 }
11324 }
11325 else
11326 {
11329 /* Turn the identifier into an id-expression. */
11330 capture_init_expr
11335 {
11338 }
11341 {
11344 capture_init_expr);
11349 }
11352 {
11355 capture_init_expr))
11359 }
11361 capture_init_expr
11362 = finish_id_expression
11364 capture_init_expr,
11378 {
11383 {
11384 /* If what follows is an initializer, the second '...' is
11385 invalid. But for cases like [...xs...], the first one
11386 is invalid. */
11393 }
11394 }
11395 }
11399 {
11404 capture_id);
11408 "capture of %qD redundant with by-reference capture "
11410 }
11412 /* Check for duplicates.
11413 Optimize for the zero or one explicit captures cases and only create
11414 the hash_set after adding second capture. */
11422 else
11423 {
11426 }
11430 else
11433 explicit_init_p);
11435 /* If there is any qualification still in effect, clear it
11436 now; we will be starting fresh with the next capture. */
11440 }
11443 }
11445 /* Parse the (optional) middle of a lambda expression.
11447 lambda-declarator:
11448 ( parameter-declaration-clause ) lambda-specifiers requires-clause [opt]
11449 lambda-specifiers (C++23)
11451 lambda-specifiers:
11452 decl-specifier-seq [opt] noexcept-specifier [opt]
11453 attribute-specifier-seq [opt] trailing-return-type [opt]
11455 LAMBDA_EXPR is the current representation of the lambda expression. */
11457 static bool
11459 {
11460 /* 5.1.1.4 of the standard says:
11461 If a lambda-expression does not include a lambda-declarator, it is as if
11462 the lambda-declarator were ().
11463 This means an empty parameter list, no attributes, and no exception
11464 specification. */
11475 cp_decl_specifier_seq lambda_specs;
11477 /* A lambda op() is const unless explicitly 'mutable'. */
11480 /* The template-parameter-list is optional, but must begin with
11481 an opening angle if present. */
11483 {
11486 "lambda templates are only available with "
11490 "lambda templates are only available with "
11498 /* We may have a constrained generic lambda; parse the requires-clause
11499 immediately after the template-parameter-list and combine with any
11500 shorthand constraints present. */
11503 {
11508 }
11510 /* We just processed one more parameter list. */
11512 }
11514 /* Committee discussion supports allowing attributes here. */
11517 /* The parameter-declaration-clause is optional (unless
11518 template-parameter-list was given), but must begin with an
11519 opening parenthesis if present. */
11521 {
11522 matching_parens parens;
11527 /* Parse parameters. */
11528 param_list
11529 = cp_parser_parameter_declaration_clause
11532 /* Default arguments shall not be specified in the
11533 parameter-declaration-clause of a lambda-declarator. */
11538 OPT_Wc__14_extensions,
11543 }
11547 /* In the decl-specifier-seq of the lambda-declarator, each
11548 decl-specifier shall either be mutable or constexpr. */
11552 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
11556 {
11558 "parameter declaration before lambda declaration "
11559 "specifiers only optional with %<-std=c++2b%> or "
11562 }
11565 {
11568 }
11570 {
11575 else
11576 {
11579 }
11580 }
11584 {
11586 "parameter declaration before lambda transaction "
11587 "qualifier only optional with %<-std=c++2b%> or "
11590 }
11592 /* Parse optional exception specification. */
11593 exception_spec
11597 {
11599 "parameter declaration before lambda exception "
11600 "specification only optional with %<-std=c++2b%> or "
11603 }
11605 /* GCC 8 accepted attributes here, and this is the place for standard C++11
11606 attributes that appertain to the function type. */
11609 else
11612 /* Parse optional trailing return type. */
11614 {
11617 "parameter declaration before lambda trailing "
11618 "return type only optional with %<-std=c++2b%> or "
11622 }
11624 /* Also allow GNU attributes at the very end of the declaration, the usual
11625 place for GNU attributes. */
11630 {
11631 /* Parse optional trailing requires clause. */
11634 /* The function parameters must be in scope all the way until after the
11635 trailing-return-type in case of decltype. */
11637 }
11639 /* Create the function call operator.
11641 Messing with declarators like this is no uglier than building up the
11642 FUNCTION_DECL by hand, and this is less likely to get out of sync with
11643 other code. */
11644 {
11645 cp_decl_specifier_seq return_type_specs;
11647 tree fco;
11654 {
11658 else
11660 "lambda only available with %<-std=c++17%> or "
11662 }
11667 {
11671 }
11679 VIRT_SPEC_UNSPECIFIED,
11680 REF_QUAL_NONE,
11681 tx_qual,
11682 exception_spec,
11683 return_type,
11684 trailing_requires_clause,
11685 UNKNOWN_LOCATION);
11689 declarator,
11692 {
11696 /* Give the object parameter a different name. */
11699 }
11701 {
11705 }
11714 }
11715 }
11717 /* Parse the body of a lambda expression, which is simply
11719 compound-statement
11721 but which requires special handling.
11722 LAMBDA_EXPR is the current representation of the lambda expression. */
11724 static void
11726 {
11728 unsigned char local_variables_forbidden_p
11732 /* The body of a lambda-expression is not a subexpression of the enclosing
11733 expression. */
11734 cp_evaluated ev;
11738 else
11739 /* Still increment function_depth so that we don't GC in the
11740 middle of an expression. */
11748 /* Clear this in case we're in the middle of a default argument. */
11752 {
11757 /* Originally C++11 required us to peek for 'return expr'; and
11758 process it specially here to deduce the return type. N3638
11759 removed the need for that. */
11763 }
11770 else
11772 }
11774 /* Statements [gram.stmt.stmt] */
11776 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
11778 static void
11780 {
11784 /* A concept is never expanded normally. */
11790 }
11792 struct cp_omp_attribute_data
11793 {
11796 c_omp_directive_kind kind;
11797 };
11799 /* Handle omp::directive and omp::sequence attributes in ATTRS
11800 (if any) at the start of a statement or in attribute-declaration. */
11802 static tree
11804 {
11815 {
11816 cnt++;
11818 {
11824 {
11826 "mixing OpenMP directives with attribute and pragma "
11830 }
11833 {
11841 else
11844 }
11850 {
11852 "unknown OpenMP directive name in %<omp::directive%>"
11855 }
11858 {
11859 /* ordered is C_OMP_DIR_CONSTRUCT only if it doesn't contain
11860 depend/doacross clause. */
11873 }
11875 {
11876 /* error with at(execution) clause is C_OMP_DIR_STANDALONE. */
11880 paren_depth++;
11882 paren_depth--;
11893 {
11896 }
11897 }
11902 }
11903 cp_omp_attribute_data v = {};
11906 }
11907 else
11920 {
11925 }
11926 else
11927 {
11929 {
11932 }
11933 }
11936 {
11938 "OpenMP construct among %<omp::directive%> attributes"
11939 " requires all %<omp::directive%> attributes on the"
11942 }
11944 {
11946 "multiple OpenMP standalone directives among"
11947 " %<omp::directive%> attributes must be all within the"
11950 }
11956 {
11958 "standalone OpenMP directives in %<omp::directive%> attribute"
11961 }
11963 {
11967 {
11969 "mixing OpenMP directives with attribute and pragma "
11972 }
11973 }
11977 tokens++;
11982 {
11989 cp_token tok = {};
11997 tok = {};
12002 }
12003 cp_token tok = {};
12015 /* Move the current source position to that of the first token in the
12016 new lexer. */
12019 }
12021 /* Handle omp::directive and omp::sequence attributes in *PATTRS
12022 (if any) at the start or after declaration-id of a declaration. */
12024 static void
12028 {
12039 {
12041 {
12048 {
12056 else
12059 }
12069 {
12071 {
12074 }
12076 {
12078 "mixing OpenMP directives with attribute and "
12081 }
12082 }
12083 }
12084 }
12087 {
12092 else
12095 }
12100 {
12109 }
12111 }
12113 /* Parse a statement.
12115 statement:
12116 labeled-statement
12117 expression-statement
12118 compound-statement
12119 selection-statement
12120 iteration-statement
12121 jump-statement
12122 declaration-statement
12123 try-block
12125 C++11:
12127 statement:
12128 labeled-statement
12129 attribute-specifier-seq (opt) expression-statement
12130 attribute-specifier-seq (opt) compound-statement
12131 attribute-specifier-seq (opt) selection-statement
12132 attribute-specifier-seq (opt) iteration-statement
12133 attribute-specifier-seq (opt) jump-statement
12134 declaration-statement
12135 attribute-specifier-seq (opt) try-block
12137 init-statement:
12138 expression-statement
12139 simple-declaration
12140 alias-declaration
12142 TM Extension:
12144 statement:
12145 atomic-statement
12147 IN_COMPOUND is true when the statement is nested inside a
12148 cp_parser_compound_statement.
12150 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12151 is a (possibly labeled) if statement which is not enclosed in braces
12152 and has an else clause. This is used to implement -Wparentheses.
12154 CHAIN is a vector of if-else-if conditions. */
12156 static void
12160 {
12166 /* A copy of IN_COMPOUND which is set to false after seeing a label.
12167 This matters for certain pragmas. */
12170 restart:
12173 /* There is no statement yet. */
12180 /* In obj-c++, seeing '[[' might be the either the beginning of
12181 c++11 attributes, or a nested objc-message-expression. So
12182 let's parse the c++11 attributes tentatively. */
12188 {
12191 }
12194 /* Peek at the next token. */
12200 {
12204 {
12231 }
12237 {
12239 std_attrs);
12241 }
12242 }
12245 /* Remember the location of the first token in the statement. */
12249 /* If this is a keyword, then that will often determine what kind of
12250 statement we have. */
12252 {
12256 {
12259 /* Looks like a labeled-statement with a case label.
12260 Parse the label, and then use tail recursion to parse
12261 the statement. */
12289 /* Objective-C++ exception-handling constructs. */
12305 /* This must be a namespace alias definition. */
12307 {
12308 /* Attributes should be parsed as part of the
12309 declaration, so let's un-parse them. */
12312 }
12330 /* It might be a keyword like `int' that can start a
12331 declaration-statement. */
12333 }
12334 }
12336 {
12337 /* If the next token is a `:', then we are looking at a
12338 labeled-statement. */
12341 {
12342 /* Looks like a labeled-statement with an ordinary label.
12343 Parse the label, and then use tail recursion to parse
12344 the statement. */
12348 /* If there's no statement, it's not a labeled-statement, just
12349 a label. That's allowed in C++23, but only if we're at the
12350 end of a compound-statement. */
12353 {
12357 "label at end of compound statement only available "
12360 }
12364 }
12365 }
12366 /* Anything that starts with a `{' must be a compound-statement. */
12368 {
12371 }
12372 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
12373 a statement all its own. */
12375 {
12376 do_pragma:;
12379 /* Only certain OpenMP pragmas are attached to statements, and thus
12380 are considered statements themselves. All others are not. In
12381 the context of a compound, accept the pragma as a "statement" and
12382 return so that we can check for a close brace. Otherwise we
12383 require a real statement and must go back and read one. */
12391 {
12393 {
12400 }
12403 }
12411 }
12413 {
12416 }
12418 /* Everything else must be a declaration-statement or an
12419 expression-statement. Try for the declaration-statement
12420 first, unless we are looking at a `;', in which case we know that
12421 we have an expression-statement. */
12423 {
12425 {
12427 /* Attributes should be parsed as part of the declaration,
12428 so let's un-parse them. */
12433 /* Try to parse the declaration-statement. */
12436 /* If that worked, we're done. */
12439 /* It didn't work, restore the post-attribute position. */
12441 {
12444 {
12449 i++;
12451 {
12457 /* Don't handle OpenMP attribs on keywords that
12458 always start a declaration statement but don't
12459 accept attribute before it and therefore
12460 the tentative cp_parser_declaration_statement
12461 fails to parse because of that. */
12466 }
12469 {
12471 std_attrs
12472 = cp_parser_handle_statement_omp_attributes
12478 }
12479 }
12480 }
12481 }
12482 /* All preceding labels have been parsed at this point. */
12488 /* Look for an expression-statement instead. */
12492 attrs_loc);
12494 /* Handle [[fallthrough]];. */
12496 {
12497 /* The next token after the fallthrough attribute is ';'. */
12499 {
12500 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12502 IFN_FALLTHROUGH,
12505 }
12506 else
12510 }
12511 }
12513 /* Set the line number for the statement. */
12517 /* Allow "[[fallthrough]];" or "[[assume(cond)]];", but warn otherwise. */
12520 OPT_Wattributes,
12522 }
12524 /* Append ATTR to attribute list ATTRS. */
12526 tree
12528 {
12534 }
12536 /* Parse the label for a labeled-statement, i.e.
12538 label:
12539 attribute-specifier-seq[opt] identifier :
12540 attribute-specifier-seq[opt] case constant-expression :
12541 attribute-specifier-seq[opt] default :
12543 labeled-statement:
12544 label statement
12546 GNU Extension:
12547 case constant-expression ... constant-expression : statement
12549 When a label is parsed without errors, the label is added to the
12550 parse tree by the finish_* functions, so this function doesn't
12551 have to return the label. */
12553 static void
12555 {
12560 /* The next token should be an identifier. */
12564 {
12567 }
12569 /* Remember whether this case or a user-defined label is allowed to fall
12570 through to. */
12575 {
12577 {
12581 /* Consume the `case' token. */
12583 /* Parse the constant-expression. */
12590 {
12591 /* Consume the `...' token. */
12597 /* We don't need to emit warnings here, as the common code
12598 will do this for us. */
12599 }
12600 else
12604 {
12607 {
12610 }
12611 }
12612 else
12615 expr);
12616 }
12620 /* Consume the `default' token. */
12624 {
12627 {
12630 }
12631 }
12632 else
12637 /* Anything else must be an ordinary label. */
12642 }
12644 /* Require the `:' token. */
12647 /* An ordinary label may optionally be followed by attributes.
12648 However, this is only permitted if the attributes are then
12649 followed by a semicolon. This is because, for backward
12650 compatibility, when parsing
12651 lab: __attribute__ ((unused)) int i;
12652 we want the attribute to attach to "i", not "lab". */
12655 {
12656 tree attrs;
12660 /* And fallthrough always binds to the expression-statement. */
12665 ;
12666 else
12668 }
12674 }
12676 /* Parse an expression-statement.
12678 expression-statement:
12679 expression [opt] ;
12681 Returns the new EXPR_STMT -- or NULL_TREE if the expression
12682 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
12683 indicates whether this expression-statement is part of an
12684 expression statement. */
12686 static tree
12688 {
12693 /* There might be attribute fallthrough. */
12696 /* If the next token is a ';', then there is no expression
12697 statement. */
12699 {
12703 {
12706 }
12707 }
12711 /* Handle [[fallthrough]];. */
12713 {
12714 /* The next token after the fallthrough attribute is ';'. */
12716 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
12719 else
12723 }
12725 /* Allow "[[fallthrough]];", but warn otherwise. */
12730 /* Give a helpful message for "A<T>::type t;" and the like. */
12733 {
12740 {
12741 /* A::A a; */
12746 }
12747 }
12749 /* Consume the final `;'. */
12754 /* This is the final expression statement of a statement
12755 expression. */
12761 }
12763 /* Parse a compound-statement.
12765 compound-statement:
12766 { statement-seq [opt] label-seq [opt] }
12768 label-seq:
12769 label
12770 label-seq label
12772 GNU extension:
12774 compound-statement:
12775 { label-declaration-seq [opt] statement-seq [opt] }
12777 label-declaration-seq:
12778 label-declaration
12779 label-declaration-seq label-declaration
12781 Returns a tree representing the statement. */
12783 static tree
12786 {
12787 tree compound_stmt;
12788 matching_braces braces;
12790 /* Consume the `{'. */
12797 /* Begin the compound-statement. */
12799 /* If the next keyword is `__label__' we have a label declaration. */
12802 /* Parse an (optional) statement-seq. */
12805 /* Consume the `}'. */
12808 /* Finish the compound-statement. */
12812 }
12814 /* Parse an (optional) statement-seq.
12816 statement-seq:
12817 statement
12818 statement-seq [opt] statement */
12820 static void
12822 {
12823 /* Scan statements until there aren't any more. */
12825 {
12828 /* If we are looking at a `}', then we have run out of
12829 statements; the same is true if we have reached the end
12830 of file, or have stumbled upon a stray '@end'. */
12837 /* If we are in a compound statement and find 'else' then
12838 something went wrong. */
12840 {
12843 else
12844 {
12847 }
12848 }
12850 /* Parse the statement. */
12852 }
12853 }
12855 /* Return true if this is the C++20 version of range-based-for with
12856 init-statement. */
12858 static bool
12860 {
12863 /* Save tokens so that we can put them back. */
12866 /* There has to be an unnested ; followed by an unnested :. */
12869 CPP_SEMICOLON,
12873 /* We found the semicolon, eat it now. */
12876 /* Now look for ':' that is not nested in () or {}. */
12879 CPP_COLON,
12882 out:
12883 /* Roll back the tokens we skipped. */
12887 }
12889 /* Return true if we're looking at (init; cond), false otherwise. */
12891 static bool
12893 {
12894 /* Save tokens so that we can put them back. */
12897 /* Look for ';' that is not nested in () or {}. */
12900 CPP_SEMICOLON,
12903 /* Roll back the tokens we skipped. */
12907 }
12909 /* Parse a selection-statement.
12911 selection-statement:
12912 if ( init-statement [opt] condition ) statement
12913 if ( init-statement [opt] condition ) statement else statement
12914 switch ( init-statement [opt] condition ) statement
12916 Returns the new IF_STMT or SWITCH_STMT.
12918 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12919 is a (possibly labeled) if statement which is not enclosed in
12920 braces and has an else clause. This is used to implement
12921 -Wparentheses.
12923 CHAIN is a vector of if-else-if conditions. This is used to implement
12924 -Wduplicated-cond. */
12926 static tree
12929 {
12932 token_indent_info guard_tinfo;
12937 /* Peek at the next token. */
12941 /* See what kind of keyword it is. */
12944 {
12947 {
12948 tree statement;
12949 tree condition;
12954 RID_CONSTEXPR))
12955 {
12960 "%<if constexpr%> only available with "
12962 }
12965 {
12967 RID_CONSTEVAL))
12971 RID_CONSTEVAL))
12972 {
12975 }
12976 }
12978 {
12982 "%<if consteval%> only available with "
12993 {
12996 }
13002 {
13003 location_t before_loc
13009 }
13013 /* If the next token is `else', parse the else-clause. */
13015 RID_ELSE))
13016 {
13020 /* Consume the `else' keyword. */
13026 {
13030 }
13034 guard_tinfo);
13037 {
13038 location_t before_loc
13043 }
13046 }
13050 {
13054 }
13058 }
13060 /* Look for the `('. */
13061 matching_parens parens;
13063 {
13066 }
13068 /* Begin the selection-statement. */
13070 {
13073 }
13074 else
13077 /* Parse the optional init-statement. */
13079 {
13080 tree decl;
13083 OPT_Wc__17_extensions,
13084 "init-statement in selection statements only available "
13087 /* A non-empty init-statement can have arbitrary side
13088 effects. */
13091 }
13093 /* Parse the condition. */
13095 /* Look for the `)'. */
13101 {
13105 /* Add the condition. */
13112 /* Parse the then-clause. */
13116 /* Outside a template, the non-selected branch of a constexpr
13117 if is a 'discarded statement', i.e. unevaluated. */
13122 {
13125 }
13128 guard_tinfo);
13135 {
13139 }
13141 /* If the next token is `else', parse the else-clause. */
13143 RID_ELSE))
13144 {
13148 {
13151 }
13153 guard_tinfo
13155 /* Consume the `else' keyword. */
13158 {
13160 RID_IF)
13162 {
13163 /* We've got "if (COND) else if (COND2)". Start
13164 the condition chain and add COND as the first
13165 element. */
13169 {
13170 /* Wrap it in a NOP_EXPR so that we can set the
13171 location of the condition. */
13173 condition);
13176 }
13177 }
13179 RID_IF))
13180 /* This is if-else without subsequent if. Zap the
13181 condition chain; we would have already warned at
13182 this point. */
13184 }
13186 /* Parse the else-clause. */
13192 /* If we are currently parsing a then-clause, then
13193 IF_P will not be NULL. We set it to true to
13194 indicate that this if statement has an else clause.
13195 This may trigger the Wparentheses warning below
13196 when we get back up to the parent if statement. */
13201 {
13205 }
13206 }
13207 else
13208 {
13209 /* This if statement does not have an else clause. If
13210 NESTED_IF is true, then the then-clause has an if
13211 statement which does have an else clause. We warn
13212 about the potential ambiguity. */
13215 "suggest explicit braces to avoid ambiguous"
13218 /* We don't need the condition chain anymore. */
13220 }
13222 /* Now we're all done with the if-statement. */
13224 }
13225 else
13226 {
13230 /* Add the condition. */
13233 /* Parse the body of the switch-statement. */
13239 guard_tinfo);
13243 /* Now we're all done with the switch-statement. */
13245 }
13248 }
13254 }
13255 }
13257 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
13258 If we have seen at least one decl-specifier, and the next token is not
13259 a parenthesis (after "int (" we might be looking at a functional cast)
13260 neither we are dealing with a concept-check expression then we must be
13261 looking at a declaration. */
13263 static void
13266 {
13275 }
13277 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
13278 The declarator shall not specify a function or an array. Returns
13279 TRUE if the declarator is valid, FALSE otherwise. */
13281 static bool
13284 location_t loc)
13285 {
13289 {
13294 else
13302 }
13303 else
13305 }
13307 /* Parse a condition.
13309 condition:
13310 expression
13311 type-specifier-seq declarator = initializer-clause
13312 type-specifier-seq declarator braced-init-list
13314 GNU Extension:
13316 condition:
13317 type-specifier-seq declarator asm-specification [opt]
13318 attributes [opt] = assignment-expression
13320 Returns the expression that should be tested. */
13322 static tree
13324 {
13325 cp_decl_specifier_seq type_specifiers;
13329 /* Try the declaration first. */
13331 /* New types are not allowed in the type-specifier-seq for a
13332 condition. */
13334 parser->type_definition_forbidden_message
13336 /* Parse the type-specifier-seq. */
13338 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
13341 /* Restore the saved message. */
13344 /* Gather the attributes that were provided with the
13345 decl-specifiers. */
13350 /* If all is well, we might be looking at a declaration. */
13352 {
13353 tree decl;
13354 tree asm_specification;
13355 tree attributes;
13360 /* Parse the declarator. */
13362 CP_PARSER_FLAGS_NONE,
13368 /* Parse the attributes. */
13370 /* Parse the asm-specification. */
13372 /* If the next token is not an `=' or '{', then we might still be
13373 looking at an expression. For example:
13375 if (A(a).x)
13377 looks like a decl-specifier-seq and a declarator -- but then
13378 there is no `=', so this is an expression. */
13383 /* If we did see an `=' or '{', then we are looking at a declaration
13384 for sure. */
13386 {
13387 tree pushed_scope;
13394 /* Create the declaration. */
13401 /* Parse the initializer. */
13403 {
13407 }
13409 {
13410 /* Consume the `='. */
13414 }
13415 else
13416 {
13419 }
13423 /* Process the initializer. */
13426 asm_specification,
13427 flags);
13433 }
13434 }
13435 /* If we didn't even get past the declarator successfully, we are
13436 definitely not looking at a declaration. */
13437 else
13440 /* Otherwise, we are looking at an expression. */
13442 }
13444 /* Parses a for-statement or range-for-statement until the closing ')',
13445 not included. */
13447 static tree
13449 {
13453 /* Begin the for-statement. */
13456 /* Maybe parse the optional init-statement in a range-based for loop. */
13458 /* Checked for diagnostic purposes only. */
13460 {
13461 tree dummy;
13464 {
13466 OPT_Wc__20_extensions,
13467 "range-based %<for%> loops with initializer only "
13470 }
13471 }
13473 /* Parse the initialization. */
13479 else
13481 }
13483 static tree
13486 {
13487 /* Normal for loop */
13490 tree stmt;
13493 /* The init-statement has already been parsed in
13494 cp_parser_init_statement, so no work is needed here. */
13497 /* If there's a condition, process it. */
13501 {
13505 }
13507 {
13511 }
13513 /* Look for the `;'. */
13516 /* If there's an expression, process it. */
13522 }
13524 /* Tries to parse a range-based for-statement:
13526 range-based-for:
13527 decl-specifier-seq declarator : expression
13529 The decl-specifier-seq declarator and the `:' are already parsed by
13530 cp_parser_init_statement. If processing_template_decl it returns a
13531 newly created RANGE_FOR_STMT; if not, it is converted to a
13532 regular FOR_STMT. */
13534 static tree
13537 {
13544 /* Get the range declaration momentarily out of the way so that
13545 the range expression doesn't clash with it. */
13547 {
13549 {
13551 /* For decomposition declaration get all of the corresponding
13552 declarations out of the way. */
13556 {
13562 {
13568 }
13569 }
13570 }
13572 {
13577 }
13578 }
13581 {
13584 }
13585 else
13588 /* Put the range declaration(s) back into scope. */
13590 {
13594 }
13596 /* finish_omp_for has its own code for the following, so just
13597 return the range_expr instead. */
13601 /* If in template, STMT is converted to a normal for-statement
13602 at instantiation. If not, it is done just ahead. */
13604 {
13614 /* do_auto_deduction doesn't mess with template init-lists. */
13617 }
13618 else
13619 {
13623 unroll);
13624 }
13626 }
13628 /* Subroutine of cp_convert_range_for: given the initializer expression,
13629 builds up the range temporary. */
13631 static tree
13633 {
13634 /* Find out the type deduced by the declaration
13635 `auto &&__range = range_expr'. */
13640 /* Create the __range variable. */
13647 }
13649 /* Used by cp_parser_range_for in template context: we aren't going to
13650 do a full conversion yet, but we still need to resolve auto in the
13651 type of the for-range-declaration if present. This is basically
13652 a shortcut version of cp_convert_range_for. */
13654 static void
13656 {
13659 {
13662 iter_type = (cp_parser_perform_range_for_lookup
13665 {
13667 iter_type);
13670 tf_warning_or_error);
13673 tf_warning_or_error,
13674 adc_variable_type);
13675 }
13676 }
13677 }
13679 /* Warns when the loop variable should be changed to a reference type to
13680 avoid unnecessary copying. I.e., from
13682 for (const auto x : range)
13684 where range returns a reference, to
13686 for (const auto &x : range)
13688 if this version doesn't make a copy.
13690 This function also warns when the loop variable is initialized with
13691 a value of a different type resulting in a copy:
13693 int arr[10];
13694 for (const double &x : arr)
13696 DECL is the RANGE_DECL; EXPR is the *__for_begin expression.
13697 This function is never called when processing_template_decl is on. */
13699 static void
13701 {
13713 {
13716 {
13717 auto_diagnostic_group d;
13719 "loop variable %qD of type %qT binds to a temporary "
13722 {
13724 TYPE_QUAL_CONST);
13729 }
13730 }
13732 }
13736 /* Since small trivially copyable types are cheap to copy, we suppress the
13737 warning for them. 64B is a common size of a cache line. */
13743 /* If we can initialize a reference directly, suggest that to avoid the
13744 copy. */
13747 {
13748 auto_diagnostic_group d;
13752 {
13756 }
13757 }
13758 }
13760 /* Converts a range-based for-statement into a normal
13761 for-statement, as per the definition.
13763 for (RANGE_DECL : RANGE_EXPR)
13764 BLOCK
13766 should be equivalent to:
13768 {
13769 auto &&__range = RANGE_EXPR;
13770 for (auto __begin = BEGIN_EXPR, __end = END_EXPR;
13771 __begin != __end;
13772 ++__begin)
13773 {
13774 RANGE_DECL = *__begin;
13775 BLOCK
13776 }
13777 }
13779 If RANGE_EXPR is an array:
13780 BEGIN_EXPR = __range
13781 END_EXPR = __range + ARRAY_SIZE(__range)
13782 Else if RANGE_EXPR has a member 'begin' or 'end':
13783 BEGIN_EXPR = __range.begin()
13784 END_EXPR = __range.end()
13785 Else:
13786 BEGIN_EXPR = begin(__range)
13787 END_EXPR = end(__range);
13789 If __range has a member 'begin' but not 'end', or vice versa, we must
13790 still use the second alternative (it will surely fail, however).
13791 When calling begin()/end() in the third alternative we must use
13792 argument dependent lookup, but always considering 'std' as an associated
13793 namespace. */
13795 tree
13799 {
13807 /* If an error happened previously do nothing or else a lot of
13808 unhelpful errors would be issued. */
13810 else
13811 {
13812 tree range_temp;
13816 /* Can't bind a reference to an array of runtime bound. */
13818 else
13819 {
13824 LOOKUP_ONLYCONVERTING);
13826 }
13829 }
13831 /* The new for initialization statement. */
13833 iter_type);
13839 LOOKUP_ONLYCONVERTING);
13849 LOOKUP_ONLYCONVERTING);
13853 /* The new for condition. */
13860 /* The new increment expression. */
13863 tf_warning_or_error);
13869 /* The declaration is initialized with *__begin inside the loop body. */
13874 LOOKUP_ONLYCONVERTING);
13881 }
13883 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
13884 We need to solve both at the same time because the method used
13885 depends on the existence of members begin or end.
13886 Returns the type deduced for the iterator expression. */
13888 static tree
13890 {
13892 {
13895 }
13898 {
13903 }
13905 {
13906 /* If RANGE is an array, we will use pointer arithmetic. */
13909 range,
13913 }
13914 else
13915 {
13916 /* If it is not an array, we must do a bit of magic. */
13926 tf_warning_or_error);
13929 tf_warning_or_error);
13932 {
13933 /* Use the member functions. */
13936 }
13937 else
13938 {
13939 /* Use global functions with ADL. */
13940 releasing_vec vec;
13945 tf_warning_or_error);
13947 tf_warning_or_error);
13949 tf_warning_or_error);
13951 tf_warning_or_error);
13952 }
13954 /* Last common checks. */
13956 {
13957 /* If one of the expressions is an error do no more checks. */
13960 }
13963 /* Can happen, when, eg, in a template context, Koenig lookup
13964 can't resolve begin/end (c++/58503). */
13966 else
13967 {
13969 /* The unqualified type of the __begin and __end temporaries should
13970 be the same, as required by the multiple auto declaration. */
13972 {
13979 /* P0184R0 allows __begin and __end to have different types,
13980 but make sure they are comparable so we can give a better
13982 else
13986 }
13988 }
13989 }
13990 }
13992 /* Helper function for cp_parser_perform_range_for_lookup.
13993 Builds a tree for RANGE.IDENTIFIER(). */
13995 static tree
13997 {
14005 releasing_vec vec;
14009 tf_warning_or_error);
14011 }
14013 /* Parse an iteration-statement.
14015 iteration-statement:
14016 while ( condition ) statement
14017 do statement while ( expression ) ;
14018 for ( init-statement condition [opt] ; expression [opt] )
14019 statement
14021 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
14023 static tree
14026 {
14029 tree statement;
14031 token_indent_info guard_tinfo;
14033 /* Peek at the next token. */
14040 /* Remember whether or not we are already within an iteration
14041 statement. */
14044 /* See what kind of keyword it is. */
14047 {
14049 {
14050 tree condition;
14052 /* Begin the while-statement. */
14054 /* Look for the `('. */
14055 matching_parens parens;
14057 /* Parse the condition. */
14060 /* Look for the `)'. */
14062 /* Parse the dependent statement. */
14068 /* We're done with the while-statement. */
14070 }
14074 {
14075 tree expression;
14077 /* Begin the do-statement. */
14079 /* Parse the body of the do-statement. */
14086 /* Look for the `while' keyword. */
14088 /* Look for the `('. */
14089 matching_parens parens;
14091 /* Parse the expression. */
14093 /* We're done with the do-statement. */
14095 /* Look for the `)'. */
14097 /* Look for the `;'. */
14099 }
14103 {
14104 /* Look for the `('. */
14105 matching_parens parens;
14110 /* Look for the `)'. */
14113 /* Parse the body of the for-statement. */
14120 /* We're done with the for-statement. */
14122 }
14129 }
14132 }
14134 /* Parse an init-statement or the declarator of a range-based-for.
14135 Returns true if a range-based-for declaration is seen.
14137 init-statement:
14138 expression-statement
14139 simple-declaration
14140 alias-declaration */
14142 static bool
14144 {
14145 /* If the next token is a `;', then we have an empty
14146 expression-statement. Grammatically, this is also a
14147 simple-declaration, but an invalid one, because it does not
14148 declare anything. Therefore, if we did not handle this case
14149 specially, we would issue an error message about an invalid
14150 declaration. */
14152 {
14156 /* A colon is used in range-based for. */
14159 /* We're going to speculatively look for a declaration, falling back
14160 to an expression, if necessary. */
14164 {
14170 OPT_Wc__23_extensions,
14171 "alias-declaration in init-statement only "
14173 }
14174 else
14175 /* Parse the declaration. */
14178 decl);
14181 {
14182 /* It is a range-for, consume the ':'. */
14187 OPT_Wc__11_extensions,
14188 "range-based %<for%> loops only available with "
14190 }
14192 /* The ';' is not consumed yet because we told
14193 cp_parser_simple_declaration not to. */
14198 /* If the tentative parse failed, then we shall need to look for an
14199 expression-statement. */
14200 }
14201 /* If we are here, it is an expression-statement. */
14204 }
14206 /* Parse a jump-statement.
14208 jump-statement:
14209 break ;
14210 continue ;
14211 return expression [opt] ;
14212 return braced-init-list ;
14213 coroutine-return-statement;
14214 goto identifier ;
14216 GNU extension:
14218 jump-statement:
14219 goto * expression ;
14221 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
14223 static tree
14225 {
14231 /* Peek at the next token. */
14236 /* See what kind of keyword it is. */
14239 {
14243 {
14260 }
14266 {
14270 /* Fall through. */
14280 }
14286 {
14287 tree expr;
14291 {
14295 }
14298 else
14299 /* If the next token is a `;', then there is no
14300 expression. */
14302 /* Build the return-statement, check co-return first, since type
14303 deduction is not valid there. */
14308 else
14310 /* Look for the final `;'. */
14312 }
14319 {
14323 }
14325 /* Create the goto-statement. */
14327 {
14328 /* Issue a warning about this use of a GNU extension. */
14330 /* Consume the '*' token. */
14332 /* Parse the dependent expression. */
14334 }
14335 else
14337 /* Look for the final `;'. */
14344 }
14347 }
14349 /* Parse a declaration-statement.
14351 declaration-statement:
14352 block-declaration */
14354 static void
14356 {
14359 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14362 /* Parse the block-declaration. */
14365 /* Free any declarators allocated. */
14367 }
14369 /* Some dependent statements (like `if (cond) statement'), are
14370 implicitly in their own scope. In other words, if the statement is
14371 a single statement (as opposed to a compound-statement), it is
14372 none-the-less treated as if it were enclosed in braces. Any
14373 declarations appearing in the dependent statement are out of scope
14374 after control passes that point. This function parses a statement,
14375 but ensures that is in its own scope, even if it is not a
14376 compound-statement.
14378 If IF_P is not NULL, *IF_P is set to indicate whether the statement
14379 is a (possibly labeled) if statement which is not enclosed in
14380 braces and has an else clause. This is used to implement
14381 -Wparentheses.
14383 CHAIN is a vector of if-else-if conditions. This is used to implement
14384 -Wduplicated-cond.
14386 Returns the new statement. */
14388 static tree
14392 {
14393 tree statement;
14396 token_indent_info body_tinfo
14402 /* Mark if () ; with a special NOP_EXPR. */
14404 {
14415 }
14416 /* if a compound is opened, we simply parse the statement directly. */
14419 /* If the token is not a `{', then we must take special action. */
14420 else
14421 {
14422 /* Create a compound-statement. */
14424 /* Parse the dependent-statement. */
14427 /* Finish the dummy compound-statement. */
14429 }
14431 token_indent_info next_tinfo
14440 /* Return the statement. */
14442 }
14444 /* For some dependent statements (like `while (cond) statement'), we
14445 have already created a scope. Therefore, even if the dependent
14446 statement is a compound-statement, we do not want to create another
14447 scope. */
14449 static void
14452 {
14453 /* If the token is a `{', then we must take special action. */
14455 {
14456 token_indent_info body_tinfo
14462 token_indent_info next_tinfo
14471 }
14472 else
14473 {
14474 /* Avoid calling cp_parser_compound_statement, so that we
14475 don't create a new scope. Do everything else by hand. */
14476 matching_braces braces;
14478 /* If the next keyword is `__label__' we have a label declaration. */
14481 /* Parse an (optional) statement-seq. */
14484 }
14485 }
14487 /* Modules */
14489 /* Parse a module-name,
14490 identifier
14491 module-name . identifier
14492 header-name
14494 Returns a pointer to module object, NULL. */
14498 {
14501 {
14505 }
14510 {
14513 }
14516 {
14518 {
14521 }
14532 }
14535 }
14537 /* Named module-declaration
14538 __module ; PRAGMA_EOL
14539 __module private ; PRAGMA_EOL (unimplemented)
14540 [__export] __module module-name attr-spec-seq-opt ; PRAGMA_EOL
14541 */
14543 static module_parse
14546 {
14547 /* We're a pseudo pragma. */
14552 {
14556 }
14559 {
14560 /* Start global module fragment. */
14565 }
14570 {
14578 {
14581 }
14582 else
14584 "private module fragment only permitted in purview"
14586 }
14588 {
14589 /* Neither the first declaration, nor in a GMF. */
14592 skip_eol:
14594 }
14595 else
14596 {
14606 }
14609 }
14611 /* Import-declaration
14612 [__export] __import module-name attr-spec-seq-opt ; PRAGMA_EOL */
14614 static void
14617 {
14618 /* We're a pseudo pragma. */
14623 {
14626 note_lexer:
14628 " disambiguation, to prevent this being considered a"
14630 skip_eol:
14632 }
14634 {
14637 }
14638 else
14639 {
14652 {
14653 /* Module-purview imports must not be from source inclusion
14654 [cpp.import]/7 */
14663 }
14666 }
14667 }
14669 /* export-declaration.
14671 export declaration
14672 export { declaration-seq-opt } */
14674 static void
14676 {
14695 {
14702 }
14703 else
14704 {
14705 /* Explicitly check if the next tokens might be a
14706 module-directive line, so we can give a clearer error message
14707 about why the directive will be rejected. */
14714 }
14717 }
14719 /* Declarations [gram.dcl.dcl] */
14721 /* Parse an optional declaration-sequence. TOP_LEVEL is true, if this
14722 is the top-level declaration sequence. That affects whether we
14723 deal with module-preamble.
14725 declaration-seq:
14726 declaration
14727 declaration-seq declaration */
14729 static void
14731 {
14733 {
14739 else
14741 }
14742 }
14744 /* Parse a declaration.
14746 declaration:
14747 block-declaration
14748 function-definition
14749 template-declaration
14750 explicit-instantiation
14751 explicit-specialization
14752 linkage-specification
14753 namespace-definition
14755 C++17:
14756 deduction-guide
14758 modules:
14759 (all these are only allowed at the outermost level, check
14760 that semantically, for better diagnostics)
14761 module-declaration
14762 module-export-declaration
14763 module-import-declaration
14764 export-declaration
14766 GNU extension:
14768 declaration:
14769 __extension__ declaration */
14771 static void
14773 {
14776 /* Check for the `__extension__' keyword. */
14778 {
14779 /* Parse the qualified declaration. */
14781 /* Restore the PEDANTIC flag. */
14785 }
14787 /* Try to figure out what kind of declaration is present. */
14793 {
14795 /* A declaration consisting of a single semicolon is invalid
14796 * before C++11. Allow it unless we're being pedantic. */
14800 }
14804 CPP_SEMICOLON))
14805 {
14810 {
14813 std_attrs);
14815 {
14818 {
14820 CPP_PRAGMA));
14822 }
14824 }
14825 }
14833 }
14835 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
14840 /* Conditionally, allow attributes to precede a linkage specification. */
14842 {
14850 {
14852 /* We might have already been here. */
14854 {
14862 }
14865 }
14866 else
14867 {
14870 }
14871 }
14872 /* If we already had some attributes, and we've added more, then prepend.
14873 Otherwise attributes just contains any that we just read. */
14875 {
14879 }
14881 /* If the next token is `extern' and the following token is a string
14882 literal, then we have a linkage specification. */
14886 /* If the next token is `template', then we have either a template
14887 declaration, an explicit instantiation, or an explicit
14888 specialization. */
14890 {
14891 /* `template <>' indicates a template specialization. */
14895 /* `template <' indicates a template declaration. */
14898 /* Anything else must be an explicit instantiation. */
14899 else
14901 }
14902 /* If the next token is `export', it's new-style modules or
14903 old-style template. */
14905 {
14908 else
14910 }
14912 {
14917 // In module purview this will be ill-formed.
14923 else
14925 }
14926 /* If the next token is `extern', 'static' or 'inline' and the one
14927 after that is `template', we have a GNU extended explicit
14928 instantiation directive. */
14935 /* If the next token is `namespace', check for a named or unnamed
14936 namespace definition. */
14945 /* An unnamed namespace definition. */
14949 /* An inline (associated) namespace definition. */
14953 /* Objective-C++ declaration/definition. */
14960 /* At this point we may have a template declared by a concept
14961 introduction. */
14966 else
14967 /* Try to parse a block-declaration, or a function-definition. */
14970 /* Free any declarators allocated. */
14972 }
14974 /* Parse a namespace-scope declaration. */
14976 static void
14978 {
14982 /* A top-level declaration can consist solely of a #pragma. A
14983 nested declaration cannot, so this is done here and not in
14984 cp_parser_declaration. (A #pragma at block scope is
14985 handled in cp_parser_statement.) */
14987 else
14988 /* Parse the declaration itself. */
14990 }
14992 /* Parse a block-declaration.
14994 block-declaration:
14995 simple-declaration
14996 asm-definition
14997 namespace-alias-definition
14998 using-declaration
14999 using-directive
15001 GNU Extension:
15003 block-declaration:
15004 __extension__ block-declaration
15006 C++0x Extension:
15008 block-declaration:
15009 static_assert-declaration
15011 If STATEMENT_P is TRUE, then this block-declaration is occurring as
15012 part of a declaration-statement. */
15014 static void
15017 {
15020 /* Check for the `__extension__' keyword. */
15022 {
15023 /* Parse the qualified declaration. */
15025 /* Restore the PEDANTIC flag. */
15029 }
15031 /* Peek at the next token to figure out which kind of declaration is
15032 present. */
15036 /* If the next keyword is `asm', we have an asm-definition. */
15038 {
15042 }
15043 /* If the next keyword is `namespace', we have a
15044 namespace-alias-definition. */
15047 /* If the next keyword is `using', we have a
15048 using-declaration, a using-directive, or an alias-declaration. */
15050 {
15055 /* If the token after `using' is `namespace', then we have a
15056 using-directive. */
15062 /* If the second token after 'using' is '=', then we have an
15063 alias-declaration. */
15069 /* Otherwise, it's a using-declaration. */
15070 else
15073 }
15074 /* If the next keyword is `__label__' we have a misplaced label
15075 declaration. */
15077 {
15081 /* If the next token is now a `;', consume it. */
15084 }
15085 /* If the next token is `static_assert' we have a static assertion. */
15088 /* If the next tokens after attributes is `using namespace', then we have
15089 a using-directive. */
15092 RID_USING)
15094 RID_NAMESPACE))
15095 {
15099 }
15100 /* Anything else must be a simple-declaration. */
15101 else
15104 }
15106 /* Parse a simple-declaration.
15108 simple-declaration:
15109 decl-specifier-seq [opt] init-declarator-list [opt] ;
15110 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15111 brace-or-equal-initializer ;
15113 init-declarator-list:
15114 init-declarator
15115 init-declarator-list , init-declarator
15117 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
15118 function-definition as a simple-declaration.
15120 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
15121 parsed declaration if it is an uninitialized single declarator not followed
15122 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
15123 if present, will not be consumed. */
15125 static void
15129 {
15130 cp_decl_specifier_seq decl_specifiers;
15139 /* Defer access checks until we know what is being declared; the
15140 checks for names appearing in the decl-specifier-seq should be
15141 done as if we were in the scope of the thing being declared. */
15144 /* Parse the decl-specifier-seq. We have to keep track of whether
15145 or not the decl-specifier-seq declares a named class or
15146 enumeration type, since that is the only case in which the
15147 init-declarator-list is allowed to be empty.
15149 [dcl.dcl]
15151 In a simple-declaration, the optional init-declarator-list can be
15152 omitted only when declaring a class or enumeration, that is when
15153 the decl-specifier-seq contains either a class-specifier, an
15154 elaborated-type-specifier, or an enum-specifier. */
15156 CP_PARSER_FLAGS_OPTIONAL,
15159 /* We no longer need to defer access checks. */
15162 cp_omp_declare_simd_data odsd;
15168 /* In a block scope, a valid declaration must always have a
15169 decl-specifier-seq. By not trying to parse declarators, we can
15170 resolve the declaration/expression ambiguity more quickly. */
15173 {
15176 }
15178 /* If the next two tokens are both identifiers, the code is
15179 erroneous. The usual cause of this situation is code like:
15181 T t;
15183 where "T" should name a type -- but does not. */
15186 {
15187 /* If parsing tentatively, we should commit; we really are
15188 looking at a declaration. */
15190 /* Give up. */
15192 }
15196 /* Look for C++17 decomposition declaration. */
15204 {
15205 tree decl
15207 maybe_range_for_decl,
15210 /* The next token should be either a `,' or a `;'. */
15212 /* If it's a `;', we are done. */
15216 {
15220 }
15221 /* Anything else is an error. */
15222 else
15223 {
15224 /* If we have already issued an error message we don't need
15225 to issue another one. */
15230 /* Skip tokens until we reach the end of the statement. */
15232 /* If the next token is now a `;', consume it. */
15236 }
15237 }
15238 else
15241 tree last_type;
15243 /* NULL_TREE if both variable and function declaration are allowed,
15244 error_mark_node if function declaration are not allowed and
15245 a FUNCTION_DECL that should be diagnosed if it is followed by
15246 variable declarations. */
15247 tree auto_function_declaration;
15250 auto_specifier_p
15254 /* Keep going until we hit the `;' at the end of the simple
15255 declaration. */
15258 CPP_SEMICOLON))
15259 {
15262 tree decl;
15266 {
15267 /* If we are processing next declarator, comma is expected */
15272 {
15276 }
15277 }
15278 else
15281 /* Parse the init-declarator. */
15283 CP_PARSER_FLAGS_NONE,
15286 function_definition_allowed_p,
15288 declares_class_or_enum,
15290 maybe_range_for_decl,
15293 /* If an error occurred while parsing tentatively, exit quickly.
15294 (That usually happens when in the body of a function; each
15295 statement is treated as a declaration-statement until proven
15296 otherwise.) */
15301 {
15302 /* If the init-declarator-list contains more than one
15303 init-declarator, they shall all form declarations of
15304 variables. */
15306 auto_function_declaration
15310 {
15312 "non-variable %qD in declaration with more than one "
15317 }
15318 }
15322 {
15326 {
15327 /* If the list of declarators contains more than one declarator,
15328 the type of each declared variable is determined as described
15329 above. If the type deduced for the template parameter U is not
15330 the same in each deduction, the program is ill-formed. */
15335 }
15336 else
15338 }
15340 /* Handle function definitions specially. */
15342 {
15343 /* If the next token is a `,', then we are probably
15344 processing something like:
15346 void f() {}, *p;
15348 which is erroneous. */
15350 {
15353 "mixing"
15355 }
15356 /* Otherwise, we're done with the list of declarators. */
15357 else
15358 {
15362 }
15363 }
15366 /* The next token should be either a `,' or a `;'. */
15368 /* If it's a `,', there are more declarators to come. */
15371 /* If it's a `;', we are done. */
15375 {
15380 }
15381 /* Anything else is an error. */
15382 else
15383 {
15384 /* If we have already issued an error message we don't need
15385 to issue another one. */
15390 /* Skip tokens until we reach the end of the statement. */
15392 /* If the next token is now a `;', consume it. */
15396 }
15397 /* After the first time around, a function-definition is not
15398 allowed -- even if it was OK at first. For example:
15400 int i, f() {}
15402 is not valid. */
15404 }
15406 /* Issue an error message if no declarators are present, and the
15407 decl-specifier-seq does not itself declare a class or
15408 enumeration: [dcl.dcl]/3. */
15410 {
15412 {
15416 /* Ensure an error is issued anyway when finish_decltype_type,
15417 called via cp_parser_decl_specifier_seq, returns a class or
15418 an enumeration (c++/51786). */
15421 }
15422 /* Perform any deferred access checks. */
15424 }
15426 /* Consume the `;'. */
15427 finish:
15431 {
15437 }
15439 done:
15442 }
15444 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
15445 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
15446 initializer ; */
15448 static tree
15453 {
15458 /* Parse the identifier-list. */
15462 {
15470 }
15474 {
15480 else
15481 {
15484 }
15485 }
15489 "structured bindings only available with "
15492 tree pushed_scope;
15499 NULL_TREE);
15506 cp_expr e;
15507 cp_decl_specifier_seq decl_specs;
15512 {
15516 else
15517 {
15520 }
15521 tree elt_pushed_scope;
15527 {
15528 /* Ensure we've diagnosed redeclaration if we aren't creating
15529 a new VAR_DECL. */
15532 }
15533 else
15537 }
15540 {
15543 }
15547 {
15555 || (is_direct_init
15558 {
15562 }
15565 {
15570 }
15571 }
15573 {
15575 /* Ensure DECL_VALUE_EXPR is created for all the decls but
15576 the underlying DECL. */
15578 }
15584 {
15587 }
15590 }
15592 /* Names of storage classes. */
15595 cp_storage_class_name[] = {
15597 };
15599 /* Parse a decl-specifier-seq.
15601 decl-specifier-seq:
15602 decl-specifier-seq [opt] decl-specifier
15603 decl-specifier attribute-specifier-seq [opt] (C++11)
15605 decl-specifier:
15606 storage-class-specifier
15607 type-specifier
15608 function-specifier
15609 friend
15610 typedef
15612 GNU Extension:
15614 decl-specifier:
15615 attributes
15617 Concepts Extension:
15619 decl-specifier:
15620 concept
15622 Set *DECL_SPECS to a representation of the decl-specifier-seq.
15624 The parser flags FLAGS is used to control type-specifier parsing.
15626 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
15627 flags:
15629 1: one of the decl-specifiers is an elaborated-type-specifier
15630 (i.e., a type declaration)
15631 2: one of the decl-specifiers is an enum-specifier or a
15632 class-specifier (i.e., a type definition)
15634 */
15636 static void
15638 cp_parser_flags flags,
15641 {
15645 cp_decl_spec ds;
15647 /* Clear DECL_SPECS. */
15650 /* Assume no class or enumeration type is declared. */
15653 /* Keep reading specifiers until there are no more to read. */
15655 {
15660 /* Peek at the next token. */
15663 /* Save the first token of the decl spec list for error
15664 reporting. */
15667 /* Handle attributes. */
15670 {
15671 /* Parse the attributes. */
15674 /* In a sequence of declaration specifiers, c++11 attributes
15675 appertain to the type that precede them. In that case
15676 [dcl.spec]/1 says:
15678 The attribute-specifier-seq affects the type only for
15679 the declaration it appears in, not other declarations
15680 involving the same type.
15682 But for now let's force the user to position the
15683 attribute either at the beginning of the declaration or
15684 after the declarator-id, which would clearly mean that it
15685 applies to the declarator. */
15687 {
15689 /* The c++11 attribute is at the beginning of the
15690 declaration. It appertains to the entity being
15692 else
15693 {
15695 {
15696 /* This is an attribute following a
15697 class-specifier. */
15702 }
15703 else
15704 {
15705 decl_specs->std_attributes
15709 }
15711 }
15712 }
15714 decl_specs->attributes
15719 }
15720 /* Assume we will find a decl-specifier keyword. */
15722 /* If the next token is an appropriate keyword, we can simply
15723 add it to the list. */
15725 {
15726 /* decl-specifier:
15727 friend
15728 constexpr
15729 constinit */
15732 {
15737 }
15738 else
15739 {
15741 /* Consume the token. */
15743 }
15768 /* Warn for concept as a decl-specifier. We'll rewrite these as
15769 concept declarations later. */
15771 {
15776 else
15779 }
15781 /* In C++20 a concept definition is just 'concept name = expr;'
15782 Support that syntax as a TS extension by pretending we've seen
15783 the 'bool' specifier. */
15787 {
15791 }
15794 /* function-specifier:
15795 inline
15796 virtual
15797 explicit */
15804 /* decl-specifier:
15805 typedef */
15808 /* Consume the token. */
15814 /* A constructor declarator cannot appear in a typedef. */
15816 /* The "typedef" keyword can only occur in a declaration; we
15817 may as well commit at this point. */
15821 {
15831 }
15834 /* storage-class-specifier:
15835 auto
15836 register
15837 static
15838 extern
15839 mutable
15841 GNU Extension:
15842 thread */
15845 {
15846 /* Consume the token. */
15849 /* Complain about `auto' as a storage specifier, if
15850 we're complaining about C++0x compatibility. */
15854 "%<auto%> changes meaning in C++11; "
15857 /* Set the storage class anyway. */
15859 token);
15860 }
15861 else
15862 /* C++0x auto type-specifier. */
15870 /* Consume the token. */
15873 token);
15876 /* Consume the token. */
15882 /* We did not yet find a decl-specifier yet. */
15885 }
15897 {
15903 "%qD only valid in lambda with %<-std=c++23%> or "
15905 }
15910 /* Constructors are a special case. The `S' in `S()' is not a
15911 decl-specifier; it is the beginning of the declarator. */
15912 constructor_p
15913 = (!found_decl_spec
15914 && constructor_possible_p
15915 && (cp_parser_constructor_declarator_p
15917 ds_friend))));
15919 /* If we don't have a DECL_SPEC yet, then we must be looking at
15920 a type-specifier. */
15922 {
15925 tree type_spec;
15930 type_spec
15932 decl_specs,
15938 /* If this type-specifier referenced a user-defined type
15939 (a typedef, class-name, etc.), then we can't allow any
15940 more such type-specifiers henceforth.
15942 [dcl.spec]
15944 The longest sequence of decl-specifiers that could
15945 possibly be a type name is taken as the
15946 decl-specifier-seq of a declaration. The sequence shall
15947 be self-consistent as described below.
15949 [dcl.type]
15951 As a general rule, at most one type-specifier is allowed
15952 in the complete decl-specifier-seq of a declaration. The
15953 only exceptions are the following:
15955 -- const or volatile can be combined with any other
15956 type-specifier.
15958 -- signed or unsigned can be combined with char, long,
15959 short, or int.
15961 -- ..
15963 Example:
15965 typedef char* Pc;
15966 void g (const int Pc);
15968 Here, Pc is *not* part of the decl-specifier seq; it's
15969 the declarator. Therefore, once we see a type-specifier
15970 (other than a cv-qualifier), we forbid any additional
15971 user-defined types. We *do* still allow things like `int
15972 int' to be considered a decl-specifier-seq, and issue the
15973 error message later. */
15976 /* A constructor declarator cannot follow a type-specifier. */
15978 {
15986 }
15987 }
15989 /* If we still do not have a DECL_SPEC, then there are no more
15990 decl-specifiers. */
15995 {
15999 "standard attributes must precede the decl-specifiers to "
16000 "apply to the declaration, or follow them to apply to "
16002 }
16005 /* After we see one decl-specifier, further decl-specifiers are
16006 always optional. */
16008 }
16010 /* Don't allow a friend specifier with a class definition. */
16015 }
16017 /* Parse an (optional) storage-class-specifier.
16019 storage-class-specifier:
16020 auto
16021 register
16022 static
16023 extern
16024 mutable
16026 GNU Extension:
16028 storage-class-specifier:
16029 thread
16031 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
16033 static tree
16035 {
16037 {
16041 /* Fall through for C++98. */
16049 /* Consume the token. */
16054 }
16055 }
16057 /* Parse an (optional) function-specifier.
16059 function-specifier:
16060 inline
16061 virtual
16062 explicit
16064 C++20 Extension:
16065 explicit(constant-expression)
16067 Returns an IDENTIFIER_NODE corresponding to the keyword used.
16068 Updates DECL_SPECS, if it is non-NULL. */
16070 static tree
16073 {
16076 {
16082 /* 14.5.2.3 [temp.mem]
16084 A member function template shall not be virtual. */
16088 else
16093 {
16095 /* If we see '(', it's C++20 explicit(bool). */
16096 tree expr;
16098 {
16099 matching_parens parens;
16102 /* New types are not allowed in an explicit-specifier. */
16105 parser->type_definition_forbidden_message
16110 "%<explicit(bool)%> only available with %<-std=c++20%> "
16113 /* Parse the constant-expression. */
16116 /* Restore the saved message. */
16119 }
16120 else
16121 /* The explicit-specifier explicit without a constant-expression is
16122 equivalent to the explicit-specifier explicit(true). */
16125 /* [dcl.fct.spec]
16126 "the constant-expression, if supplied, shall be a contextually
16127 converted constant expression of type bool." */
16129 /* We could evaluate it -- mark the decl as appropriate. */
16135 /* The expression was value-dependent. Remember it so that we can
16136 substitute it later. */
16139 }
16143 }
16145 /* Consume the token. */
16147 }
16149 /* Parse a linkage-specification.
16151 linkage-specification:
16152 extern string-literal { declaration-seq [opt] }
16153 extern string-literal declaration */
16155 static void
16157 {
16158 tree linkage;
16160 /* Look for the `extern' keyword. */
16161 cp_token *extern_token
16164 /* Look for the string-literal. */
16168 /* Transform the literal into an identifier. If the literal is a
16169 wide-character string, or contains embedded NULs, then we can't
16170 handle it as the user wants. */
16174 {
16176 /* Assume C++ linkage. */
16178 }
16179 else
16182 /* We're now using the new linkage. */
16187 /* Preserve the location of the innermost linkage specification,
16188 tracking the locations of nested specifications via a local. */
16189 location_t saved_location
16191 /* Construct a location ranging from the start of the "extern" to
16192 the end of the string-literal, with the caret at the start, e.g.:
16193 extern "C" {
16194 ^~~~~~~~~~
16195 */
16196 parser->innermost_linkage_specification_location
16201 /* If the next token is a `{', then we're using the first
16202 production. */
16204 {
16208 /* Consume the `{' token. */
16209 matching_braces braces;
16211 /* Parse the declarations. */
16213 /* Look for the closing `}'. */
16215 }
16216 /* Otherwise, there's just one declaration. */
16217 else
16218 {
16221 saved_in_unbraced_linkage_specification_p
16225 parser->in_unbraced_linkage_specification_p
16227 }
16229 /* We're done with the linkage-specification. */
16233 /* Restore location of parent linkage specification, if any. */
16235 }
16237 /* Parse a static_assert-declaration.
16239 static_assert-declaration:
16240 static_assert ( constant-expression , string-literal ) ;
16241 static_assert ( constant-expression ) ; (C++17)
16243 If MEMBER_P, this static_assert is a class member. */
16245 static void
16247 {
16248 cp_expr condition;
16249 location_t token_loc;
16250 tree message;
16253 /* Peek at the `static_assert' token so we can keep track of exactly
16254 where the static assertion started. */
16257 /* Look for the `static_assert' keyword. */
16259 RT_STATIC_ASSERT))
16262 /* We know we are in a static assertion; commit to any tentative
16263 parse. */
16267 /* Parse the `(' starting the static assertion condition. */
16268 matching_parens parens;
16271 /* Parse the constant-expression. Allow a non-constant expression
16272 here in order to give better diagnostics in finish_static_assert. */
16273 condition =
16279 {
16282 "%<static_assert%> without a message "
16284 /* Eat the ')' */
16289 }
16290 else
16291 {
16292 /* Parse the separating `,'. */
16295 /* Parse the string-literal message. */
16300 /* A `)' completes the static assertion. */
16306 }
16308 /* A semicolon terminates the declaration. */
16311 /* Get the location for the static assertion. Use that of the
16312 condition if available, otherwise, use that of the "static_assert"
16313 token. */
16318 /* Complete the static assertion, which may mean either processing
16319 the static assert now or saving it for template instantiation. */
16322 }
16324 /* Parse the expression in decltype ( expression ). */
16326 static tree
16329 {
16331 tree expr;
16333 /* First, try parsing an id-expression. */
16344 {
16347 cp_id_kind idk;
16351 /* Lookup the name we got back from the id-expression. */
16356 /* A template without args is not a complete id-expression. */
16365 {
16366 /* Complete lookup of the id-expression. */
16367 expr = (finish_id_expression
16380 /* We found an id-expression, but it was something that we
16381 should not have found. This is an error, not something
16382 we can recover from, so note that we found an
16383 id-expression and we'll recover as gracefully as
16384 possible. */
16386 }
16391 /* We have an id-expression. */
16393 }
16396 {
16397 /* Abort the id-expression parse. */
16400 /* Parsing tentatively, again. */
16403 /* Parse a class member access. */
16411 /* We have an id-expression. */
16413 }
16416 /* We have parsed the complete id-expression or member access. */
16418 else
16419 {
16420 /* Abort our attempt to parse an id-expression or member access
16421 expression. */
16424 /* Parse a full expression. */
16427 }
16430 }
16432 /* Parse a `decltype' type. Returns the type.
16434 decltype-specifier:
16435 decltype ( expression )
16436 C++14:
16437 decltype ( auto ) */
16439 static tree
16441 {
16446 {
16447 /* Already parsed. */
16450 }
16452 /* Look for the `decltype' token. */
16456 /* Parse the opening `('. */
16457 matching_parens parens;
16461 /* Since we're going to preserve any side-effects from this parse, set up a
16462 firewall to protect our callers from cp_parser_commit_to_tentative_parse
16463 in the expression. */
16466 /* If in_declarator_p, a reparse as an expression might succeed (60361).
16467 Otherwise, commit now for better diagnostics. */
16478 {
16479 /* decltype (auto) */
16482 {
16484 "%<decltype(auto)%> type specifier only available with "
16487 }
16488 }
16489 else
16490 {
16491 /* decltype (expression) */
16493 /* Types cannot be defined in a `decltype' expression. Save away the
16494 old message and set the new one. */
16496 parser->type_definition_forbidden_message
16499 /* The restrictions on constant-expressions do not apply inside
16500 decltype expressions. */
16501 bool saved_integral_constant_expression_p
16503 bool saved_non_integral_constant_expression_p
16507 /* Within a parenthesized expression, a `>' token is always
16508 the greater-than operator. */
16509 bool saved_greater_than_is_operator_p
16513 /* Don't synthesize an implicit template type parameter here. This
16514 could happen with C++23 code like
16516 void f(decltype(new auto{0}));
16518 where we want to deduce the auto right away so that the parameter
16519 is of type 'int *'. */
16523 /* Do not actually evaluate the expression. */
16526 /* Do not warn about problems with the expression. */
16532 /* Go back to evaluating expressions. */
16536 /* The `>' token might be the end of a template-id or
16537 template-parameter-list now. */
16538 parser->greater_than_is_operator_p
16541 /* Restore the old message and the integral constant expression
16542 flags. */
16544 parser->integral_constant_expression_p
16546 parser->non_integral_constant_expression_p
16548 }
16550 /* Parse to the closing `)'. */
16552 {
16556 }
16558 /* If we got a parse error while tentative, bail out now. */
16560 {
16563 }
16566 /* Build auto. */
16568 else
16570 tf_warning_or_error);
16572 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
16573 it again. */
16590 }
16592 /* Special member functions [gram.special] */
16594 /* Parse a conversion-function-id.
16596 conversion-function-id:
16597 operator conversion-type-id
16599 Returns an IDENTIFIER_NODE representing the operator. */
16601 static tree
16603 {
16604 tree type;
16605 tree saved_scope;
16606 tree saved_qualifying_scope;
16607 tree saved_object_scope;
16610 /* Look for the `operator' token. */
16613 /* When we parse the conversion-type-id, the current scope will be
16614 reset. However, we need that information in able to look up the
16615 conversion function later, so we save it here. */
16619 /* We must enter the scope of the class so that the names of
16620 entities declared within the class are available in the
16621 conversion-type-id. For example, consider:
16623 struct S {
16624 typedef int I;
16625 operator I();
16626 };
16628 S::operator I() { ... }
16630 In order to see that `I' is a type-name in the definition, we
16631 must be in the scope of `S'. */
16634 /* Parse the conversion-type-id. */
16636 /* Leave the scope of the class, if any. */
16639 /* Restore the saved scope. */
16643 /* If the TYPE is invalid, indicate failure. */
16647 }
16649 /* Parse a conversion-type-id:
16651 conversion-type-id:
16652 type-specifier-seq conversion-declarator [opt]
16654 Returns the TYPE specified. */
16656 static tree
16658 {
16659 tree attributes;
16660 cp_decl_specifier_seq type_specifiers;
16662 tree type_specified;
16665 /* Parse the attributes. */
16669 parser->type_definition_forbidden_message
16672 /* Parse the type-specifiers. DR 2413 clarifies that `typename' is
16673 optional in conversion-type-id. */
16681 /* If that didn't work, stop. */
16684 /* Parse the conversion-declarator. */
16692 /* Don't give this error when parsing tentatively. This happens to
16693 work because we always parse this definitively once. */
16696 {
16698 {
16701 }
16705 }
16708 }
16710 /* Parse an (optional) conversion-declarator.
16712 conversion-declarator:
16713 ptr-operator conversion-declarator [opt]
16715 */
16719 {
16722 cp_cv_quals cv_quals;
16724 /* We don't know if there's a ptr-operator next, or not. */
16726 /* Try the ptr-operator. */
16729 /* If it worked, look for more conversion-declarators. */
16731 {
16734 /* Parse another optional declarator. */
16737 declarator = cp_parser_make_indirect_declarator
16741 }
16744 }
16746 /* Parse an (optional) ctor-initializer.
16748 ctor-initializer:
16749 : mem-initializer-list */
16751 static void
16753 {
16754 /* If the next token is not a `:', then there is no
16755 ctor-initializer. */
16757 {
16758 /* Do default initialization of any bases and members. */
16762 }
16764 /* Consume the `:' token. */
16766 /* And the mem-initializer-list. */
16768 }
16770 /* Parse a mem-initializer-list.
16772 mem-initializer-list:
16773 mem-initializer ... [opt]
16774 mem-initializer ... [opt] , mem-initializer-list */
16776 static void
16778 {
16783 /* Let the semantic analysis code know that we are starting the
16784 mem-initializer-list. */
16789 /* Loop through the list. */
16791 {
16792 tree mem_initializer;
16795 /* Parse the mem-initializer. */
16797 /* If the next token is a `...', we're expanding member initializers. */
16803 {
16804 /* Consume the `...'. */
16808 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
16809 can be expanded but members cannot. */
16812 {
16817 }
16819 /* Construct the pack expansion type. */
16822 }
16825 {
16829 }
16830 /* Look for a target constructor. */
16834 {
16837 {
16841 }
16843 }
16844 /* Add it to the list, unless it was erroneous. */
16846 {
16849 }
16850 /* If the next token is not a `,', we're done. */
16853 /* Consume the `,' token. */
16855 }
16857 /* Perform semantic analysis. */
16860 }
16862 /* Parse a mem-initializer.
16864 mem-initializer:
16865 mem-initializer-id ( expression-list [opt] )
16866 mem-initializer-id braced-init-list
16868 GNU extension:
16870 mem-initializer:
16871 ( expression-list [opt] )
16873 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
16874 class) or FIELD_DECL (for a non-static data member) to initialize;
16875 the TREE_VALUE is the expression-list. An empty initialization
16876 list is represented by void_list_node. */
16878 static tree
16880 {
16881 tree mem_initializer_id;
16882 tree expression_list;
16883 tree member;
16886 /* Find out what is being initialized. */
16888 {
16892 }
16893 else
16894 {
16898 }
16904 {
16911 }
16912 else
16913 {
16925 }
16938 /* We can't attach the source location of this initializer directly to
16939 the list node, so we instead attach it to a dummy EMPTY_CLASS_EXPR
16940 within the TREE_TYPE of the list node. */
16941 location_t loc
16948 }
16950 /* Parse a mem-initializer-id.
16952 mem-initializer-id:
16953 :: [opt] nested-name-specifier [opt] class-name
16954 decltype-specifier (C++11)
16955 identifier
16957 Returns a TYPE indicating the class to be initialized for the first
16958 production (and the second in C++11). Returns an IDENTIFIER_NODE
16959 indicating the data member to be initialized for the last production. */
16961 static tree
16963 {
16967 tree id;
16971 /* `typename' is not allowed in this context ([temp.res]). */
16973 {
16975 "keyword %<typename%> not allowed in this context (a qualified "
16978 }
16979 /* Look for the optional `::' operator. */
16980 global_scope_p
16984 /* Look for the optional nested-name-specifier. The simplest way to
16985 implement:
16987 [temp.res]
16989 The keyword `typename' is not permitted in a base-specifier or
16990 mem-initializer; in these contexts a qualified name that
16991 depends on a template-parameter is implicitly assumed to be a
16992 type name.
16994 is to assume that we have seen the `typename' keyword at this
16995 point. */
16996 nested_name_specifier_p
17005 /* If there is a `::' operator or a nested-name-specifier, then we
17006 are definitely looking for a class-name. */
17011 typename_type,
17015 /* Otherwise, we could also be looking for an ordinary identifier. */
17018 /* Try a decltype-specifier. */
17020 else
17021 /* Otherwise, try a class-name. */
17025 none_type,
17029 /* If we found one, we're done. */
17032 /* Otherwise, look for an ordinary identifier. */
17034 }
17036 /* Overloading [gram.over] */
17038 /* Parse an operator-function-id.
17040 operator-function-id:
17041 operator operator
17043 Returns an IDENTIFIER_NODE for the operator which is a
17044 human-readable spelling of the identifier, e.g., `operator +'. */
17046 static cp_expr
17048 {
17050 /* Look for the `operator' keyword. */
17053 /* And then the name of the operator itself. */
17055 }
17057 /* Return an identifier node for a user-defined literal operator.
17058 The suffix identifier is chained to the operator name identifier. */
17060 tree
17062 {
17063 tree identifier;
17071 }
17073 /* Parse an operator.
17075 operator:
17076 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
17077 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
17078 || ++ -- , ->* -> () []
17080 GNU Extensions:
17082 operator:
17083 <? >? <?= >?=
17085 Returns an IDENTIFIER_NODE for the operator which is a
17086 human-readable spelling of the identifier, e.g., `operator +'. */
17088 static cp_expr
17090 {
17095 /* Peek at the next token. */
17100 /* Figure out which operator we have. */
17105 {
17107 {
17108 /* The keyword should be either `new', `delete' or `co_await'. */
17115 else
17118 /* Consume the `new', `delete' or co_await token. */
17121 /* Peek at the next token. */
17123 /* If it's a `[' token then this is the array variant of the
17124 operator. */
17127 {
17128 /* Consume the `[' token. */
17130 /* Look for the `]' token. */
17135 }
17138 }
17301 /* Consume the `?'. */
17303 /* Look for the matching `:'. */
17309 {
17310 /* Consume the `('. */
17311 matching_parens parens;
17313 /* Look for the matching `)'. */
17320 }
17323 /* Consume the `['. */
17325 /* Look for the matching `]'. */
17336 /* FALLTHRU */
17345 {
17346 cp_expr str;
17347 tree string_tree;
17353 /* Consume the string. */
17359 {
17363 }
17364 else
17365 {
17367 /* Look for the suffix identifier. */
17370 {
17373 }
17375 {
17379 }
17380 else
17381 {
17384 }
17385 }
17390 {
17393 }
17396 {
17399 }
17401 {
17404 }
17405 /* Generate a location of the form:
17406 "" _suffix_identifier
17407 ^~~~~~~~~~~~~~~~~~~~~
17408 with caret == start at the start token, finish at the end of the
17409 suffix identifier. */
17410 location_t combined_loc
17413 }
17416 /* Anything else is an error. */
17418 }
17420 /* If we have selected an identifier, we need to consume the
17421 operator token. */
17423 {
17427 }
17428 /* Otherwise, no valid operator name was present. */
17429 else
17430 {
17433 }
17437 }
17439 /* Parse a template-declaration.
17441 template-declaration:
17442 export [opt] template < template-parameter-list > declaration
17444 If MEMBER_P is TRUE, this template-declaration occurs within a
17445 class-specifier.
17447 The grammar rule given by the standard isn't correct. What
17448 is really meant is:
17450 template-declaration:
17451 export [opt] template-parameter-list-seq
17452 decl-specifier-seq [opt] init-declarator [opt] ;
17453 export [opt] template-parameter-list-seq
17454 function-definition
17456 template-parameter-list-seq:
17457 template-parameter-list-seq [opt]
17458 template < template-parameter-list >
17460 Concept Extensions:
17462 template-parameter-list-seq:
17463 template < template-parameter-list > requires-clause [opt]
17465 requires-clause:
17466 requires logical-or-expression */
17468 static void
17470 {
17471 /* Check for `export'. */
17473 {
17474 /* Consume the `export' token. */
17476 /* Warn that this use of export is deprecated. */
17481 else
17483 }
17486 }
17488 /* Parse a template-parameter-list.
17490 template-parameter-list:
17491 template-parameter
17492 template-parameter-list , template-parameter
17494 Returns a TREE_LIST. Each node represents a template parameter.
17495 The nodes are connected via their TREE_CHAINs. */
17497 static tree
17499 {
17502 /* Don't create wrapper nodes within a template-parameter-list,
17503 since we don't want to have different types based on the
17504 spelling location of constants and decls within them. */
17505 auto_suppress_location_wrappers sentinel;
17509 /* The loop below parses the template parms. We first need to know
17510 the total number of template parms to be able to compute proper
17511 canonical types of each dependent type. So after the loop, when
17512 we know the total number of template parms,
17513 end_template_parm_list computes the proper canonical types and
17514 fixes up the dependent types accordingly. */
17516 {
17517 tree parameter;
17520 location_t parm_loc;
17522 /* Parse the template-parameter. */
17527 /* Add it to the list. */
17530 parm_loc,
17531 parameter,
17532 is_non_type,
17533 is_parameter_pack);
17534 else
17535 {
17538 }
17540 /* If the next token is not a `,', we're done. */
17543 /* Otherwise, consume the `,' token. */
17545 }
17548 }
17550 /* Parse a introduction-list.
17552 introduction-list:
17553 introduced-parameter
17554 introduction-list , introduced-parameter
17556 introduced-parameter:
17557 ...[opt] identifier
17559 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
17560 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
17561 WILDCARD_DECL will also have DECL_NAME set and token location in
17562 DECL_SOURCE_LOCATION. */
17564 static tree
17566 {
17570 {
17579 /* Build placeholder. */
17587 /* If the next token is not a `,', we're done. */
17590 /* Otherwise, consume the `,' token. */
17592 }
17594 /* Convert the vec into a TREE_VEC. */
17597 tree parm;
17603 }
17605 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
17606 is an abstract declarator. */
17610 {
17615 }
17617 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
17618 is an abstract declarator. */
17622 {
17626 else
17628 }
17630 /* Returns true if TYPE would declare a constrained constrained-parameter. */
17634 {
17639 }
17641 /* Returns true if PARM declares a constrained-parameter. */
17645 {
17647 }
17649 /* Check that the type parameter is only a declarator-id, and that its
17650 type is not cv-qualified. */
17652 bool
17655 {
17660 {
17663 }
17665 /* Don't allow cv-qualified type parameters. */
17668 {
17671 }
17674 }
17676 /* Finish parsing/processing a template type parameter and checking
17677 various restrictions. */
17681 tree id,
17683 {
17686 else
17688 }
17690 static tree
17692 {
17693 /* FIXME: This should probably be copied, and we may need to adjust
17694 the template parameter depths. */
17704 }
17706 /* Finish parsing/processing a template template parameter by borrowing
17707 the template parameter list from the prototype parameter. */
17709 static tree
17711 tree proto,
17712 tree id,
17714 {
17718 }
17720 /* Create a new non-type template parameter from the given PARM
17721 declarator. */
17723 static tree
17726 {
17732 }
17734 /* Build a constrained template parameter based on the PARMDECL
17735 declarator. The type of PARMDECL is the constrained type, which
17736 refers to the prototype template parameter that ultimately
17737 specifies the type of the declared parameter. */
17739 static tree
17743 {
17749 /* Build the parameter. Return an error if the declarator was invalid. */
17750 tree parm;
17755 parmdecl);
17756 else
17761 /* Finish the parameter decl and create a node attaching the
17762 default argument and constraint. */
17767 }
17769 /* Returns true if the parsed type actually represents the declaration
17770 of a type template-parameter. */
17772 static bool
17774 {
17777 }
17779 /* Returns true if the parsed type actually represents the declaration of
17780 a template template-parameter. */
17782 static bool
17784 {
17787 }
17789 /* Parse a default argument for a type template-parameter.
17790 Note that diagnostics are handled in cp_parser_template_parameter. */
17792 static tree
17794 {
17797 /* Consume the `=' token. */
17802 /* Tell cp_parser_lambda_expression this is a default argument. */
17806 /* Parse the default-argument. */
17809 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17810 NULL);
17814 {
17818 }
17821 }
17823 /* Parse a default argument for a template template-parameter. */
17825 static tree
17827 {
17832 /* Consume the `='. */
17834 /* Parse the id-expression. */
17836 /* save token before parsing the id-expression, for error
17837 reporting */
17839 tree default_argument
17847 /* If the id-expression was a template-id that refers to
17848 a template-class, we already have the declaration here,
17849 so no further lookup is needed. */
17850 ;
17851 else
17852 /* Look up the name. */
17853 default_argument
17855 none_type,
17861 /* See if the default argument is valid. */
17865 }
17867 /* Parse a template-parameter.
17869 template-parameter:
17870 type-parameter
17871 parameter-declaration
17873 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
17874 the parameter. The TREE_PURPOSE is the default value, if any.
17875 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
17876 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
17877 set to true iff this parameter is a parameter pack. */
17879 static tree
17882 {
17885 tree parm;
17887 /* Assume it is a type parameter or a template parameter. */
17889 /* Assume it not a parameter pack. */
17891 /* Peek at the next token. */
17893 /* If it is `template', we have a type-parameter. */
17896 /* If it is `class' or `typename' we do not know yet whether it is a
17897 type parameter or a non-type parameter. Consider:
17899 template <typename T, typename T::X X> ...
17901 or:
17903 template <class C, class D*> ...
17905 Here, the first parameter is a type parameter, and the second is
17906 a non-type parameter. We can tell by looking at the token after
17907 the identifier -- if it is a `,', `=', or `>' then we have a type
17908 parameter. */
17910 {
17911 /* Peek at the token after `class' or `typename'. */
17913 /* If it's an ellipsis, we have a template type parameter
17914 pack. */
17917 /* If it's an identifier, skip it. */
17920 /* Now, see if the token looks like the end of a template
17921 parameter. */
17926 }
17928 /* Otherwise, it is a non-type parameter or a constrained parameter.
17930 [temp.param]
17932 When parsing a default template-argument for a non-type
17933 template-parameter, the first non-nested `>' is taken as the end
17934 of the template parameter-list rather than a greater-than
17935 operator. */
17936 parameter_declarator
17938 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
17945 /* If the parameter declaration is marked as a parameter pack, set
17946 *IS_PARAMETER_PACK to notify the caller. */
17951 {
17952 /* Can happen in some cases of erroneous input (c++/34892). */
17954 /* Consume the `...' for better error recovery. */
17956 }
17958 /* The parameter may have been constrained type parameter. */
17961 parameter_declarator,
17962 is_non_type);
17964 // Now we're sure that the parameter is a non-type parameter.
17975 }
17977 /* Parse a type-parameter.
17979 type-parameter:
17980 class identifier [opt]
17981 class identifier [opt] = type-id
17982 typename identifier [opt]
17983 typename identifier [opt] = type-id
17984 template < template-parameter-list > class identifier [opt]
17985 template < template-parameter-list > class identifier [opt]
17986 = id-expression
17988 GNU Extension (variadic templates):
17990 type-parameter:
17991 class ... identifier [opt]
17992 typename ... identifier [opt]
17994 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
17995 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
17996 the declaration of the parameter.
17998 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
18000 static tree
18002 {
18004 tree parameter;
18006 /* Look for a keyword to tell us what kind of parameter this is. */
18012 {
18015 {
18016 tree identifier;
18017 tree default_argument;
18019 /* If the next token is an ellipsis, we have a template
18020 argument pack. */
18022 {
18023 /* Consume the `...' token. */
18028 }
18030 /* If the next token is an identifier, then it names the
18031 parameter. */
18034 else
18037 /* Create the parameter. */
18040 /* If the next token is an `=', we have a default argument. */
18042 {
18043 default_argument
18046 /* Template parameter packs cannot have default
18047 arguments. */
18049 {
18052 "template parameter pack %qD cannot have a "
18054 else
18056 "template parameter packs cannot have "
18059 }
18062 }
18063 else
18066 /* Create the combined representation of the parameter and the
18067 default argument. */
18069 }
18073 {
18074 tree identifier;
18075 tree default_argument;
18077 /* Look for the `<'. */
18079 /* Parse the template-parameter-list. */
18081 /* Look for the `>'. */
18084 /* If template requirements are present, parse them. */
18086 {
18091 }
18093 /* Look for the `class' or 'typename' keywords. */
18095 /* If the next token is an ellipsis, we have a template
18096 argument pack. */
18098 {
18099 /* Consume the `...' token. */
18104 }
18105 /* If the next token is an `=', then there is a
18106 default-argument. If the next token is a `>', we are at
18107 the end of the parameter-list. If the next token is a `,',
18108 then we are at the end of this parameter. */
18112 {
18114 /* Treat invalid names as if the parameter were nameless. */
18117 }
18118 else
18121 /* Create the template parameter. */
18123 identifier);
18125 /* If the next token is an `=', then there is a
18126 default-argument. */
18128 {
18129 default_argument
18132 /* Template parameter packs cannot have default
18133 arguments. */
18135 {
18138 "template parameter pack %qD cannot "
18140 identifier);
18141 else
18145 }
18146 }
18147 else
18150 /* Create the combined representation of the parameter and the
18151 default argument. */
18153 }
18159 }
18162 }
18164 /* Parse a template-id.
18166 template-id:
18167 template-name < template-argument-list [opt] >
18169 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
18170 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
18171 returned. Otherwise, if the template-name names a function, or set
18172 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
18173 names a class, returns a TYPE_DECL for the specialization.
18175 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
18176 uninstantiated templates. */
18178 static tree
18184 {
18185 tree templ;
18186 tree arguments;
18187 tree template_id;
18192 /* If the next token corresponds to a template-id, there is no need
18193 to reparse it. */
18197 {
18200 }
18202 /* Avoid performing name lookup if there is no possibility of
18203 finding a template-id. */
18206 && !cp_parser_nth_token_starts_template_argument_list_p
18208 {
18211 }
18213 /* Remember where the template-id starts. */
18219 /* Parse the template-name. */
18222 check_dependency_p,
18223 is_declaration,
18224 tag_type,
18227 /* Push any access checks inside the firewall we're about to create. */
18233 /* Since we're going to preserve any side-effects from this parse, set up a
18234 firewall to protect our callers from cp_parser_commit_to_tentative_parse
18235 in the template arguments. */
18239 /* If we find the sequence `[:' after a template-name, it's probably
18240 a digraph-typo for `< ::'. Substitute the tokens and check if we can
18241 parse correctly the argument list. */
18248 {
18250 /* Change `:' into `::'. */
18252 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
18253 CPP_LESS. */
18256 /* Parse the arguments. */
18259 {
18260 /* If we couldn't parse an argument list, then we revert our changes
18261 and return simply an error. Maybe this is not a template-id
18262 after all. */
18267 }
18268 /* Otherwise, emit an error about the invalid digraph, but continue
18269 parsing because we got our argument list. */
18272 {
18275 "%<<:%> is an alternate spelling for %<[%>."
18278 {
18280 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
18283 }
18284 }
18285 }
18286 else
18287 {
18288 /* Look for the `<' that starts the template-argument-list. */
18290 {
18293 }
18294 /* Parse the arguments. */
18299 && !template_keyword_p
18302 {
18303 /* This didn't go well. */
18305 {
18306 /* C++20 says that "function-name < a;" is now ill-formed. */
18308 {
18311 "operand of %<<%> is ill-formed in C++20; wrap the "
18313 }
18314 else
18315 /* We expect "f<targs>" to be followed by "(args)". */
18319 /* Purge all subsequent tokens. */
18321 }
18322 else
18326 }
18327 }
18329 /* Set the location to be of the form:
18330 template-name < template-argument-list [opt] >
18331 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
18332 with caret == start at the start of the template-name,
18333 ranging until the closing '>'. */
18334 location_t combined_loc
18337 /* Check for concepts autos where they don't belong. We could
18338 identify types in some cases of identifier TEMPL, looking ahead
18339 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
18340 types. We reject them in functions, but if what we have is an
18341 identifier, even with none_type we can't conclude it's NOT a
18342 type, we have to wait for template substitution. */
18345 /* Build a representation of the specialization. */
18348 TEMPLATE_ID_EXPR,
18352 {
18353 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
18354 template (rather than some instantiation thereof) only if
18355 is not nested within some other construct. For example, in
18356 "template <typename T> void f(T) { A<T>::", A<T> is just an
18357 instantiation of A. */
18358 bool entering_scope
18361 template_id
18363 }
18365 {
18366 /* The caller will decide whether this is a concept check or type
18367 constraint. */
18370 }
18372 {
18376 }
18379 {
18380 /* Some type template in dependent scope. */
18383 TEMPLATE_ID_EXPR,
18386 }
18387 else
18388 {
18389 /* If it's not a class-template or a template-template, it should be
18390 a function-template. */
18396 }
18398 /* If parsing tentatively, replace the sequence of tokens that makes
18399 up the template-id with a CPP_TEMPLATE_ID token. That way,
18400 should we re-parse the token stream, we will not have to repeat
18401 the effort required to do the parse, nor will we issue duplicate
18402 error messages about problems during instantiation of the
18403 template. */
18405 /* Don't do this if we had a parse error in a declarator; re-parsing
18406 might succeed if a name changes meaning (60361). */
18410 {
18411 /* Reset the contents of the START_OF_ID token. */
18415 /* Retrieve any deferred checks. Do not pop this access checks yet
18416 so the memory will not be reclaimed during token replacing below. */
18423 /* Purge all subsequent tokens. */
18426 /* ??? Can we actually assume that, if template_id ==
18427 error_mark_node, we will have issued a diagnostic to the
18428 user, as opposed to simply marking the tentative parse as
18429 failed? */
18432 }
18436 }
18438 /* Like cp_parser_template_id, called in non-type context. */
18440 static tree
18445 {
18450 /* We didn't check the arguments in cp_parser_template_id; do that now. */
18453 }
18455 /* Parse a template-name.
18457 template-name:
18458 identifier
18460 The standard should actually say:
18462 template-name:
18463 identifier
18464 operator-function-id
18466 A defect report has been filed about this issue.
18468 A conversion-function-id cannot be a template name because they cannot
18469 be part of a template-id. In fact, looking at this code:
18471 a.operator K<int>()
18473 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
18474 It is impossible to call a templated conversion-function-id with an
18475 explicit argument list, since the only allowed template parameter is
18476 the type to which it is converting.
18478 If TEMPLATE_KEYWORD_P is true, then we have just seen the
18479 `template' keyword, in a construction like:
18481 T::template f<3>()
18483 In that case `f' is taken to be a template-name, even though there
18484 is no way of knowing for sure.
18486 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
18487 name refers to a set of overloaded functions, at least one of which
18488 is a template, or an IDENTIFIER_NODE with the name of the template,
18489 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
18490 names are looked up inside uninstantiated templates. */
18492 static tree
18499 {
18500 tree identifier;
18501 tree decl;
18504 /* If the next token is `operator', then we have either an
18505 operator-function-id or a conversion-function-id. */
18507 {
18508 /* We don't know whether we're looking at an
18509 operator-function-id or a conversion-function-id. */
18511 /* Try an operator-function-id. */
18513 /* If that didn't work, try a conversion-function-id. */
18515 {
18518 }
18519 }
18520 /* Look for the identifier. */
18521 else
18524 /* If we didn't find an identifier, we don't have a template-id. */
18528 /* If the name immediately followed the `template' keyword, then it
18529 is a template-name. However, if the next token is not `<', then
18530 we do not treat it as a template-name, since it is not being used
18531 as part of a template-id. This enables us to handle constructs
18532 like:
18534 template <typename T> struct S { S(); };
18535 template <typename T> S<T>::S();
18537 correctly. We would treat `S' as a template -- if it were `S<T>'
18538 -- but we do not if there is no `<'. */
18542 {
18543 /* In a declaration, in a dependent context, we pretend that the
18544 "template" keyword was present in order to improve error
18545 recovery. For example, given:
18547 template <typename T> void f(T::X<int>);
18549 we want to treat "X<int>" as a template-id. */
18551 && !template_keyword_p
18553 && check_dependency_p
18555 /* Do not do this for dtors (or ctors), since they never
18556 need the template keyword before their name. */
18558 {
18561 /* Explain what went wrong. */
18563 identifier);
18566 /* If parsing tentatively, find the location of the "<" token. */
18569 /* Parse the template arguments so that we can issue error
18570 messages about them. */
18573 /* Skip tokens until we find a good place from which to
18574 continue parsing. */
18579 /* If parsing tentatively, permanently remove the
18580 template argument list. That will prevent duplicate
18581 error messages from being issued about the missing
18582 "template" keyword. */
18589 }
18591 /* If the "template" keyword is present, then there is generally
18592 no point in doing name-lookup, so we just return IDENTIFIER.
18593 But, if the qualifying scope is non-dependent then we can
18594 (and must) do name-lookup normally. */
18596 {
18602 {
18603 /* We're optimizing away the call to cp_parser_lookup_name, but
18604 we still need to do this. */
18608 }
18609 }
18610 }
18612 /* cp_parser_lookup_name clears OBJECT_TYPE. */
18616 /* Look up the name. */
18618 tag_type,
18621 check_dependency_p,
18627 /* 13.3 [temp.names] A < is interpreted as the delimiter of a
18628 template-argument-list if it follows a name that is not a
18629 conversion-function-id and
18630 - that follows the keyword template or a ~ after a nested-name-specifier or
18631 in a class member access expression, or
18632 - for which name lookup finds the injected-class-name of a class template
18633 or finds any declaration of a template, or
18634 - that is an unqualified name for which name lookup either finds one or
18635 more functions or finds nothing, or
18636 - that is a terminal name in a using-declarator (9.9), in a declarator-id
18637 (9.3.4), or in a type-only context other than a nested-name-specifier
18638 (13.8). */
18640 /* Handle injected-class-name. */
18643 /* If DECL is a template, then the name was a template-name. */
18645 {
18648 {
18650 tree attr;
18653 else
18656 {
18659 }
18662 {
18665 }
18666 }
18667 }
18668 else
18669 {
18670 /* Look through an overload set for any templates. */
18678 /* "an unqualified name for which name lookup either finds one or more
18679 functions or finds nothing". */
18682 && !scope
18685 {
18686 /* The "more functions" case. Just use the OVERLOAD as normally.
18687 We don't use is_overloaded_fn here to avoid considering
18688 BASELINKs. */
18690 /* Name lookup found one function. */
18692 /* Name lookup found nothing. */
18695 }
18697 /* "that follows the keyword template"..."in a type-only context" */
18705 {
18706 /* The name does not name a template. */
18709 }
18712 /* cp_parser_template_id can only handle some TYPE_DECLs. */
18715 /* Repeat the lookup at instantiation time. */
18717 }
18720 }
18722 /* Parse a template-argument-list.
18724 template-argument-list:
18725 template-argument ... [opt]
18726 template-argument-list , template-argument ... [opt]
18728 Returns a TREE_VEC containing the arguments. */
18730 static tree
18732 {
18737 /* Don't create location wrapper nodes within a template-argument-list. */
18738 auto_suppress_location_wrappers sentinel;
18742 /* Even if the template-id appears in an integral
18743 constant-expression, the contents of the argument list do
18744 not. */
18750 /* Parse the arguments. */
18752 do
18753 {
18755 /* Consume the comma. */
18758 /* Parse the template-argument. */
18761 /* If the next token is an ellipsis, we're expanding a template
18762 argument pack. */
18764 {
18766 {
18770 }
18771 /* Consume the `...' token. */
18774 /* Make the argument into a TYPE_PACK_EXPANSION or
18775 EXPR_PACK_EXPANSION. */
18777 }
18780 }
18795 }
18797 /* Parse a template-argument.
18799 template-argument:
18800 assignment-expression
18801 type-id
18802 id-expression
18804 The representation is that of an assignment-expression, type-id, or
18805 id-expression -- except that the qualified id-expression is
18806 evaluated, so that the value returned is either a DECL or an
18807 OVERLOAD.
18809 Although the standard says "assignment-expression", it forbids
18810 throw-expressions or assignments in the template argument.
18811 Therefore, we use "conditional-expression" instead. */
18813 static tree
18815 {
18816 tree argument;
18822 cp_id_kind idk;
18824 /* There's really no way to know what we're looking at, so we just
18825 try each alternative in order.
18827 [temp.arg]
18829 In a template-argument, an ambiguity between a type-id and an
18830 expression is resolved to a type-id, regardless of the form of
18831 the corresponding template-parameter.
18833 Therefore, we try a type-id first. */
18836 /* If there was no error parsing the type-id but the next token is a
18837 '>>', our behavior depends on which dialect of C++ we're
18838 parsing. In C++98, we probably found a typo for '> >'. But there
18839 are type-id which are also valid expressions. For instance:
18841 struct X { int operator >> (int); };
18842 template <int V> struct Foo {};
18843 Foo<X () >> 5> r;
18845 Here 'X()' is a valid type-id of a function type, but the user just
18846 wanted to write the expression "X() >> 5". Thus, we remember that we
18847 found a valid type-id, but we still try to parse the argument as an
18848 expression to see what happens.
18850 In C++0x, the '>>' will be considered two separate '>'
18851 tokens. */
18855 /* Similarly for >= which
18856 cp_parser_next_token_ends_template_argument_p treats for
18857 diagnostics purposes as mistyped > =, but can be valid
18858 after a type-id. */
18860 {
18863 }
18864 else
18865 {
18866 /* If the next token isn't a `,' or a `>', then this argument wasn't
18867 really finished. This means that the argument is not a valid
18868 type-id. */
18871 /* If that worked, we're done. */
18874 }
18875 /* We're still not sure what the argument will be. */
18877 /* Try a template. */
18885 /* If the next token isn't a `,' or a `>', then this argument wasn't
18886 really finished. */
18890 {
18891 /* Figure out what is being referred to. If the id-expression
18892 was for a class template specialization, then we will have a
18893 TYPE_DECL at this point. There is no need to do name lookup
18894 at this point in that case. */
18897 none_type,
18906 }
18908 {
18914 }
18915 /* It must be a non-type argument. In C++17 any constant-expression is
18916 allowed. */
18920 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
18922 -- an integral constant-expression of integral or enumeration
18923 type; or
18925 -- the name of a non-type template-parameter; or
18927 -- the name of an object or function with external linkage...
18929 -- the address of an object or function with external linkage...
18931 -- a pointer to member... */
18932 /* Look for a non-type template parameter. */
18934 {
18946 }
18948 /* If the next token is "&", the argument must be the address of an
18949 object or function with external linkage. */
18952 {
18955 }
18956 /* See if we might have an id-expression. */
18963 {
18966 address_p,
18973 else
18974 {
18975 tree probe;
18978 {
18979 /* Strip the dereference temporarily. */
18982 }
18984 /* If we're in a template, we represent a qualified-id referring
18985 to a static data member as a SCOPE_REF even if the scope isn't
18986 dependent so that we can check access control later. */
18991 {
18992 /* A variable without external linkage might still be a
18993 valid constant-expression, so no error is issued here
18994 if the external-linkage check fails. */
18997 }
18999 /* All overloaded functions are allowed; if the external
19000 linkage test does not pass, an error will be issued
19001 later. */
19002 ;
19006 /* A pointer-to-member. */
19007 ;
19009 ;
19010 else
19014 {
19018 else
19021 }
19022 }
19023 }
19024 /* If the argument started with "&", there are no other valid
19025 alternatives at this point. */
19027 {
19030 }
19032 general_expr:
19033 /* If the argument wasn't successfully parsed as a type-id followed
19034 by '>>', the argument can only be a constant expression now.
19035 Otherwise, we try parsing the constant-expression tentatively,
19036 because the argument could really be a type-id. */
19042 else
19043 {
19044 /* In C++20, we can encounter a braced-init-list. */
19047 {
19050 }
19052 /* With C++17 generalized non-type template arguments we need to handle
19053 lvalue constant expressions, too. */
19056 }
19064 /* We did our best to parse the argument as a non type-id, but that
19065 was the only alternative that matched (albeit with a '>' after
19066 it). We can assume it's just a typo from the user, and a
19067 diagnostic will then be issued. */
19069 }
19071 /* Parse an explicit-instantiation.
19073 explicit-instantiation:
19074 template declaration
19076 Although the standard says `declaration', what it really means is:
19078 explicit-instantiation:
19079 template decl-specifier-seq [opt] declarator [opt] ;
19081 Things like `template int S<int>::i = 5, int S<double>::j;' are not
19082 supposed to be allowed. A defect report has been filed about this
19083 issue.
19085 GNU Extension:
19087 explicit-instantiation:
19088 storage-class-specifier template
19089 decl-specifier-seq [opt] declarator [opt] ;
19090 function-specifier template
19091 decl-specifier-seq [opt] declarator [opt] ; */
19093 static void
19095 {
19097 cp_decl_specifier_seq decl_specifiers;
19102 /* Look for an (optional) storage-class-specifier or
19103 function-specifier. */
19105 {
19106 extension_specifier
19109 extension_specifier
19112 }
19114 /* Look for the `template' keyword. */
19116 /* Let the front end know that we are processing an explicit
19117 instantiation. */
19119 /* [temp.explicit] says that we are supposed to ignore access
19120 control while processing explicit instantiation directives. */
19122 /* Parse a decl-specifier-seq. */
19124 CP_PARSER_FLAGS_OPTIONAL,
19128 cp_omp_declare_simd_data odsd;
19134 /* If there was exactly one decl-specifier, and it declared a class,
19135 and there's no declarator, then we have an explicit type
19136 instantiation. */
19138 {
19141 /* Turn access control back on for names used during
19142 template instantiation. */
19147 }
19148 else
19149 {
19151 tree decl;
19153 /* Parse the declarator. */
19154 declarator
19156 CP_PARSER_FLAGS_NONE,
19167 {
19170 "explicit instantiation shall not use"
19174 "explicit instantiation shall not use"
19178 "explicit instantiation shall not use"
19183 /* Turn access control back on for names used during
19184 template instantiation. */
19186 /* Do the explicit instantiation. */
19188 }
19189 else
19190 {
19192 /* Skip the body of the explicit instantiation. */
19194 }
19195 }
19196 /* We're done with the instantiation. */
19202 }
19204 /* Parse an explicit-specialization.
19206 explicit-specialization:
19207 template < > declaration
19209 Although the standard says `declaration', what it really means is:
19211 explicit-specialization:
19212 template <> decl-specifier [opt] init-declarator [opt] ;
19213 template <> function-definition
19214 template <> explicit-specialization
19215 template <> template-declaration */
19217 static void
19219 {
19222 /* Look for the `template' keyword. */
19224 /* Look for the `<'. */
19226 /* Look for the `>'. */
19228 /* We have processed another parameter list. */
19231 /* [temp]
19233 A template ... explicit specialization ... shall not have C
19234 linkage. */
19237 {
19241 /* Give it C++ linkage to avoid confusing other parts of the
19242 front end. */
19244 }
19246 /* Let the front end know that we are beginning a specialization. */
19248 {
19249 /* If the next keyword is `template', we need to figure out
19250 whether or not we're looking a template-declaration. */
19252 {
19257 else
19259 }
19260 else
19261 /* Parse the dependent declaration. */
19267 }
19269 /* We're done with the specialization. */
19272 /* For the erroneous case of a template with C linkage, we pushed an
19273 implicit C++ linkage scope; exit that scope now. */
19277 /* We're done with this parameter list. */
19279 }
19281 /* Preserve the attributes across a garbage collect (by making it a GC
19282 root), which can occur when parsing a member function. */
19286 /* Parse a type-specifier.
19288 type-specifier:
19289 simple-type-specifier
19290 class-specifier
19291 enum-specifier
19292 elaborated-type-specifier
19293 cv-qualifier
19295 GNU Extension:
19297 type-specifier:
19298 __complex__
19300 Returns a representation of the type-specifier. For a
19301 class-specifier, enum-specifier, or elaborated-type-specifier, a
19302 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
19304 The parser flags FLAGS is used to control type-specifier parsing.
19306 If IS_DECLARATION is TRUE, then this type-specifier is appearing
19307 in a decl-specifier-seq.
19309 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
19310 class-specifier, enum-specifier, or elaborated-type-specifier, then
19311 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
19312 if a type is declared; 2 if it is defined. Otherwise, it is set to
19313 zero.
19315 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
19316 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
19317 is set to FALSE. */
19319 static tree
19321 cp_parser_flags flags,
19326 {
19332 /* Assume this type-specifier does not declare a new type. */
19335 /* And that it does not specify a cv-qualifier. */
19338 /* Peek at the next token. */
19341 /* If we're looking at a keyword, we can use that to guide the
19342 production we choose. */
19345 {
19350 /* Look for the enum-specifier. */
19352 /* If that worked, we're done. */
19354 {
19359 type_spec,
19360 token,
19363 }
19364 else
19367 /* Any of these indicate either a class-specifier, or an
19368 elaborated-type-specifier. */
19375 /* Parse tentatively so that we can back up if we don't find a
19376 class-specifier. */
19380 /* Look for the class-specifier. */
19385 /* If that worked, we're done. */
19387 {
19392 type_spec,
19393 token,
19396 }
19398 /* Fall through. */
19399 elaborated_type_specifier:
19400 /* We're declaring (not defining) a class or enum. */
19404 /* Fall through. */
19406 /* Look for an elaborated-type-specifier. */
19407 type_spec
19408 = (cp_parser_elaborated_type_specifier
19411 is_declaration));
19414 type_spec,
19415 token,
19438 /* The `__complex__' keyword is a GNU extension. */
19444 }
19446 /* Handle simple keywords. */
19448 {
19450 {
19453 }
19455 }
19457 /* If we do not already have a type-specifier, assume we are looking
19458 at a simple-type-specifier. */
19460 decl_specs,
19461 flags);
19463 /* If we didn't find a type-specifier, and a type-specifier was not
19464 optional in this context, issue an error message. */
19466 {
19469 }
19472 }
19474 /* Parse a simple-type-specifier.
19476 simple-type-specifier:
19477 :: [opt] nested-name-specifier [opt] type-name
19478 :: [opt] nested-name-specifier template template-id
19479 char
19480 wchar_t
19481 bool
19482 short
19483 int
19484 long
19485 signed
19486 unsigned
19487 float
19488 double
19489 void
19491 C++11 Extension:
19493 simple-type-specifier:
19494 auto
19495 decltype ( expression )
19496 char16_t
19497 char32_t
19498 __underlying_type ( type-id )
19500 C++17 extension:
19502 nested-name-specifier(opt) template-name
19504 GNU Extension:
19506 simple-type-specifier:
19507 __int128
19508 __typeof__ unary-expression
19509 __typeof__ ( type-id )
19510 __typeof__ ( type-id ) { initializer-list , [opt] }
19512 Concepts Extension:
19514 simple-type-specifier:
19515 constrained-type-specifier
19517 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
19518 appropriately updated. */
19520 static tree
19523 cp_parser_flags flags)
19524 {
19529 /* Peek at the next token. */
19532 /* If we're looking at a keyword, things are easy. */
19534 {
19572 {
19575 /* Check if the alternate "__intN__" form has been used instead of
19576 "__intN". */
19580 }
19602 CASE_RID_FLOATN_NX:
19617 {
19618 /* The 'auto' might be the placeholder return type for a function decl
19619 with trailing return type. */
19628 {
19630 {
19637 }
19640 {
19643 }
19646 }
19650 {
19653 }
19656 {
19659 }
19660 else
19664 {
19667 "use of %<auto%> in lambda parameter declaration "
19668 "only available with "
19670 }
19673 "use of %<auto%> in parameter declaration "
19674 "only available with "
19678 "use of %<auto%> in parameter declaration "
19680 }
19681 else
19686 /* Since DR 743, decltype can either be a simple-type-specifier by
19687 itself or begin a nested-name-specifier. Parsing it will replace
19688 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
19689 handling below decide what to do. */
19695 /* Consume the `typeof' token. */
19697 /* Parse the operand to `typeof'. */
19699 /* If it is not already a TYPE, take its type. */
19705 token,
19710 #define DEFTRAIT_TYPE(CODE, NAME, ARITY) \
19711 case RID_##CODE:
19713 #undef DEFTRAIT_TYPE
19717 token,
19724 }
19726 /* If token is an already-parsed decltype not followed by ::,
19727 it's a simple-type-specifier. */
19730 {
19733 {
19735 token,
19737 /* Remember that we are handling a decltype in order to
19738 implement the resolution of DR 1510 when the argument
19739 isn't instantiation dependent. */
19741 }
19744 }
19746 /* If the type-specifier was for a built-in type, we're done. */
19748 {
19749 /* Record the type. */
19756 type,
19757 token,
19762 /* Consume the token. */
19768 /* There is no valid C++ program where a non-template type is
19769 followed by a "<". That usually indicates that the user thought
19770 that the type was a template. */
19775 }
19777 /* The type-specifier must be a user-defined type. */
19779 {
19785 /* Don't gobble tokens or issue error messages if this is an
19786 optional type-specifier. */
19790 /* Remember current tentative parsing state -- if we know we need
19791 a type, we can give better diagnostics here. */
19796 /* Look for the optional `::' operator. */
19797 global_p
19801 /* Look for the nested-name specifier. */
19802 qualified_p
19809 /* If we have seen a nested-name-specifier, and the next token
19810 is `template', then we are using the template-id production. */
19813 {
19814 /* Look for the template-id. */
19818 none_type,
19820 /* If the template-id did not name a type, we are out of
19821 luck. */
19823 {
19824 /* ...unless we pretend we have seen 'typename'. */
19828 else
19829 {
19832 }
19833 }
19834 }
19835 /* DR 1812: A < following a qualified-id in a typename-specifier
19836 could safely be assumed to begin a template argument list, so
19837 the template keyword should be optional. */
19839 && qualified_p
19840 && typename_p
19842 {
19848 none_type,
19850 /* This is handled below, so back off. */
19861 }
19863 /* Otherwise, look for a type-name. */
19865 {
19873 }
19876 {
19877 /* Try for a type-constraint with template arguments. We check
19878 decl_specs here to avoid trying this for a functional cast. */
19885 none_type,
19888 {
19893 /* Perhaps it's a concept-check expression. */
19895 }
19896 else
19901 }
19904 {
19905 /* Try class template argument deduction or type-constraint without
19906 template arguments. */
19910 {
19911 location_t loc
19914 none_type,
19926 else
19927 {
19932 }
19933 }
19934 else
19936 }
19938 /* If it didn't work out, we don't have a TYPE. */
19943 /* Keep track of all name-lookups performed in class scopes. */
19945 && !global_p
19946 && !qualified_p
19953 token,
19955 }
19957 /* If we didn't get a type-name, issue an error message. */
19959 {
19962 }
19965 {
19966 /* See if TYPE is an Objective-C type, and if so, parse and
19967 accept any protocol references following it. Do this before
19968 the cp_parser_check_for_invalid_template_id() call, because
19969 Objective-C types can be followed by '<...>' which would
19970 enclose protocol names rather than template arguments, and so
19971 everything is fine. */
19974 {
19978 /* Clobber the "unqualified" type previously entered into
19979 DECL_SPECS with the new, improved protocol-qualified version. */
19984 }
19986 /* There is no valid C++ program where a non-template type is
19987 followed by a "<". That usually indicates that the user
19988 thought that the type was a template. */
19990 none_type,
19992 }
19995 }
19997 /* Parse the remainder of a placholder-type-specifier.
19999 placeholder-type-specifier:
20000 type-constraint_opt auto
20001 type-constraint_opt decltype(auto)
20003 The raw form of the constraint is parsed in cp_parser_simple_type_specifier
20004 and passed as TMPL. This function converts TMPL to an actual type-constraint,
20005 parses the placeholder type, and performs some contextual syntactic analysis.
20007 LOC provides the location of the template name.
20009 TENTATIVE is true if the type-specifier parsing is tentative; in that case,
20010 don't give an error if TMPL isn't a valid type-constraint, as the template-id
20011 might actually be a concept-check,
20013 Note that the Concepts TS allows the auto or decltype(auto) to be
20014 omitted in a constrained-type-specifier. */
20016 static tree
20019 {
20025 /* Get the arguments as written for subsequent analysis. */
20028 {
20031 }
20032 else
20033 /* A concept-name with no arguments can't be an expression. */
20038 /* Get the concept and prototype parameter for the constraint. */
20045 /* As per the standard, require auto or decltype(auto), except in some
20046 cases (template parameter lists, -fconcepts-ts enabled). */
20049 {
20053 {
20055 matching_parens parens;
20059 }
20060 }
20062 /* A type constraint constrains a contextually determined type or type
20063 parameter pack. However, the Concepts TS does allow concepts
20064 to introduce non-type and template template parameters. */
20066 {
20069 {
20071 {
20074 }
20076 }
20077 }
20079 /* In a template parameter list, a type-parameter can be introduced
20080 by type-constraints alone. */
20082 {
20083 /* In a default argument we may not be creating new parameters. */
20085 {
20086 /* If this assert turns out to be false, do error() instead. */
20089 }
20091 }
20093 /* Diagnose issues placeholder issues. */
20097 {
20099 /* Perhaps it's a concept-check expression (c++/91073). */
20106 /* Fall through. This is an error of omission. */
20107 }
20109 {
20110 /* A trailing return type only allows type-constraints. */
20113 }
20115 /* In a parameter-declaration-clause, a placeholder-type-specifier
20116 results in an invented template parameter. */
20118 {
20120 {
20126 }
20129 }
20131 /* Determine if the type should be deduced using template argument
20132 deduction or decltype deduction. Note that the latter is always
20133 used for type-constraints in trailing return types. */
20138 /* Otherwise, this is the type of a variable or return type. */
20141 else
20143 }
20145 /* Parse a type-name.
20147 type-name:
20148 class-name
20149 enum-name
20150 typedef-name
20151 simple-template-id [in c++0x]
20153 enum-name:
20154 identifier
20156 typedef-name:
20157 identifier
20159 Concepts:
20161 type-name:
20162 concept-name
20163 partial-concept-id
20165 concept-name:
20166 identifier
20168 Returns a TYPE_DECL for the type. */
20170 static tree
20172 {
20173 tree type_decl;
20175 /* We can't know yet whether it is a class-name or not. */
20177 /* Try a class-name. */
20179 typename_keyword_p,
20181 none_type,
20185 /* If it's not a class-name, keep looking. */
20187 {
20189 /* It must be a typedef-name or an enum-name. */
20193 /* It is either a simple-template-id representing an
20194 instantiation of an alias template... */
20198 none_type,
20200 /* Note that this must be an instantiation of an alias template
20201 because [temp.names]/6 says:
20203 A template-id that names an alias template specialization
20204 is a type-name.
20206 Whereas [temp.names]/7 says:
20208 A simple-template-id that names a class template
20209 specialization is a class-name.
20211 With concepts, this could also be a partial-concept-id that
20212 declares a non-type template parameter. */
20217 else
20221 /* ... Or a typedef-name or an enum-name. */
20223 }
20226 }
20228 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
20229 or a concept-name.
20231 enum-name:
20232 identifier
20234 typedef-name:
20235 identifier
20237 concept-name:
20238 identifier
20240 Returns a TYPE_DECL for the type. */
20242 static tree
20244 {
20245 tree type_decl;
20246 tree identifier;
20253 /* Look up the type-name. */
20260 {
20261 /* See if this is an Objective-C type. */
20266 }
20268 /* Issue an error if we did not find a type-name. */
20270 /* In Objective-C, we have the complication that class names are
20271 normally type names and start declarations (eg, the
20272 "NSObject" in "NSObject *object;"), but can be used in an
20273 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
20274 is an expression. So, a classname followed by a dot is not a
20275 valid type-name. */
20278 {
20283 }
20284 /* Remember that the name was used in the definition of the
20285 current class so that we can check later to see if the
20286 meaning would have been different after the class was
20287 entirely defined. */
20293 }
20295 /* Parse an elaborated-type-specifier. Note that the grammar given
20296 here incorporates the resolution to DR68.
20298 elaborated-type-specifier:
20299 class-key :: [opt] nested-name-specifier [opt] identifier
20300 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
20301 enum-key :: [opt] nested-name-specifier [opt] identifier
20302 typename :: [opt] nested-name-specifier identifier
20303 typename :: [opt] nested-name-specifier template [opt]
20304 template-id
20306 GNU extension:
20308 elaborated-type-specifier:
20309 class-key attributes :: [opt] nested-name-specifier [opt] identifier
20310 class-key attributes :: [opt] nested-name-specifier [opt]
20311 template [opt] template-id
20312 enum attributes :: [opt] nested-name-specifier [opt] identifier
20314 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
20315 declared `friend'. If IS_DECLARATION is TRUE, then this
20316 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
20317 something is being declared.
20319 Returns the TYPE specified. */
20321 static tree
20325 {
20327 tree identifier;
20330 tree globalscope;
20333 /* For class and enum types the location of the class-key or enum-key. */
20335 /* For a scoped enum, the 'class' or 'struct' keyword id. */
20338 /* See if we're looking at the `enum' keyword. */
20340 {
20341 /* Consume the `enum' token. */
20343 /* Remember that it's an enumeration type. */
20345 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
20346 enums) is used here. */
20350 {
20358 /* Consume the `struct' or `class' and parse it anyway. */
20360 /* Create a combined location for the whole scoped-enum-key. */
20362 }
20363 else
20366 /* Parse the attributes. */
20368 }
20369 /* Or, it might be `typename'. */
20371 RID_TYPENAME))
20372 {
20373 /* Consume the `typename' token. */
20375 /* Remember that it's a `typename' type. */
20377 }
20378 /* Otherwise it must be a class-key. */
20379 else
20380 {
20385 /* Parse the attributes. */
20387 }
20389 /* Look for the `::' operator. */
20392 /* Look for the nested-name-specifier. */
20393 tree nested_name_specifier;
20395 {
20396 nested_name_specifier
20401 is_declaration);
20404 }
20405 else
20406 /* Even though `typename' is not present, the proposed resolution
20407 to Core Issue 180 says that in `class A<T>::B', `B' should be
20408 considered a type-name, even if `A<T>' is dependent. */
20409 nested_name_specifier
20414 is_declaration);
20415 /* For everything but enumeration types, consider a template-id.
20416 For an enumeration type, consider only a plain identifier. */
20418 {
20420 tree decl;
20422 /* Allow the `template' keyword. */
20424 /* If we didn't see `template', we don't know if there's a
20425 template-id or not. */
20428 /* The `template' keyword must follow a nested-name-specifier. */
20430 {
20434 }
20436 /* Parse the template-id. */
20440 tag_type,
20441 is_declaration);
20442 /* If we didn't find a template-id, look for an ordinary
20443 identifier. */
20445 ;
20446 /* We can get here when cp_parser_template_id, called by
20447 cp_parser_class_name with tag_type == none_type, succeeds
20448 and caches a BASELINK. Then, when called again here,
20449 instead of failing and returning an error_mark_node
20450 returns it (see template/typename17.C in C++11).
20451 ??? Could we diagnose this earlier? */
20453 {
20456 }
20457 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
20458 in effect, then we must assume that, upon instantiation, the
20459 template will correspond to a class. */
20463 typename_type,
20465 /* If the `typename' keyword is in effect and DECL is not a type
20466 decl, then type is non existent. */
20468 ;
20470 {
20474 /* If the next token is a semicolon, this must be a specialization,
20475 instantiation, or friend declaration. Check the scope while we
20476 still know whether or not we had a nested-name-specifier. */
20481 }
20484 }
20487 {
20492 {
20495 }
20497 /* For a `typename', we needn't call xref_tag. */
20503 /* Template parameter lists apply only if we are not within a
20504 function parameter list. */
20505 bool template_parm_lists_apply
20514 /* Look up a qualified name in the usual way. */
20516 {
20517 tree decl;
20518 tree ambiguous_decls;
20521 tag_type,
20528 /* If the lookup was ambiguous, an error will already have been
20529 issued. */
20533 /* If we are parsing friend declaration, DECL may be a
20534 TEMPLATE_DECL tree node here. However, we need to check
20535 whether this TEMPLATE_DECL results in valid code. Consider
20536 the following example:
20538 namespace N {
20539 template <class T> class C {};
20540 }
20541 class X {
20542 template <class T> friend class N::C; // #1, valid code
20543 };
20544 template <class T> class Y {
20545 friend class N::C; // #2, invalid code
20546 };
20548 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
20549 name lookup of `N::C'. We see that friend declaration must
20550 be template for the code to be valid. Note that
20551 processing_template_decl does not work here since it is
20552 always 1 for the above two cases. */
20554 decl = (cp_parser_maybe_treat_template_as_class
20559 {
20561 identifier,
20564 }
20567 {
20571 allow_template);
20575 }
20577 /* Forward declarations of nested types, such as
20579 class C1::C2;
20580 class C1::C2::C3;
20582 are invalid unless all components preceding the final '::'
20583 are complete. If all enclosing types are complete, these
20584 declarations become merely pointless.
20586 Invalid forward declarations of nested types are errors
20587 caught elsewhere in parsing. Those that are pointless arrive
20588 here. */
20596 }
20597 else
20598 {
20599 /* An elaborated-type-specifier sometimes introduces a new type and
20600 sometimes names an existing type. Normally, the rule is that it
20601 introduces a new type only if there is not an existing type of
20602 the same name already in scope. For example, given:
20604 struct S {};
20605 void f() { struct S s; }
20607 the `struct S' in the body of `f' is the same `struct S' as in
20608 the global scope; the existing definition is used. However, if
20609 there were no global declaration, this would introduce a new
20610 local class named `S'.
20612 An exception to this rule applies to the following code:
20614 namespace N { struct S; }
20616 Here, the elaborated-type-specifier names a new type
20617 unconditionally; even if there is already an `S' in the
20618 containing scope this declaration names a new type.
20619 This exception only applies if the elaborated-type-specifier
20620 forms the complete declaration:
20622 [class.name]
20624 A declaration consisting solely of `class-key identifier ;' is
20625 either a redeclaration of the name in the current scope or a
20626 forward declaration of the identifier as a class name. It
20627 introduces the name into the current scope.
20629 We are in this situation precisely when the next token is a `;'.
20631 An exception to the exception is that a `friend' declaration does
20632 *not* name a new type; i.e., given:
20634 struct S { friend struct T; };
20636 `T' is not a new type in the scope of `S'.
20638 Also, `new struct S' or `sizeof (struct S)' never results in the
20639 definition of a new type; a new type can only be declared in a
20640 declaration context. */
20642 TAG_how how;
20645 /* Friends have special name lookup rules. */
20649 CPP_SEMICOLON))
20650 /* This is a `class-key identifier ;' */
20652 else
20656 (template_parm_lists_apply
20659 /* An unqualified name was used to reference this type, so
20660 there were no qualifying templates. */
20670 }
20671 }
20676 /* Allow attributes on forward declarations of classes. */
20678 {
20689 {
20693 }
20696 else
20698 "attributes ignored on elaborated-type-specifier that is "
20700 }
20704 else
20705 {
20706 /* Diagnose class/struct/union mismatches. IS_DECLARATION is false
20707 for alias definition. */
20711 decl_class);
20713 /* Indicate whether this class was declared as a `class' or as a
20714 `struct'. */
20717 }
20719 /* A "<" cannot follow an elaborated type specifier. If that
20720 happens, the user was probably trying to form a template-id. */
20725 }
20727 /* Parse an enum-specifier.
20729 enum-specifier:
20730 enum-head { enumerator-list [opt] }
20731 enum-head { enumerator-list , } [C++0x]
20733 enum-head:
20734 enum-key identifier [opt] enum-base [opt]
20735 enum-key nested-name-specifier identifier enum-base [opt]
20737 enum-key:
20738 enum
20739 enum class [C++0x]
20740 enum struct [C++0x]
20742 enum-base: [C++0x]
20743 : type-specifier-seq
20745 opaque-enum-specifier:
20746 enum-key identifier enum-base [opt] ;
20748 GNU Extensions:
20749 enum-key attributes[opt] identifier [opt] enum-base [opt]
20750 { enumerator-list [opt] }attributes[opt]
20751 enum-key attributes[opt] identifier [opt] enum-base [opt]
20752 { enumerator-list, }attributes[opt] [C++0x]
20754 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
20755 if the token stream isn't an enum-specifier after all. */
20757 static tree
20759 {
20760 tree identifier;
20762 tree prev_scope;
20764 tree attributes;
20775 /* Parse tentatively so that we can back up if we don't find a
20776 enum-specifier. */
20779 /* Caller guarantees that the current token is 'enum', an identifier
20780 possibly follows, and the token after that is an opening brace.
20781 If we don't have an identifier, fabricate an anonymous name for
20782 the enumeration being defined. */
20785 /* Parse the "class" or "struct", which indicates a scoped
20786 enumeration type in C++0x. */
20789 {
20793 /* Consume the `struct' or `class' token. */
20797 }
20801 /* Clear the qualification. */
20806 /* Figure out in what scope the declaration is being placed. */
20812 nested_name_specifier
20820 {
20821 tree name;
20825 enum_type,
20830 input_location);
20832 {
20835 {
20836 /* Are template enums allowed in ISO? */
20840 /* ignore a typename reference, for it will be solved by name
20841 in start_enum. */
20843 }
20844 }
20847 else
20848 {
20853 }
20854 }
20855 else
20856 {
20859 else
20860 {
20866 }
20867 }
20870 /* Check for the `:' that denotes a specified underlying type in C++0x.
20871 Note that a ':' could also indicate a bitfield width, however. */
20873 {
20874 cp_decl_specifier_seq type_specifiers;
20876 /* Consume the `:'. */
20879 auto tdf
20883 /* Parse the type-specifier-seq. */
20889 /* At this point this is surely not elaborated type specifier. */
20898 /* If that didn't work, stop. */
20900 {
20906 }
20907 }
20909 /* Look for the `{' but don't consume it yet. */
20911 {
20913 {
20919 }
20920 /* An opaque-enum-specifier must have a ';' here. */
20923 {
20929 }
20930 }
20936 {
20938 {
20942 }
20945 }
20947 /* Issue an error message if type-definitions are forbidden here. */
20950 else
20951 /* Create the new type. We do this before consuming the opening
20952 brace so the enum will be recorded as being on the line of its
20953 tag (or the 'enum' keyword, if there is no tag). */
20957 /* If the next token is not '{' it is an opaque-enum-specifier or an
20958 elaborated-type-specifier. */
20960 {
20965 {
20966 /* The following catches invalid code such as:
20967 enum class S<int>::E { A, B, C }; */
20975 {
20979 nested_name_specifier);
20981 }
20984 {
20986 "%qT for enum declaration does not name a class "
20989 }
20990 /* If that scope does not contain the scope in which the
20991 class was originally declared, the program is invalid. */
20993 nested_name_specifier))
20994 {
20997 "declaration of %qD in namespace %qD which does not "
21000 else
21002 "declaration of %qD in %qD which does not "
21006 }
21007 /* If that scope is the scope where the declaration is being placed
21008 the program is invalid. */
21012 {
21016 }
21017 }
21022 /* Consume the opening brace. */
21023 matching_braces braces;
21030 {
21034 }
21035 else
21036 {
21042 }
21046 /* If the next token is not '}', then there are some enumerators. */
21048 {
21050 /* Don't warn for enum {} a; here. */
21054 }
21055 else
21056 {
21057 /* We've seen a '{' so we know we're in an enum-specifier.
21058 Commit to any tentative parse to get syntax errors. */
21061 }
21063 /* Consume the final '}'. */
21068 }
21069 else
21070 {
21071 /* If a ';' follows, then it is an opaque-enum-specifier
21072 and additional restrictions apply. */
21074 {
21081 }
21082 }
21084 /* Look for trailing attributes to apply to this enumeration, and
21085 apply them if appropriate. */
21087 {
21090 trailing_attr,
21092 }
21094 /* Finish up the enumeration. */
21096 {
21101 }
21104 {
21106 {
21109 }
21112 }
21114 }
21116 /* Parse an enumerator-list. The enumerators all have the indicated
21117 TYPE.
21119 enumerator-list:
21120 enumerator-definition
21121 enumerator-list , enumerator-definition */
21123 static void
21125 {
21127 {
21128 /* Parse an enumerator-definition. */
21131 /* If the next token is not a ',', we've reached the end of
21132 the list. */
21135 /* Otherwise, consume the `,' and keep going. */
21137 /* If the next token is a `}', there is a trailing comma. */
21139 {
21144 }
21145 }
21146 }
21148 /* Parse an enumerator-definition. The enumerator has the indicated
21149 TYPE.
21151 enumerator-definition:
21152 enumerator
21153 enumerator = constant-expression
21155 enumerator:
21156 identifier
21158 GNU Extensions:
21160 enumerator-definition:
21161 enumerator attributes [opt]
21162 enumerator attributes [opt] = constant-expression */
21164 static void
21166 {
21167 tree identifier;
21168 tree value;
21169 location_t loc;
21171 /* Save the input location because we are interested in the location
21172 of the identifier and not the location of the explicit value. */
21175 /* Look for the identifier. */
21180 /* Parse any specified attributes. */
21183 /* If the next token is an '=', then there is an explicit value. */
21185 {
21186 /* Consume the `=' token. */
21188 /* Parse the value. */
21190 }
21191 else
21194 /* If we are processing a template, make sure the initializer of the
21195 enumerator doesn't contain any bare template parameter pack. */
21197 {
21198 /* In a lambda it should work, but doesn't currently. */
21200 {
21203 }
21204 }
21208 /* Create the enumerator. */
21210 }
21212 /* Parse a namespace-name.
21214 namespace-name:
21215 original-namespace-name
21216 namespace-alias
21218 Returns the NAMESPACE_DECL for the namespace. */
21220 static tree
21222 {
21223 tree identifier;
21224 tree namespace_decl;
21228 /* Get the name of the namespace. */
21233 /* Look up the identifier in the currently active scope. Look only
21234 for namespaces, due to:
21236 [basic.lookup.udir]
21238 When looking up a namespace-name in a using-directive or alias
21239 definition, only namespace names are considered.
21241 And:
21243 [basic.lookup.qual]
21245 During the lookup of a name preceding the :: scope resolution
21246 operator, object, function, and enumerator names are ignored.
21248 (Note that cp_parser_qualifying_entity only calls this
21249 function if the token after the name is the scope resolution
21250 operator.) */
21252 none_type,
21258 /* If it's not a namespace, issue an error. */
21261 {
21263 {
21264 auto_diagnostic_group d;
21265 name_hint hint;
21269 identifier,
21272 {
21278 }
21279 else
21281 identifier);
21282 }
21283 else
21286 }
21289 }
21291 /* Parse a namespace-definition.
21293 namespace-definition:
21294 named-namespace-definition
21295 unnamed-namespace-definition
21297 named-namespace-definition:
21298 original-namespace-definition
21299 extension-namespace-definition
21301 original-namespace-definition:
21302 namespace identifier { namespace-body }
21304 extension-namespace-definition:
21305 namespace original-namespace-name { namespace-body }
21307 unnamed-namespace-definition:
21308 namespace { namespace-body } */
21310 static void
21312 {
21313 tree identifier;
21323 {
21326 }
21328 /* Look for the `namespace' keyword. */
21329 cp_token* token
21332 /* Parse any specified attributes before the identifier. */
21336 {
21340 RID_INLINE);
21342 {
21346 "definitions only available with %<-std=c++20%> or "
21349 }
21352 {
21357 "standard attributes on namespaces must precede "
21360 /* Parse any attributes specified after the identifier. */
21362 }
21365 {
21366 /* Don't forget that the innermost namespace might have been
21367 marked as inline. Use |= because we cannot overwrite
21368 IS_INLINE in case the outermost namespace is inline, but
21369 there are no nested inlines. */
21372 }
21376 "nested namespace definitions only available with "
21379 /* Nested namespace names can create new namespaces (unlike
21380 other qualified-ids). */
21385 else
21388 }
21400 /* Start the namespace. */
21407 /* Look for the `{' to validate starting the namespace. */
21408 matching_braces braces;
21410 {
21411 /* Parse the body of the namespace. */
21414 /* Look for the final `}'. */
21416 }
21421 /* Pop the nested namespace definitions. */
21424 }
21426 /* Parse a namespace-body.
21428 namespace-body:
21429 declaration-seq [opt] */
21431 static void
21433 {
21435 }
21437 /* Parse a namespace-alias-definition.
21439 namespace-alias-definition:
21440 namespace identifier = qualified-namespace-specifier ; */
21442 static void
21444 {
21445 tree identifier;
21446 tree namespace_specifier;
21450 /* Look for the `namespace' keyword. */
21452 /* Look for the identifier. */
21456 /* Look for the `=' token. */
21459 {
21461 /* Skip the definition. */
21466 }
21468 /* Look for the qualified-namespace-specifier. */
21469 namespace_specifier
21472 /* Look for the `;' token. */
21475 /* Register the alias in the symbol table. */
21477 }
21479 /* Parse a qualified-namespace-specifier.
21481 qualified-namespace-specifier:
21482 :: [opt] nested-name-specifier [opt] namespace-name
21484 Returns a NAMESPACE_DECL corresponding to the specified
21485 namespace. */
21487 static tree
21489 {
21490 /* Look for the optional `::'. */
21494 /* Look for the optional nested-name-specifier. */
21502 }
21504 /* Subroutine of cp_parser_using_declaration. */
21506 static tree
21508 {
21511 {
21512 /* Create the USING_DECL. */
21521 /* Add it to the list of members in this class. */
21523 }
21524 else
21527 }
21529 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
21530 access declaration.
21532 using-declaration:
21533 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
21534 using :: unqualified-id ;
21536 access-declaration:
21537 qualified-id ;
21539 */
21541 static bool
21544 {
21548 tree identifier;
21549 tree qscope;
21554 {
21557 }
21558 else
21559 {
21560 /* Look for the `using' keyword. */
21563 again:
21564 /* Peek at the next token. */
21566 /* See if it's `typename'. */
21568 {
21569 /* Remember that we've seen it. */
21571 /* Consume the `typename' token. */
21573 }
21574 }
21576 /* Look for the optional global scope qualification. */
21577 global_scope_p
21582 /* If we saw `typename', or didn't see `::', then there must be a
21583 nested-name-specifier present. */
21585 {
21591 {
21594 }
21595 }
21596 /* Otherwise, we could be in either of the two productions. In that
21597 case, treat the nested-name-specifier as optional. */
21598 else
21610 /* Something has already gone wrong; there's no need to parse
21611 further. Since an error has occurred, the return value of
21612 cp_parser_parse_definitely will be false, as required. */
21616 /* Parse the unqualified-id. */
21624 {
21629 }
21631 {
21635 "pack expansion in using-declaration only available "
21638 }
21640 /* The function we call to handle a using-declaration is different
21641 depending on what scope we are in. */
21643 ;
21646 /* [namespace.udecl]
21648 A using declaration shall not name a template-id. */
21651 else
21652 {
21656 {
21659 }
21660 }
21664 {
21668 "comma-separated list in using-declaration only available "
21671 }
21673 /* Look for the final `;'. */
21678 "access declarations are deprecated "
21679 "in favour of using-declarations; "
21683 }
21685 /* C++20 using enum declaration.
21687 using-enum-declaration :
21688 using elaborated-enum-specifier ; */
21690 static void
21692 {
21695 /* Using cp_parser_elaborated_type_specifier rejects typedef-names, which
21696 breaks one of the motivating examples in using-enum-5.C.
21697 cp_parser_simple_type_specifier seems to be closer to what we actually
21698 want, though that hasn't been properly specified yet. */
21700 /* Consume 'enum'. */
21706 tree type = (cp_parser_simple_type_specifier
21713 {
21716 }
21720 /* The elaborated-enum-specifier shall not name a dependent type and the type
21721 shall have a reachable enum-specifier. */
21735 {
21737 auto_diagnostic_group g;
21741 ;
21744 else
21746 }
21748 /* A using-enum-declaration introduces the enumerator names of the named
21749 enumeration as if by a using-declaration for each enumerator. */
21753 }
21755 /* Parse an alias-declaration.
21757 alias-declaration:
21758 using identifier attribute-specifier-seq [opt] = type-id */
21760 static tree
21762 {
21766 cp_decl_specifier_seq decl_specs;
21770 /* Look for the `using' keyword. */
21771 cp_token *using_token
21793 /* Now we are going to parse the type-id of the declaration. */
21795 /*
21796 [dcl.type]/3 says:
21798 "A type-specifier-seq shall not define a class or enumeration
21799 unless it appears in the type-id of an alias-declaration (7.1.3) that
21800 is not the declaration of a template-declaration."
21802 In other words, if we currently are in an alias template, the
21803 type-id should not define a type.
21805 So let's set parser->type_definition_forbidden_message in that
21806 case; cp_parser_check_type_definition (called by
21807 cp_parser_class_specifier) will then emit an error if a type is
21808 defined in the type-id. */
21810 {
21814 }
21819 /* Restore the error message if need be. */
21825 {
21828 }
21830 /* A typedef-name can also be introduced by an alias-declaration. The
21831 identifier following the using keyword becomes a typedef-name. It has
21832 the same semantics as if it were introduced by the typedef
21833 specifier. In particular, it does not define a new type and it shall
21834 not appear in the type-id. */
21839 {
21842 ds_attribute,
21843 attrs_token);
21844 }
21846 ds_typedef,
21847 using_token);
21849 ds_alias,
21850 using_token);
21857 id_location,
21867 else
21878 /* If decl is a template, return its TEMPLATE_DECL so that it gets
21879 added into the symbol table; otherwise, return the TYPE_DECL. */
21883 {
21887 }
21890 }
21892 /* Parse a using-directive.
21894 using-directive:
21895 attribute-specifier-seq [opt] using namespace :: [opt]
21896 nested-name-specifier [opt] namespace-name ; */
21898 static void
21900 {
21901 tree namespace_decl;
21904 {
21905 /* Error during attribute parsing that resulted in skipping
21906 to next semicolon. */
21909 }
21911 /* Look for the `using' keyword. */
21913 /* And the `namespace' keyword. */
21915 /* Look for the optional `::' operator. */
21917 /* And the optional nested-name-specifier. */
21923 /* Get the namespace being used. */
21926 /* And any specified GNU attributes. */
21930 /* Update the symbol table. */
21933 /* Look for the final `;'. */
21935 }
21937 /* Parse an asm-definition.
21939 asm-qualifier:
21940 volatile
21941 inline
21942 goto
21944 asm-qualifier-list:
21945 asm-qualifier
21946 asm-qualifier-list asm-qualifier
21948 asm-definition:
21949 asm ( string-literal ) ;
21951 GNU Extension:
21953 asm-definition:
21954 asm asm-qualifier-list [opt] ( string-literal ) ;
21955 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
21956 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
21957 : asm-operand-list [opt] ) ;
21958 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
21959 : asm-operand-list [opt]
21960 : asm-clobber-list [opt] ) ;
21961 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
21962 : asm-clobber-list [opt]
21963 : asm-goto-list ) ;
21965 The form with asm-goto-list is valid if and only if the asm-qualifier-list
21966 contains goto, and is the only allowed form in that case. No duplicates are
21967 allowed in an asm-qualifier-list. */
21969 static void
21971 {
21972 tree string;
21977 tree asm_stmt;
21984 /* Look for the `asm' keyword. */
21987 /* In C++20, unevaluated inline assembly is permitted in constexpr
21988 functions. */
21993 "function only available with %<-std=c++20%> or "
21996 /* Handle the asm-qualifier-list. */
22004 {
22008 {
22011 {
22015 }
22016 else
22017 {
22022 }
22028 {
22032 }
22033 else
22042 {
22046 }
22047 else
22062 }
22064 }
22071 {
22074 }
22076 /* Look for the opening `('. */
22079 /* Look for the string. */
22082 {
22086 }
22088 /* If we're allowing GNU extensions, check for the extended assembly
22089 syntax. Unfortunately, the `:' tokens need not be separated by
22090 a space in C, and so, for compatibility, we tolerate that here
22091 too. Doing that means that we have to treat the `::' operator as
22092 two `:' tokens. */
22097 {
22102 /* The extended syntax was used. */
22105 /* Look for outputs. */
22107 {
22108 /* Consume the `:'. */
22110 /* Parse the output-operands. */
22112 CPP_COLON)
22114 CPP_SCOPE)
22116 CPP_CLOSE_PAREN))
22117 {
22121 }
22122 }
22123 /* If the next token is `::', there are no outputs, and the
22124 next token is the beginning of the inputs. */
22126 /* The inputs are coming next. */
22129 /* Look for inputs. */
22132 {
22133 /* Consume the `:' or `::'. */
22135 /* Parse the output-operands. */
22137 CPP_COLON)
22139 CPP_SCOPE)
22141 CPP_CLOSE_PAREN))
22142 {
22146 }
22147 }
22149 /* The clobbers are coming next. */
22152 /* Look for clobbers. */
22155 {
22157 /* Consume the `:' or `::'. */
22159 /* Parse the clobbers. */
22161 CPP_COLON)
22163 CPP_CLOSE_PAREN))
22165 }
22167 /* The labels are coming next. */
22170 /* Look for labels. */
22173 {
22175 /* Consume the `:' or `::'. */
22177 /* Parse the labels. */
22179 }
22183 }
22187 /* Look for the closing `)'. */
22195 {
22196 /* Create the ASM_EXPR. */
22198 {
22201 /* If the extended syntax was not used, mark the ASM_EXPR. */
22203 {
22209 }
22210 }
22211 else
22213 }
22214 }
22216 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
22217 type that comes from the decl-specifier-seq. */
22219 static tree
22221 {
22224 {
22237 }
22240 }
22242 /* Warn about the most vexing parse syntactic ambiguity, i.e., warn when
22243 a construct looks like a variable definition but is actually a function
22244 declaration. DECL_SPECIFIERS is the decl-specifier-seq and DECLARATOR
22245 is the declarator for this function declaration. */
22247 static void
22250 {
22251 /* Only warn if we are declaring a function at block scope. */
22255 /* And only if there is no storage class specified. */
22267 /* Don't warn when the whole declarator (not just the declarator-id!)
22268 was parenthesized. That is, don't warn for int(n()) but do warn
22269 for int(f)(). */
22273 tree type;
22275 {
22280 /* If the return type is void there is no ambiguity. */
22283 }
22285 /* Code like long f(); will have null ->type. If we have any
22286 type-specifiers, pretend we've seen int. */
22288 else
22291 auto_diagnostic_group d;
22296 /* The T t() case. */
22298 {
22300 "empty parentheses were disambiguated as a function "
22302 {
22303 /* () means value-initialization (C++03 and up); {} (C++11 and up)
22304 means value-initialization or aggregate-initialization, nothing
22305 means default-initialization. We can only suggest removing the
22306 parentheses/adding {} if T has a default constructor. */
22308 {
22314 {
22318 else
22321 }
22322 }
22323 }
22325 }
22327 /* If we had (...) or the parameter-list wasn't parenthesized,
22328 we're done. */
22332 /* The T t(X()) case. */
22334 {
22336 "parentheses were disambiguated as a function "
22338 {
22340 /* {}-initialization means that we can use an initializer-list
22341 constructor if no default constructor is available, so don't
22342 suggest using {} for classes that have an initializer_list
22343 constructor. */
22345 {
22350 }
22351 else
22352 {
22356 }
22357 }
22358 }
22359 /* The T t(X(), X()) case. */
22361 "parentheses were disambiguated as a function "
22363 {
22366 {
22371 }
22372 }
22373 }
22375 /* If DECLARATOR with DECL_SPECS is a function declarator that has
22376 the form of a deduction guide, tag it as such. CTOR_DTOR_OR_CONV_P
22377 has the same meaning as in cp_parser_declarator. */
22379 static void
22384 {
22390 {
22398 {
22402 }
22403 }
22404 }
22406 /* Declarators [gram.dcl.decl] */
22408 /* Parse an init-declarator.
22410 init-declarator:
22411 declarator initializer [opt]
22413 GNU Extension:
22415 init-declarator:
22416 declarator asm-specification [opt] attributes [opt] initializer [opt]
22418 function-definition:
22419 decl-specifier-seq [opt] declarator ctor-initializer [opt]
22420 function-body
22421 decl-specifier-seq [opt] declarator function-try-block
22423 GNU Extension:
22425 function-definition:
22426 __extension__ function-definition
22428 TM Extension:
22430 function-definition:
22431 decl-specifier-seq [opt] declarator function-transaction-block
22433 The parser flags FLAGS is used to control type-specifier parsing.
22435 The DECL_SPECIFIERS apply to this declarator. Returns a
22436 representation of the entity declared. If MEMBER_P is TRUE, then
22437 this declarator appears in a class scope. The new DECL created by
22438 this declarator is returned.
22440 The CHECKS are access checks that should be performed once we know
22441 what entity is being declared (and, therefore, what classes have
22442 befriended it).
22444 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
22445 for a function-definition here as well. If the declarator is a
22446 declarator for a function-definition, *FUNCTION_DEFINITION_P will
22447 be TRUE upon return. By that point, the function-definition will
22448 have been completely parsed.
22450 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
22451 is FALSE.
22453 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
22454 parsed declaration if it is an uninitialized single declarator not followed
22455 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
22456 if present, will not be consumed. If returned, this declarator will be
22457 created with SD_INITIALIZED but will not call cp_finish_decl.
22459 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
22460 and there is an initializer, the pointed location_t is set to the
22461 location of the '=' or `(', or '{' in C++11 token introducing the
22462 initializer. */
22464 static tree
22466 cp_parser_flags flags,
22476 {
22480 tree prefix_attributes;
22482 tree asm_specification;
22483 tree initializer;
22485 tree scope;
22487 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
22488 initialized with "= ..", CPP_OPEN_PAREN if initialized with
22489 "(...)". */
22504 /* Assume that this is not the declarator for a function
22505 definition. */
22509 /* Default arguments are only permitted for function parameters. */
22513 /* Defer access checks while parsing the declarator; we cannot know
22514 what names are accessible until we know what is being
22515 declared. */
22520 /* Parse the declarator. */
22521 declarator
22526 /* Gather up the deferred checks. */
22531 /* If the DECLARATOR was erroneous, there's no need to go
22532 further. */
22536 /* Check that the number of template-parameter-lists is OK. */
22546 /* Figure out what scope the entity declared by the DECLARATOR is
22547 located in. `grokdeclarator' sometimes changes the scope, so
22548 we compute it now. */
22551 /* Perform any lookups in the declared type which were thought to be
22552 dependent, but are not in the scope of the declarator. */
22553 decl_specifiers->type
22556 /* If we're allowing GNU extensions, look for an
22557 asm-specification. */
22559 {
22560 /* Look for an asm-specification. */
22563 }
22564 else
22567 /* Gather the attributes that were provided with the
22568 decl-specifiers. */
22571 /* Look for attributes. */
22575 /* Peek at the next token. */
22581 {
22582 /* Handle C++17 deduction guides. Note that class-scope
22583 non-template deduction guides are instead handled in
22584 cp_parser_member_declaration. */
22586 decl_specifiers,
22587 declarator,
22593 /* Check to see if the token indicates the start of a
22594 function-definition. */
22596 {
22598 {
22599 /* If a function-definition should not appear here, issue an
22600 error message. */
22604 }
22606 location_t func_brace_location
22609 /* Neither attributes nor an asm-specification are allowed
22610 on a function-definition. */
22613 "an %<asm%> specification is not allowed "
22617 "attributes are not allowed "
22619 /* This is a function-definition. */
22622 /* Parse the function definition. */
22625 decl_specifiers,
22626 declarator,
22627 prefix_attributes);
22628 else
22629 decl =
22630 (cp_parser_function_definition_from_specifiers_and_declarator
22634 {
22635 /* This is where the prologue starts... */
22638 }
22641 }
22642 }
22644 {
22645 /* A non-template declaration involving a function parameter list
22646 containing an implicit template parameter will be made into a
22647 template. If the resulting declaration is not going to be an
22648 actual function then finish the template scope here to prevent it.
22649 An error message will be issued once we have a decl to talk about.
22651 FIXME probably we should do type deduction rather than create an
22652 implicit template, but the standard currently doesn't allow it. */
22655 }
22657 /* [dcl.dcl]
22659 Only in function declarations for constructors, destructors, type
22660 conversions, and deduction guides can the decl-specifier-seq be omitted.
22662 We explicitly postpone this check past the point where we handle
22663 function-definitions because we tolerate function-definitions
22664 that are missing their return types in some modes. */
22666 {
22670 }
22672 /* An `=' or an '{' in C++11, indicate an initializer. An '(' may indicate
22673 an initializer as well. */
22677 {
22678 /* Don't get fooled into thinking that F(i)(1)(2) is an initializer.
22679 It isn't; it's an expression. (Here '(i)' would have already been
22680 parsed as a declarator.) */
22683 {
22690 /* If this is an initializer, only a ',' or ';' can follow: either
22691 we have another init-declarator, or we're at the end of an
22692 init-declarator-list which can only be followed by a ';'. */
22697 /* Not an init-declarator. */
22699 }
22711 {
22717 }
22718 }
22719 else
22720 {
22721 /* If the init-declarator isn't initialized and isn't followed by a
22722 `,' or `;', it's not a valid init-declarator. */
22725 {
22728 else
22729 {
22733 }
22734 }
22737 }
22739 /* Because start_decl has side-effects, we should only call it if we
22740 know we're going ahead. By this point, we know that we cannot
22741 possibly be looking at any other construct. */
22744 /* Enter the newly declared entry in the symbol table. If we're
22745 processing a declaration in a class-specifier, we wait until
22746 after processing the initializer. */
22748 {
22756 /* Adjust location of decl if declarator->id_loc is more appropriate:
22757 set, and decl wasn't merged with another decl, in which case its
22758 location would be different from input_location, and more accurate. */
22763 }
22765 /* Enter the SCOPE. That way unqualified names appearing in the
22766 initializer will be looked up in SCOPE. */
22769 /* Perform deferred access control checks, now that we know in which
22770 SCOPE the declared entity resides. */
22772 {
22775 /* If the entity being declared is a function, pretend that we
22776 are in its scope. If it is a `friend', it may have access to
22777 things that would not otherwise be accessible. */
22779 {
22782 }
22784 /* Perform access checks for template parameters. */
22787 /* Perform the access control checks for the declarator and the
22788 decl-specifiers. */
22791 /* Restore the saved value. */
22794 }
22796 /* Parse the initializer. */
22801 {
22803 {
22806 else
22807 {
22808 /* If the declaration was erroneous, we don't really
22809 know what the user intended, so just silently
22810 consume the initializer. */
22817 }
22818 }
22819 else
22820 {
22821 /* We want to record the extra mangling scope for in-class
22822 initializers of class members and initializers of static
22823 data member templates and namespace-scope initializers.
22824 The former involves deferring parsing of the initializer
22825 until end of class as with default arguments. So right
22826 here we only handle the latter two. */
22830 && !member_p
22843 }
22844 }
22846 /* The old parser allows attributes to appear after a parenthesized
22847 initializer. Mark Mitchell proposed removing this functionality
22848 on the GCC mailing lists on 2002-08-13. This parser accepts the
22849 attributes -- but ignores them. Made a permerror in GCC 8. */
22855 {
22858 {
22862 }
22863 }
22865 /* And now complain about a non-function implicit template. */
22870 /* For an in-class declaration, use `grokfield' to create the
22871 declaration. */
22873 {
22875 {
22878 }
22887 }
22889 /* Finish processing the declaration. But, skip member
22890 declarations. */
22892 {
22895 asm_specification,
22896 /* If the initializer is in parentheses, then this is
22897 a direct-initialization, which means that an
22898 `explicit' constructor is OK. Otherwise, an
22899 `explicit' constructor cannot be used. */
22902 }
22905 /* Core issue #226 (C++0x only): A default template-argument
22906 shall not be specified in a friend class template
22907 declaration. */
22916 {
22919 else
22921 }
22928 }
22930 /* Parse a declarator.
22932 declarator:
22933 direct-declarator
22934 ptr-operator declarator
22936 abstract-declarator:
22937 ptr-operator abstract-declarator [opt]
22938 direct-abstract-declarator
22940 GNU Extensions:
22942 declarator:
22943 attributes [opt] direct-declarator
22944 attributes [opt] ptr-operator declarator
22946 abstract-declarator:
22947 attributes [opt] ptr-operator abstract-declarator [opt]
22948 attributes [opt] direct-abstract-declarator
22950 The parser flags FLAGS is used to control type-specifier parsing.
22952 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
22953 detect constructors, destructors, deduction guides, or conversion operators.
22954 It is set to -1 if the declarator is a name, and +1 if it is a
22955 function. Otherwise it is set to zero. Usually you just want to
22956 test for >0, but internally the negative value is used.
22958 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
22959 a decl-specifier-seq unless it declares a constructor, destructor,
22960 or conversion. It might seem that we could check this condition in
22961 semantic analysis, rather than parsing, but that makes it difficult
22962 to handle something like `f()'. We want to notice that there are
22963 no decl-specifiers, and therefore realize that this is an
22964 expression, not a declaration.)
22966 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
22967 the declarator is a direct-declarator of the form "(...)".
22969 MEMBER_P is true iff this declarator is a member-declarator.
22971 FRIEND_P is true iff this declarator is a friend.
22973 STATIC_P is true iff the keyword static was seen. */
22977 cp_parser_declarator_kind dcl_kind,
22978 cp_parser_flags flags,
22982 {
22985 cp_cv_quals cv_quals;
22986 tree class_type;
22989 /* Assume this is not a constructor, destructor, or type-conversion
22990 operator. */
22997 /* Check for the ptr-operator production. */
22999 /* Parse the ptr-operator. */
23005 /* If that worked, then we have a ptr-operator. */
23007 {
23008 /* If a ptr-operator was found, then this declarator was not
23009 parenthesized. */
23012 /* The dependent declarator is optional if we are parsing an
23013 abstract-declarator. */
23017 /* Parse the dependent declarator. */
23023 /* If we are parsing an abstract-declarator, we must handle the
23024 case where the dependent declarator is absent. */
23029 declarator = cp_parser_make_indirect_declarator
23031 }
23032 /* Everything else is a direct-declarator. */
23033 else
23034 {
23037 CPP_OPEN_PAREN);
23041 }
23046 }
23048 /* Parse a direct-declarator or direct-abstract-declarator.
23050 direct-declarator:
23051 declarator-id
23052 direct-declarator ( parameter-declaration-clause )
23053 cv-qualifier-seq [opt]
23054 ref-qualifier [opt]
23055 exception-specification [opt]
23056 direct-declarator [ constant-expression [opt] ]
23057 ( declarator )
23059 direct-abstract-declarator:
23060 direct-abstract-declarator [opt]
23061 ( parameter-declaration-clause )
23062 cv-qualifier-seq [opt]
23063 ref-qualifier [opt]
23064 exception-specification [opt]
23065 direct-abstract-declarator [opt] [ constant-expression [opt] ]
23066 ( abstract-declarator )
23068 Returns a representation of the declarator. DCL_KIND is
23069 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
23070 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
23071 we are parsing a direct-declarator. It is
23072 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
23073 of ambiguity we prefer an abstract declarator, as per
23074 [dcl.ambig.res].
23075 The parser flags FLAGS is used to control type-specifier parsing.
23076 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
23077 as for cp_parser_declarator. */
23081 cp_parser_declarator_kind dcl_kind,
23082 cp_parser_flags flags,
23085 {
23096 {
23097 /* Peek at the next token. */
23100 {
23101 /* This is either a parameter-declaration-clause, or a
23102 parenthesized declarator. When we know we are parsing a
23103 named declarator, it must be a parenthesized declarator
23104 if FIRST is true. For instance, `(int)' is a
23105 parameter-declaration-clause, with an omitted
23106 direct-abstract-declarator. But `((*))', is a
23107 parenthesized abstract declarator. Finally, when T is a
23108 template parameter `(T)' is a
23109 parameter-declaration-clause, and not a parenthesized
23110 named declarator.
23112 We first try and parse a parameter-declaration-clause,
23113 and then try a nested declarator (if FIRST is true).
23115 It is not an error for it not to be a
23116 parameter-declaration-clause, even when FIRST is
23117 false. Consider,
23119 int i (int);
23120 int i (3);
23122 The first is the declaration of a function while the
23123 second is the definition of a variable, including its
23124 initializer.
23126 Having seen only the parenthesis, we cannot know which of
23127 these two alternatives should be selected. Even more
23128 complex are examples like:
23130 int i (int (a));
23131 int i (int (3));
23133 The former is a function-declaration; the latter is a
23134 variable initialization.
23136 Thus again, we try a parameter-declaration-clause, and if
23137 that fails, we back out and return. */
23140 {
23141 tree params;
23146 /* In a member-declarator, the only valid interpretation
23147 of a parenthesis is the start of a
23148 parameter-declaration-clause. (It is invalid to
23149 initialize a static data member with a parenthesized
23150 initializer; only the "=" form of initialization is
23151 permitted.) */
23155 /* Consume the `('. */
23157 matching_parens parens;
23160 {
23161 /* If this is going to be an abstract declarator, we're
23162 in a declarator and we can't have default args. */
23165 }
23169 /* Parse the parameter-declaration-clause. */
23170 params
23172 const location_t parens_end
23175 /* Consume the `)'. */
23178 /* If all went well, parse the cv-qualifier-seq,
23179 ref-qualifier and the exception-specification. */
23181 {
23182 cp_cv_quals cv_quals;
23183 cp_virt_specifiers virt_specifiers;
23184 cp_ref_qualifier ref_qual;
23185 tree exception_specification;
23186 tree late_return;
23187 tree attrs;
23190 unsigned char local_variables_forbidden_p
23192 /* 'this' is not allowed in static member functions. */
23202 /* Parse the cv-qualifier-seq. */
23204 /* Parse the ref-qualifier. */
23206 /* Parse the tx-qualifier. */
23212 /* DR 1207: 'this' is in scope after the cv-quals. */
23215 /* If it turned out that this is e.g. a pointer to a
23216 function, we don't want to delay noexcept parsing. */
23220 /* Parse the exception-specification. */
23221 exception_specification
23223 flags);
23227 cp_omp_declare_simd_data odsd;
23229 && declarator
23232 {
23236 }
23238 /* In here, we handle cases where attribute is used after
23239 the function declaration. For example:
23240 void func (int x) __attribute__((vector(..))); */
23243 late_return
23245 requires_clause);
23249 /* Parse the virt-specifier-seq. */
23253 parens_start,
23254 parens_end);
23255 /* Create the function-declarator. */
23257 params,
23258 cv_quals,
23259 virt_specifiers,
23260 ref_qual,
23261 tx_qual,
23262 exception_specification,
23263 late_return,
23264 requires_clause,
23265 parens_loc);
23268 /* Any subsequent parameter lists are to do with
23269 return type, so are not those of the declared
23270 function. */
23276 /* Restore the state of local_variables_forbidden_p. */
23277 parser->local_variables_forbidden_p
23279 }
23281 /* Remove the function parms from scope. */
23285 /* Repeat the main loop. */
23287 }
23289 /* If this is the first, we can try a parenthesized
23290 declarator. */
23292 {
23299 /* Consume the `('. */
23300 matching_parens parens;
23302 /* Parse the nested declarator. */
23305 declarator
23307 ctor_dtor_or_conv_p,
23313 /* Expect a `)'. */
23321 }
23322 /* Otherwise, we must be done. */
23323 else
23325 }
23329 {
23330 /* Parse an array-declarator. */
23340 /* Consume the `['. */
23342 /* Peek at the next token. */
23344 /* If the next token is `]', then there is no
23345 constant-expression. */
23347 {
23349 bounds
23361 {
23362 /* Normally, the array bound must be an integral constant
23363 expression. However, as an extension, we allow VLAs
23364 in function scopes as long as they aren't part of a
23365 parameter declaration. */
23369 }
23372 {
23373 /* Remember this wasn't a constant-expression. */
23376 }
23377 }
23378 else
23380 /* Look for the closing `]'. */
23382 {
23385 }
23390 }
23392 {
23393 {
23394 tree qualifying_scope;
23395 tree unqualified_name;
23396 tree attrs;
23397 special_function_kind sfk;
23402 /* Parse a declarator-id */
23405 {
23408 /* If we see an ellipsis, we should be looking at a
23409 parameter pack. */
23411 {
23412 /* Consume the `...' */
23416 }
23417 }
23420 unqualified_name
23424 {
23428 {
23429 /* Check whether an error occurred. */
23432 /* We already consumed the ellipsis to mark a
23433 parameter pack, but we have no way to report it,
23434 so abort the tentative parse. We will be exiting
23435 immediately anyway. */
23437 }
23438 else
23444 && (qualifying_scope
23446 {
23449 }
23450 }
23455 {
23460 }
23466 {
23467 /* In the declaration of a member of a template class
23468 outside of the class itself, the SCOPE will sometimes
23469 be a TYPENAME_TYPE. For example, given:
23471 template <typename T>
23472 int S<T>::R::i = 3;
23474 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
23475 this context, we must resolve S<T>::R to an ordinary
23476 type, rather than a typename type.
23478 The reason we normally avoid resolving TYPENAME_TYPEs
23479 is that a specialization of `S' might render
23480 `S<T>::R' not a type. However, if `S' is
23481 specialized, then this `i' will not be used, so there
23482 is no harm in resolving the types here. */
23483 tree type;
23485 /* Resolve the TYPENAME_TYPE. */
23488 /* If that failed, the declarator is invalid. */
23490 {
23493 "cannot define member of dependent typedef "
23495 else
23500 }
23502 }
23507 {
23508 tree class_type;
23513 else
23517 {
23521 {
23522 /* We do not attempt to print the declarator
23523 here because we do not have enough
23524 information about its original syntactic
23525 form. */
23529 }
23532 {
23536 "use %<%T::%D%> instead of %<%T::%D%> to "
23538 class_type,
23543 }
23545 }
23548 {
23555 for an unnamed type, even if the type
23556 got a name for linkage purposes. */
23558 /* Handle correctly (c++/19200):
23560 struct S {
23561 struct T{};
23562 friend void S(T);
23563 };
23565 and also:
23567 namespace N {
23568 void S();
23569 }
23571 struct S {
23572 friend void N::S();
23573 }; */
23576 class_type))
23585 }
23586 }
23588 unqualified_name,
23596 /* We're looking for this case in [temp.res]:
23597 A qualified-id is assumed to name a type if [...]
23598 - it is a decl-specifier of the decl-specifier-seq of a
23599 parameter-declaration in a declarator of a function or
23600 function template declaration, ... */
23606 {
23607 /* ...whose declarator-id is qualified. If it isn't, never
23608 assume the parameters to refer to types. */
23611 else
23612 {
23613 /* Now we have something like
23614 template <typename T> int C::x(S::p);
23615 which can be a function template declaration or a
23616 variable template definition. If name lookup for
23617 the declarator-id C::x finds one or more function
23618 templates, assume S::p to name a type. Otherwise,
23619 don't. */
23620 tree decl
23622 none_type,
23630 /* Allow
23631 template<typename T>
23632 A<T>::A(T::type) { } */
23635 qualifying_scope)))
23637 }
23638 }
23639 }
23641 handle_declarator:;
23644 {
23645 /* Any names that appear after the declarator-id for a
23646 member are looked up in the containing scope. */
23648 {
23649 /* But declarations with qualified-ids can't appear in a
23650 function. */
23654 }
23656 }
23660 /* Default args are only allowed on function
23661 declarations. */
23663 else
23667 }
23668 /* We're done. */
23669 else
23671 }
23673 /* For an abstract declarator, we might wind up with nothing at this
23674 point. That's an error; the declarator is not optional. */
23678 {
23679 /* Record overly parenthesized declarator so we can give a
23680 diagnostic about confusing decl/expr disambiguation. */
23682 {
23683 /* If the open and close parens are on different lines, this
23684 is probably a formatting thing, so ignore. */
23689 }
23694 }
23696 /* If we entered a scope, we must exit it now. */
23704 }
23706 /* Parse a ptr-operator.
23708 ptr-operator:
23709 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
23710 * cv-qualifier-seq [opt]
23711 &
23712 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
23713 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
23715 GNU Extension:
23717 ptr-operator:
23718 & cv-qualifier-seq [opt]
23720 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
23721 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
23722 an rvalue reference. In the case of a pointer-to-member, *TYPE is
23723 filled in with the TYPE containing the member. *CV_QUALS is
23724 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
23725 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
23726 Note that the tree codes returned by this function have nothing
23727 to do with the types of trees that will be eventually be created
23728 to represent the pointer or reference type being parsed. They are
23729 just constants with suggestive names. */
23730 static enum tree_code
23735 {
23740 /* Assume that it's not a pointer-to-member. */
23742 /* And that there are no cv-qualifiers. */
23745 /* Peek at the next token. */
23748 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
23758 {
23759 /* Consume the `*', `&' or `&&'. */
23762 /* A `*' can be followed by a cv-qualifier-seq, and so can a
23763 `&', if we are allowing GNU extensions. (The only qualifier
23764 that can legally appear after `&' is `restrict', but that is
23765 enforced during semantic analysis. */
23773 }
23774 else
23775 {
23776 /* Try the pointer-to-member case. */
23778 /* Look for the optional `::' operator. */
23781 /* Look for the nested-name specifier. */
23788 /* If we found it, and the next token is a `*', then we are
23789 indeed looking at a pointer-to-member operator. */
23792 {
23793 /* Indicate that the `*' operator was used. */
23801 else
23802 {
23803 /* The type of which the member is a member is given by the
23804 current SCOPE. */
23806 /* The next name will not be qualified. */
23810 /* Look for optional c++11 attributes. */
23814 /* Look for the optional cv-qualifier-seq. */
23816 }
23817 }
23818 /* If that didn't work we don't have a ptr-operator. */
23821 }
23824 }
23826 /* Parse an (optional) cv-qualifier-seq.
23828 cv-qualifier-seq:
23829 cv-qualifier cv-qualifier-seq [opt]
23831 cv-qualifier:
23832 const
23833 volatile
23835 GNU Extension:
23837 cv-qualifier:
23838 __restrict__
23840 Returns a bitmask representing the cv-qualifiers. */
23842 static cp_cv_quals
23844 {
23848 {
23850 cp_cv_quals cv_qualifier;
23852 /* Peek at the next token. */
23854 /* See if it's a cv-qualifier. */
23856 {
23872 }
23878 {
23883 }
23884 else
23885 {
23888 }
23889 }
23892 }
23894 /* Parse an (optional) ref-qualifier
23896 ref-qualifier:
23897 &
23898 &&
23900 Returns cp_ref_qualifier representing ref-qualifier. */
23902 static cp_ref_qualifier
23904 {
23907 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
23912 {
23917 {
23929 }
23934 {
23937 }
23938 else
23939 {
23942 }
23943 }
23946 }
23948 /* Parse an optional tx-qualifier.
23950 tx-qualifier:
23951 transaction_safe
23952 transaction_safe_dynamic */
23954 static tree
23956 {
23959 {
23964 {
23968 {
23971 {
23974 }
23975 else
23977 }
23978 }
23979 }
23981 }
23983 /* Parse an (optional) virt-specifier-seq.
23985 virt-specifier-seq:
23986 virt-specifier virt-specifier-seq [opt]
23988 virt-specifier:
23989 override
23990 final
23992 Returns a bitmask representing the virt-specifiers. */
23994 static cp_virt_specifiers
23996 {
24000 {
24002 cp_virt_specifiers virt_specifier;
24004 /* Peek at the next token. */
24006 /* See if it's a virt-specifier-qualifier. */
24010 {
24013 }
24015 {
24018 }
24020 {
24022 }
24023 else
24027 {
24032 }
24033 else
24034 {
24037 }
24038 }
24040 }
24042 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
24043 is in scope even though it isn't real. */
24045 void
24047 {
24048 tree this_parm;
24051 {
24052 /* We don't clear this between NSDMIs. Is it already what we want? */
24059 }
24062 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
24064 current_class_ref
24067 }
24069 /* Return true iff our current scope is a non-static data member
24070 initializer. */
24072 bool
24074 {
24075 /* We recognize NSDMI context by the context-less 'this' pointer set up
24076 by the function above. */
24082 }
24084 /* True if we're parsing a function declarator. */
24086 bool
24088 {
24089 /* this_entity is NULL for a function parameter scope while parsing the
24090 declarator; it is set when parsing the body of the function. */
24093 }
24095 /* Parse a late-specified return type, if any. This is not a separate
24096 non-terminal, but part of a function declarator, which looks like
24098 -> trailing-type-specifier-seq abstract-declarator(opt)
24100 Returns the type indicated by the type-id.
24102 In addition to this, parse any queued up #pragma omp declare simd
24103 clauses, and #pragma acc routine clauses.
24105 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
24106 function. */
24108 static tree
24111 {
24115 && declarator
24119 && declarator
24122 /* Peek at the next token. */
24124 /* A late-specified return type is indicated by an initial '->'. */
24133 {
24134 /* Consume the ->. */
24138 }
24140 /* Function declarations may be followed by a trailing
24141 requires-clause. */
24145 declarator->attributes
24149 declarator->attributes
24154 }
24156 /* Parse a declarator-id.
24158 declarator-id:
24159 id-expression
24160 :: [opt] nested-name-specifier [opt] type-name
24162 In the `id-expression' case, the value returned is as for
24163 cp_parser_id_expression if the id-expression was an unqualified-id.
24164 If the id-expression was a qualified-id, then a SCOPE_REF is
24165 returned. The first operand is the scope (either a NAMESPACE_DECL
24166 or TREE_TYPE), but the second is still just a representation of an
24167 unqualified-id. */
24169 static tree
24171 {
24172 tree id;
24173 /* The expression must be an id-expression. Assume that qualified
24174 names are the names of types so that:
24176 template <class T>
24177 int S<T>::R::i = 3;
24179 will work; we must treat `S<T>::R' as the name of a type.
24180 Similarly, assume that qualified names are templates, where
24181 required, so that:
24183 template <class T>
24184 int S<T>::R<T>::i = 3;
24186 will work, too. */
24192 optional_p);
24196 }
24198 /* Parse a type-id.
24200 type-id:
24201 type-specifier-seq abstract-declarator [opt]
24203 The parser flags FLAGS is used to control type-specifier parsing.
24205 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
24207 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24208 i.e. we've just seen "->".
24210 Returns the TYPE specified. */
24212 static tree
24216 {
24217 cp_decl_specifier_seq type_specifier_seq;
24220 /* Parse the type-specifier-seq. */
24223 is_trailing_return,
24231 /* A bare template name as a template argument is a template template
24232 argument, not a placeholder, so fail parsing it as a type argument. */
24233 {
24237 }
24241 /* There might or might not be an abstract declarator. */
24243 /* Look for the declarator. */
24244 abstract_declarator
24251 /* Check to see if there really was a declarator. */
24256 /* The concepts TS allows 'auto' as a type-id. */
24259 /* DR 625 prohibits use of auto as a template-argument. We allow 'auto'
24260 outside the template-argument-list context here only for the sake of
24261 diagnostic: grokdeclarator then can emit a better error message for
24262 e.g. using T = auto. */
24268 && !auto_typeid_ok
24269 /* None of the valid uses of 'auto' in C++14 involve the type-id
24270 nonterminal, but it is valid in a trailing-return-type. */
24273 {
24274 /* A type-id with type 'auto' is only ok if the abstract declarator
24275 is a function declarator with a late-specified return type.
24277 A type-id with 'auto' is also valid in a trailing-return-type
24278 in a compound-requirement. */
24285 else
24286 {
24288 {
24291 {
24292 auto_diagnostic_group g;
24296 tmpl);
24298 tmpl);
24299 }
24302 auto_node);
24303 else
24305 }
24307 }
24308 }
24311 is_template_arg);
24312 }
24314 /* Wrapper for cp_parser_type_id_1. */
24316 static tree
24319 {
24321 }
24323 /* Wrapper for cp_parser_type_id_1. */
24325 static tree
24327 {
24328 tree r;
24330 parser->type_definition_forbidden_message
24335 {
24338 }
24340 }
24342 /* Wrapper for cp_parser_type_id_1. */
24344 static tree
24346 {
24349 }
24351 /* Parse a type-specifier-seq.
24353 type-specifier-seq:
24354 type-specifier type-specifier-seq [opt]
24356 GNU extension:
24358 type-specifier-seq:
24359 attributes type-specifier-seq [opt]
24361 The parser flags FLAGS is used to control type-specifier parsing.
24363 If IS_DECLARATION is true, we are at the start of a "condition" or
24364 exception-declaration, so we might be followed by a declarator-id.
24366 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
24367 i.e. we've just seen "->".
24369 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
24371 static void
24373 cp_parser_flags flags,
24377 {
24381 /* Clear the TYPE_SPECIFIER_SEQ. */
24385 /* In the context of a trailing return type, enum E { } is an
24386 elaborated-type-specifier followed by a function-body, not an
24387 enum-specifier. */
24391 /* Parse the type-specifiers and attributes. */
24393 {
24394 tree type_specifier;
24397 /* Check for attributes first. */
24399 {
24400 /* GNU attributes at the end of a declaration apply to the
24401 declaration as a whole, not to the trailing return type. So look
24402 ahead to see if these attributes are at the end. */
24405 {
24411 }
24412 type_specifier_seq->attributes
24416 }
24418 /* record the token of the beginning of the type specifier seq,
24419 for error reporting purposes*/
24423 /* Look for the type-specifier. */
24425 flags,
24426 type_specifier_seq,
24428 NULL,
24431 {
24432 /* If the first type-specifier could not be found, this is not a
24433 type-specifier-seq at all. */
24435 {
24436 /* Set in_declarator_p to avoid skipping to the semicolon. */
24448 }
24449 /* If subsequent type-specifiers could not be found, the
24450 type-specifier-seq is complete. */
24452 }
24455 /* The standard says that a condition can be:
24457 type-specifier-seq declarator = assignment-expression
24459 However, given:
24461 struct S {};
24462 if (int S = ...)
24464 we should treat the "S" as a declarator, not as a
24465 type-specifier. The standard doesn't say that explicitly for
24466 type-specifier-seq, but it does say that for
24467 decl-specifier-seq in an ordinary declaration. Perhaps it
24468 would be clearer just to allow a decl-specifier-seq here, and
24469 then add a semantic restriction that if any decl-specifiers
24470 that are not type-specifiers appear, the program is invalid. */
24473 }
24474 }
24476 /* Return whether the function currently being declared has an associated
24477 template parameter list. */
24479 static bool
24481 {
24494 }
24496 /* Parse a parameter-declaration-clause.
24498 parameter-declaration-clause:
24499 parameter-declaration-list [opt] ... [opt]
24500 parameter-declaration-list , ...
24502 The parser flags FLAGS is used to control type-specifier parsing.
24504 Returns a representation for the parameter declarations. A return
24505 value of NULL indicates a parameter-declaration-clause consisting
24506 only of an ellipsis. */
24508 static tree
24510 cp_parser_flags flags)
24511 {
24512 tree parameters;
24520 && !processing_template_parmlist
24521 && !processing_explicit_instantiation
24522 /* default_arg_ok_p tracks whether this is a parameter-clause for an
24523 actual function or a random abstract declarator. */
24529 /* Peek at the next token. */
24531 /* Check for trivial parameter-declaration-clauses. */
24533 {
24534 /* Consume the `...' token. */
24537 }
24539 /* There are no parameters. */
24541 /* Check for `(void)', too, which is a special case. */
24545 {
24546 /* Consume the `void' token. */
24548 /* There are no parameters. */
24550 }
24552 /* A vector of parameters that haven't been pushed yet. */
24555 /* Parse the parameter-declaration-list. */
24558 /* If a parse error occurred while parsing the
24559 parameter-declaration-list, then the entire
24560 parameter-declaration-clause is erroneous. */
24564 /* Peek at the next token. */
24566 /* If it's a `,', the clause should terminate with an ellipsis. */
24568 {
24569 /* Consume the `,'. */
24571 /* Expect an ellipsis. */
24572 ellipsis_p
24574 }
24575 /* It might also be `...' if the optional trailing `,' was
24576 omitted. */
24578 {
24579 /* Consume the `...' token. */
24581 /* And remember that we saw it. */
24583 }
24584 else
24587 /* A valid parameter-declaration-clause can only be followed by a ')'.
24588 So it's time to push all the parameters we have seen now that we
24589 know we have a valid declaration. Note that here we may not have
24590 committed yet, nor should we. Pushing here will detect the error
24591 of redefining a parameter. */
24596 /* Finish the parameter list. */
24601 }
24603 /* Parse a parameter-declaration-list.
24605 parameter-declaration-list:
24606 parameter-declaration
24607 parameter-declaration-list , parameter-declaration
24609 The parser flags FLAGS is used to control type-specifier parsing.
24610 PENDING_DECLS is a vector of parameters that haven't been pushed yet.
24612 Returns a representation of the parameter-declaration-list, as for
24613 cp_parser_parameter_declaration_clause. However, the
24614 `void_list_node' is never appended to the list. */
24616 static tree
24618 cp_parser_flags flags,
24620 {
24626 /* The special considerations that apply to a function within an
24627 unbraced linkage specifications do not apply to the parameters
24628 to the function. */
24629 saved_in_unbraced_linkage_specification_p
24633 /* Look for more parameters. */
24635 {
24640 /* Parse the parameter. */
24641 parameter
24646 /* We don't know yet if the enclosing context is unavailable or deprecated,
24647 so wait and deal with it in grokparms if appropriate. */
24651 {
24654 PARM,
24659 }
24663 /* If a parse error occurred parsing the parameter declaration,
24664 then the entire parameter-declaration-list is erroneous. */
24666 {
24669 }
24676 {
24677 /* We cannot always pushdecl while parsing tentatively because
24678 it may have side effects and we can't be sure yet if we're
24679 parsing a declaration, e.g.:
24681 S foo(int(x), int(x), int{x});
24683 where it's not clear if we're dealing with a constructor call
24684 or a function declaration until we've seen the last argument
24685 which breaks it up.
24686 It's safe to pushdecl so long as it doesn't result in a clash
24687 with an already-pushed parameter. But we don't delay pushing
24688 different parameters to handle
24690 S foo(int(i), decltype(i) j = 42);
24692 which is valid. */
24695 /* See if PARAMETERS already contains a parameter with the same
24696 DECL_NAME as DECL. */
24702 }())
24704 else
24706 }
24709 {
24713 }
24715 /* Add the new parameter to the list. */
24719 /* If the parameters were parenthesized, it's the case of
24720 T foo(X(x)) which looks like a variable definition but
24721 is a function declaration. */
24725 /* Peek at the next token. */
24728 /* These are for Objective-C++ */
24731 /* The parameter-declaration-list is complete. */
24734 {
24737 /* Peek at the next token. */
24739 /* If it's an ellipsis, then the list is complete. */
24742 /* Otherwise, there must be more parameters. Consume the
24743 `,'. */
24745 /* When parsing something like:
24747 int i(float f, double d)
24749 we can tell after seeing the declaration for "f" that we
24750 are not looking at an initialization of a variable "i",
24751 but rather at the declaration of a function "i".
24753 Due to the fact that the parsing of template arguments
24754 (as specified to a template-id) requires backtracking we
24755 cannot use this technique when inside a template argument
24756 list. */
24760 /* However, a parameter-declaration of the form
24761 "float(f)" (which is a valid declaration of a
24762 parameter "f") can also be interpreted as an
24763 expression (the conversion of "f" to "float"). */
24766 }
24767 else
24768 {
24776 }
24777 }
24779 parser->in_unbraced_linkage_specification_p
24782 /* Reset implicit_template_scope if we are about to leave the function
24783 parameter list that introduced it. Note that for out-of-line member
24784 definitions, there will be one or more class scopes before we get to
24785 the template parameter scope. */
24789 {
24793 {
24796 }
24797 }
24800 }
24802 /* Parse a parameter declaration.
24804 parameter-declaration:
24805 decl-specifier-seq ... [opt] declarator
24806 decl-specifier-seq declarator = assignment-expression
24807 decl-specifier-seq ... [opt] abstract-declarator [opt]
24808 decl-specifier-seq abstract-declarator [opt] = assignment-expression
24810 The parser flags FLAGS is used to control type-specifier parsing.
24812 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
24813 declares a template parameter. (In that case, a non-nested `>'
24814 token encountered during the parsing of the assignment-expression
24815 is not interpreted as a greater-than operator.)
24817 Returns a representation of the parameter, or NULL if an error
24818 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
24819 true iff the declarator is of the form "(p)". */
24823 cp_parser_flags flags,
24826 {
24828 cp_decl_specifier_seq decl_specifiers;
24830 tree default_argument;
24835 /* In a template parameter, `>' is not an operator.
24837 [temp.param]
24839 When parsing a default template-argument for a non-type
24840 template-parameter, the first non-nested `>' is taken as the end
24841 of the template parameter-list rather than a greater-than
24842 operator. */
24844 /* Type definitions may not appear in parameter types. */
24846 parser->type_definition_forbidden_message
24853 /* Parse the declaration-specifiers. */
24856 flags,
24860 /* [dcl.spec.auto.general]: "A placeholder-type-specifier of the form
24861 type-constraint opt auto can be used as a decl-specifier of the
24862 decl-specifier-seq of a parameter-declaration of a function declaration
24863 or lambda-expression..." but we must not synthesize an implicit template
24864 type parameter in its declarator. That is, in "void f(auto[auto{10}]);"
24865 we want to synthesize only the first auto. */
24869 /* Complain about missing 'typename' or other invalid type names. */
24874 /* If an error occurred, there's no reason to attempt to parse the
24875 rest of the declaration. */
24877 {
24880 }
24882 /* Peek at the next token. */
24885 /* If the next token is a `)', `,', `=', `>', or `...', then there
24886 is no declarator. However, when variadic templates are enabled,
24887 there may be a declarator following `...'. */
24892 {
24896 }
24897 /* Otherwise, there should be a declarator. */
24898 else
24899 {
24903 /* After seeing a decl-specifier-seq, if the next token is not a
24904 "(" or "{", there is no possibility that the code is a valid
24905 expression. Therefore, if parsing tentatively, we commit at
24906 this point. */
24908 /* In an expression context, having seen:
24910 (int((char ...
24912 we cannot be sure whether we are looking at a
24913 function-type (taking a "char" as a parameter) or a cast
24914 of some object of type "char" to "int". */
24918 {
24920 {
24923 /* This is a CTAD expression, not a parameter declaration. */
24925 }
24926 else
24928 }
24929 /* Parse the declarator. */
24932 CP_PARSER_DECLARATOR_EITHER,
24933 CP_PARSER_FLAGS_NONE,
24935 parenthesized_p,
24940 /* After the declarator, allow more attributes. */
24941 decl_specifiers.attributes
24945 /* If the declarator is a template parameter pack, remember that and
24946 clear the flag in the declarator itself so we don't get errors
24947 from grokdeclarator. */
24949 {
24952 }
24953 }
24955 /* If the next token is an ellipsis, and we have not seen a declarator
24956 name, and if either the type of the declarator contains parameter
24957 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
24958 for, eg, abbreviated integral type names), then we actually have a
24959 parameter pack expansion expression. Otherwise, leave the ellipsis
24960 for a C-style variadic function. */
24963 /* If a function parameter pack was specified and an implicit template
24964 parameter was introduced during cp_parser_parameter_declaration,
24965 change any implicit parameters introduced into packs. */
24970 {
24978 }
24981 {
24992 {
24993 /* Consume the `...'. */
24997 /* Build a pack expansion type */
25002 else
25004 }
25005 }
25007 /* The restriction on defining new types applies only to the type
25008 of the parameter, not to the default argument. */
25011 /* If the next token is `=', then process a default argument. */
25013 {
25018 /* If we are defining a class, then the tokens that make up the
25019 default argument must be saved and processed later. */
25025 /* A constrained-type-specifier may declare a type
25026 template-parameter. */
25028 default_argument
25031 /* A constrained-type-specifier may declare a
25032 template-template-parameter. */
25034 default_argument
25037 /* Outside of a class definition, we can just parse the
25038 assignment-expression. */
25039 else
25040 default_argument
25044 {
25046 "default arguments are only "
25048 }
25050 || template_parameter_pack_p
25053 {
25054 /* Find the name of the parameter pack. */
25061 template_parm_p
25067 else
25069 template_parm_p
25076 }
25077 }
25078 else
25084 /* Generate a location for the parameter, ranging from the start of the
25085 initial token to the end of the final token (using input_location for
25086 the latter, set up by cp_lexer_set_source_position_from_token when
25087 consuming tokens).
25089 If we have a identifier, then use it for the caret location, e.g.
25091 extern int callee (int one, int (*two)(int, int), float three);
25092 ~~~~~~^~~~~~~~~~~~~~
25094 otherwise, reuse the start location for the caret location e.g.:
25096 extern int callee (int one, int (*)(int, int), float three);
25097 ^~~~~~~~~~~~~~~~~
25099 */
25105 input_location);
25108 declarator,
25109 default_argument,
25110 param_loc,
25111 template_parameter_pack_p);
25112 }
25114 /* Parse a default argument and return it.
25116 TEMPLATE_PARM_P is true if this is a default argument for a
25117 non-type template parameter. */
25118 static tree
25120 {
25126 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
25127 set correctly. */
25134 /* Local variable names (and the `this' keyword) may not
25135 appear in a default argument. */
25138 /* Parse the assignment-expression. */
25143 /* The "this" pointer is not valid in a default argument. */
25145 {
25150 }
25151 default_argument
25153 /* Restore the "this" pointer. */
25155 {
25158 }
25167 }
25169 /* Parse a function-body.
25171 function-body:
25172 compound_statement */
25174 static void
25176 {
25180 }
25182 /* Parse a ctor-initializer-opt followed by a function-body. Return
25183 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
25184 is true we are parsing a function-try-block. */
25186 static void
25189 {
25191 const bool check_body_p
25199 {
25202 "function-try-block body of %<constexpr%> constructor only "
25204 else
25206 "function-try-block body of %<constexpr%> function only "
25208 }
25210 /* Begin the function body. */
25212 /* Parse the optional ctor-initializer. */
25215 /* If we're parsing a constexpr constructor definition, we need
25216 to check that the constructor body is indeed empty. However,
25217 before we get to cp_parser_function_body lot of junk has been
25218 generated, so we can't just check that we have an empty block.
25219 Rather we take a snapshot of the outermost block, and check whether
25220 cp_parser_function_body changed its state. */
25222 {
25226 }
25227 /* Parse the function-body. */
25231 /* Finish the function body. */
25233 }
25235 /* Parse an initializer.
25237 initializer:
25238 = initializer-clause
25239 ( expression-list )
25241 Returns an expression representing the initializer. If no
25242 initializer is present, NULL_TREE is returned.
25244 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
25245 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
25246 set to TRUE if there is no initializer present. If there is an
25247 initializer, and it is not a constant-expression, *NON_CONSTANT_P
25248 is set to true; otherwise it is set to false. */
25250 static tree
25253 {
25255 tree init;
25257 /* Peek at the next token. */
25260 /* Let our caller know whether or not this initializer was
25261 parenthesized. */
25263 /* Assume that the initializer is constant. */
25267 {
25268 /* Consume the `='. */
25270 /* Parse the initializer-clause. */
25272 }
25274 {
25279 non_constant_p);
25284 }
25286 {
25291 }
25292 else
25293 {
25294 /* Anything else is an error. */
25297 }
25303 }
25305 /* Parse an initializer-clause.
25307 initializer-clause:
25308 assignment-expression
25309 braced-init-list
25311 Returns an expression representing the initializer.
25313 If the `assignment-expression' production is used the value
25314 returned is simply a representation for the expression.
25316 Otherwise, calls cp_parser_braced_list. */
25318 static cp_expr
25320 {
25321 cp_expr initializer;
25323 /* Assume the expression is constant. */
25326 /* If it is not a `{', then we are looking at an
25327 assignment-expression. */
25329 {
25330 initializer
25333 non_constant_p);
25334 }
25335 else
25339 }
25341 /* Parse a brace-enclosed initializer list.
25343 braced-init-list:
25344 { initializer-list , [opt] }
25345 { designated-initializer-list , [opt] }
25346 { }
25348 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
25349 the elements of the initializer-list (or NULL, if the last
25350 production is used). The TREE_TYPE for the CONSTRUCTOR will be
25351 NULL_TREE. There is no way to detect whether or not the optional
25352 trailing `,' was provided. NON_CONSTANT_P is as for
25353 cp_parser_initializer. */
25355 static cp_expr
25357 {
25358 tree initializer;
25361 /* Consume the `{' token. */
25362 matching_braces braces;
25364 /* Create a CONSTRUCTOR to represent the braced-initializer. */
25366 /* If it's not a `}', then there is a non-trivial initializer. */
25368 {
25370 /* Parse the initializer list. */
25374 /* A trailing `,' token is allowed. */
25377 }
25378 else
25380 /* Now, there should be a trailing `}'. */
25386 /* Build a location of the form:
25387 { ... }
25388 ^~~~~~~
25389 with caret==start at the open brace, finish at the close brace. */
25393 }
25395 /* Consume tokens up to, and including, the next non-nested closing `]'.
25396 Returns true iff we found a closing `]'. */
25398 static bool
25400 {
25404 {
25408 {
25412 /* FALLTHRU */
25415 /* If we've run out of tokens, then there is no closing `]'. */
25424 {
25427 }
25432 }
25434 /* Consume the token. */
25436 }
25437 }
25439 /* Return true if we are looking at an array-designator, false otherwise. */
25441 static bool
25443 {
25444 /* Consume the `['. */
25449 /* Skip tokens until the next token is a closing square bracket.
25450 If we find the closing `]', and the next token is a `=', then
25451 we are looking at an array designator. */
25452 bool array_designator_p
25456 /* Roll back the tokens we skipped. */
25460 }
25462 /* Parse an initializer-list.
25464 initializer-list:
25465 initializer-clause ... [opt]
25466 initializer-list , initializer-clause ... [opt]
25468 C++20 Extension:
25470 designated-initializer-list:
25471 designated-initializer-clause
25472 designated-initializer-list , designated-initializer-clause
25474 designated-initializer-clause:
25475 designator brace-or-equal-initializer
25477 designator:
25478 . identifier
25480 GNU Extension:
25482 initializer-list:
25483 designation initializer-clause ...[opt]
25484 initializer-list , designation initializer-clause ...[opt]
25486 designation:
25487 . identifier =
25488 identifier :
25489 [ constant-expression ] =
25491 Returns a vec of constructor_elt. The VALUE of each elt is an expression
25492 for the initializer. If the INDEX of the elt is non-NULL, it is the
25493 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
25494 as for cp_parser_initializer. Set *DESIGNATED to a boolean whether there
25495 are any designators. */
25500 {
25505 /* Assume all of the expressions are constant. */
25511 /* Parse the rest of the list. */
25513 {
25515 tree designator;
25516 tree initializer;
25520 /* Handle the C++20 syntax, '. id ='. */
25528 {
25531 "C++ designated initializers only available with "
25533 /* Consume the `.'. */
25535 /* Consume the identifier. */
25538 /* Consume the `='. */
25540 }
25541 /* Also, if the next token is an identifier and the following one is a
25542 colon, we are looking at the GNU designated-initializer
25543 syntax. */
25548 {
25549 /* Warn the user that they are using an extension. */
25552 /* Consume the identifier. */
25554 /* Consume the `:'. */
25556 }
25557 /* Also handle C99 array designators, '[ const ] ='. */
25561 {
25562 /* In C++11, [ could start a lambda-introducer. */
25568 {
25571 }
25572 else
25573 {
25578 }
25583 && (!require_potential_rvalue_constant_expression
25587 /* Warn the user that they are using an extension. */
25590 }
25591 else
25595 {
25598 }
25602 {
25606 }
25610 /* Parse the initializer. */
25613 /* If any clause is non-constant, so is the entire initializer. */
25617 /* If we have an ellipsis, this is an initializer pack
25618 expansion. */
25620 {
25623 /* Consume the `...'. */
25630 /* Turn the initializer into an initializer expansion. */
25632 }
25634 /* Add it to the vector. */
25637 /* If the next token is not a comma, we have reached the end of
25638 the list. */
25642 /* Peek at the next token. */
25644 /* If the next token is a `}', then we're still done. An
25645 initializer-clause can have a trailing `,' after the
25646 initializer-list and before the closing `}'. */
25650 /* Suppress location wrappers in a long initializer to save memory
25651 (14179). The cutoff is chosen arbitrarily. */
25655 /* Look one level down because it's easy. Looking deeper would require
25656 passing down a nelts pointer, and I don't think multi-level massive
25657 initializers are common enough to justify this. */
25663 /* Consume the `,' token. */
25665 }
25667 /* The same identifier shall not appear in multiple designators
25668 of a designated-initializer-list. */
25670 {
25675 {
25677 {
25679 "%<.%s%> designator used multiple times in "
25683 }
25684 else
25686 }
25690 }
25696 }
25698 /* Classes [gram.class] */
25700 /* Parse a class-name.
25702 class-name:
25703 identifier
25704 template-id
25706 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
25707 to indicate that names looked up in dependent types should be
25708 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
25709 keyword has been used to indicate that the name that appears next
25710 is a template. TAG_TYPE indicates the explicit tag given before
25711 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
25712 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
25713 is the class being defined in a class-head. If ENUM_OK is TRUE,
25714 enum-names are also accepted.
25716 Returns the TYPE_DECL representing the class. */
25718 static tree
25727 {
25728 tree decl;
25731 /* All class-names start with an identifier. */
25734 {
25737 }
25739 /* PARSER->SCOPE can be cleared when parsing the template-arguments
25740 to a template-id, so we save it here. Consider object scope too,
25741 so that make_typename_type below can use it (cp_parser_template_name
25742 considers object scope also). This may happen with code like
25744 p->template A<T>::a()
25746 where we first want to look up A<T>::a in the class of the object
25747 expression, as per [basic.lookup.classref]. */
25749 /* This only checks parser->scope to avoid duplicate errors; if
25750 ->object_type is erroneous, go on to give a parse error. */
25754 /* Any name names a type if we're following the `typename' keyword
25755 in a qualified name where the enclosing scope is type-dependent. */
25760 /* Handle the common case (an identifier, but not a template-id)
25761 efficiently. */
25764 {
25768 /* Look for the identifier. */
25772 /* If the next token isn't an identifier, we are certainly not
25773 looking at a class-name. */
25776 /* If we know this is a type-name, there's no need to look it
25777 up. */
25780 else
25781 {
25782 tree ambiguous_decls;
25783 /* If we already know that this lookup is ambiguous, then
25784 we've already issued an error message; there's no reason
25785 to check again. */
25787 {
25790 }
25791 /* If the next token is a `::', then the name must be a type
25792 name.
25794 [basic.lookup.qual]
25796 During the lookup for a name preceding the :: scope
25797 resolution operator, object, function, and enumerator
25798 names are ignored. */
25801 /* Look up the name. */
25803 tag_type,
25806 check_dependency_p,
25810 {
25814 }
25815 }
25816 }
25817 else
25818 {
25819 /* Try a template-id. */
25821 check_dependency_p,
25822 tag_type,
25823 is_declaration);
25826 }
25830 /* If this is a typename, create a TYPENAME_TYPE. */
25832 {
25837 }
25841 /* Check to see that it is really the name of a class. */
25845 /* Situations like this:
25847 template <typename T> struct A {
25848 typename T::template X<int>::I i;
25849 };
25851 are problematic. Is `T::template X<int>' a class-name? The
25852 standard does not seem to be definitive, but there is no other
25853 valid interpretation of the following `::'. Therefore, those
25854 names are considered class-names. */
25855 {
25859 }
25864 /* In Objective-C 2.0, a classname followed by '.' starts a
25865 dot-syntax expression, and it's not a type-name. */
25877 }
25879 /* Make sure that any member-function parameters are in scope.
25880 For instance, a function's noexcept-specifier can use the function's
25881 parameters:
25883 struct S {
25884 void fn (int p) noexcept(noexcept(p));
25885 };
25887 so we need to make sure name lookup can find them. This is used
25888 when we delay parsing of the noexcept-specifier. */
25890 static void
25892 {
25899 {
25903 }
25904 }
25906 /* Undo the effects of inject_parm_decls. */
25908 static void
25910 {
25913 }
25915 /* Parse a class-specifier.
25917 class-specifier:
25918 class-head { member-specification [opt] }
25920 Returns the TREE_TYPE representing the class. */
25922 tree
25924 {
25927 tree type;
25941 /* Parse the class-head. */
25944 /* If the class-head was a semantic disaster, skip the entire body
25945 of the class. */
25947 {
25951 }
25953 /* Look for the `{'. */
25954 matching_braces braces;
25956 {
25959 }
25964 /* Issue an error message if type-definitions are forbidden here. */
25966 /* Remember that we are defining one more class. */
25968 /* Inside the class, surrounding template-parameter-lists do not
25969 apply. */
25970 saved_num_template_parameter_lists
25973 /* We are not in a function body. */
25976 /* Or in a loop. */
25979 /* Or in a switch. */
25982 /* We are not immediately inside an extern "lang" block. */
25983 saved_in_unbraced_linkage_specification_p
25987 /* Start the class. */
25989 {
25991 /* SCOPE must be a scope nested inside current scope. */
25995 else
25997 }
26001 /* If the type is erroneous, skip the entire body of the class. */
26003 else
26004 /* Parse the member-specification. */
26007 /* Look for the trailing `}'. */
26009 /* Look for trailing attributes to apply to this class. */
26017 /* We've finished a type definition. Check for the common syntax
26018 error of forgetting a semicolon after the definition. We need to
26019 be careful, as we can't just check for not-a-semicolon and be done
26020 with it; the user might have typed:
26022 class X { } c = ...;
26023 class X { } *p = ...;
26025 and so forth. Instead, enumerate all the possible tokens that
26026 might follow this production; if we don't see one of them, then
26027 complain and silently insert the semicolon. */
26028 {
26033 /* Don't try to parse c++11 attributes here. As per the
26034 grammar, that should be a task for
26035 cp_parser_decl_specifier_seq. */
26039 {
26051 /* While it's legal for type qualifiers and storage class
26052 specifiers to follow type definitions in the grammar, only
26053 compiler testsuites contain code like that. Assume that if
26054 we see such code, then what we're really seeing is a case
26055 like:
26057 class X { }
26058 const <type> var = ...;
26060 or
26062 class Y { }
26063 static <type> func (...) ...
26065 i.e. the qualifier or specifier applies to the next
26066 declaration. To do so, however, we need to look ahead one
26067 more token to see if *that* token is a type specifier.
26069 This code could be improved to handle:
26071 class Z { }
26072 static const <type> var = ...; */
26075 {
26078 /* Handling user-defined types here would be nice, but very
26079 tricky. */
26080 want_semicolon
26083 }
26087 }
26089 /* If we don't have a type, then something is very wrong and we
26090 shouldn't try to do anything clever. Likewise for not seeing the
26091 closing brace. */
26093 {
26094 /* Locate the closing brace. */
26095 cp_token_position prev
26100 /* We want to suggest insertion of a ';' immediately *after* the
26101 closing brace, so, if we can, offset the location by 1 column. */
26108 /* If we successfully offset the location, suggest the fix-it. */
26121 else
26124 /* Unget one token and smash it to look as though we encountered
26125 a semicolon in the input stream. */
26130 }
26131 }
26133 /* If this class is not itself within the scope of another class,
26134 then we need to parse the bodies of all of the queued function
26135 definitions. Note that the queued functions defined in a class
26136 are not always processed immediately following the
26137 class-specifier for that class. Consider:
26139 struct A {
26140 struct B { void f() { sizeof (A); } };
26141 };
26143 If `f' were processed before the processing of `A' were
26144 completed, there would be no way to compute the size of `A'.
26145 Note that the nesting we are interested in here is lexical --
26146 not the semantic nesting given by TYPE_CONTEXT. In particular,
26147 for:
26149 struct A { struct B; };
26150 struct A::B { void f() { } };
26152 there is no need to delay the parsing of `A::B::f'. */
26154 {
26155 tree decl;
26162 {
26163 /* Skip default arguments, NSDMIs, etc, in order to improve
26164 error recovery (c++/71169, c++/71832). */
26168 }
26170 /* In a first pass, parse default arguments to the functions.
26171 Then, in a second pass, parse the bodies of the functions.
26172 This two-phased approach handles cases like:
26174 struct S {
26175 void f() { g(); }
26176 void g(int i = 3);
26177 };
26179 */
26181 {
26183 /* If there are default arguments that have not yet been processed,
26184 take care of them now. */
26186 {
26191 }
26192 /* Make sure that any template parameters are in scope. */
26194 /* Parse the default argument expressions. */
26196 /* Remove any template parameters from the symbol table. */
26198 }
26201 /* If there are noexcept-specifiers that have not yet been processed,
26202 take care of them now. Do this before processing NSDMIs as they
26203 may depend on noexcept-specifiers already having been processed. */
26207 {
26210 {
26215 }
26220 /* Make sure that any template parameters are in scope. */
26223 /* Make sure that any member-function parameters are in scope.
26224 This function doesn't expect ccp to be set. */
26228 /* 'this' is not allowed in static member functions. */
26229 unsigned char local_variables_forbidden_p
26234 /* Now we can parse the noexcept-specifier. */
26240 /* Update the fn's type directly -- it might have escaped
26241 beyond this decl :( */
26243 /* Update any instantiations we've already created. We must
26244 keep the new noexcept-specifier wrapped in a DEFERRED_NOEXCEPT
26245 so that maybe_instantiate_noexcept can tsubst the NOEXCEPT_EXPR
26246 in the pattern. */
26251 /* Restore the state of local_variables_forbidden_p. */
26254 /* The finish_struct call above performed various override checking,
26255 but it skipped unparsed noexcept-specifier operands. Now that we
26256 have resolved them, check again. */
26259 /* Remove any member-function parameters from the symbol table. */
26262 /* Remove any template parameters from the symbol table. */
26264 }
26267 /* Now parse any NSDMIs. */
26269 {
26271 {
26276 }
26279 }
26286 /* Now parse the body of the functions. */
26288 {
26289 /* OpenMP UDRs need to be parsed before all other functions. */
26296 }
26297 else
26301 }
26303 /* Put back any saved access checks. */
26306 /* Restore saved state. */
26310 parser->num_template_parameter_lists
26312 parser->in_unbraced_linkage_specification_p
26316 }
26318 /* Parse a class-head.
26320 class-head:
26321 class-key identifier [opt] base-clause [opt]
26322 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
26323 class-key nested-name-specifier [opt] template-id
26324 base-clause [opt]
26326 class-virt-specifier:
26327 final
26329 GNU Extensions:
26330 class-key attributes identifier [opt] base-clause [opt]
26331 class-key attributes nested-name-specifier identifier base-clause [opt]
26332 class-key attributes nested-name-specifier [opt] template-id
26333 base-clause [opt]
26335 Upon return BASES is initialized to the list of base classes (or
26336 NULL, if there are none) in the same form returned by
26337 cp_parser_base_clause.
26339 Returns the TYPE of the indicated class. Sets
26340 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
26341 involving a nested-name-specifier was used, and FALSE otherwise.
26343 Returns error_mark_node if this is not a class-head.
26345 Returns NULL_TREE if the class-head is syntactically valid, but
26346 semantically invalid in a way that means we should skip the entire
26347 body of the class. */
26349 static tree
26352 {
26353 tree nested_name_specifier;
26357 tree attributes;
26358 tree bases;
26368 /* Assume no nested-name-specifier will be present. */
26370 /* Assume no template parameter lists will be used in defining the
26371 type. */
26375 /* Look for the class-key. */
26382 /* Parse the attributes. */
26385 /* If the next token is `::', that is invalid -- but sometimes
26386 people do try to write:
26388 struct ::S {};
26390 Handle this gracefully by accepting the extra qualifier, and then
26391 issuing an error about it later if this really is a
26392 class-head. If it turns out just to be an elaborated type
26393 specifier, remain silent. */
26399 /* Determine the name of the class. Begin by looking for an
26400 optional nested-name-specifier. */
26402 nested_name_specifier
26408 /* If there was a nested-name-specifier, then there *must* be an
26409 identifier. */
26414 {
26416 /* Although the grammar says `identifier', it really means
26417 `class-name' or `template-name'. You are only allowed to
26418 define a class that has already been declared with this
26419 syntax.
26421 The proposed resolution for Core Issue 180 says that wherever
26422 you see `class T::X' you should treat `X' as a type-name.
26424 It is OK to define an inaccessible class; for example:
26426 class A { class B; };
26427 class A::B {};
26429 We do not know if we will see a class-name, or a
26430 template-name. We look for a class-name first, in case the
26431 class-name is a template-id; if we looked for the
26432 template-name first we would stop after the template-name. */
26439 class_type,
26443 /* If that didn't work, ignore the nested-name-specifier. */
26445 {
26451 }
26452 /* If we could not find a corresponding TYPE, treat this
26453 declaration like an unqualified declaration. */
26456 /* Otherwise, count the number of templates used in TYPE and its
26457 containing scopes. */
26458 else
26460 }
26461 /* Otherwise, the identifier is optional. */
26462 else
26463 {
26464 /* We don't know whether what comes next is a template-id,
26465 an identifier, or nothing at all. */
26467 /* Check for a template-id. */
26472 class_key,
26474 /* If that didn't work, it could still be an identifier. */
26476 {
26478 {
26481 }
26482 else
26484 }
26485 else
26486 {
26489 }
26490 }
26495 {
26497 class_key,
26499 }
26502 /* If it's not a `:' or a `{' then we can't really be looking at a
26503 class-head, since a class-head only appears as part of a
26504 class-specifier. We have to detect this situation before calling
26505 xref_tag, since that has irreversible side-effects. */
26507 {
26511 }
26513 /* At this point, we're going ahead with the class-specifier, even
26514 if some other problem occurs. */
26517 {
26522 }
26523 /* Issue the error about the overly-qualified name now. */
26525 {
26530 }
26532 {
26537 }
26539 {
26540 tree scope;
26543 /* [temp.names]: in a qualified-id formed by a class-head-name, the
26544 keyword template shall not appear at the top level. */
26548 /* Reject typedef-names in class heads. */
26550 {
26553 type);
26556 }
26558 /* Figure out in what scope the declaration is being placed. */
26560 /* If that scope does not contain the scope in which the
26561 class was originally declared, the program is invalid. */
26563 {
26566 "declaration of %qD in namespace %qD which does not "
26569 else
26575 }
26576 /* [dcl.meaning]
26578 A declarator-id shall not be qualified except for the
26579 definition of a ... nested class outside of its class
26580 ... [or] the definition or explicit instantiation of a
26581 class member of a namespace outside of its namespace. */
26585 }
26586 /* An explicit-specialization must be preceded by "template <>". If
26587 it is not, try to recover gracefully. */
26590 && !processing_template_parmlist
26592 {
26593 /* Build a location of this form:
26594 struct typename <ARGS>
26595 ^~~~~~~~~~~~~~~~~~~~~~
26596 with caret==start at the start token, and
26597 finishing at the end of the type. */
26598 location_t reported_loc
26600 class_head_start_location,
26606 "an explicit specialization must be preceded by"
26609 /* Take the same action that would have been taken by
26610 cp_parser_explicit_specialization. */
26613 }
26614 /* There must be no "return" statements between this point and the
26615 end of this function; set "type "to the correct return value and
26616 use "goto done;" to return. */
26617 /* Make sure that the right number of template parameters were
26618 present. */
26620 template_id_p,
26623 {
26624 /* If something went wrong, there is no point in even trying to
26625 process the class-definition. */
26628 }
26630 /* Look up the type. */
26632 {
26636 {
26640 }
26641 else
26642 {
26646 /* Check the scope while we still know whether or not we had a
26647 nested-name-specifier. */
26650 }
26653 }
26655 {
26658 /* Given:
26660 template <typename T> struct S { struct T };
26661 template <typename T> struct S<T>::T { };
26663 we will get a TYPENAME_TYPE when processing the definition of
26664 `S::T'. We need to resolve it to the actual type before we
26665 try to define it. */
26667 {
26670 {
26673 }
26674 }
26678 {
26681 }
26683 /* Enter the scope indicated by the nested-name-specifier. */
26685 /* Get the canonical version of this type. */
26687 /* Call push_template_decl if it seems like we should be defining a
26688 template either from the template headers or the type we're
26689 defining, so that we diagnose both extra and missing headers. */
26693 {
26696 {
26699 }
26700 }
26704 }
26706 {
26707 /* If the class was unnamed, create a dummy name. */
26715 }
26717 /* Diagnose class/struct/union mismatches. */
26721 /* Indicate whether this class was declared as a `class' or as a
26722 `struct'. */
26726 /* If this type was already complete, and we see another definition,
26727 that's an error. Likewise if the type is already being defined:
26728 this can happen, eg, when it's defined from within an expression
26729 (c++/84605). */
26732 {
26734 type);
26736 type);
26739 }
26744 {
26747 {
26748 /* In a lambda this should work, but doesn't currently. */
26751 }
26753 /* Apply attributes now, before any use of the class as a template
26754 argument in its base list. */
26757 }
26759 /* Associate constraints with the type. */
26763 /* We will have entered the scope containing the class; the names of
26764 base classes should be looked up in that context. For example:
26766 struct A { struct B {}; struct C; };
26767 struct A::C : B {};
26769 is valid. */
26771 /* Get the list of base-classes, if there is one. Defer access checking
26772 until the entire list has been seen, as per [class.access.general]. */
26775 {
26781 }
26782 else
26785 /* If we're really defining a class, process the base classes.
26786 If they're invalid, fail. */
26790 /* Now that all bases have been seen and attached to the class, check
26791 accessibility of the types named in the base-clause. This must be
26792 done relative to the class scope, so that we accept e.g.
26794 struct A { protected: struct B {}; };
26795 struct C : A::B, A {}; // OK: A::B is accessible via base A
26797 as per [class.access.general]. */
26804 done:
26805 /* Leave the scope given by the nested-name-specifier. We will
26806 enter the class scope itself while processing the members. */
26811 {
26814 }
26820 out:
26823 }
26825 /* Parse a class-key.
26827 class-key:
26828 class
26829 struct
26830 union
26832 Returns the kind of class-key specified, or none_type to indicate
26833 error. */
26835 static enum tag_types
26837 {
26841 /* Look for the class-key. */
26846 /* Check to see if the TOKEN is a class-key. */
26851 }
26853 /* Parse a type-parameter-key.
26855 type-parameter-key:
26856 class
26857 typename
26858 */
26860 static void
26862 {
26863 /* Look for the type-parameter-key. */
26867 {
26871 /* typename is not allowed in a template template parameter
26872 by the standard until C++17. */
26874 "ISO C++ forbids typename key in template template parameter;"
26876 }
26877 else
26881 }
26883 /* Parse an (optional) member-specification.
26885 member-specification:
26886 member-declaration member-specification [opt]
26887 access-specifier : member-specification [opt] */
26889 static void
26891 {
26893 {
26897 /* Peek at the next token. */
26899 /* If it's a `}', or EOF then we've seen all the members. */
26905 /* See if this token is a keyword. */
26908 {
26912 /* Consume the access-specifier. */
26914 /* Remember which access-specifier is active. */
26916 /* Look for the `:'. */
26921 /* Accept #pragmas at class scope. */
26923 {
26926 }
26928 /* Otherwise, the next construction must be a
26929 member-declaration. */
26931 }
26932 }
26933 }
26935 /* Parse a member-declaration.
26937 member-declaration:
26938 decl-specifier-seq [opt] member-declarator-list [opt] ;
26939 function-definition ; [opt]
26940 :: [opt] nested-name-specifier template [opt] unqualified-id ;
26941 using-declaration
26942 template-declaration
26943 alias-declaration
26945 member-declarator-list:
26946 member-declarator
26947 member-declarator-list , member-declarator
26949 member-declarator:
26950 declarator pure-specifier [opt]
26951 declarator constant-initializer [opt]
26952 identifier [opt] : constant-expression
26954 GNU Extensions:
26956 member-declaration:
26957 __extension__ member-declaration
26959 member-declarator:
26960 declarator attributes [opt] pure-specifier [opt]
26961 declarator attributes [opt] constant-initializer [opt]
26962 identifier [opt] attributes [opt] : constant-expression
26964 C++0x Extensions:
26966 member-declaration:
26967 static_assert-declaration */
26969 static void
26971 {
26972 cp_decl_specifier_seq decl_specifiers;
26973 tree prefix_attributes;
26974 tree decl;
26983 /* Check for the `__extension__' keyword. */
26985 {
26986 /* Recurse. */
26988 /* Restore the old value of the PEDANTIC flag. */
26992 }
26994 /* Check for a template-declaration. */
26996 {
26997 /* An explicit specialization here is an error condition, and we
26998 expect the specialization handler to detect and report this. */
27002 else
27006 }
27007 /* Check for a template introduction. */
27011 /* Check for a using-declaration. */
27013 {
27015 /* Parse the using-declaration. */
27019 else
27020 {
27021 tree decl;
27025 /* Note that if we actually see the '=' token after the
27026 identifier, cp_parser_alias_declaration commits the
27027 tentative parse. In that case, we really expect an
27028 alias-declaration. Otherwise, we expect a using
27029 declaration. */
27030 alias_decl_expected =
27036 else
27039 }
27041 }
27043 /* Check for @defs. */
27045 {
27050 {
27055 }
27057 }
27059 /* If the next token is `static_assert' we have a static assertion. */
27061 {
27064 }
27068 cp_omp_declare_simd_data odsd;
27072 /* Parse the decl-specifier-seq. */
27075 (CP_PARSER_FLAGS_OPTIONAL
27085 /* Check for an invalid type-name. */
27089 /* If there is no declarator, then the decl-specifier-seq should
27090 specify a type. */
27092 {
27093 /* If there was no decl-specifier-seq, and the next token is a
27094 `;', then we have something like:
27096 struct S { ; };
27098 [class.mem]
27100 Each member-declaration shall declare at least one member
27101 name of the class. */
27103 {
27106 {
27110 }
27111 }
27112 else
27113 {
27114 /* See if this declaration is a friend. */
27116 /* If there were decl-specifiers, check to see if there was
27117 a class-declaration. */
27120 /* Nested classes have already been added to the class, but
27121 a `friend' needs to be explicitly registered. */
27123 {
27124 /* If the `friend' keyword was present, the friend must
27125 be introduced with a class-key. */
27128 "in C++03 a class-key must be used "
27130 /* In this case:
27132 template <typename T> struct A {
27133 friend struct A<T>::B;
27134 };
27136 A<T>::B will be represented by a TYPENAME_TYPE, and
27137 therefore not recognized by check_tag_decl. */
27139 {
27143 }
27144 /* Warn if an attribute cannot appear here, as per
27145 [dcl.attr.grammar]/5. But not when declares_class_or_enum:
27146 we ignore attributes in elaborated-type-specifiers. */
27149 {
27154 "that appertains to a friend declaration that "
27156 }
27159 "friend declaration does not name a class or "
27161 else
27164 }
27165 /* If there is no TYPE, an error message will already have
27166 been issued. */
27168 ;
27169 /* An anonymous aggregate has to be handled specially; such
27170 a declaration really declares a data member (with a
27171 particular type), as opposed to a nested class. */
27173 {
27174 /* C++11 9.5/6. */
27177 "a storage class on an anonymous aggregate "
27180 /* Remove constructors and such from TYPE, now that we
27181 know it is an anonymous aggregate. */
27183 /* And make the corresponding data member. */
27186 /* Add it to the class. */
27188 }
27189 else
27190 cp_parser_check_access_in_redeclaration
27193 }
27194 }
27195 else
27196 {
27199 /* Clear attributes from the decl_specifiers but keep them
27200 around as prefix attributes that apply them to the entity
27201 being declared. */
27209 /* See if these declarations will be friends. */
27212 /* Keep going until we hit the `;' at the end of the
27213 declaration. */
27215 {
27217 tree first_attribute;
27218 tree initializer;
27221 /* Peek at the next token. */
27224 /* The following code wants to know early if it is a bit-field
27225 or some other declaration. Attributes can appear before
27226 the `:' token. Skip over them without consuming any tokens
27227 to peek if they are followed by `:'. */
27232 {
27233 size_t n
27236 }
27238 /* Check for a bitfield declaration. */
27244 {
27245 tree identifier;
27246 tree width;
27248 location_t id_location
27253 else
27256 /* Look for attributes that apply to the bitfield. */
27259 /* Consume the `:' token. */
27262 /* Get the width of the bitfield. */
27266 /* In C++20 and as extension for C++11 and above we allow
27267 default member initializers for bit-fields. */
27272 CPP_OPEN_BRACE)))
27273 {
27274 location_t loc
27279 "default member initializers for bit-fields "
27280 "only available with %<-std=c++20%> or "
27285 {
27289 }
27290 }
27291 else
27292 {
27293 /* Look for attributes that apply to the bitfield after
27294 the `:' token and width. This is where GCC used to
27295 parse attributes in the past, pedwarn if there is
27296 a std attribute. */
27299 "ISO C++ allows bit-field attributes only "
27303 }
27307 /* Remember which attributes are prefix attributes and
27308 which are not. */
27310 /* Combine the attributes. */
27313 /* Create the bitfield declaration. */
27316 identifier,
27317 sfk_none,
27318 id_location)
27322 attributes);
27323 }
27324 else
27325 {
27327 tree asm_specification;
27331 /* We can't delay parsing for friends,
27332 alias-declarations, and typedefs, even though the
27333 standard seems to require it. */
27338 /* Parse the declarator. */
27339 declarator
27341 flags,
27347 /* If something went wrong parsing the declarator, make sure
27348 that we at least consume some tokens. */
27350 {
27351 /* Skip to the end of the statement. */
27353 /* If the next token is not a semicolon, that is
27354 probably because we just skipped over the body of
27355 a function. So, we consume a semicolon if
27356 present, but do not issue an error message if it
27357 is not present. */
27359 CPP_SEMICOLON))
27362 }
27364 /* Handle class-scope non-template C++17 deduction guides. */
27367 declarator,
27371 cp_parser_check_for_definition_in_return_type
27375 /* Look for an asm-specification. */
27377 /* Look for attributes that apply to the declaration. */
27379 /* Remember which attributes are prefix attributes and
27380 which are not. */
27382 /* Combine the attributes. */
27385 /* If it's an `=', then we have a constant-initializer or a
27386 pure-specifier. It is not correct to parse the
27387 initializer before registering the member declaration
27388 since the member declaration should be in scope while
27389 its initializer is processed. However, the rest of the
27390 front end does not yet provide an interface that allows
27391 us to handle this correctly. */
27393 {
27394 /* In [class.mem]:
27396 A pure-specifier shall be used only in the declaration of
27397 a virtual function.
27399 A member-declarator can contain a constant-initializer
27400 only if it declares a static member of integral or
27401 enumeration type.
27403 Therefore, if the DECLARATOR is for a function, we look
27404 for a pure-specifier; otherwise, we look for a
27405 constant-initializer. When we call `grokfield', it will
27406 perform more stringent semantics checks. */
27419 {
27421 /* Don't require a constant rvalue in C++11, since we
27422 might want a reference constant. We'll enforce
27423 constancy later. */
27425 /* Parse the initializer. */
27428 }
27429 else
27430 /* Parse the initializer. */
27432 }
27435 {
27437 declarator->init_loc
27441 else
27443 }
27444 /* Detect invalid bit-field cases such as
27446 int *p : 4;
27447 int &&r : 3;
27449 and similar. */
27451 /* If there were no type specifiers, it was a
27452 constructor. */
27454 {
27455 /* This is called for a decent diagnostic only. */
27464 /* Avoid "extra ;" pedwarns. */
27466 CPP_SEMICOLON))
27469 }
27470 /* Otherwise, there is no initializer. */
27471 else
27474 /* See if we are probably looking at a function
27475 definition. We are certainly not looking at a
27476 member-declarator. Calling `grokfield' has
27477 side-effects, so we must not do it unless we are sure
27478 that we are looking at a member-declarator. */
27481 {
27482 /* The grammar does not allow a pure-specifier to be
27483 used when a member function is defined. (It is
27484 possible that this fact is an oversight in the
27485 standard, since a pure function may be defined
27486 outside of the class-specifier. */
27492 declarator,
27493 attributes);
27497 /* If the member was not a friend, declare it here. */
27500 /* Peek at the next token. */
27502 /* If the next token is a semicolon, consume it. */
27504 {
27505 location_t semicolon_loc
27510 "extra %<;%> after in-class "
27512 }
27514 }
27515 else
27519 /* Create the declaration. */
27524 {
27527 else
27529 }
27530 }
27535 /* Reset PREFIX_ATTRIBUTES. */
27537 {
27542 }
27544 /* If there is any qualification still in effect, clear it
27545 now; we will be starting fresh with the next declarator. */
27549 /* If it's a `,', then there are more declarators. */
27551 {
27554 {
27560 }
27561 }
27562 /* If the next token isn't a `;', then we have a parse error. */
27564 CPP_SEMICOLON))
27565 {
27566 /* The next token might be a ways away from where the
27567 actual semicolon is missing. Find the previous token
27568 and use that for our error position. */
27575 /* Assume that the user meant to provide a semicolon. If
27576 we were to cp_parser_skip_to_end_of_statement, we might
27577 skip to a semicolon inside a member function definition
27578 and issue nonsensical error messages. */
27580 }
27583 {
27584 /* Add DECL to the list of members. */
27586 /* Explicitly include, eg, NSDMIs, for better error
27587 recovery (c++/58650). */
27595 /* Add DECL to the queue of NSDMI to be parsed later. */
27597 }
27601 }
27602 }
27605 out:
27608 }
27610 /* Parse a pure-specifier.
27612 pure-specifier:
27613 = 0
27615 Returns INTEGER_ZERO_NODE if a pure specifier is found.
27616 Otherwise, ERROR_MARK_NODE is returned. */
27618 static tree
27620 {
27623 /* Look for the `=' token. */
27626 /* Look for the `0' token. */
27635 /* Accept = default or = delete in c++0x mode. */
27638 {
27641 }
27643 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
27645 {
27650 }
27652 {
27655 }
27658 }
27660 /* Parse a constant-initializer.
27662 constant-initializer:
27663 = constant-expression
27665 Returns a representation of the constant-expression. */
27667 static tree
27669 {
27670 /* Look for the `=' token. */
27674 /* It is invalid to write:
27676 struct S { static const int i = { 7 }; };
27678 */
27680 {
27683 /* Consume the opening brace. */
27684 matching_braces braces;
27686 /* Skip the initializer. */
27688 /* Look for the trailing `}'. */
27692 }
27695 }
27697 /* Derived classes [gram.class.derived] */
27699 /* Parse a base-clause.
27701 base-clause:
27702 : base-specifier-list
27704 base-specifier-list:
27705 base-specifier ... [opt]
27706 base-specifier-list , base-specifier ... [opt]
27708 Returns a TREE_LIST representing the base-classes, in the order in
27709 which they were declared. The representation of each node is as
27710 described by cp_parser_base_specifier.
27712 In the case that no bases are specified, this function will return
27713 NULL_TREE, not ERROR_MARK_NODE. */
27715 static tree
27717 {
27720 /* Look for the `:' that begins the list. */
27723 /* Scan the base-specifier-list. */
27725 {
27727 tree base;
27730 /* Look for the base-specifier. */
27732 /* Look for the (optional) ellipsis. */
27734 {
27735 /* Consume the `...'. */
27739 }
27741 /* Add BASE to the front of the list. */
27743 {
27745 /* Make this a pack expansion type. */
27749 {
27752 }
27753 }
27754 /* Peek at the next token. */
27756 /* If it's not a comma, then the list is complete. */
27759 /* Consume the `,'. */
27761 }
27763 /* PARSER->SCOPE may still be non-NULL at this point, if the last
27764 base class had a qualified name. However, the next name that
27765 appears is certainly not qualified. */
27771 }
27773 /* Parse a base-specifier.
27775 base-specifier:
27776 :: [opt] nested-name-specifier [opt] class-name
27777 virtual access-specifier [opt] :: [opt] nested-name-specifier
27778 [opt] class-name
27779 access-specifier virtual [opt] :: [opt] nested-name-specifier
27780 [opt] class-name
27782 Returns a TREE_LIST. The TREE_PURPOSE will be one of
27783 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
27784 indicate the specifiers provided. The TREE_VALUE will be a TYPE
27785 (or the ERROR_MARK_NODE) indicating the type that was specified. */
27787 static tree
27789 {
27797 tree type;
27799 /* Process the optional `virtual' and `access-specifier'. */
27801 {
27802 /* Peek at the next token. */
27804 /* Process `virtual'. */
27806 {
27808 /* If `virtual' appears more than once, issue an error. */
27810 {
27814 }
27818 /* Consume the `virtual' token. */
27826 /* If more than one access specifier appears, issue an
27827 error. */
27830 {
27834 }
27838 /* Consume the access-specifier. */
27846 }
27847 }
27848 /* It is not uncommon to see programs mechanically, erroneously, use
27849 the 'typename' keyword to denote (dependent) qualified types
27850 as base classes. */
27852 {
27857 else
27859 "keyword %<typename%> not allowed in this context "
27862 }
27864 /* Look for the optional `::' operator. */
27866 /* Look for the nested-name-specifier. The simplest way to
27867 implement:
27869 [temp.res]
27871 The keyword `typename' is not permitted in a base-specifier or
27872 mem-initializer; in these contexts a qualified name that
27873 depends on a template-parameter is implicitly assumed to be a
27874 type name.
27876 is to pretend that we have seen the `typename' keyword at this
27877 point. */
27883 /* If the base class is given by a qualified name, assume that names
27884 we see are type names or templates, as appropriate. */
27890 /* DR 950 allows decltype as a base-specifier. */
27892 else
27893 {
27894 /* Otherwise, look for the class-name. */
27896 class_scope_p,
27897 template_p,
27898 typename_type,
27903 }
27909 }
27911 /* Exception handling [gram.exception] */
27913 /* Save the tokens that make up the noexcept-specifier for a member-function.
27914 Returns a DEFERRED_PARSE. */
27916 static tree
27918 {
27920 /* We want everything up to, including, the final ')'. */
27924 /* As with default arguments and NSDMIs, make use of DEFERRED_PARSE
27925 to carry the information we will need. */
27927 /* Save away the noexcept-specifier; we will process it when the
27928 class is complete. */
27933 }
27935 /* Used for late processing of noexcept-specifiers of member-functions.
27936 DEFAULT_ARG is the unparsed operand of a noexcept-specifier which
27937 we saved for later; parse it now. DECL is the declaration of the
27938 member function. */
27940 static tree
27942 {
27943 /* Make sure we've gotten something that hasn't been parsed yet. */
27948 /* Push the saved tokens for the noexcept-specifier onto the parser's
27949 lexer stack. */
27953 /* Parse the cached noexcept-specifier. */
27954 tree parsed_arg
27956 CP_PARSER_FLAGS_NONE,
27961 /* Revert to the main lexer. */
27964 /* Restore the queue. */
27967 /* And we're done. */
27969 }
27971 /* Perform late checking of overriding function with respect to their
27972 noexcept-specifiers. TYPE is the class and FNDECL is the function
27973 that potentially overrides some virtual function with the same
27974 signature. */
27976 static void
27978 {
27980 tree base_binfo;
27986 {
27995 }
27996 }
27998 /* Parse an (optional) noexcept-specification.
28000 noexcept-specification:
28001 noexcept ( constant-expression ) [opt]
28003 If no noexcept-specification is present, returns NULL_TREE.
28004 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
28005 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
28006 there are no parentheses. CONSUMED_EXPR will be set accordingly.
28007 Otherwise, returns a noexcept specification unless RETURN_COND is true,
28008 in which case a boolean condition is returned instead. The parser flags
28009 FLAGS is used to control parsing. QUALS are qualifiers indicating whether
28010 the (member) function is `const'. */
28012 static tree
28014 cp_parser_flags flags,
28018 {
28022 /* Peek at the next token. */
28025 /* Is it a noexcept-specification? */
28027 {
28028 tree expr;
28030 /* [class.mem]/6 says that a noexcept-specifer (within the
28031 member-specification of the class) is a complete-class context of
28032 a class. So, if the noexcept-specifier has the optional expression,
28033 just save the tokens, and reparse this after we're done with the
28034 class. */
28038 /* No need to delay parsing for a number literal or true/false. */
28050 {
28051 matching_parens parens;
28055 {
28056 /* Types may not be defined in an exception-specification. */
28058 parser->type_definition_forbidden_message
28062 expr
28068 {
28071 }
28073 /* Restore the saved message. */
28075 }
28076 else
28077 {
28080 }
28083 }
28084 else
28085 {
28089 }
28091 /* We cannot build a noexcept-spec right away because this will check
28092 that expr is a constexpr. */
28095 else
28097 }
28098 else
28100 }
28102 /* Parse an (optional) exception-specification.
28104 exception-specification:
28105 throw ( type-id-list [opt] )
28107 Returns a TREE_LIST representing the exception-specification. The
28108 TREE_VALUE of each node is a type. The parser flags FLAGS is used to
28109 control parsing. QUALS are qualifiers indicating whether the (member)
28110 function is `const'. */
28112 static tree
28114 cp_parser_flags flags)
28115 {
28117 tree type_id_list;
28120 /* Peek at the next token. */
28123 /* Is it a noexcept-specification? */
28124 type_id_list
28132 /* If it's not `throw', then there's no exception-specification. */
28138 /* Consume the `throw'. */
28141 /* Look for the `('. */
28142 matching_parens parens;
28145 /* Peek at the next token. */
28147 /* If it's not a `)', then there is a type-id-list. */
28149 {
28150 /* Types may not be defined in an exception-specification. */
28152 parser->type_definition_forbidden_message
28154 /* Parse the type-id-list. */
28156 /* Restore the saved message. */
28160 {
28164 }
28167 "dynamic exception specifications are deprecated in "
28169 }
28170 /* In C++17, throw() is equivalent to noexcept (true). throw()
28171 is deprecated in C++11 and above as well, but is still widely used,
28172 so don't warn about it yet. */
28175 else
28178 /* Look for the `)'. */
28182 }
28184 /* Parse an (optional) type-id-list.
28186 type-id-list:
28187 type-id ... [opt]
28188 type-id-list , type-id ... [opt]
28190 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
28191 in the order that the types were presented. */
28193 static tree
28195 {
28199 {
28201 tree type;
28205 /* Get the next type-id. */
28207 /* Check for invalid 'auto'. */
28209 {
28213 }
28214 /* Parse the optional ellipsis. */
28216 {
28217 /* Consume the `...'. */
28220 /* Turn the type into a pack expansion expression. */
28222 }
28223 /* Add it to the list. */
28225 /* Peek at the next token. */
28227 /* If it is not a `,', we are done. */
28230 /* Consume the `,'. */
28232 }
28235 }
28237 /* Parse a try-block.
28239 try-block:
28240 try compound-statement handler-seq */
28242 static tree
28244 {
28245 tree try_block;
28252 "%<try%> in %<constexpr%> function only "
28262 }
28264 /* Parse a function-try-block.
28266 function-try-block:
28267 try ctor-initializer [opt] function-body handler-seq */
28269 static void
28271 {
28272 tree compound_stmt;
28273 tree try_block;
28275 /* Look for the `try' keyword. */
28278 /* Let the rest of the front end know where we are. */
28280 /* Parse the function-body. */
28281 cp_parser_ctor_initializer_opt_and_function_body
28283 /* We're done with the `try' part. */
28285 /* Parse the handlers. */
28287 /* We're done with the handlers. */
28289 }
28291 /* Parse a handler-seq.
28293 handler-seq:
28294 handler handler-seq [opt] */
28296 static void
28298 {
28300 {
28303 /* Parse the handler. */
28305 /* Peek at the next token. */
28307 /* If it's not `catch' then there are no more handlers. */
28310 }
28311 }
28313 /* Parse a handler.
28315 handler:
28316 catch ( exception-declaration ) compound-statement */
28318 static void
28320 {
28321 tree handler;
28322 tree declaration;
28326 matching_parens parens;
28333 }
28335 /* Parse an exception-declaration.
28337 exception-declaration:
28338 type-specifier-seq declarator
28339 type-specifier-seq abstract-declarator
28340 type-specifier-seq
28341 ...
28343 Returns a VAR_DECL for the declaration, or NULL_TREE if the
28344 ellipsis variant is used. */
28346 static tree
28348 {
28349 cp_decl_specifier_seq type_specifiers;
28353 /* If it's an ellipsis, it's easy to handle. */
28355 {
28356 /* Consume the `...' token. */
28359 }
28361 /* Types may not be defined in exception-declarations. */
28363 parser->type_definition_forbidden_message
28366 /* Parse the type-specifier-seq. */
28371 /* If it's a `)', then there is no declarator. */
28374 else
28376 CP_PARSER_FLAGS_NONE,
28383 /* Restore the saved message. */
28390 }
28392 /* Parse a throw-expression.
28394 throw-expression:
28395 throw assignment-expression [opt]
28397 Returns a THROW_EXPR representing the throw-expression. */
28399 static tree
28401 {
28402 tree expression;
28408 /* Figure out whether or not there is an assignment-expression
28409 following the "throw" keyword. */
28417 else
28420 /* Construct a location e.g.:
28421 throw x
28422 ^~~~~~~
28423 with caret == start at the start of the "throw" token, and
28424 the end at the end of the final token we consumed. */
28430 }
28432 /* Parse a yield-expression.
28434 yield-expression:
28435 co_yield assignment-expression
28436 co_yield braced-init-list
28438 Returns a CO_YIELD_EXPR representing the yield-expression. */
28440 static tree
28442 {
28443 tree expr;
28451 {
28454 /* ??? : probably a moot point? */
28457 }
28458 else
28465 }
28467 /* GNU Extensions */
28469 /* Parse an (optional) asm-specification.
28471 asm-specification:
28472 asm ( string-literal )
28474 If the asm-specification is present, returns a STRING_CST
28475 corresponding to the string-literal. Otherwise, returns
28476 NULL_TREE. */
28478 static tree
28480 {
28482 tree asm_specification;
28484 /* Peek at the next token. */
28486 /* If the next token isn't the `asm' keyword, then there's no
28487 asm-specification. */
28491 /* Consume the `asm' token. */
28493 /* Look for the `('. */
28494 matching_parens parens;
28497 /* Look for the string-literal. */
28500 /* Look for the `)'. */
28504 }
28506 /* Parse an asm-operand-list.
28508 asm-operand-list:
28509 asm-operand
28510 asm-operand-list , asm-operand
28512 asm-operand:
28513 string-literal ( expression )
28514 [ string-literal ] string-literal ( expression )
28516 Returns a TREE_LIST representing the operands. The TREE_VALUE of
28517 each node is the expression. The TREE_PURPOSE is itself a
28518 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
28519 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
28520 is a STRING_CST for the string literal before the parenthesis. Returns
28521 ERROR_MARK_NODE if any of the operands are invalid. */
28523 static tree
28525 {
28530 {
28531 tree string_literal;
28532 tree expression;
28533 tree name;
28536 {
28537 /* Consume the `[' token. */
28539 /* Read the operand name. */
28544 /* Look for the closing `]'. */
28546 }
28547 else
28549 /* Look for the string-literal. */
28552 /* Look for the `('. */
28553 matching_parens parens;
28555 /* Parse the expression. */
28557 /* Look for the `)'. */
28565 /* Add this operand to the list. */
28567 expression,
28568 asm_operands);
28569 /* If the next token is not a `,', there are no more
28570 operands. */
28573 /* Consume the `,'. */
28575 }
28578 }
28580 /* Parse an asm-clobber-list.
28582 asm-clobber-list:
28583 string-literal
28584 asm-clobber-list , string-literal
28586 Returns a TREE_LIST, indicating the clobbers in the order that they
28587 appeared. The TREE_VALUE of each node is a STRING_CST. */
28589 static tree
28591 {
28595 {
28596 tree string_literal;
28598 /* Look for the string literal. */
28600 /* Add it to the list. */
28602 /* If the next token is not a `,', then the list is
28603 complete. */
28606 /* Consume the `,' token. */
28608 }
28611 }
28613 /* Parse an asm-label-list.
28615 asm-label-list:
28616 identifier
28617 asm-label-list , identifier
28619 Returns a TREE_LIST, indicating the labels in the order that they
28620 appeared. The TREE_VALUE of each node is a label. */
28622 static tree
28624 {
28628 {
28631 /* Look for the identifier. */
28634 {
28637 {
28643 }
28644 }
28645 /* If the next token is not a `,', then the list is
28646 complete. */
28649 /* Consume the `,' token. */
28651 }
28654 }
28656 /* Return TRUE iff the next tokens in the stream are possibly the
28657 beginning of a GNU extension attribute. */
28659 static bool
28661 {
28663 }
28665 /* Return TRUE iff the next tokens in the stream are possibly the
28666 beginning of a standard C++-11 attribute specifier. */
28668 static bool
28670 {
28672 }
28674 /* Return TRUE iff the next Nth tokens in the stream are possibly the
28675 beginning of a standard C++-11 attribute specifier. */
28677 static bool
28679 {
28687 }
28689 /* Return TRUE iff the next Nth tokens in the stream are possibly the
28690 beginning of a GNU extension attribute. */
28692 static bool
28694 {
28698 }
28700 /* Return true iff the next tokens can be the beginning of either a
28701 GNU attribute list, or a standard C++11 attribute sequence. */
28703 static bool
28705 {
28708 }
28710 /* Return true iff the next Nth tokens can be the beginning of either
28711 a GNU attribute list, or a standard C++11 attribute sequence. */
28713 static bool
28715 {
28718 }
28720 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
28721 of GNU attributes, or return NULL. */
28723 static tree
28725 {
28728 {
28733 else
28735 }
28737 }
28739 /* Parse an (optional) series of attributes.
28741 attributes:
28742 attributes attribute
28744 attribute:
28745 __attribute__ (( attribute-list [opt] ))
28747 The return value is as for cp_parser_gnu_attribute_list. */
28749 static tree
28751 {
28758 {
28760 tree attribute_list;
28763 /* Peek at the next token. */
28765 /* If it's not `__attribute__', then we're done. */
28769 /* Consume the `__attribute__' keyword. */
28771 /* Look for the two `(' tokens. */
28772 matching_parens outer_parens;
28775 matching_parens inner_parens;
28779 /* Peek at the next token. */
28782 /* Parse the attribute-list. */
28784 else
28785 /* If the next token is a `)', then there is no attribute
28786 list. */
28789 /* Look for the two `)' tokens. */
28797 /* Add these new attributes to the list. */
28799 }
28802 }
28804 /* Parse a GNU attribute-list.
28806 attribute-list:
28807 attribute
28808 attribute-list , attribute
28810 attribute:
28811 identifier
28812 identifier ( identifier )
28813 identifier ( identifier , expression-list )
28814 identifier ( expression-list )
28816 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
28817 to an attribute. The TREE_PURPOSE of each node is the identifier
28818 indicating which attribute is in use. The TREE_VALUE represents
28819 the arguments, if any. */
28821 static tree
28823 {
28827 /* Don't create wrapper nodes within attributes: the
28828 handlers don't know how to handle them. */
28829 auto_suppress_location_wrappers sentinel;
28833 {
28835 tree identifier;
28836 tree attribute;
28838 /* Look for the identifier. We also allow keywords here; for
28839 example `__attribute__ ((const))' is legal. */
28843 {
28846 /* Consume the token, but save it since we need it for the
28847 SIMD enabled function parsing. */
28850 /* Save away the identifier that indicates which attribute
28851 this is. */
28853 /* For keywords, use the canonical spelling, not the
28854 parsed identifier. */
28861 /* Peek at the next token. */
28863 /* If it's an `(', then parse the attribute arguments. */
28865 {
28871 vec = cp_parser_parenthesized_expression_list
28877 else
28878 {
28881 }
28882 /* Save the arguments away. */
28884 }
28887 {
28888 /* Add this attribute to the list. */
28891 }
28894 }
28895 /* Unless EXACTLY_ONE is set look for more attributes.
28896 If the next token isn't a `,', we're done. */
28900 /* Consume the comma and keep going. */
28902 }
28905 /* We built up the list in reverse order. */
28907 }
28909 /* Parse arguments of omp::directive attribute.
28911 ( directive-name ,[opt] clause-list[opt] )
28913 For directive just remember the first/last tokens for subsequent
28914 parsing. */
28916 static void
28918 {
28921 {
28927 }
28930 {
28936 }
28945 }
28947 /* Parse arguments of omp::sequence attribute.
28949 ( omp::[opt] directive-attr [ , omp::[opt] directive-attr ]... ) */
28951 static void
28953 {
28954 matching_parens parens;
28956 do
28957 {
28962 {
28966 }
28971 else
28976 {
28985 }
28989 UNKNOWN_LOCATION);
28992 else
28997 }
29002 }
29004 /* Parse a standard C++11 attribute.
29006 The returned representation is a TREE_LIST which TREE_PURPOSE is
29007 the scoped name of the attribute, and the TREE_VALUE is its
29008 arguments list.
29010 Note that the scoped name of the attribute is itself a TREE_LIST
29011 which TREE_PURPOSE is the namespace of the attribute, and
29012 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
29013 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
29014 and which TREE_PURPOSE is directly the attribute name.
29016 Clients of the attribute code should use get_attribute_namespace
29017 and get_attribute_name to get the actual namespace and name of
29018 attributes, regardless of their being GNU or C++11 attributes.
29020 attribute:
29021 attribute-token attribute-argument-clause [opt]
29023 attribute-token:
29024 identifier
29025 attribute-scoped-token
29027 attribute-scoped-token:
29028 attribute-namespace :: identifier
29030 attribute-namespace:
29031 identifier
29033 attribute-argument-clause:
29034 ( balanced-token-seq )
29036 balanced-token-seq:
29037 balanced-token [opt]
29038 balanced-token-seq balanced-token
29040 balanced-token:
29041 ( balanced-token-seq )
29042 [ balanced-token-seq ]
29043 { balanced-token-seq }. */
29045 static tree
29047 {
29054 /* First, parse name of the attribute, a.k.a attribute-token. */
29071 {
29072 /* We are seeing a scoped attribute token. */
29087 else
29088 {
29092 }
29098 NULL_TREE);
29100 }
29102 {
29106 NULL_TREE);
29107 }
29108 else
29109 {
29112 NULL_TREE);
29114 /* We used to treat C++11 noreturn attribute as equivalent to GNU's,
29115 but no longer: we have to be able to tell [[noreturn]] and
29116 __attribute__((noreturn)) apart. */
29117 /* C++14 deprecated attribute is equivalent to GNU's. */
29120 /* C++17 fallthrough attribute is equivalent to GNU's. */
29123 /* C++23 assume attribute is equivalent to GNU's. */
29126 /* Transactional Memory TS optimize_for_synchronized attribute is
29127 equivalent to GNU transaction_callable. */
29131 /* Transactional Memory attributes are GNU attributes. */
29134 }
29136 /* Now parse the optional argument clause of the attribute. */
29139 {
29144 {
29146 attr_id);
29148 }
29150 }
29152 {
29156 /* Maybe we don't expect to see any arguments for this attribute. */
29160 {
29162 attr_id);
29168 }
29172 /* The assume attribute needs special handling of the argument. */
29176 /* A GNU attribute that takes an identifier in parameter. */
29179 /* If this is a fake attribute created to handle -Wno-attributes,
29180 we must skip parsing the arguments. */
29182 {
29184 {
29186 {
29189 }
29191 {
29197 }
29198 }
29200 /* For unknown attributes, just skip balanced tokens instead of
29201 trying to parse the arguments. */
29205 }
29207 vec = cp_parser_parenthesized_expression_list
29213 else
29214 {
29216 /* e.g. [[attr()]]. */
29219 attr_id);
29222 }
29226 else
29228 }
29231 }
29233 /* Warn if the attribute ATTRIBUTE appears more than once in the
29234 attribute-list ATTRIBUTES. This used to be enforced for certain
29235 attributes, but the restriction was removed in P2156. Note that
29236 carries_dependency ([dcl.attr.depend]) isn't implemented yet in GCC.
29237 LOC is the location of ATTRIBUTE. Returns true if ATTRIBUTE was not
29238 found in ATTRIBUTES. */
29240 static bool
29242 {
29251 {
29256 }
29258 }
29260 /* Parse a list of standard C++-11 attributes.
29262 attribute-list:
29263 attribute [opt]
29264 attribute-list , attribute[opt]
29265 attribute ...
29266 attribute-list , attribute ...
29267 */
29269 static tree
29271 {
29276 {
29282 {
29284 {
29287 }
29288 }
29291 {
29296 else
29297 {
29302 }
29304 }
29308 }
29311 }
29313 /* Parse a standard C++-11 attribute specifier.
29315 attribute-specifier:
29316 [ [ attribute-using-prefix [opt] attribute-list ] ]
29317 alignment-specifier
29319 attribute-using-prefix:
29320 using attribute-namespace :
29322 alignment-specifier:
29323 alignas ( type-id ... [opt] )
29324 alignas ( alignment-expression ... [opt] ). */
29326 static tree
29328 {
29334 {
29341 {
29352 {
29355 "attribute using prefix only available "
29361 }
29362 else
29364 }
29371 else
29372 /* Warn about parsing c++11 attribute in non-c++11 mode, only
29373 when we are sure that we have actually parsed them. */
29375 }
29376 else
29377 {
29378 tree alignas_expr;
29380 /* Look for an alignment-specifier. */
29391 matching_parens parens;
29399 {
29406 }
29411 /* Handle alignas (pack...). */
29413 {
29416 }
29418 /* Something went wrong, so don't build the attribute. */
29422 /* Missing ')' means the code cannot possibly be valid; go ahead
29423 and commit to make sure we issue a hard error. */
29431 /* Build the C++-11 representation of an 'aligned'
29432 attribute. */
29433 attributes
29436 }
29439 }
29441 /* Parse a standard C++-11 attribute-specifier-seq.
29443 attribute-specifier-seq:
29444 attribute-specifier-seq [opt] attribute-specifier */
29446 static tree
29448 {
29452 /* Don't create wrapper nodes within attributes: the
29453 handlers don't know how to handle them. */
29454 auto_suppress_location_wrappers sentinel;
29457 {
29466 else
29469 }
29472 }
29474 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
29475 return index of the first token after balanced-token, or N on failure. */
29477 static size_t
29479 {
29482 do
29484 {
29488 /* FALLTHRU */
29490 /* Ran out of tokens. */
29512 }
29515 }
29517 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
29518 return index of the first token after the GNU attribute tokens, or N on
29519 failure. */
29521 static size_t
29523 {
29525 {
29537 }
29539 }
29541 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
29542 next token), return index of the first token after the standard C++11
29543 attribute tokens, or N on failure. */
29545 static size_t
29547 {
29549 {
29552 {
29559 }
29562 {
29567 }
29568 else
29570 }
29572 }
29574 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
29575 as the next token), return index of the first token after the attribute
29576 tokens, or N on failure. */
29578 static size_t
29580 {
29584 }
29586 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
29587 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
29588 current value of the PEDANTIC flag, regardless of whether or not
29589 the `__extension__' keyword is present. The caller is responsible
29590 for restoring the value of the PEDANTIC flag. */
29592 static bool
29594 {
29595 /* Save the old value of the PEDANTIC flag. */
29599 {
29600 /* Consume the `__extension__' token. */
29602 /* We're not being pedantic while the `__extension__' keyword is
29603 in effect. */
29607 }
29610 }
29612 /* Parse a label declaration.
29614 label-declaration:
29615 __label__ label-declarator-seq ;
29617 label-declarator-seq:
29618 identifier , label-declarator-seq
29619 identifier */
29621 static void
29623 {
29624 /* Look for the `__label__' keyword. */
29628 {
29629 tree identifier;
29631 /* Look for an identifier. */
29633 /* If we failed, stop. */
29636 /* Declare it as a label. */
29638 /* If the next token is a `;', stop. */
29641 /* Look for the `,' separating the label declarations. */
29643 }
29645 /* Look for the final `;'. */
29647 }
29649 // -------------------------------------------------------------------------- //
29650 // Concept definitions
29652 static tree
29654 {
29655 /* A concept definition is an unevaluated context. */
29656 cp_unevaluated u;
29663 {
29667 }
29670 {
29674 }
29676 processing_constraint_expression_sentinel parsing_constraint;
29681 /* Consume the trailing ';'. Diagnose the problem if it isn't there,
29682 but continue as if it were. */
29686 }
29688 // -------------------------------------------------------------------------- //
29689 // Requires Clause
29691 /* Diagnose an expression that should appear in ()'s within a requires-clause
29692 and suggest where to place those parentheses. */
29694 static void
29696 {
29698 }
29700 static void
29702 {
29707 }
29709 /* Characterizes the likely kind of expression intended by a mis-written
29710 primary constraint. */
29711 enum primary_constraint_error
29712 {
29713 pce_ok,
29714 pce_maybe_operator,
29715 pce_maybe_postfix
29716 };
29718 /* Returns true if the token(s) following a primary-expression in a
29719 constraint-logical-* expression would require parentheses. */
29721 static primary_constraint_error
29723 {
29726 {
29731 {
29732 /* An equal sign may be part of the definition of a function,
29733 and not an assignment operator, when parsing the expression
29734 for a trailing requires-clause. For example:
29736 template<typename T>
29737 struct S {
29738 S() requires C<T> = default;
29739 };
29741 Don't try to reparse this a binary operator. */
29747 }
29749 /* Arithmetic operators. */
29755 /* Bitwise operators. */
29761 /* Relational operators. */
29769 /* Pointer-to-member. */
29772 /* Assignment operators. */
29783 /* Conditional operator */
29785 /* Unenclosed binary or conditional operator. */
29789 {
29790 /* A primary constraint that precedes the parameter-list of a
29791 lambda expression is followed by an open paren.
29793 []<typename T> requires C (T a, T b) { ... }
29795 Don't try to re-parse this as a postfix expression. */
29800 }
29802 {
29803 /* A primary-constraint-expression followed by a '[[' is not a
29804 postfix expression. */
29809 }
29813 /* Unenclosed postfix operator. */
29817 /* A primary constraint that precedes the lambda-declarator of a
29818 lambda expression is followed by trailing return type.
29820 []<typename T> requires C -> void {}
29822 Don't try to re-parse this as a postfix expression in
29823 C++23 and later. In C++20 ( needs to come in between but we
29824 allow it to be omitted with pedwarn. */
29827 /* Unenclosed postfix operator. */
29829 }
29830 }
29832 /* Returns true if the next token begins a unary expression, preceded by
29833 an operator or keyword. */
29835 static bool
29837 {
29840 {
29851 {
29853 {
29869 }
29870 }
29874 }
29877 }
29879 /* Parse a primary expression within a constraint. */
29881 static cp_expr
29883 {
29884 /* If this looks like a unary expression, parse it as such, but diagnose
29885 it as ill-formed; it requires parens. */
29887 {
29891 }
29894 cp_id_kind idk;
29905 {
29906 /* The primary-expression could be part of an unenclosed non-logical
29907 compound expression. */
29909 }
29911 {
29914 }
29916 /* Retry the parse at a lower precedence. If that succeeds, diagnose the
29917 error, but return the expression as if it were valid. */
29922 else
29925 {
29928 }
29930 /* Otherwise, something has gone very wrong, and we can't generate a more
29931 meaningful diagnostic or recover. */
29934 }
29936 /* Parse a constraint-logical-and-expression.
29938 constraint-logical-and-expression:
29939 primary-expression
29940 constraint-logical-and-expression '&&' primary-expression */
29942 static cp_expr
29944 {
29947 {
29951 }
29953 }
29955 /* Parse a constraint-logical-or-expression.
29957 constraint-logical-or-expression:
29958 constraint-logical-and-expression
29959 constraint-logical-or-expression '||' constraint-logical-and-expression */
29961 static cp_expr
29963 {
29966 {
29970 }
29972 }
29974 /* Parse the expression after a requires-clause. This has a different grammar
29975 than that in the concepts TS. */
29977 static tree
29979 {
29980 processing_constraint_expression_sentinel parsing_constraint;
29987 }
29989 /* Parse a expression after a requires clause.
29991 constraint-expression:
29992 logical-or-expression
29994 The required logical-or-expression must be a constant expression. Note
29995 that we don't check that the expression is constepxr here. We defer until
29996 we analyze constraints and then, we only check atomic constraints. */
29998 static tree
30000 {
30001 processing_constraint_expression_sentinel parsing_constraint;
30010 }
30012 /* Optionally parse a requires clause:
30014 requires-clause:
30015 `requires` constraint-logical-or-expression.
30016 [ConceptsTS]
30017 `requires constraint-expression.
30019 LAMBDA_P is true when the requires-clause is parsed before the
30020 parameter-list of a lambda-declarator. */
30022 static tree
30024 {
30025 /* A requires clause is an unevaluated context. */
30026 cp_unevaluated u;
30030 {
30033 {
30035 "%<requires%> only available with "
30037 /* Parse and discard the requires-clause. */
30040 }
30042 }
30046 {
30047 /* An opening brace following the start of a requires-clause is
30048 ill-formed; the user likely forgot the second `requires' that
30049 would start a requires-expression. */
30054 /* Don't consume the `requires', so that it's reused as the start of a
30055 requires-expression. */
30056 }
30057 else
30062 else
30064 }
30066 /*---------------------------------------------------------------------------
30067 Requires expressions
30068 ---------------------------------------------------------------------------*/
30070 /* Parse a requires expression
30072 requirement-expression:
30073 'requires' requirement-parameter-list [opt] requirement-body */
30075 static tree
30077 {
30081 /* Avoid committing to outer tentative parse. */
30084 /* This is definitely a requires-expression. */
30088 {
30089 /* Local parameters are delared as variables within the scope
30090 of the expression. They are not visible past the end of
30091 the expression. Expressions within the requires-expression
30092 are unevaluated. */
30093 struct scope_sentinel
30094 {
30096 {
30100 }
30103 {
30106 }
30109 /* Parse the optional parameter list. */
30111 {
30115 }
30116 else
30119 /* Parse the requirement body. */
30125 }
30127 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
30128 the parm chain. */
30133 {
30134 /* Perform semantic processing now to diagnose any invalid types and
30135 expressions. */
30140 }
30142 }
30144 /* Parse a parameterized requirement.
30146 requirement-parameter-list:
30147 '(' parameter-declaration-clause ')' */
30149 static tree
30151 {
30152 matching_parens parens;
30156 tree parms = (cp_parser_parameter_declaration_clause
30162 /* Modify the declared parameters by removing their context
30163 so they don't refer to the enclosing scope and explicitly
30164 indicating that they are constraint variables. */
30166 {
30171 {
30174 }
30175 }
30178 }
30180 /* Parse the body of a requirement.
30182 requirement-body:
30183 '{' requirement-list '}' */
30184 static tree
30186 {
30187 matching_braces braces;
30197 }
30199 /* Parse a sequence of requirements.
30201 requirement-seq:
30202 requirement
30203 requirement-seq requirement */
30205 static tree
30207 {
30209 do
30210 {
30214 }
30218 /* If there are no valid requirements, this is not a valid expression. */
30222 /* Reverse the order of requirements so they are analyzed in order. */
30224 }
30226 /* Parse a syntactic requirement or type requirement.
30228 requirement:
30229 simple-requirement
30230 compound-requirement
30231 type-requirement
30232 nested-requirement */
30234 static tree
30236 {
30243 else
30245 }
30247 /* Parse a simple requirement.
30249 simple-requirement:
30250 expression ';' */
30252 static tree
30254 {
30265 /* Sometimes we don't get locations, so use the cached token location
30266 as a reasonable approximation. */
30271 {
30274 {
30277 }
30279 {
30283 "if a concept-id is a valid expression; add "
30285 }
30287 }
30290 }
30292 /* Parse a type requirement
30294 type-requirement
30295 nested-name-specifier [opt] required-type-name ';'
30297 required-type-name:
30298 type-name
30299 'template' [opt] simple-template-id */
30301 static tree
30303 {
30307 // Save the scope before parsing name specifiers.
30318 tree type;
30320 {
30329 }
30330 else
30350 }
30352 /* Parse a compound requirement
30354 compound-requirement:
30355 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
30357 static tree
30359 {
30360 /* Parse an expression enclosed in '{ }'s. */
30361 matching_braces braces;
30372 {
30376 }
30378 /* If the expression was invalid, skip the remainder of the requirement. */
30380 {
30384 }
30386 /* Parse the optional noexcept. */
30389 {
30392 }
30394 /* Parse the optional trailing return type. */
30397 {
30403 /* C++20 allows either a type-id or a type-constraint. Parsing
30404 a type-id will subsume the parsing for a type-constraint but
30405 allow for more syntactic forms (e.g., const C<T>*). */
30414 /* Check that we haven't written something like 'const C<T>*'. */
30416 {
30418 {
30423 }
30424 }
30426 /* P1452R2 removed the trailing-return-type option. */
30429 }
30441 }
30443 /* Parse a nested requirement. This is the same as a requires clause.
30445 nested-requirement:
30446 requires-clause */
30448 static tree
30450 {
30462 }
30464 /* Support Functions */
30466 /* Return the appropriate prefer_type argument for lookup_name based on
30467 tag_type. */
30471 {
30473 {
30477 }
30478 }
30480 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
30481 NAME should have one of the representations used for an
30482 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
30483 is returned. If PARSER->SCOPE is a dependent type, then a
30484 SCOPE_REF is returned.
30486 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
30487 returned; the name was already resolved when the TEMPLATE_ID_EXPR
30488 was formed. Abstractly, such entities should not be passed to this
30489 function, because they do not need to be looked up, but it is
30490 simpler to check for this special case here, rather than at the
30491 call-sites.
30493 In cases not explicitly covered above, this function returns a
30494 DECL, OVERLOAD, or baselink representing the result of the lookup.
30495 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
30496 is returned.
30498 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
30499 (e.g., "struct") that was used. In that case bindings that do not
30500 refer to types are ignored.
30502 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
30503 ignored.
30505 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
30506 are ignored.
30508 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
30509 types.
30511 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
30512 TREE_LIST of candidates if name-lookup results in an ambiguity, and
30513 NULL_TREE otherwise. */
30515 static cp_expr
30522 location_t name_location)
30523 {
30524 tree decl;
30527 /* Assume that the lookup will be unambiguous. */
30531 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
30532 no longer valid. Note that if we are parsing tentatively, and
30533 the parse fails, OBJECT_TYPE will be automatically restored. */
30539 /* A template-id has already been resolved; there is no lookup to
30540 do. */
30544 {
30548 }
30550 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
30551 it should already have been checked to make sure that the name
30552 used matches the type being destroyed. */
30554 {
30555 tree type;
30557 /* Figure out to which type this destructor applies. */
30562 else
30564 /* If that's not a class type, there is no destructor. */
30568 /* In a non-static member function, check implicit this->. */
30571 tf_warning_or_error);
30580 }
30582 /* By this point, the NAME should be an ordinary identifier. If
30583 the id-expression was a qualified name, the qualifying scope is
30584 stored in PARSER->SCOPE at this point. */
30587 /* Perform the lookup. */
30589 {
30595 /* If the SCOPE is dependent, the lookup must be deferred until
30596 the template is instantiated -- unless we are explicitly
30597 looking up names in uninstantiated templates. Even then, we
30598 cannot look up the name if the scope is not a class type; it
30599 might, for example, be a template type parameter. */
30604 /* Defer lookup. */
30606 else
30607 {
30610 /* If PARSER->SCOPE is a dependent type, then it must be a
30611 class type, and we must not be checking dependencies;
30612 otherwise, we would have processed this lookup above. So
30613 that PARSER->SCOPE is not considered a dependent base by
30614 lookup_member, we must enter the scope here. */
30618 /* If the PARSER->SCOPE is a template specialization, it
30619 may be instantiated during name lookup. In that case,
30620 errors may be issued. Even if we rollback the current
30621 tentative parse, those errors are valid. */
30626 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
30627 lookup result and the nested-name-specifier nominates a class C:
30628 * if the name specified after the nested-name-specifier, when
30629 looked up in C, is the injected-class-name of C (Clause 9), or
30630 * if the name specified after the nested-name-specifier is the
30631 same as the identifier or the simple-template-id's template-
30632 name in the last component of the nested-name-specifier,
30633 the name is instead considered to name the constructor of
30634 class C. [ Note: for example, the constructor is not an
30635 acceptable lookup result in an elaborated-type-specifier so
30636 the constructor would not be used in place of the
30637 injected-class-name. --end note ] Such a constructor name
30638 shall be used only in the declarator-id of a declaration that
30639 names a constructor or in a using-declaration. */
30649 }
30651 /* If the scope is a dependent type and either we deferred lookup or
30652 we did lookup but didn't find the name, rememeber the name. */
30655 {
30657 {
30658 tree type;
30660 /* The resolution to Core Issue 180 says that `struct
30661 A::B' should be considered a type-name, even if `A'
30662 is dependent. */
30667 }
30671 CPP_CLOSE_PAREN)))
30675 else
30678 is_template);
30679 }
30682 }
30684 {
30687 /* Look up the name in the scope of the OBJECT_TYPE, unless the
30688 OBJECT_TYPE is not a class. */
30690 /* If the OBJECT_TYPE is a template specialization, it may
30691 be instantiated during name lookup. In that case, errors
30692 may be issued. Even if we rollback the current tentative
30693 parse, those errors are valid. */
30695 name,
30698 tf_warning_or_error);
30699 else
30703 /* Look it up in the enclosing context. DR 141: When looking for a
30704 template-name after -> or ., only consider class templates. */
30706 /* DR 141: When looking in the
30707 current enclosing context for a
30708 template-name after -> or ., only
30709 consider class templates. */
30713 /* If we did unqualified lookup of a dependent member-qualified name and
30714 found something, do we want to use it? P1787 clarified that we need
30715 to look in the object scope first even if it's dependent, but for now
30716 let's still use it in some cases.
30717 FIXME remember unqualified lookup result to use if member lookup fails
30718 at instantiation time. */
30720 {
30722 /* Only use the unqualified class template lookup if we're actually
30723 looking at a template arg list. */
30726 }
30728 /* If we know we're looking for a type (e.g. A in p->A::x),
30729 mock up a typename. */
30732 {
30734 typename_type);
30736 }
30740 }
30741 else
30742 {
30747 }
30749 /* If the lookup failed, let our caller know. */
30753 /* If we have resolved the name of a member declaration, check to
30754 see if the declaration is accessible. When the name resolves to
30755 set of overloaded functions, accessibility is checked when
30756 overload resolution is done. If we have a TREE_LIST, then the lookup
30757 is either ambiguous or it found multiple injected-class-names, the
30758 accessibility of which is trivially satisfied.
30760 During an explicit instantiation, access is not checked at all,
30761 as per [temp.explicit]. */
30764 tf_warning_or_error);
30766 /* Pull out the template from an injected-class-name (or multiple). */
30770 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
30772 {
30775 /* The error message we have to print is too complicated for
30776 cp_parser_error, so we incorporate its actions directly. */
30778 {
30780 name);
30782 }
30784 }
30795 }
30797 /* Like cp_parser_lookup_name, but for use in the typical case where
30798 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
30799 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
30801 static tree
30803 {
30805 none_type,
30810 location);
30811 }
30813 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
30814 the current context, return the TYPE_DECL. If TAG_NAME_P is
30815 true, the DECL indicates the class being defined in a class-head,
30816 or declared in an elaborated-type-specifier.
30818 Otherwise, return DECL. */
30820 static tree
30822 {
30823 /* If the TEMPLATE_DECL is being declared as part of a class-head,
30824 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
30826 struct A {
30827 template <typename T> struct B;
30828 };
30830 template <typename T> struct A::B {};
30832 Similarly, in an elaborated-type-specifier:
30834 namespace N { struct X{}; }
30836 struct A {
30837 template <typename T> friend struct N::X;
30838 };
30840 However, if the DECL refers to a class type, and we are in
30841 the scope of the class, then the name lookup automatically
30842 finds the TYPE_DECL created by build_self_reference rather
30843 than a TEMPLATE_DECL. For example, in:
30845 template <class T> struct S {
30846 S s;
30847 };
30849 there is no need to handle such case. */
30855 }
30857 /* If too many, or too few, template-parameter lists apply to the
30858 declarator, issue an error message. Returns TRUE if all went well,
30859 and FALSE otherwise. */
30861 static bool
30864 location_t declarator_location)
30865 {
30867 {
30869 {
30878 {
30879 /* If the DECLARATOR has the form `X<y>' then it uses one
30880 additional level of template parameters. */
30883 }
30885 return cp_parser_check_template_parameters
30887 declarator);
30888 }
30904 }
30906 }
30908 /* NUM_TEMPLATES were used in the current declaration. If that is
30909 invalid, return FALSE and issue an error messages. Otherwise,
30910 return TRUE. If DECLARATOR is non-NULL, then we are checking a
30911 declarator and we can print more accurate diagnostics. */
30913 static bool
30917 location_t location,
30919 {
30920 /* If there are the same number of template classes and parameter
30921 lists, that's OK. */
30924 /* If there are more, but only one more, and the name ends in an identifier,
30925 then we are declaring a primary template. That's OK too. */
30933 /* If there are more template classes than parameter lists, we have
30934 something like:
30936 template <class T> void S<T>::R<T>::f (); */
30938 {
30948 else
30951 }
30952 /* Otherwise, there are too many template parameter lists. We have
30953 something like:
30955 template <class T> template <class U> void S::f(); */
30958 }
30960 /* Parse an optional `::' token indicating that the following name is
30961 from the global namespace. If so, PARSER->SCOPE is set to the
30962 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
30963 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
30964 Returns the new value of PARSER->SCOPE, if the `::' token is
30965 present, and NULL_TREE otherwise. */
30967 static tree
30969 {
30972 /* Peek at the next token. */
30974 /* If we're looking at a `::' token then we're starting from the
30975 global namespace, not our current location. */
30977 {
30978 /* Consume the `::' token. */
30980 /* Set the SCOPE so that we know where to start the lookup. */
30986 }
30988 {
30992 }
30995 }
30997 /* Returns TRUE if the upcoming token sequence is the start of a
30998 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
30999 declarator is preceded by the `friend' specifier. The parser flags FLAGS
31000 is used to control type-specifier parsing. */
31002 static bool
31005 {
31008 tree nested_name_specifier;
31011 /* The common case is that this is not a constructor declarator, so
31012 try to avoid doing lots of work if at all possible. It's not
31013 valid declare a constructor at function scope. */
31016 /* And only certain tokens can begin a constructor declarator. */
31021 /* DR 2237 (C++20 only): A simple-template-id is no longer valid as the
31022 declarator-id of a constructor or destructor. */
31026 /* Parse tentatively; we are going to roll back all of the tokens
31027 consumed here. */
31029 /* Assume that we are looking at a constructor declarator. */
31032 /* Look for the optional `::' operator. */
31035 /* Look for the nested-name-specifier. */
31036 nested_name_specifier
31043 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
31046 {
31051 }
31057 /* Outside of a class-specifier, there must be a
31058 nested-name-specifier. Except in C++17 mode, where we
31059 might be declaring a guiding declaration. */
31066 /* If we have a class scope, this is easy; DR 147 says that S::S always
31067 names the constructor, and no other qualified name could. */
31070 {
31080 }
31081 /* If we still think that this might be a constructor-declarator,
31082 look for a class-name. */
31084 {
31085 /* If we have:
31087 template <typename T> struct S {
31088 S();
31089 };
31091 we must recognize that the nested `S' names a class. */
31095 tree type_decl;
31099 none_type,
31106 {
31112 none_type,
31117 else
31119 }
31121 /* If there was no class-name, then this is not a constructor.
31122 Otherwise, if we are in a class-specifier and we aren't
31123 handling a friend declaration, check that its type matches
31124 current_class_type (c++/38313). Note: error_mark_node
31125 is left alone for error recovery purposes. */
31127 && (outside_class_specifier_p
31133 /* If we're still considering a constructor, we have to see a `(',
31134 to begin the parameter-declaration-clause, followed by either a
31135 `)', an `...', or a decl-specifier. We need to check for a
31136 type-specifier to avoid being fooled into thinking that:
31138 S (f) (int);
31140 is a constructor. (It is actually a function named `f' that
31141 takes one parameter (of type `int') and returns a value of type
31142 `S'. */
31150 /* A parameter declaration begins with a decl-specifier,
31151 which is either the "attribute" keyword, a storage class
31152 specifier, or (usually) a type-specifier. */
31154 /* GNU attributes can actually appear both at the start of
31155 a parameter and parenthesized declarator.
31156 S (__attribute__((unused)) int);
31157 is a constructor, but
31158 S (__attribute__((unused)) foo) (int);
31159 is a function declaration. [[attribute]] can appear in the
31160 first form too, but not in the second form. */
31162 {
31163 tree type;
31169 {
31173 }
31175 /* Names appearing in the type-specifier should be looked up
31176 in the scope of the class. */
31180 {
31183 {
31187 {
31190 }
31191 }
31193 }
31195 /* Inside the constructor parameter list, surrounding
31196 template-parameter-lists do not apply. */
31197 saved_num_template_parameter_lists
31201 /* Look for the type-specifier. It's not optional, but its typename
31202 might be. Unless this is a friend declaration; we don't want to
31203 treat
31205 friend S (T::fn)(int);
31207 as a constructor, but with P0634, we might assume a type when
31208 looking for the type-specifier. It is actually a function named
31209 `T::fn' that takes one parameter (of type `int') and returns a
31210 value of type `S'. Constructors can be friends, but they must
31211 use a qualified name.
31213 Parse with an empty set of declaration specifiers since we're
31214 trying to match a decl-specifier-seq of the first parameter.
31215 This must be non-null so that cp_parser_simple_type_specifier
31216 will recognize a constrained placeholder type such as:
31217 'C<int> auto' where C is a type concept. */
31218 cp_decl_specifier_seq ctor_specs;
31228 parser->num_template_parameter_lists
31231 /* Leave the scope of the class. */
31236 }
31237 }
31239 /* We did not really want to consume any tokens. */
31243 }
31245 /* Parse the definition of the function given by the DECL_SPECIFIERS,
31246 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
31247 they must be performed once we are in the scope of the function.
31249 Returns the function defined. */
31251 static tree
31252 cp_parser_function_definition_from_specifiers_and_declarator
31255 tree attributes,
31257 {
31258 tree fn;
31261 /* Begin the function-definition. */
31264 /* The things we're about to see are not directly qualified by any
31265 template headers we've seen thus far. */
31268 /* If there were names looked up in the decl-specifier-seq that we
31269 did not check, check them now. We must wait until we are in the
31270 scope of the function to perform the checks, since the function
31271 might be a friend. */
31275 {
31280 }
31283 {
31284 /* Skip the entire function. */
31287 }
31289 {
31290 /* Seen already, skip it. An error message has already been output. */
31294 /* If this is a function from a class, pop the nested class. */
31297 }
31298 else
31299 {
31304 }
31307 }
31309 /* Parse the part of a function-definition that follows the
31310 declarator. INLINE_P is TRUE iff this function is an inline
31311 function defined within a class-specifier.
31313 Returns the function defined. */
31315 static tree
31318 {
31319 tree fn;
31324 bool fully_implicit_function_template_p
31327 tree implicit_template_parms
31330 cp_binding_level* implicit_template_scope
31336 /* If the next token is `return', then the code may be trying to
31337 make use of the "named return value" extension that G++ used to
31338 support. */
31341 {
31342 /* Consume the `return' keyword. */
31344 /* Look for the identifier that indicates what value is to be
31345 returned. */
31347 /* Issue an error message. */
31350 /* Skip tokens until we reach the start of the function body. */
31352 {
31359 }
31360 }
31361 /* The `extern' in `extern "C" void f () { ... }' does not apply to
31362 anything declared inside `f'. */
31363 saved_in_unbraced_linkage_specification_p
31366 /* Inside the function, surrounding template-parameter-lists do not
31367 apply. */
31368 saved_num_template_parameter_lists
31372 /* If the next token is `try', `__transaction_atomic', or
31373 `__transaction_relaxed`, then we are looking at either function-try-block
31374 or function-transaction-block. Note that all of these include the
31375 function-body. */
31379 RID_TRANSACTION_RELAXED))
31383 else
31384 cp_parser_ctor_initializer_opt_and_function_body
31387 /* Finish the function. */
31391 && !inline_p
31397 /* Generate code for it, if necessary. */
31400 /* Restore the saved values. */
31401 parser->in_unbraced_linkage_specification_p
31403 parser->num_template_parameter_lists
31407 parser->fully_implicit_function_template_p
31409 parser->implicit_template_parms
31411 parser->implicit_template_scope
31418 }
31420 /* Parse a template-declaration body (following argument list). */
31422 static void
31424 tree parameter_list,
31426 {
31430 /* We just processed one more parameter list. */
31433 /* Get the deferred access checks from the parameter list. These
31434 will be checked once we know what is being declared, as for a
31435 member template the checks must be performed in the scope of the
31436 class containing the member. */
31439 /* Tentatively parse for a new template parameter list, which can either be
31440 the template keyword or a template introduction. */
31449 /* Allow 'concept bool' to be handled as per the TS. */
31451 else
31452 {
31455 checks,
31456 member_p,
31460 /* If this is a member template declaration, let the front
31461 end know. */
31463 {
31468 }
31473 }
31474 /* We are done with the current parameter list. */
31479 /* Finish up. */
31482 /* Check the template arguments for a literal operator template. */
31486 {
31490 else
31491 {
31494 {
31501 /* OK, C++20 string literal operator template. We don't need
31502 to warn in lower dialects here because we will have already
31507 }
31509 {
31518 else
31519 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
31521 "ISO C++ did not adopt string literal operator templa"
31523 }
31524 else
31526 }
31528 {
31531 "template %qD has invalid parameter list; expected "
31532 "non-type template parameter pack %<<char...>%> or "
31534 decl);
31535 else
31537 "template %qD has invalid parameter list; expected "
31539 decl);
31540 }
31541 }
31543 /* Register member declarations. */
31546 /* If DECL is a function template, we must return to parse it later.
31547 (Even though there is no definition, there might be default
31548 arguments that need handling.) */
31552 }
31554 /* Parse a template introduction header for a template-declaration. Returns
31555 false if tentative parse fails. */
31557 static bool
31559 {
31569 /* In classes don't parse valid unnamed bitfields as invalid
31570 template introductions. */
31574 /* Look for the optional `::' operator. */
31577 /* Look for the nested-name-specifier. */
31587 /* Look up the concept for which we will be matching
31588 template parameters. */
31600 /* Look for opening brace for introduction. */
31601 matching_braces braces;
31610 /* Build vector of placeholder parameters and grab
31611 matching identifiers. */
31614 /* Look for closing brace for introduction. */
31618 /* The introduction-list shall not be empty. */
31621 {
31622 /* In cp_parser_introduction_list we have already issued an error. */
31624 }
31627 {
31631 }
31633 /* Build and associate the constraint. */
31638 introduction_list,
31639 introduction_loc);
31641 {
31648 member_p);
31650 }
31656 }
31658 /* Parse a normal template-declaration following the template keyword. */
31660 static void
31662 {
31663 tree parameter_list;
31667 /* Look for the `<' token. */
31671 {
31672 /* 14.5.2.2 [temp.mem]
31674 A local class shall not have member templates. */
31679 }
31680 /* [temp]
31682 A template ... shall not have C linkage. */
31684 {
31687 /* Give it C++ linkage to avoid confusing other parts of the
31688 front end. */
31691 }
31692 else
31695 /* We cannot perform access checks on the template parameter
31696 declarations until we know what is being declared, just as we
31697 cannot check the decl-specifier list. */
31700 /* If the next token is `>', then we have an invalid
31701 specialization. Rather than complain about an invalid template
31702 parameter, issue an error message here. */
31704 {
31708 }
31709 else
31710 {
31711 /* Parse the template parameters. */
31713 }
31715 /* Look for the `>'. */
31718 /* Manage template requirements */
31720 {
31725 }
31728 member_p);
31730 /* For the erroneous case of a template with C linkage, we pushed an
31731 implicit C++ linkage scope; exit that scope now. */
31734 }
31736 /* Parse a template-declaration, assuming that the `export' (and
31737 `extern') keywords, if present, has already been scanned. MEMBER_P
31738 is as for cp_parser_template_declaration. */
31740 static bool
31742 {
31744 {
31748 }
31753 }
31755 /* Perform the deferred access checks from a template-parameter-list.
31756 CHECKS is a TREE_LIST of access checks, as returned by
31757 get_deferred_access_checks. */
31759 static void
31760 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
31761 {
31765 }
31767 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
31768 `function-definition' sequence that follows a template header.
31769 If MEMBER_P is true, this declaration appears in a class scope.
31771 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
31772 *FRIEND_P is set to TRUE iff the declaration is a friend. */
31774 static tree
31780 {
31783 cp_decl_specifier_seq decl_specifiers;
31787 /* This function is only used when processing a template
31788 declaration. */
31792 /* Defer access checks until we know what is being declared. */
31795 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
31796 alternative. */
31799 (CP_PARSER_FLAGS_OPTIONAL
31804 cp_omp_declare_simd_data odsd;
31813 /* There are no template typedefs. */
31815 {
31819 }
31821 /* Gather up the access checks that occurred the
31822 decl-specifier-seq. */
31825 /* Check for the declaration of a template class. */
31827 {
31830 {
31833 /* In this case:
31835 struct C {
31836 friend template <typename T> struct A<T>::B;
31837 };
31839 A<T>::B will be represented by a TYPENAME_TYPE, and
31840 therefore not recognized by shadow_tag. */
31842 && !decl
31849 else
31852 /* If this is a declaration, but not a definition, associate
31853 any constraints with the type declaration. Constraints
31854 are associated with definitions in cp_parser_class_specifier. */
31858 /* Perform access checks for template parameters. */
31861 /* Give a helpful diagnostic for
31862 template <class T> struct A { } a;
31863 if we aren't already recovering from an error. */
31866 {
31868 "a class template declaration must not declare "
31872 }
31873 }
31874 }
31876 /* Complain about missing 'typename' or other invalid type names. */
31879 {
31880 /* cp_parser_parse_and_diagnose_invalid_type_name calls
31881 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
31882 the rest of this declaration. */
31885 }
31887 /* If it's not a template class, try for a template function. If
31888 the next token is a `;', then this declaration does not declare
31889 anything. But, if there were errors in the decl-specifiers, then
31890 the error might well have come from an attempted class-specifier.
31891 In that case, there's no need to warn about a missing declarator. */
31895 {
31897 /* We don't delay parsing for friends, though CWG 2510 may change
31898 that. */
31902 flags,
31904 checks,
31906 member_p,
31907 declares_class_or_enum,
31911 /* 7.1.1-1 [dcl.stc]
31913 A storage-class-specifier shall not be specified in an explicit
31914 specialization... */
31916 && explicit_specialization_p
31918 {
31922 }
31926 }
31928 /* Look for a trailing `;' after the declaration. */
31934 out:
31937 /* Clear any current qualification; whatever comes next is the start
31938 of something new. */
31946 }
31948 /* Parse a cast-expression that is not the operand of a unary "&". */
31950 static cp_expr
31952 {
31955 }
31957 /* Parse a functional cast to TYPE. Returns an expression
31958 representing the cast. */
31960 static cp_expr
31962 {
31964 tree expression_list;
31965 cp_expr cast;
31974 {
31984 /* Create a location of the form:
31985 type_name{i, f}
31986 ^~~~~~~~~~~~~~~
31987 with caret == start at the start of the type name,
31988 finishing at the closing brace. */
31993 }
32002 else
32003 {
32006 }
32008 /* Create a location of the form:
32009 float(i)
32010 ^~~~~~~~
32011 with caret == start at the start of the type name,
32012 finishing at the closing paren. */
32016 tf_warning_or_error);
32018 /* [expr.const]/1: In an integral constant expression "only type
32019 conversions to integral or enumeration type can be used". */
32025 NIC_CONSTRUCTOR))
32029 }
32031 /* Save the tokens that make up the body of a member function defined
32032 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
32033 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
32034 specifiers applied to the declaration. Returns the FUNCTION_DECL
32035 for the member function. */
32037 static tree
32041 tree attributes)
32042 {
32045 tree fn;
32048 /* Create the FUNCTION_DECL. */
32052 /* If something went badly wrong, bail out now. */
32054 {
32055 /* If there's a function-body, skip it. */
32060 }
32062 /* Remember it, if there are default args to post process. */
32065 /* Save away the tokens that make up the body of the
32066 function. */
32072 RID_TRANSACTION_ATOMIC))
32073 {
32075 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
32082 {
32088 }
32089 else
32092 {
32096 }
32097 }
32099 /* Handle function try blocks. */
32101 {
32104 }
32105 /* We can have braced-init-list mem-initializers before the fn body. */
32107 {
32110 {
32111 /* cache_group will stop after an un-nested { } pair, too. */
32115 /* variadic mem-inits have ... after the ')'. */
32118 }
32119 }
32121 /* Handle function try blocks. */
32127 /* Save away the inline definition; we will process it when the
32128 class is complete. */
32132 /* We need to know that this was defined in the class, so that
32133 friend templates are handled correctly. */
32136 /* Add FN to the queue of functions to be parsed later. */
32140 }
32142 /* Save the tokens that make up the in-class initializer for a non-static
32143 data member. Returns a DEFERRED_PARSE. */
32145 static tree
32147 {
32149 }
32151 /* Parse a template-argument-list, as well as the trailing ">" (but
32152 not the opening "<"). See cp_parser_template_argument_list for the
32153 return value. */
32155 static tree
32157 {
32158 tree arguments;
32159 tree saved_scope;
32160 tree saved_qualifying_scope;
32161 tree saved_object_scope;
32164 /* [temp.names]
32166 When parsing a template-id, the first non-nested `>' is taken as
32167 the end of the template-argument-list rather than a greater-than
32168 operator. */
32169 saved_greater_than_is_operator_p
32172 /* Parsing the argument list may modify SCOPE, so we save it
32173 here. */
32177 /* We need to evaluate the template arguments, even though this
32178 template-id may be nested within a "sizeof". */
32179 cp_evaluated ev;
32180 /* Parse the template-argument-list itself. */
32185 {
32188 }
32189 else
32191 /* Look for the `>' that ends the template-argument-list. If we find
32192 a '>>' instead, it's probably just a typo. */
32194 {
32196 {
32197 /* In C++0x, a `>>' in a template argument list or cast
32198 expression is considered to be two separate `>'
32199 tokens. So, change the current token to a `>', but don't
32200 consume it: it will be consumed later when the outer
32201 template argument list (or cast expression) is parsed.
32202 Note that this replacement of `>' for `>>' is necessary
32203 even if we are parsing tentatively: in the tentative
32204 case, after calling
32205 cp_parser_enclosed_template_argument_list we will always
32206 throw away all of the template arguments and the first
32207 closing `>', either because the template argument list
32208 was erroneous or because we are replacing those tokens
32209 with a CPP_TEMPLATE_ID token. The second `>' (which will
32210 not have been thrown away) is needed either to close an
32211 outer template argument list or to complete a new-style
32212 cast. */
32215 }
32217 {
32218 /* If we're in a nested template argument list, the '>>' has
32219 to be a typo for '> >'. We emit the error message, but we
32220 continue parsing and we push a '>' as next token, so that
32221 the argument list will be parsed correctly. Note that the
32222 global source location is still on the token before the
32223 '>>', so we need to say explicitly where we want it. */
32231 }
32232 else
32233 {
32234 /* If this is not a nested template argument list, the '>>'
32235 is a typo for '>'. Emit an error message and continue.
32236 Same deal about the token location, but here we can get it
32237 right by consuming the '>>' before issuing the diagnostic. */
32240 "spurious %<>>%>, use %<>%> to terminate "
32242 }
32243 }
32244 /* Similarly for >>= and >=. */
32247 {
32253 {
32256 }
32258 {
32261 else
32264 }
32265 else
32266 {
32269 }
32275 }
32276 else
32278 /* The `>' token might be a greater-than operator again now. */
32279 parser->greater_than_is_operator_p
32281 /* Restore the SAVED_SCOPE. */
32287 }
32289 /* MEMBER_FUNCTION is a member function, or a friend. If default
32290 arguments, or the body of the function have not yet been parsed,
32291 parse them now. */
32293 static void
32295 {
32298 /* If this member is a template, get the underlying
32299 FUNCTION_DECL. */
32303 /* There should not be any class definitions in progress at this
32304 point; the bodies of members are only parsed outside of all class
32305 definitions. */
32307 /* While we're parsing the member functions we might encounter more
32308 classes. We want to handle them right away, but we don't want
32309 them getting mixed up with functions that are currently in the
32310 queue. */
32313 /* Make sure that any template parameters are in scope. */
32316 /* If the body of the function has not yet been parsed, parse it
32317 now. Except if the tokens have been purged (PR c++/39751). */
32320 {
32321 tree function_scope;
32324 /* The function is no longer pending; we are processing it. */
32329 /* If this is a local class, enter the scope of the containing
32330 function. */
32335 /* Push the body of the function onto the lexer stack. */
32338 /* Let the front end know that we going to be defining this
32339 function. */
32343 /* #pragma omp declare reduction needs special parsing. */
32345 {
32350 }
32351 else
32352 /* Now, parse the body of the function. */
32356 /* Leave the scope of the containing function. */
32360 }
32362 /* Remove any template parameters from the symbol table. */
32365 /* Restore the queue. */
32367 }
32369 /* If DECL contains any default args, remember it on the unparsed
32370 functions queue. */
32372 static void
32374 {
32375 tree probe;
32378 probe;
32381 {
32385 }
32387 /* Remember if there is a noexcept-specifier to post process. */
32391 }
32393 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
32394 which is either a FIELD_DECL or PARM_DECL. Parse it and return
32395 the result. For a PARM_DECL, PARMTYPE is the corresponding type
32396 from the parameter-type-list. */
32398 static tree
32401 {
32403 tree parsed_arg;
32409 /* Push the saved tokens for the default argument onto the parser's
32410 lexer stack. */
32416 /* Parse the default argument. */
32427 {
32428 /* In a non-template class, check conversions now. In a template,
32429 we'll wait and instantiate these as needed. */
32432 tf_warning_or_error);
32435 else
32437 }
32439 /* If the token stream has not been completely used up, then
32440 there was extra junk after the end of the default
32441 argument. */
32443 {
32446 else
32448 }
32450 /* Revert to the main lexer. */
32454 }
32456 /* FIELD is a non-static data member with an initializer which we saved for
32457 later; parse it now. */
32459 static void
32461 {
32462 tree def;
32469 NULL_TREE);
32475 }
32477 /* FN is a FUNCTION_DECL which may contains a parameter with an
32478 unparsed DEFERRED_PARSE. Parse the default args now. This function
32479 assumes that the current scope is the scope in which the default
32480 argument should be processed. */
32482 static void
32484 {
32487 /* While we're parsing the default args, we might (due to the
32488 statement expression extension) encounter more classes. We want
32489 to handle them right away, but we don't want them getting mixed
32490 up with default args that are currently in the queue. */
32493 /* Local variable names (and the `this' keyword) may not appear
32494 in a default argument. */
32502 /* Gather the PARM_DECLs into a vec so we can keep track of them when
32503 pushdecl clears DECL_CHAIN. */
32504 releasing_vec parms;
32514 {
32516 tree parsed_arg;
32525 /* This can happen for a friend declaration for a function
32526 already declared with default arguments. */
32529 parsed_arg
32531 default_arg,
32535 /* Update any instantiations we've already created. */
32538 }
32542 /* Restore DECL_CHAINs after clobbering by pushdecl. */
32545 {
32548 }
32552 /* Make sure no default arg is missing. */
32555 /* Restore the state of local_variables_forbidden_p. */
32558 /* Restore the queue. */
32560 }
32562 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
32564 sizeof ... ( identifier )
32566 where the 'sizeof' token has already been consumed. */
32568 static tree
32570 {
32571 /* Consume the `...'. */
32575 matching_parens parens;
32579 else
32587 /* The name is not qualified. */
32607 }
32609 /* Parse the operand of `sizeof' (or a similar operator). Returns
32610 either a TYPE or an expression, depending on the form of the
32611 input. The KEYWORD indicates which kind of expression we have
32612 encountered. */
32614 static tree
32616 {
32623 /* If it's a `...', then we are computing the length of a parameter
32624 pack. */
32629 /* Types cannot be defined in a `sizeof' expression. Save away the
32630 old message. */
32633 parser->type_definition_forbidden_message
32635 parser->type_definition_forbidden_message_arg
32638 /* The restrictions on constant-expressions do not apply inside
32639 sizeof expressions. */
32640 saved_integral_constant_expression_p
32642 saved_non_integral_constant_expression_p
32649 /* Do not actually evaluate the expression. */
32652 /* If it's a `(', then we might be looking at the type-id
32653 construction. */
32655 {
32660 /* We can't be sure yet whether we're looking at a type-id or an
32661 expression. */
32664 matching_parens parens;
32667 /* Note: as a GNU Extension, compound literals are considered
32668 postfix-expressions as they are in C99, so they are valid
32669 arguments to sizeof. See comment in cp_parser_cast_expression
32670 for details. */
32673 else
32674 {
32677 /* Look for the type-id. */
32679 /* Look for the closing `)'. */
32682 }
32684 /* If all went well, then we're done. */
32687 else
32688 {
32689 /* Commit to the tentative_firewall so we get syntax errors. */
32693 }
32694 }
32695 else
32698 /* Go back to evaluating expressions. */
32702 /* And restore the old one. */
32705 parser->integral_constant_expression_p
32707 parser->non_integral_constant_expression_p
32711 }
32713 /* If the current declaration has no declarator, return true. */
32715 static bool
32717 {
32718 /* If the next token is a `;' or a `,' then there is no
32719 declarator. */
32722 }
32724 /* Update the DECL_SPECS to reflect the storage class indicated by
32725 KEYWORD. */
32727 static void
32732 {
32733 cp_storage_class storage_class;
32736 {
32754 }
32757 {
32761 }
32763 {
32770 else
32777 }
32782 {
32785 }
32790 /* A storage class specifier cannot be applied alongside a typedef
32791 specifier. If there is a typedef specifier present then set
32792 conflicting_specifiers_p which will trigger an error later
32793 on in grokdeclarator. */
32796 {
32803 }
32804 }
32806 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
32807 is true, the type is a class or enum definition. */
32809 static void
32811 tree type_spec,
32814 {
32817 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
32818 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
32819 this is what happened. In system headers, we ignore these
32820 declarations so that G++ can work with system headers that are not
32821 C++-safe. */
32823 && !type_definition_p
32834 {
32837 ds_redefined_builtin_type_spec,
32838 token);
32840 {
32844 }
32845 }
32848 else
32849 {
32854 }
32855 }
32857 /* True iff TOKEN is the GNU keyword __thread. */
32859 static bool
32861 {
32864 }
32866 /* Set the location for a declarator specifier and check if it is
32867 duplicated.
32869 DECL_SPECS is the sequence of declarator specifiers onto which to
32870 set the location.
32872 DS is the single declarator specifier to set which location is to
32873 be set onto the existing sequence of declarators.
32875 LOCATION is the location for the declarator specifier to
32876 consider. */
32878 static void
32881 {
32890 {
32894 }
32895 else
32896 {
32898 {
32902 else
32903 {
32906 OPT_Wlong_long,
32908 }
32909 }
32911 {
32915 {
32919 }
32920 else
32921 {
32924 }
32925 }
32926 else
32927 {
32945 "consteval"
32946 };
32950 }
32951 }
32952 }
32954 /* Return true iff the declarator specifier DS is present in the
32955 sequence of declarator specifiers DECL_SPECS. */
32957 bool
32959 cp_decl_spec ds)
32960 {
32967 }
32969 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
32970 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
32972 static bool
32974 {
32976 }
32978 /* Issue an error message indicating that TOKEN_DESC was expected.
32979 If KEYWORD is true, it indicated this function is called by
32980 cp_parser_require_keword and the required token can only be
32981 a indicated keyword.
32983 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
32984 within any error as the location of an "opening" token matching
32985 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
32986 RT_CLOSE_PAREN). */
32988 static void
32990 required_token token_desc,
32992 location_t matching_location)
32993 {
32999 {
33074 }
33077 {
33079 {
33157 }
33158 }
33162 }
33165 /* If the next token is of the indicated TYPE, consume it. Otherwise,
33166 issue an error message indicating that TOKEN_DESC was expected.
33168 Returns the token consumed, if the token had the appropriate type.
33169 Otherwise, returns NULL.
33171 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
33172 within any error as the location of an "opening" token matching
33173 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
33174 RT_CLOSE_PAREN). */
33179 required_token token_desc,
33180 location_t matching_location)
33181 {
33184 else
33185 {
33186 /* Output the MESSAGE -- unless we're parsing tentatively. */
33189 matching_location);
33191 }
33192 }
33194 /* Skip an entire parameter list from start to finish. The next token must
33195 be the initial "<" of the parameter list. Returns true on success and
33196 false otherwise. */
33198 static bool
33200 {
33201 /* Consume the "<" because cp_parser_skip_to_end_of_template_parameter_list
33202 requires it. */
33205 }
33207 /* Ensure we are at the end of a template parameter list. If we are, return.
33208 If we are not, something has gone wrong, in which case issue an error and
33209 skip to end of the parameter list. */
33211 static void
33213 {
33214 /* Are we ready, yet? If not, issue error message. */
33219 }
33221 /* You should only call this function from inside a template parameter list
33222 (i.e. the current token should at least be the initial "<" of the
33223 parameter list). If you are skipping the entire list, it may be better to
33224 use cp_parser_skip_entire_template_parameter_list.
33226 Tokens are skipped until the final ">" is found, or if we see
33227 '{', '}', ';', or if we find an unbalanced ')' or ']'.
33229 Returns true if we successfully reached the end, and false if
33230 something unexpected happened (e.g. end of file). */
33232 static bool
33234 {
33235 /* Current level of '< ... >'. */
33237 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
33240 /* Skip tokens until the desired token is found. */
33242 {
33243 /* Peek at the next token. */
33245 {
33253 /* C++0x views the `>>' operator as two `>' tokens, but
33254 C++98 does not. */
33257 {
33258 /* We've hit a `>>' where the first `>' closes the
33259 template argument list, and the second `>' is
33260 spurious. Just consume the `>>' and stop; we've
33261 already produced at least one error. */
33264 }
33265 /* Fall through for C++0x, so we handle the second `>' in
33266 the `>>'. */
33271 {
33272 /* We've reached the token we want, consume it and stop. */
33275 }
33294 /* The '>' was probably forgotten, don't look further. */
33299 }
33301 /* Consume this token. */
33303 }
33304 }
33306 /* If the next token is the indicated keyword, consume it. Otherwise,
33307 issue an error message indicating that TOKEN_DESC was expected.
33309 Returns the token consumed, if the token had the appropriate type.
33310 Otherwise, returns NULL. */
33315 required_token token_desc)
33316 {
33320 {
33322 UNKNOWN_LOCATION);
33324 }
33327 }
33329 /* Returns TRUE iff TOKEN is a token that can begin the body of a
33330 function-definition. */
33332 static bool
33334 {
33337 /* A ctor-initializer begins with a `:'. */
33339 /* A function-try-block begins with `try'. */
33341 /* A function-transaction-block begins with `__transaction_atomic'
33342 or `__transaction_relaxed'. */
33345 /* The named return value extension begins with `return'. */
33347 }
33349 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
33350 definition. */
33352 static bool
33354 {
33361 }
33363 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
33364 C++0x) ending a template-argument. */
33366 static bool
33368 {
33376 /* For better diagnostics, treat >>= like that too, that
33377 shouldn't appear non-nested in template arguments. */
33379 }
33381 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
33382 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
33384 static bool
33387 {
33393 /* Check for the sequence `<::' in the original code. It would be lexed as
33394 `[:', where `[' is a digraph, and there is no whitespace before
33395 `:'. */
33397 {
33402 }
33404 }
33406 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
33407 or none_type otherwise. */
33409 static enum tag_types
33411 {
33413 {
33423 }
33424 }
33426 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
33427 or none_type otherwise or if the token is null. */
33429 static enum tag_types
33431 {
33436 {
33444 }
33445 }
33447 /* Diagnose redundant enum-keys. */
33449 static void
33452 {
33458 /* Look up the NAME to see if it unambiguously refers to the TYPE. */
33463 /* The enum-key is redundant for uses of the TYPE that are not
33464 declarations and for which name lookup returns just the type
33465 itself. */
33473 {
33474 /* Avoid issuing the diagnostic for apparently redundant (unscoped)
33475 enum tag in shared C/C++ code in files (such as headers) included
33476 in the main source file. */
33479 LRK_MACRO_DEFINITION_LOCATION,
33483 }
33491 }
33493 /* Describes the set of declarations of a struct, class, or class template
33494 or its specializations. Used for -Wmismatched-tags. */
33496 class class_decl_loc_t
33497 {
33502 {
33504 }
33506 /* Constructs an object for a single declaration of a class with
33507 CLASS_KEY at the current location in the current function (or
33508 at another scope). KEY_REDUNDANT is true if the class-key may
33509 be omitted in the current context without an ambiguity with
33510 another symbol with the same name.
33511 DEF_P is true for a class declaration that is a definition.
33512 CURLOC is the associated location. */
33516 {
33519 key_redundant);
33521 }
33523 /* Copy, assign, and destroy the object. Necessary because LOCVEC
33524 isn't safely copyable and assignable and doesn't release storage
33525 on its own. */
33529 { }
33532 {
33540 }
33543 {
33545 }
33547 /* Issues -Wmismatched-tags for a single class. */
33550 /* Issues -Wmismatched-tags for all classes. */
33553 /* Adds TYPE_DECL to the collection of class decls and diagnoses
33554 redundant tags (if -Wredundant-tags is enabled). */
33557 /* Either adds this decl to the collection of class decls
33558 or diagnoses it, whichever is appropriate. */
33564 {
33566 }
33569 {
33571 }
33574 {
33576 }
33579 {
33581 }
33583 /* True if a definition for the class has been seen. */
33585 {
33587 }
33589 /* The location of a single mention of a class type with the given
33590 class-key. */
33591 struct class_key_loc_t
33592 {
33595 { }
33597 /* The function the type is mentioned in. */
33598 tree func;
33599 /* The exact location. */
33600 location_t loc;
33601 /* The class-key used in the mention of the type. */
33602 tag_types class_key;
33603 /* True when the class-key could be omitted at this location
33604 without an ambiguity with another symbol of the same name. */
33606 };
33607 /* Avoid using auto_vec here since it's not safe to copy due to pr90904. */
33609 /* LOCVEC index of the definition or UINT_MAX if none exists. */
33611 /* The class-key the class was last declared with or none_type when
33612 it has been declared with a mismatched key. */
33613 tag_types def_class_key;
33615 /* A mapping between a TYPE_DECL for a class and the class_decl_loc_t
33616 description above. */
33619 };
33623 /* Issue an error message if the CLASS_KEY does not match the TYPE.
33624 DEF_P is expected to be set for a definition of class TYPE. DECL_P
33625 is set for a declaration of class TYPE and clear for a reference to
33626 it that is not a declaration of it. */
33628 static void
33632 {
33638 {
33642 type))
33646 }
33651 /* Only consider the true class-keys below and ignore typename_type,
33652 etc. that are not C++ class-keys. */
33659 }
33661 /* Returns the template or specialization of one to which the RECORD_TYPE
33662 TYPE corresponds. */
33664 static tree
33666 {
33669 /* Determine the template or its partial specialization to which TYPE
33670 corresponds. */
33679 }
33682 /* Adds the class TYPE to the collection of class decls and diagnoses
33683 redundant tags (if -Wredundant-tags is enabled).
33684 DEF_P is expected to be set for a definition of class TYPE. DECL_P
33685 is set for a (likely, based on syntactic context) declaration of class
33686 TYPE and clear for a reference to it that is not a declaration of it. */
33688 void
33691 {
33694 /* Look up the NAME to see if it unambiguously refers to the TYPE
33695 and set KEY_REDUNDANT if so. */
33700 /* The class-key is redundant for uses of the CLASS_TYPE that are
33701 neither definitions of it nor declarations, and for which name
33702 lookup returns just the type itself. */
33713 {
33714 /* Avoid issuing the diagnostic for apparently redundant struct
33715 and union class-keys in shared C/C++ code in files (such as
33716 headers) included in the main source file. */
33719 LRK_MACRO_DEFINITION_LOCATION,
33723 }
33725 /* Set if a declaration of TYPE has previously been seen or if it must
33726 exist in a precompiled header. */
33730 {
33733 {
33734 /* TYPE_DECL is the first declaration or definition of the type
33735 (outside precompiled headers -- see below). Just create
33736 a new entry for it and return unless it's a declaration
33737 involving a template that may need to be diagnosed by
33738 -Wredundant-tags. */
33742 }
33743 else
33744 {
33745 /* TYPE was previously defined in some unknown precompiled header.
33746 Simply add a record of its definition at an unknown location and
33747 proceed below to add a reference to it at the current location.
33748 (Declarations in precompiled headers that are not definitions
33749 are ignored.) */
33750 tag_types def_key
33755 }
33756 }
33758 /* A prior declaration of TYPE_DECL has been seen. */
33761 {
33768 type);
33769 }
33772 /* Do nothing if this is the first declaration of the type. */
33776 /* Do nothing if the class-key in this declaration matches
33777 the definition. */
33781 def_p);
33782 }
33784 /* Either adds this DECL corresponding to the TYPE_DECL to the collection
33785 of class decls or diagnoses it, whichever is appropriate. */
33787 void
33789 tag_types class_key,
33792 {
33793 /* Reset the CLASS_KEY associated with this type on mismatch.
33794 This is an optimization that lets the diagnostic code skip
33795 over classes that use the same class-key in all declarations. */
33799 /* Set IDXDEF to the index of the vector corresponding to
33800 the definition. */
33804 /* Append a record of this declaration to the vector. */
33806 redundant);
33812 /* As a space optimization diagnose declarations of a class
33813 whose definition has been seen and purge the LOCVEC of
33814 all entries except the definition. */
33817 {
33823 }
33824 else
33825 /* Pop the entry pushed above for this declaration. */
33827 }
33829 /* Issues -Wmismatched-tags for a single class. */
33831 void
33833 {
33837 /* Number of uses of the class. */
33840 /* The class (or template) declaration guiding the decisions about
33841 the diagnostic. For ordinary classes it's the same as THIS. For
33842 uses of instantiations of templates other than their declarations
33843 it points to the record for the declaration of the corresponding
33844 primary template or partial specialization. */
33849 {
33850 /* For implicit instantiations of a primary template look up
33851 the primary or partial specialization and use it as
33852 the expected class-key rather than using the class-key of
33853 the first reference to the instantiation. The primary must
33854 be (and inevitably is) at index zero. */
33858 }
33859 else
33860 {
33861 /* Skip declarations that consistently use the same class-key. */
33864 }
33866 /* Set if a definition for the class has been seen. */
33869 /* The index of the declaration whose class-key this declaration
33870 is expected to match. It's either the class-key of the class
33871 definition if one exists or the first declaration otherwise. */
33874 /* The class-key the class is expected to be declared with: it's
33875 either the key used in its definition or the first declaration
33876 if no definition has been provided.
33877 For implicit instantiations of a primary template it's
33878 the class-key used to declare the primary with. The primary
33879 must be at index zero. */
33883 /* Advance IDX to the first declaration that either is not
33884 a definition or that doesn't match the first declaration
33885 if no definition is provided. */
33890 /* Save the current function before changing it below. */
33892 /* Set the function declaration to print in diagnostic context. */
33900 auto_diagnostic_group d;
33901 /* Issue a warning for the first mismatched declaration.
33902 Avoid using "%#qT" since the class-key for the same type will
33903 be the same regardless of which one was used in the declaraion. */
33907 {
33908 /* Suggest how to avoid the warning for each instance since
33909 the guidance may be different depending on context. */
33911 (key_redundant_p
33914 xpectkstr);
33916 /* Also point to the first declaration or definition that guided
33917 the decision to issue the warning above. */
33919 (def_p
33923 }
33925 /* Issue warnings for the remaining inconsistent declarations. */
33927 {
33929 /* Skip over the declarations that match either the definition
33930 if one was provided or the first declaration. */
33936 /* Set the function declaration to print in diagnostic context. */
33941 /* Suggest how to avoid the warning for each instance since
33942 the guidance may be different depending on context. */
33944 (key_redundant_p
33947 xpectkstr);
33948 }
33950 /* Restore the current function in case it was replaced above. */
33952 }
33954 /* Issues -Wmismatched-tags for all classes. Called at the end
33955 of processing a translation unit, after declarations of all class
33956 types and their uses have been recorded. */
33958 void
33960 {
33961 /* CLASS2LOC should be empty if both -Wmismatched-tags and
33962 -Wredundant-tags are disabled. */
33964 || warn_redundant_tags
33967 /* Save the current function before changing on return. It should
33968 be null at this point. */
33972 {
33973 /* Iterate over the collected class/struct/template declarations. */
33976 {
33980 }
33981 }
33984 }
33986 /* Issue an error message if DECL is redeclared with different
33987 access than its original declaration [class.access.spec/3].
33988 This applies to nested classes, nested class templates and
33989 enumerations [class.mem/1]. */
33991 static void
33993 {
34004 }
34006 /* Look for the `template' keyword, as a syntactic disambiguator.
34007 Return TRUE iff it is present, in which case it will be
34008 consumed. */
34010 static bool
34012 {
34014 {
34015 /* In C++98 the `template' keyword can only be used within templates;
34016 outside templates the parser can always figure out what is a
34017 template and what is not. In C++11, per the resolution of DR 468,
34018 `template' is allowed in cases where it is not strictly necessary. */
34021 {
34024 "in C++98 %<template%> (as a disambiguator) is only "
34026 /* If this part of the token stream is rescanned, the same
34027 error message would be generated. So, we purge the token
34028 from the stream. */
34031 }
34032 else
34033 {
34034 /* Consume the `template' keyword. */
34037 }
34038 }
34040 }
34042 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
34043 set PARSER->SCOPE, and perform other related actions. */
34045 static void
34047 {
34050 /* Get the stored value. */
34052 /* Set the scope from the stored value. */
34057 }
34059 /* Consume tokens up through a non-nested END token. Returns TRUE if we
34060 encounter the end of a block before what we were looking for. */
34062 static bool
34066 {
34068 {
34071 /* Abort a parenthesized expression if we encounter a semicolon. */
34075 /* If we've reached the end of the file, stop. */
34081 /* We've hit the end of an enclosing block, so there's been some
34082 kind of syntax error. */
34085 /* Consume the token. */
34087 /* See if it starts a new group. */
34089 {
34091 /* In theory this should probably check end == '}', but
34092 cp_parser_save_member_function_body needs it to exit
34093 after either '}' or ')' when called with ')'. */
34096 }
34098 {
34102 }
34107 }
34108 }
34110 /* Like above, for caching a default argument or NSDMI. Both of these are
34111 terminated by a non-nested comma, but it can be unclear whether or not a
34112 comma is nested in a template argument list unless we do more parsing.
34113 In order to handle this ambiguity, when we encounter a ',' after a '<'
34114 we try to parse what follows as a parameter-declaration-list (in the
34115 case of a default argument) or a member-declarator (in the case of an
34116 NSDMI). If that succeeds, then we stop caching. */
34118 static tree
34120 {
34125 tree default_argument;
34127 /* Add tokens until we have processed the entire default
34128 argument. We add the range [first_token, token). */
34131 {
34132 /* For list-initialization, this is straightforward. */
34135 }
34137 {
34140 /* Peek at the next token. */
34142 /* What we do depends on what token we have. */
34144 {
34145 /* In valid code, a default argument must be
34146 immediately followed by a `,' `)', or `...'. */
34149 {
34150 /* If we've seen a '<', we might be in a
34151 template-argument-list. Until Core issue 325 is
34152 resolved, we don't know how this situation ought
34153 to be handled, so try to DTRT. We check whether
34154 what comes after the comma is a valid parameter
34155 declaration list. If it is, then the comma ends
34156 the default argument; otherwise the default
34157 argument continues. */
34161 /* Set ITALP so cp_parser_parameter_declaration_list
34162 doesn't decide to commit to this parse. */
34169 {
34170 /* Parse declarators until we reach a non-comma or
34171 somthing that cannot be an initializer.
34172 Just checking whether we're looking at a single
34173 declarator is insufficient. Consider:
34174 int var = tuple<T,U>::x;
34175 The template parameter 'U' looks exactly like a
34176 declarator. */
34177 do
34178 {
34182 CP_PARSER_FLAGS_NONE,
34191 }
34193 /* If we met an '=' or ';' then the original comma
34194 was the end of the NSDMI. Otherwise assume
34195 we're still in the NSDMI. */
34198 }
34199 else
34200 {
34203 tree t = cp_parser_parameter_declaration_list
34209 }
34216 }
34217 /* FALLTHRU */
34220 /* If we run into a non-nested `;', `}', or `]',
34221 then the code is invalid -- but the default
34222 argument is certainly over. */
34227 /* Handle correctly int n = sizeof ... ( p ); */
34230 /* Update DEPTH, if necessary. */
34245 /* This might be the comparison operator, or it might
34246 start a template argument list. */
34253 /* Fall through for C++0x, which treats the `>>'
34254 operator like two `>' tokens in certain
34255 cases. */
34260 {
34261 /* This might be an operator, or it might close a
34262 template argument list. But if a previous '<'
34263 started a template argument list, this will have
34264 closed it, so we can't be in one anymore. */
34268 }
34271 /* If we run out of tokens, issue an error message. */
34279 /* In these cases, we should look for template-ids.
34280 For example, if the default argument is
34281 `X<int, double>()', we need to do name lookup to
34282 figure out whether or not `X' is a template; if
34283 so, the `,' does not end the default argument.
34285 That is not yet done. */
34290 }
34292 /* If we've reached the end, stop. */
34296 /* Add the token to the token block. */
34298 }
34300 /* Create a DEFERRED_PARSE to represent the unparsed default
34301 argument. */
34308 }
34310 /* A location to use for diagnostics about an unparsed DEFERRED_PARSE. */
34312 location_t
34314 {
34319 }
34321 /* Begin parsing tentatively. We always save tokens while parsing
34322 tentatively so that if the tentative parsing fails we can restore the
34323 tokens. */
34325 static void
34327 {
34328 /* Enter a new parsing context. */
34330 /* Begin saving tokens. */
34332 /* In order to avoid repetitive access control error messages,
34333 access checks are queued up until we are no longer parsing
34334 tentatively. */
34336 }
34338 /* Commit to the currently active tentative parse. */
34340 static void
34342 {
34346 /* Mark all of the levels as committed. */
34349 {
34356 }
34357 }
34359 /* Commit to the topmost currently active tentative parse.
34361 Note that this function shouldn't be called when there are
34362 irreversible side-effects while in a tentative state. For
34363 example, we shouldn't create a permanent entry in the symbol
34364 table, or issue an error message that might not apply if the
34365 tentative parse is aborted. */
34367 static void
34369 {
34374 {
34382 }
34383 }
34385 /* Abort the currently active tentative parse. All consumed tokens
34386 will be rolled back, and no diagnostics will be issued. */
34388 static void
34390 {
34394 /* Now, pretend that we want to see if the construct was
34395 successfully parsed. */
34397 }
34399 /* Stop parsing tentatively. If a parse error has occurred, restore the
34400 token stream. Otherwise, commit to the tokens we have consumed.
34401 Returns true if no error occurred; false otherwise. */
34403 static bool
34405 {
34409 /* Remember whether or not an error occurred, since we are about to
34410 destroy that information. */
34412 /* Remove the topmost context from the stack. */
34415 /* If no parse errors occurred, commit to the tentative parse. */
34417 {
34418 /* Commit to the tokens read tentatively, unless that was
34419 already done. */
34424 }
34425 /* Otherwise, if errors occurred, roll back our state so that things
34426 are just as they were before we began the tentative parse. */
34427 else
34428 {
34431 }
34432 /* Add the context to the front of the free list. */
34437 }
34439 /* Returns true if we are parsing tentatively and are not committed to
34440 this tentative parse. */
34442 static bool
34444 {
34447 }
34449 /* Returns nonzero iff an error has occurred during the most recent
34450 tentative parse. */
34452 static bool
34454 {
34457 }
34459 /* Returns nonzero if GNU extensions are allowed. */
34461 static bool
34463 {
34465 }
34466 \f
34467 /* Objective-C++ Productions */
34470 /* Parse an Objective-C expression, which feeds into a primary-expression
34471 above.
34473 objc-expression:
34474 objc-message-expression
34475 objc-string-literal
34476 objc-encode-expression
34477 objc-protocol-expression
34478 objc-selector-expression
34480 Returns a tree representation of the expression. */
34482 static cp_expr
34484 {
34485 /* Try to figure out what kind of declaration is present. */
34489 {
34499 {
34511 }
34512 /* FALLTHRU */
34518 }
34521 }
34523 /* Parse an Objective-C message expression.
34525 objc-message-expression:
34526 [ objc-message-receiver objc-message-args ]
34528 Returns a representation of an Objective-C message. */
34530 static tree
34532 {
34545 /* Construct a location e.g.
34546 [self func1:5]
34547 ^~~~~~~~~~~~~~
34548 ranging from the '[' to the ']', with the caret at the start. */
34554 }
34556 /* Parse an objc-message-receiver.
34558 objc-message-receiver:
34559 expression
34560 simple-type-specifier
34562 Returns a representation of the type or expression. */
34564 static tree
34566 {
34567 tree rcv;
34569 /* An Objective-C message receiver may be either (1) a type
34570 or (2) an expression. */
34574 /* If that worked out, fine. */
34581 CP_PARSER_FLAGS_NONE);
34588 }
34590 /* Parse the arguments and selectors comprising an Objective-C message.
34592 objc-message-args:
34593 objc-selector
34594 objc-selector-args
34595 objc-selector-args , objc-comma-args
34597 objc-selector-args:
34598 objc-selector [opt] : assignment-expression
34599 objc-selector-args objc-selector [opt] : assignment-expression
34601 objc-comma-args:
34602 assignment-expression
34603 objc-comma-args , assignment-expression
34605 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
34606 selector arguments and TREE_VALUE containing a list of comma
34607 arguments. */
34609 static tree
34611 {
34617 {
34623 /* Detect if we have a unary selector. */
34632 sel_args
34637 }
34639 /* Handle non-selector arguments, if any. */
34641 {
34642 tree arg;
34647 addl_args
34652 }
34655 {
34658 }
34661 }
34663 /* Parse an Objective-C encode expression.
34665 objc-encode-expression:
34666 @encode objc-typename
34668 Returns an encoded representation of the type argument. */
34670 static cp_expr
34672 {
34673 tree type;
34678 matching_parens parens;
34685 {
34689 }
34691 /* This happens if we find @encode(T) (where T is a template
34692 typename or something dependent on a template typename) when
34693 parsing a template. In that case, we can't compile it
34694 immediately, but we rather create an AT_ENCODE_EXPR which will
34695 need to be instantiated when the template is used.
34696 */
34698 {
34702 }
34705 /* Build a location of the form:
34706 @encode(int)
34707 ^~~~~~~~~~~~
34708 with caret==start at the @ token, finishing at the close paren. */
34712 }
34714 /* Parse an Objective-C @defs expression. */
34716 static tree
34718 {
34719 tree name;
34722 matching_parens parens;
34728 }
34730 /* Parse an Objective-C protocol expression.
34732 objc-protocol-expression:
34733 @protocol ( identifier )
34735 Returns a representation of the protocol expression. */
34737 static tree
34739 {
34740 tree proto;
34744 matching_parens parens;
34749 /* Build a location of the form:
34750 @protocol(prot)
34751 ^~~~~~~~~~~~~~~
34752 with caret==start at the @ token, finishing at the close paren. */
34757 }
34759 /* Parse an Objective-C selector expression.
34761 objc-selector-expression:
34762 @selector ( objc-method-signature )
34764 objc-method-signature:
34765 objc-selector
34766 objc-selector-seq
34768 objc-selector-seq:
34769 objc-selector :
34770 objc-selector-seq objc-selector :
34772 Returns a representation of the method selector. */
34774 static tree
34776 {
34783 matching_parens parens;
34789 {
34798 {
34799 /* Detect if we have a unary selector. */
34801 {
34804 }
34805 else
34806 {
34808 }
34809 }
34814 {
34815 sel_seq
34818 sel_seq
34821 }
34822 else
34823 sel_seq
34828 }
34830 finish_selector:
34834 /* Build a location of the form:
34835 @selector(func)
34836 ^~~~~~~~~~~~~~~
34837 with caret==start at the @ token, finishing at the close paren. */
34840 /* TODO: objc_build_selector_expr doesn't always honor the location. */
34843 }
34845 /* Parse a list of identifiers.
34847 objc-identifier-list:
34848 identifier
34849 objc-identifier-list , identifier
34851 Returns a TREE_LIST of identifier nodes. */
34853 static tree
34855 {
34856 tree identifier;
34857 tree list;
34868 {
34875 identifier));
34877 }
34880 }
34882 /* Parse an Objective-C alias declaration.
34884 objc-alias-declaration:
34885 @compatibility_alias identifier identifier ;
34887 This function registers the alias mapping with the Objective-C front end.
34888 It returns nothing. */
34890 static void
34892 {
34900 }
34902 /* Parse an Objective-C class forward-declaration.
34904 objc-class-declaration:
34905 @class objc-identifier-list ;
34907 The function registers the forward declarations with the Objective-C
34908 front end. It returns nothing. */
34910 static void
34912 {
34915 {
34916 tree id;
34926 else
34928 }
34930 }
34932 /* Parse a list of Objective-C protocol references.
34934 objc-protocol-refs-opt:
34935 objc-protocol-refs [opt]
34937 objc-protocol-refs:
34938 < objc-identifier-list >
34940 Returns a TREE_LIST of identifiers, if any. */
34942 static tree
34944 {
34948 {
34952 }
34955 }
34957 /* Parse a Objective-C visibility specification. */
34959 static void
34961 {
34965 {
34980 }
34982 /* Eat '@private'/'@protected'/'@public'. */
34984 }
34986 /* Parse an Objective-C method type. Return 'true' if it is a class
34987 (+) method, and 'false' if it is an instance (-) method. */
34991 {
34994 else
34996 }
34998 /* Parse an Objective-C protocol qualifier. */
35000 static tree
35002 {
35015 {
35020 }
35023 }
35025 /* Parse an Objective-C typename. */
35027 static tree
35029 {
35033 {
35036 matching_parens parens;
35040 /* An ObjC type name may consist of just protocol qualifiers, in which
35041 case the type shall default to 'id'. */
35043 {
35046 /* If the type could not be parsed, an error has already
35047 been produced. For error recovery, behave as if it had
35048 not been specified, which will use the default type
35049 'id'. */
35051 {
35053 /* We need to skip to the closing parenthesis as
35054 cp_parser_type_id() does not seem to do it for
35055 us. */
35060 }
35061 }
35065 }
35068 }
35070 /* Check to see if TYPE refers to an Objective-C selector name. */
35072 static bool
35074 {
35080 }
35082 /* Parse an Objective-C selector. */
35084 static tree
35086 {
35090 {
35093 }
35095 /* C++ operator names are allowed to appear in ObjC selectors. */
35097 {
35110 }
35111 }
35113 /* Parse an Objective-C params list. */
35115 static tree
35117 {
35123 {
35133 /* Detect if we have a unary selector. */
35136 {
35139 }
35143 {
35144 /* Something went quite wrong. There should be a colon
35145 here, but there is not. Stop parsing parameters. */
35147 }
35149 /* New ObjC allows attributes on parameters too. */
35154 params
35157 type_name,
35158 identifier,
35159 parm_attr));
35162 }
35165 {
35168 }
35170 /* We allow tail attributes for the method. */
35172 {
35180 }
35183 {
35186 }
35188 }
35190 /* Parse the non-keyword Objective-C params. */
35192 static tree
35195 {
35201 {
35203 tree parm;
35209 {
35214 }
35216 /* TODO: parse attributes for tail parameters. */
35226 }
35228 /* We allow tail attributes for the method. */
35230 {
35232 {
35237 }
35238 else
35239 /* We have an error, but parse the attributes, so that we can
35240 carry on. */
35246 }
35249 }
35251 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
35253 static void
35255 {
35258 /* If the next token is `extern' and the following token is a string
35259 literal, then we have a linkage specification. */
35261 && cp_parser_is_pure_string_literal
35264 /* Handle #pragma, if any. */
35267 /* Allow stray semicolons. */
35270 /* Mark methods as optional or required, when building protocols. */
35272 {
35275 }
35277 {
35280 }
35283 /* Other stray characters must generate errors. */
35285 {
35289 }
35290 /* Finally, try to parse a block-declaration, or a function-definition. */
35291 else
35293 }
35295 /* Parse a method signature. */
35297 static tree
35299 {
35315 }
35317 static bool
35319 {
35320 tree tattr;
35325 /* If the attributes are followed by a method introducer, this is not allowed.
35326 Dump the attributes and flag the situation. */
35331 /* Otherwise, the attributes introduce some interstitial code, possibly so
35332 rewind to allow that check. */
35335 }
35337 /* Parse an Objective-C method prototype list. */
35339 static void
35341 {
35345 {
35347 {
35352 else
35356 {
35360 }
35363 }
35369 OPT_Wattributes,
35371 else
35372 /* Allow for interspersed non-ObjC++ code. */
35376 }
35380 else
35384 }
35386 /* Parse an Objective-C method definition list. */
35388 static void
35390 {
35392 {
35396 {
35399 }
35401 {
35404 }
35406 {
35410 tree attribute;
35414 else
35415 {
35419 /* For historical reasons, we accept an optional semicolon. */
35425 tree meth
35429 }
35430 }
35431 /* The following case will be removed once @synthesize is
35432 completely implemented. */
35443 else
35444 /* Allow for interspersed non-ObjC++ code. */
35446 }
35449 }
35451 /* Parse Objective-C ivars. */
35453 static void
35455 {
35466 {
35467 cp_decl_specifier_seq declspecs;
35469 tree prefix_attributes;
35477 CP_PARSER_FLAGS_OPTIONAL,
35481 /* auto, register, static, extern, mutable. */
35483 {
35486 }
35488 /* thread_local. */
35490 {
35493 }
35495 /* typedef. */
35497 {
35500 }
35505 /* Keep going until we hit the `;' at the end of the
35506 declaration. */
35508 {
35513 /* Check for a (possibly unnamed) bitfield declaration. */
35521 {
35522 /* Get the name of the bitfield. */
35527 eat_colon:
35529 /* Get the width of the bitfield. */
35530 width
35532 }
35533 else
35534 {
35535 /* Parse the declarator. */
35536 declarator
35538 CP_PARSER_FLAGS_NONE,
35544 }
35546 /* Look for attributes that apply to the ivar. */
35548 /* Remember which attributes are prefix attributes and
35549 which are not. */
35551 /* Combine the attributes. */
35555 /* Create the bitfield declaration. */
35558 else
35563 /* Add the instance variable. */
35567 /* Reset PREFIX_ATTRIBUTES. */
35569 {
35574 }
35579 {
35582 }
35584 }
35588 }
35593 /* Do not consume the RID_AT_END, so it will be read again as terminating
35594 the @interface of @implementation. */
35598 /* For historical reasons, we accept an optional semicolon. */
35601 }
35603 /* Parse an Objective-C protocol declaration. */
35605 static void
35607 {
35613 {
35618 }
35620 /* See if we have a forward declaration or a definition. */
35623 /* Try a forward declaration first. */
35625 {
35627 {
35628 tree id;
35638 else
35640 }
35642 }
35644 /* Ok, we got a full-fledged definition (or at least should). */
35645 else
35646 {
35651 }
35652 }
35654 /* Parse an Objective-C superclass or category. */
35656 static void
35661 {
35667 {
35670 }
35672 {
35673 matching_parens parens;
35676 /* If there is no category name, and this is an @interface, we
35677 have a class extension. */
35679 {
35682 }
35683 else
35687 }
35688 }
35690 /* Parse an Objective-C class interface. */
35692 static void
35694 {
35702 {
35703 /* It's hard to recover because even if valid @interface stuff
35704 is to follow, we can't compile it (or validate it) if we
35705 don't even know which class it refers to. Let's assume this
35706 was a stray '@interface' token in the stream and skip it.
35707 */
35709 }
35714 /* We have either a class or a category on our hands. */
35717 else
35718 {
35720 /* Handle instance variable declarations, if any. */
35723 }
35726 }
35728 /* Parse an Objective-C class implementation. */
35730 static void
35732 {
35739 {
35740 /* It's hard to recover because even if valid @implementation
35741 stuff is to follow, we can't compile it (or validate it) if
35742 we don't even know which class it refers to. Let's assume
35743 this was a stray '@implementation' token in the stream and
35744 skip it.
35745 */
35747 }
35751 /* We have either a class or a category on our hands. */
35754 else
35755 {
35757 /* Handle instance variable declarations, if any. */
35760 }
35763 }
35765 /* Consume the @end token and finish off the implementation. */
35767 static void
35769 {
35772 }
35774 /* Parse an Objective-C declaration. */
35776 static void
35778 {
35779 /* Try to figure out what kind of declaration is present. */
35784 {
35800 }
35803 {
35826 }
35827 }
35829 /* Parse an Objective-C try-catch-finally statement.
35831 objc-try-catch-finally-stmt:
35832 @try compound-statement objc-catch-clause-seq [opt]
35833 objc-finally-clause [opt]
35835 objc-catch-clause-seq:
35836 objc-catch-clause objc-catch-clause-seq [opt]
35838 objc-catch-clause:
35839 @catch ( objc-exception-declaration ) compound-statement
35841 objc-finally-clause:
35842 @finally compound-statement
35844 objc-exception-declaration:
35845 parameter-declaration
35846 '...'
35848 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
35850 Returns NULL_TREE.
35852 PS: This function is identical to c_parser_objc_try_catch_finally_statement
35853 for C. Keep them in sync. */
35855 static tree
35857 {
35858 location_t location;
35859 tree stmt;
35864 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
35865 node, lest it get absorbed into the surrounding block. */
35871 {
35875 matching_parens parens;
35881 {
35882 /* We have "@catch (...)" (where the '...' are literally
35883 what is in the code). Skip the '...'.
35884 parameter_declaration is set to NULL_TREE, and
35885 objc_being_catch_clauses() knows that that means
35886 '...'. */
35889 }
35890 else
35891 {
35892 /* We have "@catch (NSException *exception)" or something
35893 like that. Parse the parameter declaration. */
35898 else
35903 }
35906 else
35907 {
35908 /* If there was no open parenthesis, we are recovering from
35909 an error, and we are trying to figure out what mistake
35910 the user has made. */
35912 /* If there is an immediate closing parenthesis, the user
35913 probably forgot the opening one (ie, they typed "@catch
35914 NSException *e)". Parse the closing parenthesis and keep
35915 going. */
35919 /* If these is no immediate closing parenthesis, the user
35920 probably doesn't know that parenthesis are required at
35921 all (ie, they typed "@catch NSException *e"). So, just
35922 forget about the closing parenthesis and keep going. */
35923 }
35927 }
35929 {
35932 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
35933 node, lest it get absorbed into the surrounding block. */
35937 }
35940 }
35942 /* Parse an Objective-C synchronized statement.
35944 objc-synchronized-stmt:
35945 @synchronized ( expression ) compound-statement
35947 Returns NULL_TREE. */
35949 static tree
35951 {
35952 location_t location;
35959 matching_parens parens;
35964 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
35965 node, lest it get absorbed into the surrounding block. */
35970 }
35972 /* Parse an Objective-C throw statement.
35974 objc-throw-stmt:
35975 @throw assignment-expression [opt] ;
35977 Returns a constructed '@throw' statement. */
35979 static tree
35981 {
35993 }
35995 /* Parse an Objective-C statement. */
35997 static tree
35999 {
36000 /* Try to figure out what kind of declaration is present. */
36004 {
36015 }
36018 }
36020 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
36021 look ahead to see if an objc keyword follows the attributes. This
36022 is to detect the use of prefix attributes on ObjC @interface and
36023 @protocol. */
36025 static bool
36027 {
36032 {
36036 else
36039 }
36042 }
36044 /* This routine is a minimal replacement for
36045 c_parser_struct_declaration () used when parsing the list of
36046 types/names or ObjC++ properties. For example, when parsing the
36047 code
36049 @property (readonly) int a, b, c;
36051 this function is responsible for parsing "int a, int b, int c" and
36052 returning the declarations as CHAIN of DECLs.
36054 TODO: Share this code with cp_parser_objc_class_ivars. It's very
36055 similar parsing. */
36056 static tree
36058 {
36060 cp_decl_specifier_seq declspecs;
36062 tree prefix_attributes;
36065 CP_PARSER_FLAGS_NONE,
36072 /* auto, register, static, extern, mutable. */
36074 {
36077 }
36079 /* thread_local. */
36081 {
36084 }
36086 /* typedef. */
36088 {
36091 }
36096 /* Keep going until we hit the `;' at the end of the declaration. */
36098 {
36103 /* Parse the declarator. */
36105 CP_PARSER_FLAGS_NONE,
36108 /* Look for attributes that apply to the ivar. */
36110 /* Remember which attributes are prefix attributes and
36111 which are not. */
36113 /* Combine the attributes. */
36123 /* Reset PREFIX_ATTRIBUTES. */
36125 {
36130 }
36137 {
36140 }
36141 else
36143 }
36145 }
36147 /* Parse an Objective-C @property declaration. The syntax is:
36149 objc-property-declaration:
36150 '@property' objc-property-attributes[opt] struct-declaration ;
36152 objc-property-attributes:
36153 '(' objc-property-attribute-list ')'
36155 objc-property-attribute-list:
36156 objc-property-attribute
36157 objc-property-attribute-list, objc-property-attribute
36159 objc-property-attribute
36160 'getter' = identifier
36161 'setter' = identifier
36162 'readonly'
36163 'readwrite'
36164 'assign'
36165 'retain'
36166 'copy'
36167 'nonatomic'
36169 For example:
36170 @property NSString *name;
36171 @property (readonly) id object;
36172 @property (retain, nonatomic, getter=getTheName) id name;
36173 @property int a, b, c;
36175 PS: This function is identical to
36176 c_parser_objc_at_property_declaration for C. Keep them in sync. */
36177 static void
36179 {
36180 /* Parse the optional attribute list.
36182 A list of parsed, but not verified, attributes. */
36188 /* Parse the optional attribute list... */
36190 {
36191 /* Eat the '('. */
36192 matching_parens parens;
36197 /* Allow empty @property attribute lists, but with a warning. */
36199 location_t attr_comb;
36201 {
36205 }
36206 else
36208 {
36215 {
36222 }
36233 /* Account for accepting the 'class' keyword in this context. */
36235 else
36239 enum objc_property_attribute_kind prop_kind
36241 property_attribute_info *prop
36245 tree meth_name;
36247 {
36252 attr_name);
36253 else
36261 {
36264 attr_name);
36267 }
36275 {
36278 attr_name);
36281 }
36283 /* Get the end of the method name, and consume the name. */
36286 /* Because method names may contain C++ keywords, we have a
36287 routine to fetch them (this also consumes the token). */
36291 {
36293 {
36295 attr_end);
36299 }
36300 else
36301 {
36305 }
36307 attr_end);
36308 }
36309 else
36311 attr_end);
36313 /* Updated location including all that was successfully
36314 parsed. */
36317 }
36319 /* If we see a comma here, then keep going - even if we already
36320 saw a syntax error. For simple mistakes e.g. (asign, getter=x)
36321 this makes a more useful output and avoid spurious warnings
36322 about missing attributes that are, in fact, specified after the
36323 one with the syntax error. */
36326 else
36328 }
36334 }
36336 /* 'properties' is the list of properties that we read. Usually a
36337 single one, but maybe more (eg, in "@property int a, b, c;" there
36338 are three).
36339 TODO: Update this parsing so that it accepts (erroneous) bitfields so
36340 that we can issue a meaningful and consistent (between C/C++) error
36341 message from objc_add_property_declaration (). */
36348 else
36349 {
36350 /* Comma-separated properties are chained together in reverse order;
36351 add them one by one. */
36355 prop_attr_list);
36356 }
36359 }
36361 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
36363 objc-synthesize-declaration:
36364 @synthesize objc-synthesize-identifier-list ;
36366 objc-synthesize-identifier-list:
36367 objc-synthesize-identifier
36368 objc-synthesize-identifier-list, objc-synthesize-identifier
36370 objc-synthesize-identifier
36371 identifier
36372 identifier = identifier
36374 For example:
36375 @synthesize MyProperty;
36376 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
36378 PS: This function is identical to c_parser_objc_at_synthesize_declaration
36379 for C. Keep them in sync.
36380 */
36381 static void
36383 {
36385 location_t loc;
36390 {
36394 {
36397 }
36399 {
36403 {
36406 }
36407 }
36408 else
36413 else
36415 }
36418 }
36420 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
36422 objc-dynamic-declaration:
36423 @dynamic identifier-list ;
36425 For example:
36426 @dynamic MyProperty;
36427 @dynamic MyProperty, AnotherProperty;
36429 PS: This function is identical to c_parser_objc_at_dynamic_declaration
36430 for C. Keep them in sync.
36431 */
36432 static void
36434 {
36436 location_t loc;
36441 {
36442 tree property;
36445 {
36448 }
36452 else
36454 }
36457 }
36459 \f
36460 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
36462 /* Returns name of the next clause.
36463 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
36464 the token is not consumed. Otherwise appropriate pragma_omp_clause is
36465 returned and the token is consumed. */
36467 static pragma_omp_clause
36469 {
36485 {
36490 {
36709 }
36710 }
36716 }
36718 /* Validate that a clause of the given type does not already exist. */
36720 static void
36723 {
36726 }
36728 /* OpenMP 2.5:
36729 variable-list:
36730 identifier
36731 variable-list , identifier
36733 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
36734 colon). An opening parenthesis will have been consumed by the caller.
36736 If KIND is nonzero, create the appropriate node and install the decl
36737 in OMP_CLAUSE_DECL and add the node to the head of the list.
36739 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
36740 return the list created.
36742 COLON can be NULL if only closing parenthesis should end the list,
36743 or pointer to bool which will receive false if the list is terminated
36744 by closing parenthesis or true if the list is terminated by colon.
36746 The optional ALLOW_DEREF argument is true if list items can use the deref
36747 (->) operator. */
36749 struct omp_dim
36750 {
36752 location_t loc;
36756 };
36758 static tree
36762 {
36768 {
36771 }
36773 {
36781 {
36787 }
36791 {
36792 cp_id_kind idk;
36795 }
36800 CPP_CLOSE_PAREN)))
36801 {
36804 }
36805 else
36806 {
36813 {
36818 }
36822 else
36825 {
36831 }
36832 }
36836 ;
36838 {
36840 {
36842 /* The OpenACC cache directive explicitly only allows "array
36843 elements or subarrays". */
36845 {
36849 }
36850 /* FALLTHROUGH. */
36854 start_component_ref:
36856 || (allow_deref
36858 {
36859 cpp_ttype ttype
36862 location_t loc
36867 decl = (cp_parser_postfix_dot_deref_expression
36870 }
36871 /* FALLTHROUGH. */
36881 {
36889 {
36892 /* Later handling is not prepared to see through these. */
36894 }
36896 parser->colon_corrects_to_scope_p
36899 {
36902 }
36903 else
36904 {
36905 /* Look for `:'. */
36907 {
36912 }
36915 else
36918 CPP_CLOSE_SQUARE))
36919 {
36921 /* Later handling is not prepared to see through these. */
36923 }
36924 }
36925 /* Look for the closing `]'. */
36927 RT_CLOSE_SQUARE))
36928 {
36933 }
36936 }
36941 && !array_section_p
36943 || (allow_deref
36945 CPP_DEREF))))
36946 {
36948 {
36952 }
36954 }
36955 else
36962 }
36965 {
36969 {
36970 depend_lvalue:
36974 }
36975 else
36977 }
36983 }
36984 else
36987 get_comma:
36991 }
36997 {
37001 }
37004 {
37007 /* Try to resync to an unnested comma. Copied from
37008 cp_parser_parenthesized_expression_list. */
37009 skip_comma:
37018 }
37021 }
37023 /* Similarly, but expect leading and trailing parenthesis. This is a very
37024 common case for omp clauses. */
37026 static tree
37029 {
37032 allow_deref);
37034 }
37036 /* OpenACC 2.0:
37037 copy ( variable-list )
37038 copyin ( variable-list )
37039 copyout ( variable-list )
37040 create ( variable-list )
37041 delete ( variable-list )
37042 present ( variable-list )
37044 OpenACC 2.6:
37045 no_create ( variable-list )
37046 attach ( variable-list )
37047 detach ( variable-list ) */
37049 static tree
37051 tree list)
37052 {
37055 {
37097 }
37105 }
37107 /* OpenACC 2.0:
37108 deviceptr ( variable-list ) */
37110 static tree
37112 {
37116 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
37117 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
37118 variable-list must only allow for pointer variables. */
37121 {
37128 }
37131 }
37133 /* OpenACC 2.5:
37134 auto
37135 finalize
37136 independent
37137 nohost
37138 seq */
37140 static tree
37142 tree list)
37143 {
37150 }
37152 /* OpenACC:
37153 num_gangs ( expression )
37154 num_workers ( expression )
37155 vector_length ( expression ) */
37157 static tree
37160 {
37163 matching_parens parens;
37171 {
37176 }
37184 }
37186 /* OpenACC:
37188 gang [( gang-arg-list )]
37189 worker [( [num:] int-expr )]
37190 vector [( [length:] int-expr )]
37192 where gang-arg is one of:
37194 [num:] int-expr
37195 static: size-expr
37197 and size-expr may be:
37199 *
37200 int-expr
37201 */
37203 static tree
37205 omp_clause_code kind,
37207 {
37216 {
37217 matching_parens parens;
37220 do
37221 {
37225 /* Gang static argument. */
37228 {
37236 {
37239 }
37241 /* Check for the '*' argument. */
37245 CPP_CLOSE_PAREN)))
37246 {
37251 {
37254 }
37256 }
37257 }
37258 /* Worker num: argument and vector length: arguments. */
37262 {
37265 }
37267 /* Now collect the actual argument. */
37269 {
37272 }
37284 {
37287 }
37289 }
37294 }
37308 cleanup_error:
37311 }
37313 /* OpenACC 2.0:
37314 tile ( size-expr-list ) */
37316 static tree
37318 {
37322 /* Collapse and tile are mutually exclusive. (The spec doesn't say
37323 so, but the spec authors never considered such a case and have
37324 differing opinions on what it might mean, including 'not
37325 allowed'.) */
37328 clause_loc);
37333 do
37334 {
37341 {
37344 }
37345 else
37349 }
37352 /* Consume the trailing ')'. */
37360 }
37362 /* OpenACC 2.0
37363 Parse wait clause or directive parameters. */
37365 static tree
37367 {
37377 {
37379 {
37382 }
37384 }
37391 {
37395 {
37398 else
37399 {
37406 }
37407 }
37408 }
37411 }
37413 /* OpenACC:
37414 wait [( int-expr-list )] */
37416 static tree
37418 {
37423 else
37424 {
37430 }
37433 }
37435 /* OpenMP 3.0:
37436 collapse ( constant-expression ) */
37438 static tree
37440 {
37442 location_t loc;
37443 HOST_WIDE_INT n;
37446 matching_parens parens;
37464 {
37467 }
37476 }
37478 /* OpenMP 2.5:
37479 default ( none | shared )
37481 OpenMP 5.1:
37482 default ( private | firstprivate )
37484 OpenACC:
37485 default ( none | present ) */
37487 static tree
37490 {
37492 tree c;
37494 matching_parens parens;
37498 {
37501 }
37503 {
37508 {
37535 }
37538 }
37539 else
37540 {
37541 invalid_kind:
37544 else
37547 }
37564 }
37566 /* OpenMP 3.1:
37567 final ( expression ) */
37569 static tree
37571 {
37574 matching_parens parens;
37593 }
37595 /* OpenMP 2.5:
37596 if ( expression )
37598 OpenMP 4.5:
37599 if ( directive-name-modifier : expression )
37601 directive-name-modifier:
37602 parallel | task | taskloop | target data | target | target update
37603 | target enter data | target exit data
37605 OpenMP 5.0:
37606 directive-name-modifier:
37607 ... | simd | cancel */
37609 static tree
37612 {
37616 matching_parens parens;
37621 {
37637 {
37640 {
37653 else
37654 {
37655 location_t loc
37660 }
37663 {
37665 {
37670 }
37672 {
37673 location_t loc
37677 }
37678 }
37679 }
37680 }
37682 {
37684 {
37687 }
37688 else
37689 {
37691 {
37692 location_t loc
37695 }
37697 }
37698 }
37699 }
37711 {
37714 {
37717 {
37729 }
37731 p);
37733 }
37735 {
37738 else
37741 }
37744 {
37748 }
37749 }
37757 }
37759 /* OpenMP 3.1:
37760 mergeable */
37762 static tree
37765 {
37766 tree c;
37769 location);
37774 }
37776 /* OpenMP 2.5:
37777 nowait */
37779 static tree
37782 {
37783 tree c;
37790 }
37792 /* OpenMP 2.5:
37793 num_threads ( expression ) */
37795 static tree
37797 location_t location)
37798 {
37801 matching_parens parens;
37821 }
37823 /* OpenMP 4.5:
37824 num_tasks ( expression )
37826 OpenMP 5.1:
37827 num_tasks ( strict : expression ) */
37829 static tree
37831 location_t location)
37832 {
37835 matching_parens parens;
37842 {
37845 {
37849 }
37850 }
37869 }
37871 /* OpenMP 4.5:
37872 grainsize ( expression )
37874 OpenMP 5.1:
37875 grainsize ( strict : expression ) */
37877 static tree
37879 location_t location)
37880 {
37883 matching_parens parens;
37890 {
37893 {
37897 }
37898 }
37917 }
37919 /* OpenMP 4.5:
37920 priority ( expression ) */
37922 static tree
37924 location_t location)
37925 {
37928 matching_parens parens;
37948 }
37950 /* OpenMP 4.5:
37951 hint ( expression ) */
37953 static tree
37955 {
37958 matching_parens parens;
37965 {
37973 }
37986 }
37988 /* OpenMP 5.1:
37989 filter ( integer-expression ) */
37991 static tree
37993 {
37996 matching_parens parens;
38014 }
38016 /* OpenMP 4.5:
38017 defaultmap ( tofrom : scalar )
38019 OpenMP 5.0:
38020 defaultmap ( implicit-behavior [ : variable-category ] ) */
38022 static tree
38024 location_t location)
38025 {
38029 enum omp_clause_defaultmap_kind category
38032 matching_parens parens;
38039 {
38040 invalid_behavior:
38042 "%<tofrom%>, %<firstprivate%>, %<none%> "
38045 }
38046 else
38047 {
38050 }
38053 {
38057 else
38064 else
38073 else
38080 else
38089 else
38095 }
38099 {
38104 {
38105 invalid_category:
38109 }
38114 {
38118 else
38125 else
38132 else
38138 }
38141 }
38151 {
38158 {
38173 }
38176 p);
38177 else
38181 }
38188 out_err:
38193 }
38195 /* OpenMP 5.0:
38196 order ( concurrent )
38198 OpenMP 5.1:
38199 order ( order-modifier : concurrent )
38201 order-modifier:
38202 reproducible
38203 unconstrained */
38205 static tree
38207 {
38213 matching_parens parens;
38219 {
38226 else
38227 {
38231 }
38234 }
38236 {
38239 }
38240 else
38241 {
38244 }
38246 {
38249 }
38261 out_err:
38266 }
38268 /* OpenMP 5.0:
38269 bind ( teams | parallel | thread ) */
38271 static tree
38273 location_t location)
38274 {
38275 tree c;
38279 matching_parens parens;
38284 {
38285 invalid:
38289 }
38290 else
38291 {
38294 }
38305 /* check_no_duplicate_clause (list, OMP_CLAUSE_BIND, "bind", location); */
38311 out_err:
38316 }
38318 /* OpenMP 2.5:
38319 ordered
38321 OpenMP 4.5:
38322 ordered ( constant-expression ) */
38324 static tree
38327 {
38329 HOST_WIDE_INT n;
38335 {
38336 matching_parens parens;
38353 {
38355 "ordered argument needs positive constant integer "
38358 }
38359 }
38365 }
38367 /* OpenMP 2.5:
38368 reduction ( reduction-operator : variable-list )
38370 reduction-operator:
38371 One of: + * - & ^ | && ||
38373 OpenMP 3.1:
38375 reduction-operator:
38376 One of: + * - & ^ | && || min max
38378 OpenMP 4.0:
38380 reduction-operator:
38381 One of: + * - & ^ | && ||
38382 id-expression
38384 OpenMP 5.0:
38385 reduction ( reduction-modifier, reduction-operator : variable-list )
38386 in_reduction ( reduction-operator : variable-list )
38387 task_reduction ( reduction-operator : variable-list ) */
38389 static tree
38392 {
38402 {
38405 {
38408 }
38411 {
38419 {
38422 }
38423 }
38424 }
38427 {
38437 }
38441 else
38442 {
38453 {
38483 }
38484 else
38485 {
38487 resync_fail:
38492 }
38493 }
38499 NULL);
38501 {
38508 }
38511 }
38513 /* OpenMP 2.5:
38514 schedule ( schedule-kind )
38515 schedule ( schedule-kind , expression )
38517 schedule-kind:
38518 static | dynamic | guided | runtime | auto
38520 OpenMP 4.5:
38521 schedule ( schedule-modifier : schedule-kind )
38522 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
38524 schedule-modifier:
38525 simd
38526 monotonic
38527 nonmonotonic */
38529 static tree
38531 {
38535 matching_parens parens;
38543 {
38552 else
38558 {
38561 }
38562 else
38563 {
38566 }
38567 }
38572 {
38577 {
38598 }
38599 }
38604 else
38610 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
38612 {
38616 }
38619 {
38634 else
38639 }
38651 invalid_kind:
38653 resync_fail:
38658 }
38660 /* OpenMP 3.0:
38661 untied */
38663 static tree
38666 {
38667 tree c;
38674 }
38676 /* OpenMP 4.0:
38677 inbranch
38678 notinbranch */
38680 static tree
38683 {
38688 }
38690 /* OpenMP 4.0:
38691 parallel
38692 for
38693 sections
38694 taskgroup */
38696 static tree
38700 {
38704 }
38706 /* OpenMP 4.5:
38707 nogroup */
38709 static tree
38712 {
38717 }
38719 /* OpenMP 4.5:
38720 simd
38721 threads */
38723 static tree
38727 {
38732 }
38734 /* OpenMP 4.0:
38735 num_teams ( expression )
38737 OpenMP 5.1:
38738 num_teams ( expression : expression ) */
38740 static tree
38742 location_t location)
38743 {
38746 matching_parens parens;
38757 {
38761 }
38778 }
38780 /* OpenMP 4.0:
38781 thread_limit ( expression ) */
38783 static tree
38785 location_t location)
38786 {
38789 matching_parens parens;
38809 }
38811 /* OpenMP 4.0:
38812 aligned ( variable-list )
38813 aligned ( variable-list : constant-expression ) */
38815 static tree
38817 {
38821 matching_parens parens;
38829 {
38839 }
38845 }
38847 /* OpenMP 5.0:
38848 allocate ( variable-list )
38849 allocate ( expression : variable-list )
38851 OpenMP 5.1:
38852 allocate ( allocator-modifier : variable-list )
38853 allocate ( allocator-modifier , allocator-modifier : variable-list )
38855 allocator-modifier:
38856 allocator ( expression )
38857 align ( expression ) */
38859 static tree
38861 {
38865 matching_parens parens;
38875 {
38881 matching_parens parens2;
38885 {
38889 }
38890 else
38891 {
38895 }
38899 {
38902 }
38906 }
38907 else
38910 {
38916 }
38919 {
38926 }
38927 else
38928 {
38932 }
38939 {
38942 }
38945 }
38947 /* OpenMP 2.5:
38948 lastprivate ( variable-list )
38950 OpenMP 5.0:
38951 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
38953 static tree
38955 {
38963 {
38968 {
38972 }
38973 }
38982 }
38984 /* OpenMP 4.0:
38985 linear ( variable-list )
38986 linear ( variable-list : expression )
38988 OpenMP 4.5:
38989 linear ( modifier ( variable-list ) )
38990 linear ( modifier ( variable-list ) : expression )
38992 modifier:
38993 val
38994 ref
38995 uval
38997 OpenMP 5.2:
38998 linear ( variable-list : modifiers-list )
39000 modifiers:
39001 val
39002 ref
39003 uval
39004 step ( expression ) */
39006 static tree
39009 {
39015 matching_parens parens;
39020 {
39031 {
39034 }
39035 else
39037 }
39042 else
39043 {
39052 }
39055 {
39059 {
39069 {
39073 }
39077 CPP_CLOSE_PAREN)))
39079 }
39083 {
39085 {
39096 {
39102 }
39104 {
39105 location_t step_loc
39108 matching_parens parens2;
39110 {
39116 CPP_CLOSE_PAREN))
39117 {
39118 cp_token *token
39126 tok_loc);
39128 {
39131 }
39134 }
39140 }
39141 else
39143 }
39144 else
39147 {
39150 }
39152 }
39155 }
39159 {
39170 {
39173 }
39176 }
39187 }
39190 {
39194 }
39197 }
39199 /* OpenMP 4.0:
39200 safelen ( constant-expression ) */
39202 static tree
39204 location_t location)
39205 {
39208 matching_parens parens;
39227 }
39229 /* OpenMP 4.0:
39230 simdlen ( constant-expression ) */
39232 static tree
39234 location_t location)
39235 {
39238 matching_parens parens;
39257 }
39259 /* OpenMP 4.5:
39260 vec:
39261 identifier [+/- integer]
39262 vec , identifier [+/- integer]
39263 */
39265 static tree
39268 {
39272 {
39275 }
39278 {
39284 {
39287 {
39295 }
39296 }
39297 }
39300 {
39307 else
39308 {
39309 t = cp_parser_lookup_name_simple
39314 id_loc);
39315 }
39321 {
39324 }
39328 {
39331 }
39335 {
39338 }
39341 add_to_vector:
39343 {
39347 }
39354 }
39357 {
39364 }
39366 }
39368 /* OpenMP 5.0:
39369 detach ( event-handle ) */
39371 static tree
39373 {
39374 matching_parens parens;
39390 else
39391 {
39394 else
39399 }
39412 }
39414 /* OpenMP 5.0:
39415 iterators ( iterators-definition )
39417 iterators-definition:
39418 iterator-specifier
39419 iterator-specifier , iterators-definition
39421 iterator-specifier:
39422 identifier = range-specification
39423 iterator-type identifier = range-specification
39425 range-specification:
39426 begin : end
39427 begin : end : step */
39429 static tree
39431 {
39435 matching_parens parens;
39439 bool saved_colon_corrects_to_scope_p
39441 bool saved_colon_doesnt_start_class_def_p
39444 do
39445 {
39446 tree iter_type;
39450 else
39451 {
39454 parser->type_definition_forbidden_message
39460 }
39464 {
39467 }
39487 {
39490 }
39505 {
39508 }
39510 }
39514 parser->colon_doesnt_start_class_def_p
39524 }
39526 /* OpenMP 5.0:
39527 affinity ( [aff-modifier :] variable-list )
39528 aff-modifier:
39529 iterator ( iterators-definition ) */
39531 static tree
39533 {
39536 matching_parens parens;
39541 {
39546 CPP_OPEN_PAREN)));
39548 {
39551 }
39553 {
39557 {
39565 }
39566 }
39567 }
39571 {
39574 {
39579 }
39580 }
39582 }
39584 /* OpenMP 4.0:
39585 depend ( depend-kind : variable-list )
39587 depend-kind:
39588 in | out | inout
39590 OpenMP 4.5:
39591 depend ( source )
39593 depend ( sink : vec )
39595 OpenMP 5.0:
39596 depend ( depend-modifier , depend-kind: variable-list )
39598 depend-kind:
39599 in | out | inout | mutexinoutset | depobj
39601 depend-modifier:
39602 iterator ( iterators-definition ) */
39604 static tree
39606 {
39611 matching_parens parens;
39615 do
39616 {
39624 {
39629 }
39646 else
39649 }
39657 {
39662 }
39665 {
39676 }
39682 {
39688 }
39689 else
39690 {
39695 {
39699 else
39701 }
39704 {
39709 }
39710 }
39713 invalid_kind:
39715 resync_fail:
39722 }
39724 /* OpenMP 5.2:
39725 doacross ( source : )
39726 doacross ( source : omp_cur_iteration )
39728 doacross ( sink : vec )
39729 doacross ( sink : omp_cur_iteration - logical_iteration ) */
39731 static tree
39733 {
39734 tree nlist;
39737 matching_parens parens;
39742 {
39743 invalid_kind:
39745 resync_fail:
39750 }
39759 else
39768 {
39770 {
39775 }
39780 }
39781 else
39789 }
39791 /* OpenMP 4.0:
39792 map ( map-kind : variable-list )
39793 map ( variable-list )
39795 map-kind:
39796 alloc | to | from | tofrom
39798 OpenMP 4.5:
39799 map-kind:
39800 alloc | to | from | tofrom | release | delete
39802 map ( always [,] map-kind: variable-list )
39804 OpenMP 5.0:
39805 map ( [map-type-modifier[,] ...] map-kind: variable-list )
39807 map-type-modifier:
39808 always | close */
39810 static tree
39812 {
39823 {
39825 {
39828 }
39831 pos++;
39832 pos++;
39833 }
39838 {
39841 {
39844 }
39848 {
39850 {
39857 }
39859 }
39861 {
39863 {
39870 }
39872 }
39873 else
39874 {
39876 "modifier other than %<always%> or "
39883 }
39886 }
39890 {
39904 else
39905 {
39911 }
39914 }
39917 {
39921 }
39930 }
39932 /* OpenMP 4.0:
39933 device ( expression )
39935 OpenMP 5.0:
39936 device ( [device-modifier :] integer-expression )
39938 device-modifier:
39939 ancestor | device_num */
39941 static tree
39943 location_t location)
39944 {
39948 matching_parens parens;
39954 {
39958 {
39961 /* A requires directive with the reverse_offload clause must be
39962 specified. */
39964 {
39966 "preceded by %<requires%> directive "
39970 }
39971 }
39973 ;
39974 else
39975 {
39979 }
39982 }
40001 }
40003 /* OpenMP 4.0:
40004 dist_schedule ( static )
40005 dist_schedule ( static , expression ) */
40007 static tree
40009 location_t location)
40010 {
40013 matching_parens parens;
40024 {
40035 }
40039 /* check_no_duplicate_clause (list, OMP_CLAUSE_DIST_SCHEDULE,
40040 "dist_schedule", location); */
40046 invalid_kind:
40048 resync_fail:
40053 }
40055 /* OpenMP 4.0:
40056 proc_bind ( proc-bind-kind )
40058 proc-bind-kind:
40059 primary | master | close | spread
40060 where OpenMP 5.1 added 'primary' and deprecated the alias 'master'. */
40062 static tree
40064 location_t location)
40065 {
40066 tree c;
40073 {
40085 else
40087 }
40088 else
40097 location);
40102 invalid_kind:
40104 resync_fail:
40109 }
40111 /* OpenMP 5.0:
40112 device_type ( host | nohost | any ) */
40114 static tree
40116 location_t location)
40117 {
40118 tree c;
40125 {
40135 else
40137 }
40138 else
40147 location);
40152 invalid_kind:
40154 resync_fail:
40159 }
40161 /* OpenACC:
40162 async [( int-expr )] */
40164 static tree
40166 {
40173 {
40174 matching_parens parens;
40183 }
40193 }
40195 /* Parse all OpenACC clauses. The set clauses allowed by the directive
40196 is a bitmask in MASK. Return the list of clauses found. */
40198 static tree
40202 {
40206 /* Don't create location wrapper nodes within OpenACC clauses. */
40207 auto_suppress_location_wrappers sentinel;
40210 {
40211 location_t here;
40212 pragma_omp_clause c_kind;
40213 omp_clause_code code;
40224 {
40231 clauses);
40284 clauses);
40289 clauses);
40307 clauses);
40312 clauses);
40325 clauses);
40332 clauses);
40338 clauses);
40346 clauses);
40350 clauses
40357 clauses);
40366 clauses);
40372 OMP_CLAUSE_VECTOR,
40379 clauses);
40388 OMP_CLAUSE_WORKER,
40394 }
40399 {
40400 /* Remove the invalid clause(s) from the list to avoid
40401 confusing the rest of the compiler. */
40404 }
40405 }
40407 saw_error:
40414 }
40416 /* Parse all OpenMP clauses. The set clauses allowed by the directive
40417 is a bitmask in MASK. Return the list of clauses found.
40418 FINISH_P set if finish_omp_clauses should be called.
40419 NESTED non-zero if clauses should be terminated by closing paren instead
40420 of end of pragma. If it is 2, additionally commas are required in between
40421 the clauses. */
40423 static tree
40427 {
40432 /* Don't create location wrapper nodes within OpenMP clauses. */
40433 auto_suppress_location_wrappers sentinel;
40436 {
40437 pragma_omp_clause c_kind;
40445 /* OpenMP 5.1 allows optional comma in between directive-name and
40446 clauses everywhere, but as we aren't done with OpenMP 5.0
40447 implementation yet, let's allow it for now only in C++11
40448 attributes. */
40450 {
40455 "clauses in %<simd%> trait should be separated "
40457 }
40463 {
40480 clauses);
40499 clauses);
40519 clauses);
40524 clauses);
40529 clauses);
40534 clauses);
40543 clauses
40589 clauses);
40593 clauses
40605 clauses);
40609 clauses
40611 OMP_CLAUSE_TASK_REDUCTION,
40627 clauses);
40632 OMP_CLAUSE_NOTINBRANCH,
40641 {
40642 clause_not_first:
40646 }
40675 {
40677 clauses);
40681 }
40682 else
40694 clauses);
40716 {
40721 }
40782 clauses
40788 clauses
40795 clauses);
40801 }
40806 {
40807 /* Remove the invalid clause(s) from the list to avoid
40808 confusing the rest of the compiler. */
40811 }
40812 }
40813 saw_error:
40817 {
40820 else
40822 }
40824 }
40826 /* OpenMP 2.5:
40827 structured-block:
40828 statement
40830 In practice, we're also interested in adding the statement to an
40831 outer node. So it is convenient if we work around the fact that
40832 cp_parser_statement calls add_stmt. */
40834 static unsigned
40836 {
40839 /* Only move the values to IN_OMP_BLOCK if they weren't false.
40840 This preserves the "not within loop or switch" style error messages
40841 for nonsense cases like
40842 void foo() {
40843 #pragma omp single
40844 break;
40845 }
40846 */
40851 }
40853 static void
40855 {
40857 }
40859 static tree
40861 {
40870 }
40872 /* OpenMP 5.0:
40873 # pragma omp allocate (list) [allocator(allocator)] */
40875 static void
40877 {
40882 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
40889 {
40890 matching_parens parens;
40898 {
40903 }
40904 }
40912 }
40914 /* OpenMP 2.5:
40915 # pragma omp atomic new-line
40916 expression-stmt
40918 expression-stmt:
40919 x binop= expr | x++ | ++x | x-- | --x
40920 binop:
40921 +, *, -, /, &, ^, |, <<, >>
40923 where x is an lvalue expression with scalar type.
40925 OpenMP 3.1:
40926 # pragma omp atomic new-line
40927 update-stmt
40929 # pragma omp atomic read new-line
40930 read-stmt
40932 # pragma omp atomic write new-line
40933 write-stmt
40935 # pragma omp atomic update new-line
40936 update-stmt
40938 # pragma omp atomic capture new-line
40939 capture-stmt
40941 # pragma omp atomic capture new-line
40942 capture-block
40944 read-stmt:
40945 v = x
40946 write-stmt:
40947 x = expr
40948 update-stmt:
40949 expression-stmt | x = x binop expr
40950 capture-stmt:
40951 v = expression-stmt
40952 capture-block:
40953 { v = x; update-stmt; } | { update-stmt; v = x; }
40955 OpenMP 4.0:
40956 update-stmt:
40957 expression-stmt | x = x binop expr | x = expr binop x
40958 capture-stmt:
40959 v = update-stmt
40960 capture-block:
40961 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
40963 OpenMP 5.1:
40964 # pragma omp atomic compare new-line
40965 conditional-update-atomic
40967 # pragma omp atomic compare capture new-line
40968 conditional-update-capture-atomic
40970 conditional-update-atomic:
40971 cond-expr-stmt | cond-update-stmt
40972 cond-expr-stmt:
40973 x = expr ordop x ? expr : x;
40974 x = x ordop expr ? expr : x;
40975 x = x == e ? d : x;
40976 cond-update-stmt:
40977 if (expr ordop x) { x = expr; }
40978 if (x ordop expr) { x = expr; }
40979 if (x == e) { x = d; }
40980 ordop:
40981 <, >
40982 conditional-update-capture-atomic:
40983 v = cond-expr-stmt
40984 { v = x; cond-expr-stmt }
40985 { cond-expr-stmt v = x; }
40986 { v = x; cond-update-stmt }
40987 { cond-update-stmt v = x; }
40988 if (x == e) { x = d; } else { v = x; }
40989 { r = x == e; if (r) { x = d; } }
40990 { r = x == e; if (r) { x = d; } else { v = x; } }
40992 where x, r and v are lvalue expressions with scalar type,
40993 expr, e and d are expressions with scalar type and e might be
40994 the same as v. */
40996 static void
40998 {
41015 {
41016 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
41025 {
41030 enum omp_memory_order new_memory_order
41046 {
41050 }
41058 {
41059 matching_parens parens;
41066 {
41076 }
41079 {
41083 else
41085 }
41086 else
41096 }
41108 {
41112 }
41113 else
41114 {
41117 "%<capture%>, %<compare%>, %<weak%>, %<fail%>, "
41118 "%<seq_cst%>, %<acq_rel%>, %<release%>, "
41120 }
41122 {
41124 {
41125 /* OpenACC permits 'update capture'. */
41132 else
41134 }
41136 {
41139 else
41141 }
41143 {
41146 else
41148 }
41150 {
41153 else
41155 }
41157 {
41160 else
41162 }
41165 }
41166 }
41168 }
41174 {
41178 else
41180 }
41182 {
41186 }
41188 {
41191 }
41193 {
41196 }
41200 {
41201 omp_requires_mask
41206 {
41216 {
41226 }
41230 }
41231 }
41232 else
41234 {
41237 {
41241 }
41247 {
41251 }
41257 }
41259 memory_order
41264 {
41274 else
41279 {
41280 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
41281 opcode. */
41286 }
41290 {
41293 }
41297 else
41298 {
41306 {
41310 }
41311 }
41314 }
41316 restart:
41318 {
41321 matching_parens parens;
41325 tree cmp_expr;
41328 else
41336 {
41342 }
41344 ;
41346 {
41350 }
41353 {
41355 "expected %<==%>, %<<%> or %<>%> comparison in %<if%> "
41358 }
41369 {
41372 }
41377 else
41390 {
41392 {
41395 }
41397 {
41402 }
41403 else
41405 }
41410 {
41415 }
41416 else
41417 {
41418 bad_if:
41422 }
41425 {
41429 {
41433 }
41461 /* Signal to c_finish_omp_atomic that in
41462 if (x == e) { x = d; } else { v = x; }
41463 case the store to v should be conditional. */
41465 }
41467 {
41470 }
41476 }
41480 {
41487 /* FALLTHROUGH */
41499 /* FALLTHROUGH */
41516 /* Undo effects of boolean_increment for post {in,de}crement. */
41518 /* FALLTHRU */
41522 {
41523 /* Undo effects of boolean_increment. */
41525 {
41526 /* This is pre or post increment. */
41531 && !structured_block
41537 }
41538 }
41539 /* FALLTHRU */
41542 {
41545 }
41547 {
41582 {
41586 }
41591 {
41597 {
41602 }
41604 {
41618 {
41620 {
41625 }
41626 else
41628 }
41633 || !structured_block
41634 || v
41640 {
41642 {
41648 }
41649 }
41657 {
41661 cond_expr:
41663 bool saved_colon_corrects_to_scope_p
41667 parser->colon_corrects_to_scope_p
41672 {
41674 {
41676 {
41680 }
41682 {
41683 opcode
41687 }
41688 }
41689 else
41690 {
41693 {
41694 opcode
41699 }
41700 }
41701 }
41703 "invalid form of "
41706 }
41710 }
41715 {
41722 }
41726 }
41730 {
41733 {
41741 }
41743 {
41748 }
41792 }
41795 {
41797 "invalid form of "
41800 }
41811 {
41813 {
41815 "invalid form of "
41818 }
41820 }
41826 }
41833 }
41834 stmt_done:
41836 {
41849 }
41851 {
41855 }
41856 done:
41858 {
41861 }
41869 invalid_compare:
41871 /* FALLTHRU */
41872 saw_error:
41877 {
41881 {
41885 }
41886 }
41887 }
41890 /* OpenMP 2.5:
41891 # pragma omp barrier new-line */
41893 static void
41895 {
41898 }
41900 /* OpenMP 2.5:
41901 # pragma omp critical [(name)] new-line
41902 structured-block
41904 OpenMP 4.5:
41905 # pragma omp critical [(name) [hint(expression)]] new-line
41906 structured-block */
41908 #define OMP_CRITICAL_CLAUSE_MASK \
41909 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
41911 static tree
41913 {
41917 {
41918 matching_parens parens;
41934 }
41941 }
41943 /* OpenMP 5.0:
41944 # pragma omp depobj ( depobj ) depobj-clause new-line
41946 depobj-clause:
41947 depend (dependence-type : locator)
41948 destroy
41949 update (dependence-type)
41951 dependence-type:
41952 in
41953 out
41954 inout
41955 mutexinout */
41957 static void
41959 {
41961 matching_parens parens;
41963 {
41966 }
41978 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
41983 {
41989 {
41990 /* Don't create location wrapper nodes within the depend clause. */
41991 auto_suppress_location_wrappers sentinel;
41997 }
42001 {
42002 matching_parens c_parens;
42004 {
42005 location_t c2_loc
42008 {
42023 }
42025 {
42029 }
42035 }
42036 else
42038 }
42039 }
42041 {
42044 }
42048 }
42051 /* OpenMP 2.5:
42052 # pragma omp flush flush-vars[opt] new-line
42054 flush-vars:
42055 ( variable-list )
42057 OpenMP 5.0:
42058 # pragma omp flush memory-order-clause new-line */
42060 static void
42062 {
42064 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
42070 {
42081 else
42083 "expected %<seq_cst%>, %<acq_rel%>, %<release%> or "
42086 }
42088 {
42091 "%<flush%> list specified together with memory order "
42094 }
42098 }
42100 /* Helper function, to parse omp for increment expression. */
42102 static tree
42104 {
42109 {
42112 }
42115 {
42127 }
42129 /* If decl is an iterator, preserve LHS and RHS of the relational
42130 expr until finish_omp_for. */
42141 }
42143 /* Helper function, to parse omp for increment expression. */
42145 static tree
42147 {
42151 cp_id_kind idk;
42155 {
42164 }
42173 {
42178 }
42185 {
42189 }
42202 do
42203 {
42210 {
42212 {
42215 else
42218 }
42219 else
42224 }
42225 }
42229 {
42235 }
42236 else
42240 }
42242 /* Parse the initialization statement of an OpenMP for loop.
42244 Return true if the resulting construct should have an
42245 OMP_CLAUSE_PRIVATE added to it. */
42247 static tree
42255 {
42261 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
42263 init-expr:
42264 var = lb
42265 integer-type var = lb
42266 random-access-iterator-type var = lb
42267 pointer-type var = lb
42268 */
42269 cp_decl_specifier_seq type_specifiers;
42271 /* First, try to parse as an initialized declaration. See
42272 cp_parser_condition, from whence the bulk of this is copied. */
42280 {
42281 /* If parsing a type specifier seq succeeded, then this
42282 MUST be a initialized declaration. */
42287 CP_PARSER_DECLARATOR_NAMED,
42288 CP_PARSER_FLAGS_NONE,
42300 else
42301 {
42311 {
42313 CPP_OPEN_PAREN))
42316 else
42317 /* Trigger an error. */
42322 }
42326 {
42334 {
42337 auto_node);
42342 }
42345 asm_specification,
42346 LOOKUP_ONLYCONVERTING);
42349 {
42352 }
42353 else
42354 {
42357 {
42359 /* Move lambda DECL_EXPRs to FOR_BLOCK. */
42361 {
42365 {
42369 }
42371 }
42373 {
42378 }
42379 }
42380 }
42382 }
42383 else
42384 {
42385 /* Consume '='. */
42389 non_class:
42392 else
42395 asm_specification,
42396 LOOKUP_ONLYCONVERTING);
42397 }
42401 }
42402 }
42403 else
42404 {
42405 cp_id_kind idk;
42406 /* If parsing a type specifier sequence failed, then
42407 this MUST be a simple expression. */
42413 && decl
42416 {
42427 {
42432 }
42437 }
42439 && decl
42442 {
42443 tree rhs;
42452 tf_warning_or_error));
42455 }
42456 else
42457 {
42462 {
42466 }
42467 }
42468 }
42470 }
42472 /* Helper for cp_parser_omp_for_loop, handle one range-for loop. */
42474 void
42478 {
42483 {
42487 /* do_auto_deduction doesn't mess with template init-lists. */
42489 {
42492 {
42498 }
42500 }
42507 }
42512 /* If an error happened previously do nothing or else a lot of
42513 unhelpful errors would be issued. */
42515 else
42516 {
42517 tree range_temp;
42521 /* Can't bind a reference to an array of runtime bound. */
42523 else
42524 {
42530 LOOKUP_ONLYCONVERTING);
42533 }
42536 }
42547 LOOKUP_ONLYCONVERTING);
42549 /* The new for initialization statement. */
42557 else
42558 {
42561 }
42564 LOOKUP_ONLYCONVERTING);
42566 /* The new for condition. */
42569 else
42575 /* The new increment expression. */
42578 else
42581 tf_warning_or_error);
42586 {
42589 }
42594 {
42599 {
42604 }
42605 }
42609 {
42615 }
42622 {
42625 }
42627 }
42629 /* Helper for cp_parser_omp_for_loop, finalize part of range for
42630 inside of the collapsed body. */
42632 void
42634 {
42642 {
42646 }
42648 /* The declaration is initialized with *__begin inside the loop body. */
42653 LOOKUP_ONLYCONVERTING);
42656 }
42658 /* Return true if next tokens contain a standard attribute that contains
42659 omp::directive (DIRECTIVE). */
42661 static bool
42664 {
42672 {
42679 }
42684 location_t last_loc
42693 {
42695 {
42699 cnt++;
42703 {
42707 }
42708 }
42709 }
42711 {
42714 }
42716 {
42718 "%<[[omp::directive(%s)]]%> must be the only specified "
42722 }
42727 }
42729 /* Parse an OpenMP structured block sequence. KIND is the corresponding
42730 separating directive. */
42732 static tree
42735 {
42741 {
42754 kind == PRAGMA_OMP_SCAN
42759 }
42763 }
42766 /* OpenMP 5.0:
42768 scan-loop-body:
42769 { structured-block scan-directive structured-block } */
42771 static void
42773 {
42776 matching_braces braces;
42786 {
42796 {
42803 }
42805 {
42808 }
42809 else
42814 }
42815 else
42821 clauses);
42825 }
42827 /* Parse the restricted form of the for statement allowed by OpenMP. */
42829 static tree
42832 {
42834 tree orig_decl;
42837 location_t loc_first;
42840 releasing_vec for_block;
42849 {
42852 }
42855 {
42858 }
42865 {
42871 }
42885 {
42888 location_t loc;
42891 {
42895 }
42898 /* Don't create location wrapper nodes within an OpenMP "for"
42899 statement. */
42900 auto_suppress_location_wrappers sentinel;
42902 matching_parens parens;
42910 {
42911 /* Save tokens so that we can put them back. */
42914 /* Look for ':' that is not nested in () or {}. */
42915 bool is_range_for
42918 CPP_COLON,
42919 /*consume_paren=*/
42922 /* Roll back the tokens we skipped. */
42926 {
42927 bool saved_colon_corrects_to_scope_p
42930 /* A colon is used in range-based for. */
42933 /* Parse the declaration. */
42935 /*function_definition_allowed_p=*/
42937 parser->colon_corrects_to_scope_p
42949 {
42951 {
42957 }
42958 else
42960 }
42964 "%<ordered%> clause with parameter on "
42968 }
42969 }
42971 add_private_clause
42977 {
42980 {
42986 }
42987 else
42989 }
42997 {
43002 {
43006 }
43009 {
43010 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
43014 {
43017 }
43018 else
43019 {
43022 }
43024 }
43025 else
43026 {
43031 }
43032 }
43035 {
43036 tree c;
43038 {
43047 decl);
43052 decl);
43053 }
43055 {
43060 else
43065 {
43068 /* For linear, signal that we need to fill up
43069 the so far unknown linear step. */
43072 }
43073 }
43074 }
43083 {
43084 /* If decl is an iterator, preserve the operator on decl
43085 until finish_omp_for. */
43087 && ((processing_template_decl
43092 else
43095 }
43097 parse_close_paren:
43108 {
43111 }
43113 {
43117 }
43124 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
43125 in between the collapsed for loops to be still considered perfectly
43126 nested. Hopefully the final version clarifies this.
43127 For now handle (multiple) {'s and empty statements. */
43130 {
43134 {
43136 bracecount++;
43137 }
43141 else
43142 {
43149 }
43150 }
43153 {
43156 }
43157 }
43162 /* Note that we saved the original contents of this flag when we entered
43163 the structured block, and so we don't need to re-save it here. */
43166 /* Note that the grammar doesn't call for a structured block here,
43167 though the loop as a whole is a structured block. */
43169 {
43175 }
43176 else
43180 else
43184 else
43189 else
43194 {
43196 {
43198 nbraces--;
43199 }
43202 else
43203 {
43205 {
43208 }
43213 }
43214 }
43217 {
43221 else
43223 }
43226 }
43228 /* Helper function for OpenMP parsing, split clauses and call
43229 finish_omp_clauses on each of the set of clauses afterwards. */
43231 static void
43234 {
43240 i == C_OMP_CLAUSE_SPLIT_TARGET
43242 }
43244 /* OpenMP 5.0:
43245 #pragma omp loop loop-clause[optseq] new-line
43246 for-loop */
43248 #define OMP_LOOP_CLAUSE_MASK \
43249 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43250 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43251 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43252 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
43253 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_BIND) \
43254 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
43256 static tree
43260 {
43271 {
43274 }
43286 }
43288 /* OpenMP 4.0:
43289 #pragma omp simd simd-clause[optseq] new-line
43290 for-loop */
43292 #define OMP_SIMD_CLAUSE_MASK \
43293 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
43294 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
43295 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
43296 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
43297 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43298 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43299 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43300 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
43301 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43302 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL) \
43303 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
43305 static tree
43309 {
43320 {
43323 }
43335 }
43337 /* OpenMP 2.5:
43338 #pragma omp for for-clause[optseq] new-line
43339 for-loop
43341 OpenMP 4.0:
43342 #pragma omp for simd for-simd-clause[optseq] new-line
43343 for-loop */
43345 #define OMP_FOR_CLAUSE_MASK \
43346 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43347 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43348 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43349 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
43350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
43352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
43353 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
43354 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
43355 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43356 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
43358 static tree
43362 {
43369 /* parallel for{, simd} disallows nowait clause, but for
43370 target {teams distribute ,}parallel for{, simd} it should be accepted. */
43373 /* Composite distribute parallel for{, simd} disallows ordered clause. */
43378 {
43383 {
43407 }
43408 }
43410 {
43413 }
43415 /* Composite distribute parallel for disallows linear clause. */
43422 {
43425 }
43437 }
43442 /* OpenMP 2.5:
43443 # pragma omp master new-line
43444 structured-block */
43446 static tree
43450 {
43458 {
43463 {
43483 }
43484 }
43486 {
43489 }
43492 {
43496 }
43497 else
43502 }
43504 /* OpenMP 5.1:
43505 # pragma omp masked masked-clauses new-line
43506 structured-block */
43508 #define OMP_MASKED_CLAUSE_MASK \
43509 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FILTER)
43511 static tree
43515 {
43524 {
43529 {
43550 }
43551 }
43553 {
43556 }
43561 {
43564 }
43568 clauses);
43569 }
43571 /* OpenMP 2.5:
43572 # pragma omp ordered new-line
43573 structured-block
43575 OpenMP 4.5:
43576 # pragma omp ordered ordered-clauses new-line
43577 structured-block */
43579 #define OMP_ORDERED_CLAUSE_MASK \
43580 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
43581 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
43583 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
43584 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
43585 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DOACROSS))
43587 static bool
43590 {
43594 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
43600 {
43605 {
43607 {
43610 }
43612 {
43614 "%qs clause may only be used in compound "
43618 }
43619 tree clauses
43621 OMP_ORDERED_DEPEND_CLAUSE_MASK,
43625 }
43626 }
43628 tree clauses
43639 }
43641 /* OpenMP 2.5:
43643 section-scope:
43644 { section-sequence }
43646 section-sequence:
43647 section-directive[opt] structured-block
43648 section-sequence section-directive structured-block */
43650 static tree
43652 {
43657 matching_braces braces;
43664 != PRAGMA_OMP_SECTION
43666 {
43668 PRAGMA_OMP_SECTION);
43671 }
43674 {
43684 {
43688 }
43690 {
43693 }
43696 PRAGMA_OMP_SECTION);
43699 }
43710 }
43712 /* OpenMP 2.5:
43713 # pragma omp sections sections-clause[optseq] newline
43714 sections-scope */
43716 #define OMP_SECTIONS_CLAUSE_MASK \
43717 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43718 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43719 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
43720 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43721 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43722 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43724 static tree
43727 {
43739 {
43742 }
43749 }
43751 /* OpenMP 2.5:
43752 # pragma omp parallel parallel-clause[optseq] new-line
43753 structured-block
43754 # pragma omp parallel for parallel-for-clause[optseq] new-line
43755 structured-block
43756 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
43757 structured-block
43759 OpenMP 4.0:
43760 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
43761 structured-block */
43763 #define OMP_PARALLEL_CLAUSE_MASK \
43764 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
43765 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43766 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43767 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
43768 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
43769 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
43770 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43771 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
43772 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43773 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
43775 static tree
43779 {
43786 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
43792 {
43800 if_p);
43804 if_p);
43807 block);
43812 }
43813 /* When combined with distribute, parallel has to be followed by for.
43814 #pragma omp target parallel is allowed though. */
43818 {
43822 }
43824 {
43828 {
43842 block);
43845 /* masked does have just filter clause, but during gimplification
43846 isn't represented by a gimplification omp context, so for
43847 #pragma omp parallel masked don't set OMP_PARALLEL_COMBINED,
43848 so that
43849 #pragma omp parallel masked
43850 #pragma omp taskloop simd lastprivate (x)
43851 isn't confused with
43852 #pragma omp parallel masked taskloop simd lastprivate (x) */
43856 }
43858 {
43872 block);
43875 /* master doesn't have any clauses and during gimplification
43876 isn't represented by a gimplification omp context, so for
43877 #pragma omp parallel master don't set OMP_PARALLEL_COMBINED,
43878 so that
43879 #pragma omp parallel master
43880 #pragma omp taskloop simd lastprivate (x)
43881 isn't confused with
43882 #pragma omp parallel master taskloop simd lastprivate (x) */
43886 }
43888 {
43903 block);
43908 }
43910 {
43913 }
43915 {
43925 block);
43928 }
43929 }
43931 {
43934 }
43939 {
43942 }
43951 }
43953 /* OpenMP 2.5:
43954 # pragma omp single single-clause[optseq] new-line
43955 structured-block */
43957 #define OMP_SINGLE_CLAUSE_MASK \
43958 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43959 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43960 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
43961 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43962 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43964 static tree
43966 {
43977 }
43979 /* OpenMP 5.1:
43980 # pragma omp scope scope-clause[optseq] new-line
43981 structured-block */
43983 #define OMP_SCOPE_CLAUSE_MASK \
43984 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
43985 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
43986 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
43987 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
43988 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
43990 static tree
43992 {
44003 }
44005 /* OpenMP 3.0:
44006 # pragma omp task task-clause[optseq] new-line
44007 structured-block */
44009 #define OMP_TASK_CLAUSE_MASK \
44010 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44011 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
44012 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
44013 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
44014 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
44015 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
44016 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
44017 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
44018 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44019 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
44020 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44021 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
44022 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DETACH) \
44023 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_AFFINITY))
44025 static tree
44027 {
44039 }
44041 /* OpenMP 3.0:
44042 # pragma omp taskwait new-line
44044 OpenMP 5.0:
44045 # pragma omp taskwait taskwait-clause[opt] new-line */
44047 #define OMP_TASKWAIT_CLAUSE_MASK \
44048 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44049 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44051 static void
44053 {
44054 tree clauses
44059 {
44066 }
44067 else
44069 }
44071 /* OpenMP 3.1:
44072 # pragma omp taskyield new-line */
44074 static void
44076 {
44079 }
44081 /* OpenMP 4.0:
44082 # pragma omp taskgroup new-line
44083 structured-block
44085 OpenMP 5.0:
44086 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
44088 #define OMP_TASKGROUP_CLAUSE_MASK \
44089 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44090 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
44092 static tree
44094 {
44095 tree clauses
44100 if_p),
44101 clauses);
44102 }
44105 /* OpenMP 2.5:
44106 # pragma omp threadprivate (variable-list) */
44108 static void
44110 {
44111 tree vars;
44117 }
44119 /* OpenMP 4.0:
44120 # pragma omp cancel cancel-clause[optseq] new-line */
44122 #define OMP_CANCEL_CLAUSE_MASK \
44123 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
44124 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
44125 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
44126 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
44127 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
44129 static void
44131 {
44135 }
44137 /* OpenMP 4.0:
44138 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
44140 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
44141 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
44142 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
44143 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
44144 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
44146 static bool
44149 {
44150 tree clauses;
44154 {
44159 {
44162 }
44163 }
44165 {
44169 }
44172 {
44177 else
44181 }
44184 OMP_CANCELLATION_POINT_CLAUSE_MASK,
44186 pragma_tok);
44189 }
44191 /* OpenMP 4.0:
44192 #pragma omp distribute distribute-clause[optseq] new-line
44193 for-loop */
44195 #define OMP_DISTRIBUTE_CLAUSE_MASK \
44196 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
44197 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
44198 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
44199 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
44200 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44201 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
44202 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDER))
44204 static tree
44208 {
44217 {
44225 else
44228 {
44234 {
44238 else
44241 }
44247 else
44261 }
44262 }
44264 {
44267 }
44272 {
44275 }
44287 }
44289 /* OpenMP 4.0:
44290 # pragma omp teams teams-clause[optseq] new-line
44291 structured-block */
44293 #define OMP_TEAMS_CLAUSE_MASK \
44294 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
44295 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
44296 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
44297 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
44298 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
44299 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
44300 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44301 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
44303 static tree
44307 {
44316 {
44320 {
44346 }
44348 {
44374 }
44375 }
44377 {
44380 }
44385 {
44388 }
44398 }
44400 /* OpenMP 4.0:
44401 # pragma omp target data target-data-clause[optseq] new-line
44402 structured-block */
44404 #define OMP_TARGET_DATA_CLAUSE_MASK \
44405 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44406 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44407 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44408 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR) \
44409 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_ADDR))
44411 static tree
44413 {
44415 omp_requires_mask
44418 tree clauses
44424 {
44427 {
44445 "%<#pragma omp target data%> with map-type other "
44446 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
44450 }
44455 }
44458 {
44461 "%<#pragma omp target data%> must contain at least "
44462 "one %<map%>, %<use_device_ptr%> or %<use_device_addr%> "
44465 }
44476 }
44478 /* OpenMP 4.5:
44479 # pragma omp target enter data target-enter-data-clause[optseq] new-line
44480 structured-block */
44482 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
44483 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44484 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44485 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44486 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44487 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44489 static bool
44492 {
44495 {
44500 {
44503 }
44504 }
44506 {
44510 }
44513 {
44519 }
44522 omp_requires_mask
44525 tree clauses
44531 {
44534 {
44556 "%<#pragma omp target enter data%> with map-type other "
44560 }
44562 }
44565 {
44568 "%<#pragma omp target enter data%> must contain at least "
44571 }
44579 }
44581 /* OpenMP 4.5:
44582 # pragma omp target exit data target-enter-data-clause[optseq] new-line
44583 structured-block */
44585 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
44586 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44587 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44588 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44589 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44590 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44592 static bool
44595 {
44598 {
44603 {
44606 }
44607 }
44609 {
44613 }
44616 {
44622 }
44625 omp_requires_mask
44628 tree clauses
44634 {
44637 {
44660 "%<#pragma omp target exit data%> with map-type other "
44661 "than %<from%>, %<tofrom%>, %<release%> or %<delete%> "
44665 }
44667 }
44670 {
44673 "%<#pragma omp target exit data%> must contain at least "
44676 }
44684 }
44686 /* OpenMP 4.0:
44687 # pragma omp target update target-update-clause[optseq] new-line */
44689 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
44690 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
44691 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
44692 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44693 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44694 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44695 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
44697 static bool
44700 {
44702 {
44708 }
44710 tree clauses
44715 {
44717 "%<#pragma omp target update%> must contain at least one "
44720 }
44723 omp_requires_mask
44732 }
44734 /* OpenMP 4.0:
44735 # pragma omp target target-clause[optseq] new-line
44736 structured-block */
44738 #define OMP_TARGET_CLAUSE_MASK \
44739 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
44740 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
44741 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
44742 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
44743 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
44744 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
44745 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
44746 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
44747 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
44748 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION) \
44749 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
44750 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR)\
44751 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HAS_DEVICE_ADDR))
44753 static bool
44756 {
44758 omp_requires_mask
44762 {
44774 {
44782 {
44783 tree stmt;
44785 {
44788 OMP_TARGET_CLAUSE_MASK,
44793 OMP_TARGET_CLAUSE_MASK,
44798 OMP_TARGET_CLAUSE_MASK,
44803 }
44805 }
44810 {
44814 if_p);
44819 if_p);
44824 if_p);
44828 }
44834 /* For combined target teams, ensure the num_teams and
44835 thread_limit clause expressions are evaluated on the host,
44836 before entering the target construct. */
44845 {
44848 tf_none);
44855 OMP_CLAUSE_FIRSTPRIVATE);
44860 }
44865 }
44867 {
44870 }
44872 {
44876 }
44878 {
44881 }
44883 {
44886 }
44888 {
44891 }
44892 }
44894 {
44897 }
44904 {
44910 }
44919 }
44921 /* OpenACC 2.0:
44922 # pragma acc cache (variable-list) new-line
44923 */
44925 static tree
44927 {
44928 /* Don't create location wrapper nodes within 'OMP_CLAUSE__CACHE_'
44929 clauses. */
44930 auto_suppress_location_wrappers sentinel;
44946 }
44948 /* OpenACC 2.0:
44949 # pragma acc data oacc-data-clause[optseq] new-line
44950 structured-block */
44952 #define OACC_DATA_CLAUSE_MASK \
44953 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
44954 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
44955 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
44956 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
44957 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
44958 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
44959 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
44960 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44961 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
44962 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
44964 static tree
44966 {
44979 }
44981 /* OpenACC 2.0:
44982 # pragma acc host_data <clauses> new-line
44983 structured-block */
44985 #define OACC_HOST_DATA_CLAUSE_MASK \
44986 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) \
44987 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
44988 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) )
44990 static tree
44992 {
45005 }
45007 /* OpenACC 2.0:
45008 # pragma acc declare oacc-data-clause[optseq] new-line
45009 */
45011 #define OACC_DECLARE_CLAUSE_MASK \
45012 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
45013 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
45014 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
45015 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
45016 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
45017 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
45018 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
45019 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
45021 static tree
45023 {
45033 {
45037 }
45040 {
45044 {
45048 }
45051 {
45063 {
45065 "%qD must be a global variable in "
45067 decl);
45070 }
45075 {
45079 }
45081 {
45083 "invalid use of %<extern%> variable %qD "
45087 }
45089 {
45091 "invalid use of %<global%> variable %qD "
45095 }
45097 }
45100 /* This seems to ignore the existence of cleanup scopes?
45101 What is the meaning for local extern decls? The local
45102 extern is in this scope, but it is referring to a decl that
45103 is namespace scope. */
45106 {
45109 }
45111 {
45113 "%qD must be a variable declared in the same scope as "
45117 }
45122 {
45127 }
45130 {
45131 tree id;
45134 /* We need to mark the aliased decl, as that is the entity
45135 that is being referred to. This won't work for
45136 dependent variables, but it didn't work for them before
45137 DECL_LOCAL_DECL_P was a thing either. But then
45138 dependent local extern variable decls are as rare as
45139 hen's teeth. */
45146 else
45152 {
45155 {
45158 {
45162 }
45163 }
45164 }
45165 }
45166 }
45179 }
45181 /* OpenACC 2.0:
45182 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
45184 or
45186 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
45188 LOC is the location of the #pragma token.
45189 */
45191 #define OACC_ENTER_DATA_CLAUSE_MASK \
45192 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
45193 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
45194 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
45195 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
45196 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
45197 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
45199 #define OACC_EXIT_DATA_CLAUSE_MASK \
45200 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
45201 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
45202 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
45203 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
45204 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DETACH) \
45205 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
45206 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
45208 static tree
45211 {
45220 {
45225 }
45232 else
45237 {
45241 }
45249 }
45251 /* OpenACC 2.0:
45252 # pragma acc loop oacc-loop-clause[optseq] new-line
45253 structured-block */
45255 #define OACC_LOOP_CLAUSE_MASK \
45256 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
45257 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
45258 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
45259 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
45260 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
45261 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
45262 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
45263 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
45264 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
45265 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
45267 static tree
45270 {
45279 {
45285 }
45294 }
45296 /* OpenACC 2.0:
45297 # pragma acc kernels oacc-kernels-clause[optseq] new-line
45298 structured-block
45300 or
45302 # pragma acc parallel oacc-parallel-clause[optseq] new-line
45303 structured-block
45305 OpenACC 2.6:
45307 # pragma acc serial oacc-serial-clause[optseq] new-line
45308 */
45310 #define OACC_KERNELS_CLAUSE_MASK \
45311 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
45312 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
45313 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
45314 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
45315 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
45316 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
45317 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
45318 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
45319 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
45320 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
45321 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
45322 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
45323 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
45324 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
45325 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
45327 #define OACC_PARALLEL_CLAUSE_MASK \
45328 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
45329 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
45330 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
45331 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
45332 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
45333 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
45334 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
45335 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
45336 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
45337 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
45338 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
45339 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
45340 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
45341 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
45342 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
45343 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
45344 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
45345 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
45347 #define OACC_SERIAL_CLAUSE_MASK \
45348 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
45349 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ATTACH) \
45350 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
45351 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
45352 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
45353 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
45354 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
45355 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
45356 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
45357 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NO_CREATE) \
45358 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
45359 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
45360 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
45361 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
45362 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
45364 static tree
45367 {
45368 omp_clause_mask mask;
45371 {
45389 }
45392 {
45396 {
45399 tree clauses;
45404 }
45405 }
45414 }
45416 /* OpenACC 2.0:
45417 # pragma acc update oacc-update-clause[optseq] new-line
45418 */
45420 #define OACC_UPDATE_CLAUSE_MASK \
45421 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
45422 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
45423 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
45424 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
45425 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
45426 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
45428 static tree
45430 {
45437 {
45439 "%<#pragma acc update%> must contain at least one "
45442 }
45450 }
45452 /* OpenACC 2.0:
45453 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
45455 LOC is the location of the #pragma token.
45456 */
45458 #define OACC_WAIT_CLAUSE_MASK \
45459 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
45461 static tree
45463 {
45477 }
45479 /* OpenMP 4.0:
45480 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
45482 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
45483 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
45484 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
45485 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
45486 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
45487 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
45488 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
45490 static void
45494 {
45496 cp_omp_declare_simd_data data;
45498 {
45506 /* It is safe to take the address of a local variable; it will only be
45507 used while this scope is live. */
45509 }
45511 {
45513 "%<#pragma omp declare %s%> followed by "
45518 }
45520 /* Store away all pragma tokens. */
45529 {
45533 {
45546 }
45551 "%<#pragma omp declare %s%> not immediately followed by "
45556 }
45557 }
45569 /* OpenMP 5.0:
45571 trait-selector:
45572 trait-selector-name[([trait-score:]trait-property[,trait-property[,...]])]
45574 trait-score:
45575 score(score-expression) */
45577 static tree
45579 {
45581 do
45582 {
45583 tree selector;
45587 else
45588 {
45591 }
45602 {
45629 }
45631 {
45633 {
45635 {
45638 }
45639 else
45640 {
45646 }
45647 }
45652 }
45662 {
45664 {
45668 }
45670 matching_parens parens;
45678 {
45685 {
45689 matching_parens parens2;
45697 {
45709 else
45712 }
45713 }
45714 else
45718 }
45721 {
45722 tree t;
45724 do
45725 {
45728 {
45736 "constant integer expression or string "
45738 else
45740 }
45741 else
45746 else
45748 }
45754 {
45758 }
45759 else
45760 {
45763 }
45766 do
45767 {
45771 {
45774 }
45777 else
45778 {
45782 }
45788 else
45790 }
45796 {
45803 else
45805 }
45806 else
45811 {
45813 "selector may not be specified in "
45816 }
45817 properties
45819 OMP_DECLARE_SIMD_CLAUSE_MASK,
45824 }
45830 }
45834 {
45837 }
45843 else
45845 }
45849 }
45851 /* OpenMP 5.0:
45853 trait-set-selector[,trait-set-selector[,...]]
45855 trait-set-selector:
45856 trait-set-selector-name = { trait-selector[, trait-selector[, ...]] }
45858 trait-set-selector-name:
45859 constructor
45860 device
45861 implementation
45862 user */
45864 static tree
45867 {
45869 do
45870 {
45873 setp
45876 {
45895 }
45897 {
45901 }
45909 matching_braces braces;
45913 tree selectors
45916 {
45919 }
45927 else
45929 }
45935 }
45937 /* Assumption clauses:
45938 OpenMP 5.1
45939 absent (directive-name-list)
45940 contains (directive-name-list)
45941 holds (expression)
45942 no_openmp
45943 no_openmp_routines
45944 no_parallelism */
45946 static void
45949 {
45965 {
45966 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
45982 {
45987 }
45989 {
45994 }
45996 {
46001 }
46003 {
46005 matching_parens parens;
46007 {
46013 {
46017 }
46023 }
46024 }
46026 {
46028 matching_parens parens;
46030 {
46031 do
46032 {
46035 location_t dloc
46038 {
46039 tree id;
46044 CPP_KEYWORD))
46045 {
46046 enum rid rid
46050 }
46051 else
46054 }
46057 else
46058 {
46071 else
46072 {
46077 "mentioned in both %<absent%> and "
46085 ? &absent_head
46088 "mentioned multiple times in %qs "
46095 }
46098 }
46101 else
46103 }
46110 }
46111 }
46113 {
46120 }
46121 else
46122 {
46126 }
46127 }
46129 }
46131 /* OpenMP 5.1
46132 # pragma omp assume clauses[optseq] new-line */
46134 static void
46136 {
46139 }
46141 /* OpenMP 5.1
46142 # pragma omp assumes clauses[optseq] new-line */
46144 static bool
46146 {
46149 }
46151 /* Finalize #pragma omp declare variant after a fndecl has been parsed, and put
46152 that into "omp declare variant base" attribute. */
46154 static tree
46156 tree attrs)
46157 {
46158 matching_parens parens;
46160 {
46161 fail:
46164 }
46169 cp_expr varid
46177 tree variant;
46184 else
46185 {
46186 tree ambiguous_decls;
46194 }
46198 {
46200 variant
46208 }
46214 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46225 {
46228 }
46240 {
46242 match_loc);
46251 }
46256 }
46259 /* Finalize #pragma omp declare simd clauses after direct declarator has
46260 been parsed, and put that into "omp declare simd" attribute. */
46262 static tree
46264 {
46270 {
46275 }
46280 {
46291 {
46292 /* For now only in C++ attributes, do it always for OpenMP 5.1.
46293 if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)
46294 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_NAME))
46295 cp_lexer_consume_token (parser->lexer); */
46299 pragma_tok);
46307 }
46308 else
46309 {
46311 attrs
46313 }
46315 }
46319 {
46325 {
46327 {
46334 {
46342 else
46345 }
46351 {
46353 "unknown OpenMP directive name in "
46356 }
46360 {
46362 "OpenMP directive other than %<declare simd%> "
46363 "or %<declare variant%> appertains to a "
46366 }
46369 {
46371 "mixing OpenMP directives with attribute and "
46374 }
46379 {
46382 }
46384 cp_token tok = {};
46392 tok = {};
46397 tok = {};
46409 /* Move the current source position to that of the first token
46410 in the new lexer. */
46420 {
46428 pragma_tok);
46432 cl);
46437 }
46438 else
46439 {
46441 attrs
46443 attrs);
46444 }
46447 }
46449 }
46450 else
46452 }
46458 }
46460 /* Helper for cp_parser_omp_declare_target, handle one to or link clause
46461 on #pragma omp declare target. Return false if errors were reported. */
46463 static bool
46465 {
46468 tree id;
46470 {
46473 }
46474 else
46477 {
46480 "%qD specified both in declare target %<link%> and %qs"
46482 else
46484 "%qD specified both in declare target %<link%> and "
46487 }
46489 {
46496 {
46499 {
46503 }
46504 }
46505 }
46509 {
46513 {
46516 }
46517 }
46519 {
46523 {
46526 }
46527 }
46529 }
46531 /* OpenMP 4.0:
46532 # pragma omp declare target new-line
46533 declarations and definitions
46534 # pragma omp end declare target new-line
46536 OpenMP 4.5:
46537 # pragma omp declare target ( extended-list ) new-line
46539 # pragma omp declare target declare-target-clauses[seq] new-line */
46541 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
46542 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
46543 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \
46544 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \
46545 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE))
46547 static void
46549 {
46554 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46558 clauses
46562 {
46564 clauses);
46567 }
46568 else
46569 {
46570 cp_omp_declare_target_attr a
46575 }
46580 {
46593 device_type);
46594 }
46598 }
46600 /* OpenMP 5.1
46601 # pragma omp begin assumes clauses[optseq] new-line
46603 # pragma omp begin declare target clauses[optseq] new-line */
46605 #define OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK \
46606 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE)
46608 static void
46610 {
46614 {
46617 }
46619 {
46623 {
46626 }
46628 {
46630 tree clauses
46632 OMP_BEGIN_DECLARE_TARGET_CLAUSE_MASK,
46634 pragma_tok);
46639 cp_omp_declare_target_attr a
46642 }
46643 else
46644 {
46647 }
46648 }
46650 {
46655 }
46656 else
46657 {
46660 }
46661 }
46663 /* OpenMP 4.0:
46664 # pragma omp end declare target new-line
46666 OpenMP 5.1:
46667 # pragma omp end assumes new-line */
46669 static void
46671 {
46675 {
46678 }
46680 {
46684 {
46687 }
46690 else
46691 {
46695 }
46699 "%<#pragma omp end declare target%> without corresponding "
46700 "%<#pragma omp declare target%> or "
46702 else
46703 {
46704 cp_omp_declare_target_attr
46707 {
46710 "%qs in attribute syntax terminated "
46715 else
46717 "%qs in pragma syntax terminated "
46722 }
46723 }
46724 }
46726 {
46733 else
46734 {
46735 cp_omp_begin_assumes_data
46738 {
46741 "%qs in attribute syntax terminated "
46744 else
46746 "%qs in pragma syntax terminated "
46749 }
46750 }
46751 }
46752 else
46753 {
46757 }
46758 }
46760 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
46761 expression and optional initializer clause of
46762 #pragma omp declare reduction. We store the expression(s) as
46763 either 3, 6 or 7 special statements inside of the artificial function's
46764 body. The first two statements are DECL_EXPRs for the artificial
46765 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
46766 expression that uses those variables.
46767 If there was any INITIALIZER clause, this is followed by further statements,
46768 the fourth and fifth statements are DECL_EXPRs for the artificial
46769 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
46770 constructor variant (first token after open paren is not omp_priv),
46771 then the sixth statement is a statement with the function call expression
46772 that uses the OMP_PRIV and optionally OMP_ORIG variable.
46773 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
46774 to initialize the OMP_PRIV artificial variable and there is seventh
46775 statement, a DECL_EXPR of the OMP_PRIV statement again. */
46777 static bool
46779 {
46791 tree combiner;
46806 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
46814 {
46817 }
46820 {
46822 matching_parens parens;
46828 {
46831 }
46847 {
46851 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
46855 == CPP_CLOSE_PAREN
46858 {
46862 }
46867 }
46868 else
46869 {
46871 /* Don't create location wrapper nodes here. */
46872 auto_suppress_location_wrappers sentinel;
46887 {
46892 }
46894 tree arg;
46907 }
46920 }
46924 UNKNOWN_LOCATION);
46927 }
46929 /* OpenMP 4.0
46930 #pragma omp declare reduction (reduction-id : typename-list : expression) \
46931 initializer-clause[opt] new-line
46933 initializer-clause:
46934 initializer (omp_priv initializer)
46935 initializer (function-name (argument-list)) */
46937 static void
46940 {
46950 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
46957 {
46989 }
47001 /* Types may not be defined in declare reduction type list. */
47004 parser->type_definition_forbidden_message
47010 saved_colon_doesnt_start_class_def_p
47015 {
47019 ;
47037 else
47042 else
47044 }
47046 /* Restore the saved message. */
47049 parser->colon_doesnt_start_class_def_p
47054 {
47055 fail:
47058 }
47064 {
47065 tree fntype
47068 NULL_TREE);
47085 {
47089 }
47095 {
47098 }
47100 {
47102 {
47108 }
47115 }
47116 else
47117 {
47120 /* We should never meet a matched duplicate decl. */
47122 }
47127 else
47130 {
47133 }
47141 else
47142 {
47146 }
47151 {
47159 }
47167 }
47171 done:
47172 /* Free any declarators allocated. */
47174 }
47176 /* OpenMP 4.0
47177 #pragma omp declare simd declare-simd-clauses[optseq] new-line
47178 #pragma omp declare reduction (reduction-id : typename-list : expression) \
47179 initializer-clause[opt] new-line
47180 #pragma omp declare target new-line
47182 OpenMP 5.0
47183 #pragma omp declare variant (identifier) match (context-selector) */
47185 static bool
47188 {
47190 {
47195 {
47200 }
47202 {
47207 }
47210 {
47213 context);
47215 }
47217 {
47220 }
47222 {
47226 }
47227 }
47232 }
47234 /* OpenMP 5.0
47235 #pragma omp requires clauses[optseq] new-line */
47237 static bool
47239 {
47245 {
47246 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
47255 {
47270 {
47273 matching_parens parens;
47275 {
47277 {
47282 this_req
47285 this_req
47288 this_req
47290 }
47292 {
47294 "expected %<seq_cst%>, %<relaxed%> or "
47297 {
47304 CPP_CLOSE_PAREN))
47307 }
47308 }
47309 else
47316 /*consume_paren=*/
47320 {
47323 }
47324 }
47326 }
47327 else
47328 {
47330 "%<unified_shared_memory%>, "
47331 "%<dynamic_allocators%>, "
47332 "%<reverse_offload%> "
47336 }
47340 {
47342 {
47349 }
47351 {
47355 }
47358 {
47361 this_req
47363 (omp_requires_mask
47365 }
47369 "lexically after first %<atomic%> construct "
47372 omp_requires_mask
47375 }
47376 }
47378 }
47384 }
47387 /* OpenMP 5.1:
47388 #pragma omp nothing new-line */
47390 static void
47392 {
47394 }
47397 /* OpenMP 5.1
47398 #pragma omp error clauses[optseq] new-line */
47400 static bool
47403 {
47412 {
47413 /* For now only in C++ attributes, do it always for OpenMP 5.1. */
47429 };
47437 {
47440 }
47442 {
47447 }
47451 matching_parens parens;
47453 {
47455 {
47459 else
47461 tf_warning_or_error,
47462 LOOKUP_NORMAL);
47463 }
47464 else
47465 {
47467 {
47475 }
47477 {
47482 {
47489 CPP_CLOSE_PAREN))
47492 }
47493 }
47494 else
47496 }
47502 /*consume_paren=*/
47506 {
47508 {
47511 }
47512 else
47514 }
47516 {
47518 {
47521 }
47522 else
47524 }
47525 }
47526 else
47528 }
47538 {
47540 {
47544 }
47545 tree fndecl
47554 }
47561 {
47565 }
47569 else
47573 }
47575 /* OpenMP 4.5:
47576 #pragma omp taskloop taskloop-clause[optseq] new-line
47577 for-loop
47579 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
47580 for-loop */
47582 #define OMP_TASKLOOP_CLAUSE_MASK \
47583 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
47584 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
47585 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
47586 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
47587 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
47588 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
47589 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
47590 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
47591 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
47592 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
47593 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
47594 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
47595 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
47596 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
47597 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALLOCATE) \
47598 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
47599 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
47601 static tree
47605 {
47612 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
47613 clause. */
47618 {
47623 {
47647 }
47648 }
47650 {
47653 }
47658 {
47661 }
47668 if_p);
47674 }
47677 /* OpenACC 2.0:
47678 # pragma acc routine oacc-routine-clause[optseq] new-line
47679 function-definition
47681 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
47682 */
47684 #define OACC_ROUTINE_CLAUSE_MASK \
47685 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
47686 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
47687 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
47688 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
47689 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NOHOST) )
47691 /* Parse the OpenACC routine pragma. This has an optional '( name )'
47692 component, which must resolve to a declared namespace-scope
47693 function. The clauses are either processed directly (for a named
47694 function), or defered until the immediatley following declaration
47695 is parsed. */
47697 static void
47700 {
47702 /* The checking for "another pragma following this one" in the "no optional
47703 '( name )'" case makes sure that we dont re-enter. */
47706 cp_oacc_routine_data data;
47712 /* It is safe to take the address of a local variable; it will only be
47713 used while this scope is live. */
47716 /* Look for optional '( name )'. */
47718 {
47719 matching_parens parens;
47722 /* We parse the name as an id-expression. If it resolves to
47723 anything other than a non-overloaded function at namespace
47724 scope, it's an error. */
47740 {
47744 }
47746 data.clauses
47750 /* The clauses are in reverse order; fix that to make later diagnostic
47751 emission easier. */
47757 {
47762 }
47764 /* Perhaps we should use the same rule as declarations in different
47765 namespaces? */
47767 {
47772 }
47775 {
47779 }
47783 }
47785 {
47786 /* Store away all pragma tokens. */
47794 /* Emit a helpful diagnostic if there's another pragma following this
47795 one. */
47797 {
47800 /* ..., and then just keep going. */
47802 }
47804 /* We only have to consider the pragma_external case here. */
47809 else
47812 }
47813 }
47815 /* Finalize #pragma acc routine clauses after direct declarator has
47816 been parsed. */
47818 static tree
47820 {
47825 {
47827 "%<#pragma acc routine%> not immediately followed by "
47830 }
47846 /* The clauses are in reverse order; fix that to make later diagnostic
47847 emission easier. */
47850 /* Later, cp_finalize_oacc_routine will process the clauses. */
47854 }
47856 /* Apply any saved OpenACC routine clauses to a just-parsed
47857 declaration. */
47859 static void
47861 {
47863 {
47864 /* Keep going if we're in error reporting mode. */
47870 {
47872 {
47874 "%<#pragma acc routine%> not immediately followed by"
47878 }
47882 }
47884 int compatible
47889 {
47892 }
47894 {
47895 }
47896 else
47897 {
47899 {
47908 }
47910 /* Set the routine's level of parallelism. */
47914 /* Add an "omp declare target" attribute. */
47919 }
47920 }
47921 }
47923 /* Main entry point to OpenMP statement pragmas. */
47925 static void
47927 {
47928 tree stmt;
47933 {
47961 if_p);
47981 if_p);
47986 if_p);
47991 if_p);
47996 if_p);
48001 if_p);
48006 if_p);
48018 if_p);
48032 if_p);
48037 if_p);
48044 }
48047 }
48048 \f
48049 /* Transactional Memory parsing routines. */
48051 /* Parse a transaction attribute.
48053 txn-attribute:
48054 attribute
48055 [ [ identifier ] ]
48057 We use this instead of cp_parser_attributes_opt for transactions to avoid
48058 the pedwarn in C++98 mode. */
48060 static tree
48062 {
48077 {
48081 /* For keywords, use the canonical spelling,
48082 not the parsed identifier. */
48086 }
48087 else
48091 error1:
48094 }
48096 /* Parse a __transaction_atomic or __transaction_relaxed statement.
48098 transaction-statement:
48099 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
48100 compound-statement
48101 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
48102 */
48104 static tree
48106 {
48117 else
48118 {
48122 }
48124 /* Parse a noexcept specification. */
48128 {
48129 /* cancel-and-throw is unimplemented. */
48132 }
48133 else
48135 CP_PARSER_FLAGS_NONE,
48140 /* Keep track if we're in the lexical scope of an outer transaction. */
48152 }
48154 /* Parse a __transaction_atomic or __transaction_relaxed expression.
48156 transaction-expression:
48157 __transaction_atomic txn-noexcept-spec[opt] ( expression )
48158 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
48159 */
48161 static tree
48163 {
48176 keyword == RID_TRANSACTION_RELAXED
48190 /* Set this early. This might mean that we allow transaction_cancel in
48191 an expression that we find out later actually has to be a constexpr.
48192 However, we expect that cxx_constant_value will be able to deal with
48193 this; also, if the noexcept has no constexpr, then what we parse next
48194 really is a transaction's body. */
48197 /* Parse a noexcept specification. */
48199 CP_PARSER_FLAGS_NONE,
48206 {
48207 matching_parens parens;
48214 }
48215 else
48216 {
48217 /* The only expression that is available got parsed for the noexcept
48218 already. noexcept is true then. */
48221 }
48230 }
48232 /* Parse a function-transaction-block.
48234 function-transaction-block:
48235 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
48236 function-body
48237 __transaction_atomic txn-attribute[opt] function-try-block
48238 __transaction_relaxed ctor-initializer[opt] function-body
48239 __transaction_relaxed function-try-block
48240 */
48242 static void
48244 {
48259 else
48260 {
48264 }
48272 else
48273 cp_parser_ctor_initializer_opt_and_function_body
48279 }
48281 /* Parse a __transaction_cancel statement.
48283 cancel-statement:
48284 __transaction_cancel txn-attribute[opt] ;
48285 __transaction_cancel txn-attribute[opt] throw-expression ;
48287 ??? Cancel and throw is not yet implemented. */
48289 static tree
48291 {
48297 RT_TRANSACTION_CANCEL);
48304 /* ??? Parse cancel-and-throw here. */
48309 {
48313 }
48315 {
48319 }
48321 {
48324 {
48330 }
48331 }
48333 {
48337 }
48343 }
48344 \f
48346 /* Special handling for the first token or line in the file. The first
48347 thing in the file might be #pragma GCC pch_preprocess, which loads a
48348 PCH file, which is a GC collection point. So we need to handle this
48349 first pragma without benefit of an existing lexer structure.
48351 Always returns one token to the caller in *FIRST_TOKEN. This is
48352 either the true first token of the file, or the first token after
48353 the initial pragma. */
48355 static void
48357 {
48365 {
48369 }
48371 /* Skip to the end of the pragma. */
48373 {
48376 do
48379 }
48381 /* Now actually load the PCH file. */
48385 /* Read one more token to return to our caller. We have to do this
48386 after reading the PCH file in, since its pointers have to be
48387 live. */
48389 }
48391 /* Parse a pragma GCC ivdep. */
48393 static bool
48395 {
48398 }
48400 /* Parse a pragma GCC unroll. */
48402 static unsigned short
48404 {
48414 {
48416 " assignment-expression that evaluates to a non-negative"
48419 }
48420 else
48421 {
48425 }
48428 }
48430 /* Normal parsing of a pragma token. Here we can (and must) use the
48431 regular lexer. */
48433 static bool
48435 {
48438 tree stmt;
48449 {
48457 {
48468 }
48473 {
48484 }
48489 {
48500 }
48505 {
48517 }
48522 {
48534 }
48539 {
48551 }
48570 {
48576 }
48584 {
48590 }
48598 {
48603 }
48609 {
48615 }
48623 {
48629 }
48671 {
48673 "%<#pragma omp requires%> may only be used at file or "
48677 }
48682 {
48684 "%<#pragma omp assumes%> may only be used at file or "
48688 }
48724 "%<#pragma omp scan%> may only be used in "
48730 "%<#pragma omp section%> may only be used in "
48735 {
48737 {
48741 }
48747 {
48751 }
48752 else
48758 {
48761 }
48764 }
48767 {
48769 {
48773 }
48774 const unsigned short unroll
48780 {
48784 }
48785 else
48791 {
48794 }
48797 }
48804 bad_stmt:
48807 }
48811 }
48813 /* The interface the pragma parsers have to the lexer. */
48815 enum cpp_ttype
48817 {
48829 else
48830 {
48834 }
48837 }
48839 \f
48840 /* External interface. */
48842 /* Parse one entire translation unit. */
48844 void
48846 {
48854 /* cp_lexer_new_main is called before doing any GC allocation
48855 because tokenization might load a PCH file. */
48864 }
48866 /* Create an identifier for a generic parameter type (a synthesized
48867 template parameter implied by `auto' or a concept identifier). */
48870 static tree
48872 {
48876 }
48878 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
48879 (creating a new template parameter list if necessary). Returns the newly
48880 created template type parm. */
48882 static tree
48884 {
48885 /* A requires-clause is not a function and cannot have placeholders. */
48887 {
48890 }
48894 /* We are either continuing a function template that already contains implicit
48895 template parameters, creating a new fully-implicit function template, or
48896 extending an existing explicit function template with implicit template
48897 parameters. */
48905 {
48909 }
48910 else
48911 {
48912 /* Roll back to the existing template parameter scope (in the case of
48913 extending an explicit function template) or introduce a new template
48914 parameter scope ahead of the function parameter scope (or class scope
48915 in the case of out-of-line member definitions). The function scope is
48916 added back after template parameter synthesis below. */
48921 {
48924 }
48926 {
48927 /* If not defining a class, then any class scope is a scope level in
48928 an out-of-line member definition. In this case simply wind back
48929 beyond the first such scope to inject the template parameter list.
48930 Otherwise wind back to the class being defined. The latter can
48931 occur in class member friend declarations such as:
48933 class A {
48934 void foo (auto);
48935 };
48936 class B {
48937 friend void A::foo (auto);
48938 };
48940 The template parameter list synthesized for the friend declaration
48941 must be injected in the scope of 'B'. This can also occur in
48942 erroneous cases such as:
48944 struct A {
48945 struct B {
48946 void foo (auto);
48947 };
48948 void B::foo (auto) {}
48949 };
48951 Here the attempted definition of 'B::foo' within 'A' is ill-formed
48952 but, nevertheless, the template parameter list synthesized for the
48953 declarator should be injected into the scope of 'A' as if the
48954 ill-formed template was specified explicitly. */
48957 {
48960 }
48961 }
48967 {
48968 /* Introduce a new template parameter list for implicit template
48969 parameters. */
48973 parser->implicit_template_scope
48980 }
48981 else
48982 {
48983 /* Synthesize implicit template parameters at the end of the explicit
48984 template parameter list. */
48991 parser->implicit_template_parms
48993 }
48994 }
48996 /* Synthesize a new template parameter and track the current template
48997 parameter chain with implicit_template_parms. */
49001 tree synth_tmpl_parm;
49004 /* Synthesize the type template parameter. */
49012 /* Attach the constraint to the parm before processing. */
49015 tree new_parm
49017 input_location,
49018 node,
49022 /* Mark the synthetic declaration "virtual". This is used when
49023 comparing template-heads to determine if whether an abbreviated
49024 function template is equivalent to an explicit template.
49026 Note that DECL_ARTIFICIAL is used elsewhere for template parameters. */
49030 // Chain the new parameter to the list of implicit parameters.
49032 parser->implicit_template_parms
49034 else
49039 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
49042 /* If creating a fully implicit function template, start the new implicit
49043 template parameter list with this synthesized type, otherwise grow the
49044 current template parameter list. */
49047 {
49053 }
49054 else
49055 {
49060 }
49062 /* If the new parameter was constrained, we need to add that to the
49063 constraints in the template parameter list. */
49065 {
49069 }
49074 }
49076 /* Finish the declaration of a fully implicit function template. Such a
49077 template has no explicit template parameter list so has not been through the
49078 normal template head and tail processing. synthesize_implicit_template_parm
49079 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
49080 provided if the declaration is a class member such that its template
49081 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
49082 form is returned. Otherwise NULL_TREE is returned. */
49084 static tree
49086 {
49091 {
49095 }
49107 }
49109 /* Like finish_fully_implicit_template, but to be used in error
49110 recovery, rearranging scopes so that we restore the state we had
49111 before synthesize_implicit_template_parm inserted the implement
49112 template parms scope. */
49114 static void
49116 {
49121 {
49130 }
49131 else
49137 }
49139 /* Helper function for diagnostics that have complained about things
49140 being used with 'extern "C"' linkage.
49142 Attempt to issue a note showing where the 'extern "C"' linkage began. */
49144 void
49146 {
49150 }