| blob | 5f69403349654386dd0d135e113df43b341d170d |
1 /* -*- C++ -*- Parser.
2 Copyright (C) 2000-2019 Free Software Foundation, Inc.
3 Written by Mark Mitchell <mark@codesourcery.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 #define INCLUDE_UNIQUE_PTR
49 \f
50 /* The lexer. */
52 /* The cp_lexer_* routines mediate between the lexer proper (in libcpp
53 and c-lex.c) and the C++ parser. */
56 {
58 };
60 /* The various kinds of non integral constant we encounter. */
62 NIC_NONE,
63 /* floating-point literal */
64 NIC_FLOAT,
65 /* %<this%> */
66 NIC_THIS,
67 /* %<__FUNCTION__%> */
68 NIC_FUNC_NAME,
69 /* %<__PRETTY_FUNCTION__%> */
70 NIC_PRETTY_FUNC,
71 /* %<__func__%> */
72 NIC_C99_FUNC,
73 /* "%<va_arg%> */
74 NIC_VA_ARG,
75 /* a cast */
76 NIC_CAST,
77 /* %<typeid%> operator */
78 NIC_TYPEID,
79 /* non-constant compound literals */
80 NIC_NCC,
81 /* a function call */
82 NIC_FUNC_CALL,
83 /* an increment */
84 NIC_INC,
85 /* an decrement */
86 NIC_DEC,
87 /* an array reference */
88 NIC_ARRAY_REF,
89 /* %<->%> */
90 NIC_ARROW,
91 /* %<.%> */
92 NIC_POINT,
93 /* the address of a label */
94 NIC_ADDR_LABEL,
95 /* %<*%> */
96 NIC_STAR,
97 /* %<&%> */
98 NIC_ADDR,
99 /* %<++%> */
100 NIC_PREINCREMENT,
101 /* %<--%> */
102 NIC_PREDECREMENT,
103 /* %<new%> */
104 NIC_NEW,
105 /* %<delete%> */
106 NIC_DEL,
107 /* calls to overloaded operators */
108 NIC_OVERLOADED,
109 /* an assignment */
110 NIC_ASSIGNMENT,
111 /* a comma operator */
112 NIC_COMMA,
113 /* a call to a constructor */
114 NIC_CONSTRUCTOR,
115 /* a transaction expression */
116 NIC_TRANSACTION
117 };
119 /* The various kinds of errors about name-lookup failing. */
121 /* NULL */
122 NLE_NULL,
123 /* is not a type */
124 NLE_TYPE,
125 /* is not a class or namespace */
126 NLE_CXX98,
127 /* is not a class, namespace, or enumeration */
128 NLE_NOT_CXX98
129 };
131 /* The various kinds of required token */
133 RT_NONE,
155 /* The type is CPP_KEYWORD */
184 RT_TRANSACTION_CANCEL /* __transaction_cancel */
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
251 static void cp_parser_initial_pragma
254 static bool cp_parser_omp_declare_reduction_exprs
256 static void cp_finalize_oacc_routine
259 /* Manifest constants. */
260 #define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
261 #define CP_SAVED_TOKEN_STACK 5
263 /* Variables. */
265 /* The stream to which debugging output should be written. */
268 /* Nonzero if we are parsing an unevaluated operand: an operand to
269 sizeof, typeof, or alignof. */
272 /* Dump up to NUM tokens in BUFFER to FILE starting with token
273 START_TOKEN. If START_TOKEN is NULL, the dump starts with the
274 first token in BUFFER. If NUM is 0, dump all the tokens. If
275 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
276 highlighted by surrounding it in [[ ]]. */
278 static void
282 {
299 {
302 }
307 {
314 nprinted++;
324 {
334 }
335 }
338 {
341 }
344 }
347 /* Dump all tokens in BUFFER to stderr. */
349 void
351 {
353 }
355 DEBUG_FUNCTION void
357 {
359 }
361 DEBUG_FUNCTION void
363 {
366 else
368 }
371 /* Dump the cp_parser tree field T to FILE if T is non-NULL. DESC is the
372 description for T. */
374 static void
376 {
378 {
381 }
382 }
385 /* Dump parser context C to FILE. */
387 static void
389 {
394 }
397 /* Print the stack of parsing contexts to FILE starting with FIRST. */
399 static void
401 {
407 {
410 }
411 }
414 /* Print the value of FLAG to FILE. DESC is a string describing the flag. */
416 static void
418 {
421 }
424 /* Print an unparsed function entry UF to FILE. */
426 static void
428 {
431 tree fn;
436 i++)
437 {
443 }
448 {
451 }
457 {
460 }
462 }
465 /* Print the stack of unparsed member functions S to FILE. */
467 static void
470 {
476 {
479 }
480 }
483 /* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
484 the given PARSER. If FILE is NULL, the output is printed on stderr. */
486 static void
488 {
500 next_token);
501 }
504 /* Dump debugging information for the given PARSER. If FILE is NULL,
505 the output is printed on stderr. */
507 void
509 {
512 expanded_location eloc;
589 }
591 DEBUG_FUNCTION void
593 {
595 }
597 DEBUG_FUNCTION void
599 {
602 else
604 }
606 /* Allocate memory for a new lexer object and return it. */
610 {
615 /* Allocate the memory. */
618 /* Initially we are not debugging. */
623 /* Create the buffer. */
627 }
630 /* Create a new main C++ lexer, the lexer that gets tokens from the
631 preprocessor. */
635 {
637 cp_token token;
639 /* It's possible that parsing the first pragma will load a PCH file,
640 which is a GC collection point. So we have to do that before
641 allocating any memory. */
646 /* Put the first token in the buffer. */
649 /* Get the remaining tokens from the preprocessor. */
651 {
654 }
663 /* Subsequent preprocessor diagnostics should use compiler
664 diagnostic functions to get the compiler source location. */
669 }
671 /* Create a new lexer whose token stream is primed with the tokens in
672 CACHE. When these tokens are exhausted, no new tokens will be read. */
676 {
681 /* We do not own the buffer. */
688 /* Initially we are not debugging. */
693 }
695 /* Frees all resources associated with LEXER. */
697 static void
699 {
703 }
705 /* This needs to be set to TRUE before the lexer-debugging infrastructure can
706 be used. The point of this flag is to help the compiler to fold away calls
707 to cp_lexer_debugging_p within this source file at compile time, when the
708 lexer is not being debugged. */
710 #define LEXER_DEBUGGING_ENABLED_P false
712 /* Returns nonzero if debugging information should be output. */
716 {
721 }
726 {
730 }
734 {
736 }
740 {
742 }
746 {
749 else
751 }
755 {
758 /* Skip past purged tokens. */
760 {
762 tp--;
763 }
766 }
768 /* nonzero if we are presently saving tokens. */
772 {
774 }
776 /* Store the next token from the preprocessor in *TOKEN. Return true
777 if we reach EOF. If LEXER is NULL, assume we are handling an
778 initial #pragma pch_preprocess, and thus want the lexer to return
779 processed strings. */
781 static void
783 {
786 /* Get a new token from the preprocessor. */
787 token->type
794 /* On some systems, some header files are surrounded by an
795 implicit extern "C" block. Set a flag in the token if it
796 comes from such a header. */
801 /* Check to see if this token is a keyword. */
803 {
805 {
806 /* Mark this token as a keyword. */
808 /* Record which keyword. */
810 }
811 else
812 {
816 {
817 /* Warn about the C++0x keyword (but still treat it as
818 an identifier). */
823 /* Clear out the C_RID_CODE so we don't warn about this
824 particular identifier-turned-keyword again. */
826 }
829 }
830 }
832 {
833 /* This only happens in Objective-C++; it must be a keyword. */
836 {
837 /* Replace 'class' with '@class', 'private' with '@private',
838 etc. This prevents confusion with the C++ keyword
839 'class', and makes the tokens consistent with other
840 Objective-C 'AT' keywords. For example '@class' is
841 reported as RID_AT_CLASS which is consistent with
842 '@synchronized', which is reported as
843 RID_AT_SYNCHRONIZED.
844 */
854 }
855 }
856 }
858 /* Update the globals input_location and the input file stack from TOKEN. */
861 {
863 {
865 }
866 }
868 /* Update the globals input_location and the input file stack from LEXER. */
871 {
874 }
876 /* Return a pointer to the next token in the token stream, but do not
877 consume it. */
881 {
883 {
887 }
889 }
891 /* Return true if the next token has the indicated TYPE. */
895 {
897 }
899 /* Return true if the next token does not have the indicated TYPE. */
903 {
905 }
907 /* Return true if the next token is the indicated KEYWORD. */
911 {
913 }
917 {
919 }
923 {
925 }
927 /* Return true if KEYWORD can start a decl-specifier. */
929 bool
931 {
933 {
934 /* auto specifier: storage-class-specifier in C++,
935 simple-type-specifier in C++0x. */
937 /* Storage classes. */
943 /* Elaborated type specifiers. */
949 /* Simple type specifiers. */
964 /* GNU extensions. */
967 /* C++0x extensions. */
979 }
980 }
982 /* Return true if the next token is a keyword for a decl-specifier. */
984 static bool
986 {
991 }
993 /* Returns TRUE iff the token T begins a decltype type. */
995 static bool
997 {
1000 }
1002 /* Returns TRUE iff the next token begins a decltype type. */
1004 static bool
1006 {
1009 }
1011 /* Called when processing a token with tree_check_value; perform or defer the
1012 associated checks and return the value. */
1014 static tree
1016 {
1017 /* Perform any access checks that were deferred. */
1022 {
1028 }
1029 /* Return the stored value. */
1031 }
1033 /* Return a pointer to the Nth token in the token stream. If N is 1,
1034 then this is precisely equivalent to cp_lexer_peek_token (except
1035 that it is not inline). One would like to disallow that case, but
1036 there is one case (cp_parser_nth_token_starts_template_id) where
1037 the caller passes a variable for N and it might be 1. */
1041 {
1044 /* N is 1-based, not zero-based. */
1055 {
1058 {
1061 }
1065 }
1068 {
1071 }
1074 }
1076 /* Return the next token, and advance the lexer's next_token pointer
1077 to point to the next non-purged token. */
1081 {
1087 do
1088 {
1091 {
1094 }
1096 }
1101 /* Provide debugging output. */
1103 {
1107 }
1110 }
1112 /* Permanently remove the next token from the token stream, and
1113 advance the next_token pointer to refer to the next non-purged
1114 token. */
1116 static void
1118 {
1127 do
1128 {
1129 tok++;
1131 {
1134 }
1135 }
1138 }
1140 /* Permanently remove all tokens after TOK, up to, but not
1141 including, the token that will be returned next by
1142 cp_lexer_peek_token. */
1144 static void
1146 {
1155 {
1160 }
1161 }
1163 /* Begin saving tokens. All tokens consumed after this point will be
1164 preserved. */
1166 static void
1168 {
1169 /* Provide debugging output. */
1174 }
1176 /* Commit to the portion of the token stream most recently saved. */
1178 static void
1180 {
1181 /* Provide debugging output. */
1186 }
1188 /* Return all tokens saved since the last call to cp_lexer_save_tokens
1189 to the token stream. Stop saving tokens. */
1191 static void
1193 {
1194 /* Provide debugging output. */
1199 }
1201 /* RAII wrapper around the above functions, with sanity checking. Creating
1202 a variable saves tokens, which are committed when the variable is
1203 destroyed unless they are explicitly rolled back by calling the rollback
1204 member function. */
1206 struct saved_token_sentinel
1207 {
1212 {
1215 }
1217 {
1220 }
1222 {
1226 }
1227 };
1229 /* Print a representation of the TOKEN on the STREAM. */
1231 static void
1233 {
1234 /* We don't use cpp_type2name here because the parser defines
1235 a few tokens of its own. */
1237 /* cpplib-defined token types */
1238 #define OP(e, s) #e,
1239 #define TK(e, s) #e,
1240 TTYPE_TABLE
1241 #undef OP
1242 #undef TK
1243 /* C++ parser token types - see "Manifest constants", above. */
1247 };
1249 /* For some tokens, print the associated data. */
1251 {
1253 /* Some keywords have a value that is not an IDENTIFIER_NODE.
1254 For example, `struct' is mapped to an INTEGER_CST. */
1257 /* fall through */
1275 /* If we have a name for the token, print it out. Otherwise, we
1276 simply give the numeric code. */
1279 else
1282 }
1283 }
1285 DEBUG_FUNCTION void
1287 {
1290 }
1292 DEBUG_FUNCTION void
1294 {
1297 else
1299 }
1302 /* Start emitting debugging information. */
1304 static void
1306 {
1313 }
1315 /* Stop emitting debugging information. */
1317 static void
1319 {
1326 }
1328 /* Create a new cp_token_cache, representing a range of tokens. */
1332 {
1337 }
1339 /* Diagnose if #pragma omp declare simd isn't followed immediately
1340 by function declaration or definition. */
1344 {
1346 {
1350 }
1351 }
1353 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
1354 and put that into "omp declare simd" attribute. */
1358 {
1360 {
1362 {
1365 }
1367 {
1370 }
1371 }
1372 }
1374 /* Diagnose if #pragma acc routine isn't followed immediately by function
1375 declaration or definition. */
1379 {
1381 {
1383 "%<#pragma acc routine%> not immediately followed by "
1386 }
1387 }
1388 \f
1389 /* Decl-specifiers. */
1391 /* Set *DECL_SPECS to represent an empty decl-specifier-seq. */
1393 static void
1395 {
1397 }
1399 /* Declarators. */
1401 /* Nothing other than the parser should be creating declarators;
1402 declarators are a semi-syntactic representation of C++ entities.
1403 Other parts of the front end that need to create entities (like
1404 VAR_DECLs or FUNCTION_DECLs) should do that directly. */
1407 (cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, cp_ref_qualifier, tree, tree, tree, tree);
1417 /* An erroneous declarator. */
1420 /* The obstack on which declarators and related data structures are
1421 allocated. */
1424 /* Alloc BYTES from the declarator memory pool. */
1428 {
1430 }
1432 /* Allocate a declarator of the indicated KIND. Clear fields that are
1433 common to all declarators. */
1437 {
1450 }
1452 /* Make a declarator for a generalized identifier. If
1453 QUALIFYING_SCOPE is non-NULL, the identifier is
1454 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
1455 UNQUALIFIED_NAME. SFK indicates the kind of special function this
1456 is, if any. */
1461 {
1464 /* It is valid to write:
1466 class C { void f(); };
1467 typedef C D;
1468 void D::f();
1470 The standard is not clear about whether `typedef const C D' is
1471 legal; as of 2002-09-15 the committee is considering that
1472 question. EDG 3.0 allows that syntax. Therefore, we do as
1473 well. */
1488 }
1490 /* Make a declarator for a pointer to TARGET. CV_QUALIFIERS is a list
1491 of modifiers such as const or volatile to apply to the pointer
1492 type, represented as identifiers. ATTRIBUTES represent the attributes that
1493 appertain to the pointer or reference. */
1495 cp_declarator *
1497 tree attributes)
1498 {
1506 {
1510 }
1511 else
1517 }
1519 /* Like make_pointer_declarator -- but for references. ATTRIBUTES
1520 represent the attributes that appertain to the pointer or
1521 reference. */
1523 cp_declarator *
1526 {
1534 {
1538 }
1539 else
1545 }
1547 /* Like make_pointer_declarator -- but for a pointer to a non-static
1548 member of CLASS_TYPE. ATTRIBUTES represent the attributes that
1549 appertain to the pointer or reference. */
1551 cp_declarator *
1554 tree attributes)
1555 {
1564 {
1567 }
1568 else
1574 }
1576 /* Make a declarator for the function given by TARGET, with the
1577 indicated PARMS. The CV_QUALIFIERS apply to the function, as in
1578 "const"-qualified member function. The EXCEPTION_SPECIFICATION
1579 indicates what exceptions can be thrown. */
1581 cp_declarator *
1583 tree parms,
1584 cp_cv_quals cv_qualifiers,
1585 cp_virt_specifiers virt_specifiers,
1586 cp_ref_qualifier ref_qualifier,
1587 tree tx_qualifier,
1588 tree exception_specification,
1589 tree late_return_type,
1590 tree requires_clause)
1591 {
1605 {
1609 }
1610 else
1614 }
1616 /* Make a declarator for an array of BOUNDS elements, each of which is
1617 defined by ELEMENT. */
1619 cp_declarator *
1621 {
1628 {
1632 }
1633 else
1637 }
1639 /* Determine whether the declarator we've seen so far can be a
1640 parameter pack, when followed by an ellipsis. */
1641 static bool
1643 {
1645 /* We already saw an ellipsis. */
1648 /* Search for a declarator name, or any other declarator that goes
1649 after the point where the ellipsis could appear in a parameter
1650 pack. If we find any of these, then this declarator cannot be
1651 made into a parameter pack. */
1654 {
1656 {
1669 }
1670 }
1673 }
1677 /* Create a parameter declarator with the indicated DECL_SPECIFIERS,
1678 DECLARATOR and DEFAULT_ARGUMENT. */
1680 cp_parameter_declarator *
1683 tree default_argument,
1684 location_t loc,
1686 {
1694 else
1702 }
1704 /* Returns true iff DECLARATOR is a declaration for a function. */
1706 static bool
1708 {
1710 {
1719 }
1721 }
1723 /* The parser. */
1725 /* Overview
1726 --------
1728 A cp_parser parses the token stream as specified by the C++
1729 grammar. Its job is purely parsing, not semantic analysis. For
1730 example, the parser breaks the token stream into declarators,
1731 expressions, statements, and other similar syntactic constructs.
1732 It does not check that the types of the expressions on either side
1733 of an assignment-statement are compatible, or that a function is
1734 not declared with a parameter of type `void'.
1736 The parser invokes routines elsewhere in the compiler to perform
1737 semantic analysis and to build up the abstract syntax tree for the
1738 code processed.
1740 The parser (and the template instantiation code, which is, in a
1741 way, a close relative of parsing) are the only parts of the
1742 compiler that should be calling push_scope and pop_scope, or
1743 related functions. The parser (and template instantiation code)
1744 keeps track of what scope is presently active; everything else
1745 should simply honor that. (The code that generates static
1746 initializers may also need to set the scope, in order to check
1747 access control correctly when emitting the initializers.)
1749 Methodology
1750 -----------
1752 The parser is of the standard recursive-descent variety. Upcoming
1753 tokens in the token stream are examined in order to determine which
1754 production to use when parsing a non-terminal. Some C++ constructs
1755 require arbitrary look ahead to disambiguate. For example, it is
1756 impossible, in the general case, to tell whether a statement is an
1757 expression or declaration without scanning the entire statement.
1758 Therefore, the parser is capable of "parsing tentatively." When the
1759 parser is not sure what construct comes next, it enters this mode.
1760 Then, while we attempt to parse the construct, the parser queues up
1761 error messages, rather than issuing them immediately, and saves the
1762 tokens it consumes. If the construct is parsed successfully, the
1763 parser "commits", i.e., it issues any queued error messages and
1764 the tokens that were being preserved are permanently discarded.
1765 If, however, the construct is not parsed successfully, the parser
1766 rolls back its state completely so that it can resume parsing using
1767 a different alternative.
1769 Future Improvements
1770 -------------------
1772 The performance of the parser could probably be improved substantially.
1773 We could often eliminate the need to parse tentatively by looking ahead
1774 a little bit. In some places, this approach might not entirely eliminate
1775 the need to parse tentatively, but it might still speed up the average
1776 case. */
1778 /* Flags that are passed to some parsing functions. These values can
1779 be bitwise-ored together. */
1781 enum
1782 {
1783 /* No flags. */
1785 /* The construct is optional. If it is not present, then no error
1786 should be issued. */
1788 /* When parsing a type-specifier, treat user-defined type-names
1789 as non-type identifiers. */
1791 /* When parsing a type-specifier, do not try to parse a class-specifier
1792 or enum-specifier. */
1794 /* When parsing a decl-specifier-seq, only allow type-specifier or
1795 constexpr. */
1797 /* When parsing a decl-specifier-seq, only allow mutable or constexpr. */
1799 /* When parsing a decl-specifier-seq, allow missing typename. */
1801 };
1803 /* This type is used for parameters and variables which hold
1804 combinations of the above flags. */
1807 /* The different kinds of declarators we want to parse. */
1809 enum cp_parser_declarator_kind
1810 {
1811 /* We want an abstract declarator. */
1812 CP_PARSER_DECLARATOR_ABSTRACT,
1813 /* We want a named declarator. */
1814 CP_PARSER_DECLARATOR_NAMED,
1815 /* We don't mind, but the name must be an unqualified-id. */
1816 CP_PARSER_DECLARATOR_EITHER
1817 };
1819 /* The precedence values used to parse binary expressions. The minimum value
1820 of PREC must be 1, because zero is reserved to quickly discriminate
1821 binary operators from other tokens. */
1823 enum cp_parser_prec
1824 {
1825 PREC_NOT_OPERATOR,
1826 PREC_LOGICAL_OR_EXPRESSION,
1827 PREC_LOGICAL_AND_EXPRESSION,
1828 PREC_INCLUSIVE_OR_EXPRESSION,
1829 PREC_EXCLUSIVE_OR_EXPRESSION,
1830 PREC_AND_EXPRESSION,
1831 PREC_EQUALITY_EXPRESSION,
1832 PREC_RELATIONAL_EXPRESSION,
1833 PREC_SHIFT_EXPRESSION,
1834 PREC_ADDITIVE_EXPRESSION,
1835 PREC_MULTIPLICATIVE_EXPRESSION,
1836 PREC_PM_EXPRESSION,
1837 NUM_PREC_VALUES = PREC_PM_EXPRESSION
1838 };
1840 /* A mapping from a token type to a corresponding tree node type, with a
1841 precedence value. */
1843 struct cp_parser_binary_operations_map_node
1844 {
1845 /* The token type. */
1847 /* The corresponding tree code. */
1849 /* The precedence of this operator. */
1851 };
1853 struct cp_parser_expression_stack_entry
1854 {
1855 /* Left hand side of the binary operation we are currently
1856 parsing. */
1857 cp_expr lhs;
1858 /* Original tree code for left hand side, if it was a binary
1859 expression itself (used for -Wparentheses). */
1861 /* Tree code for the binary operation we are parsing. */
1863 /* Precedence of the binary operation we are parsing. */
1865 /* Location of the binary operation we are parsing. */
1866 location_t loc;
1867 };
1869 /* The stack for storing partial expressions. We only need NUM_PREC_VALUES
1870 entries because precedence levels on the stack are monotonically
1871 increasing. */
1875 /* Prototypes. */
1877 /* Constructors and destructors. */
1882 /* Class variables. */
1886 /* The operator-precedence table used by cp_parser_binary_expression.
1887 Transformed into an associative array (binops_by_token) by
1888 cp_parser_new. */
1921 };
1923 /* The same as binops, but initialized by cp_parser_new so that
1924 binops_by_token[N].token_type == N. Used in cp_parser_binary_expression
1925 for speed. */
1928 /* Constructors and destructors. */
1930 /* Construct a new context. The context below this one on the stack
1931 is given by NEXT. */
1935 {
1938 /* Allocate the storage. */
1940 {
1941 /* Pull the first entry from the free list. */
1945 }
1946 else
1949 /* No errors have occurred yet in this context. */
1951 /* If this is not the bottommost context, copy information that we
1952 need from the previous context. */
1954 {
1955 /* If, in the NEXT context, we are parsing an `x->' or `x.'
1956 expression, then we are parsing one in this context, too. */
1958 /* Thread the stack. */
1960 }
1963 }
1965 /* Managing the unparsed function queues. */
1967 #define unparsed_funs_with_default_args \
1968 parser->unparsed_queues->last ().funs_with_default_args
1969 #define unparsed_funs_with_definitions \
1970 parser->unparsed_queues->last ().funs_with_definitions
1971 #define unparsed_nsdmis \
1972 parser->unparsed_queues->last ().nsdmis
1973 #define unparsed_classes \
1974 parser->unparsed_queues->last ().classes
1976 static void
1978 {
1981 }
1983 static void
1985 {
1988 }
1990 /* Prototypes. */
1992 /* Constructors and destructors. */
1997 /* Routines to parse various constructs.
1999 Those that return `tree' will return the error_mark_node (rather
2000 than NULL_TREE) if a parse error occurs, unless otherwise noted.
2001 Sometimes, they will return an ordinary node if error-recovery was
2002 attempted, even though a parse error occurred. So, to check
2003 whether or not a parse error occurred, you should always use
2004 cp_parser_error_occurred. If the construct is optional (indicated
2005 either by an `_opt' in the name of the function that does the
2006 parsing or via a FLAGS parameter), then NULL_TREE is returned if
2007 the construct is not present. */
2009 /* Lexical conventions [gram.lex] */
2011 static cp_expr cp_parser_identifier
2013 static cp_expr cp_parser_string_literal
2015 static cp_expr cp_parser_userdef_char_literal
2017 static tree cp_parser_userdef_string_literal
2019 static cp_expr cp_parser_userdef_numeric_literal
2022 /* Basic concepts [gram.basic] */
2026 /* Expressions [gram.expr] */
2028 static cp_expr cp_parser_primary_expression
2030 static cp_expr cp_parser_id_expression
2032 static cp_expr cp_parser_unqualified_id
2034 static tree cp_parser_nested_name_specifier_opt
2036 static tree cp_parser_nested_name_specifier
2038 static tree cp_parser_qualifying_entity
2040 static cp_expr cp_parser_postfix_expression
2042 static tree cp_parser_postfix_open_square_expression
2044 static tree cp_parser_postfix_dot_deref_expression
2049 /* Values for the second parameter of cp_parser_parenthesized_expression_list. */
2051 static void cp_parser_pseudo_destructor_name
2053 static cp_expr cp_parser_unary_expression
2055 static enum tree_code cp_parser_unary_operator
2057 static tree cp_parser_has_attribute_expression
2059 static tree cp_parser_new_expression
2063 static tree cp_parser_new_type_id
2071 static tree cp_parser_delete_expression
2073 static cp_expr cp_parser_cast_expression
2075 static cp_expr cp_parser_binary_expression
2077 static tree cp_parser_question_colon_clause
2079 static cp_expr cp_parser_assignment_expression
2081 static enum tree_code cp_parser_assignment_operator_opt
2083 static cp_expr cp_parser_expression
2085 static cp_expr cp_parser_constant_expression
2087 static cp_expr cp_parser_builtin_offsetof
2089 static cp_expr cp_parser_lambda_expression
2091 static void cp_parser_lambda_introducer
2093 static bool cp_parser_lambda_declarator_opt
2095 static void cp_parser_lambda_body
2098 /* Statements [gram.stmt.stmt] */
2100 static void cp_parser_statement
2102 static void cp_parser_label_for_labeled_statement
2104 static tree cp_parser_expression_statement
2106 static tree cp_parser_compound_statement
2108 static void cp_parser_statement_seq_opt
2110 static tree cp_parser_selection_statement
2112 static tree cp_parser_condition
2114 static tree cp_parser_iteration_statement
2116 static bool cp_parser_init_statement
2118 static tree cp_parser_for
2120 static tree cp_parser_c_for
2122 static tree cp_parser_range_for
2124 static void do_range_for_auto_deduction
2126 static tree cp_parser_perform_range_for_lookup
2128 static tree cp_parser_range_for_member_function
2130 static tree cp_parser_jump_statement
2132 static void cp_parser_declaration_statement
2135 static tree cp_parser_implicitly_scoped_statement
2137 static void cp_parser_already_scoped_statement
2140 /* Declarations [gram.dcl.dcl] */
2142 static void cp_parser_declaration_seq_opt
2144 static void cp_parser_declaration
2146 static void cp_parser_toplevel_declaration
2148 static void cp_parser_block_declaration
2150 static void cp_parser_simple_declaration
2152 static void cp_parser_decl_specifier_seq
2154 static tree cp_parser_storage_class_specifier_opt
2156 static tree cp_parser_function_specifier_opt
2158 static tree cp_parser_type_specifier
2161 static tree cp_parser_simple_type_specifier
2163 static tree cp_parser_type_name
2165 static tree cp_parser_nonclass_name
2167 static tree cp_parser_elaborated_type_specifier
2169 static tree cp_parser_enum_specifier
2171 static void cp_parser_enumerator_list
2173 static void cp_parser_enumerator_definition
2175 static tree cp_parser_namespace_name
2177 static void cp_parser_namespace_definition
2179 static void cp_parser_namespace_body
2181 static tree cp_parser_qualified_namespace_specifier
2183 static void cp_parser_namespace_alias_definition
2185 static bool cp_parser_using_declaration
2187 static void cp_parser_using_directive
2189 static tree cp_parser_alias_declaration
2191 static void cp_parser_asm_definition
2193 static void cp_parser_linkage_specification
2195 static void cp_parser_static_assert
2197 static tree cp_parser_decltype
2199 static tree cp_parser_decomposition_declaration
2202 /* Declarators [gram.dcl.decl] */
2204 static tree cp_parser_init_declarator
2214 static enum tree_code cp_parser_ptr_operator
2216 static cp_cv_quals cp_parser_cv_qualifier_seq_opt
2218 static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
2220 static cp_ref_qualifier cp_parser_ref_qualifier_opt
2222 static tree cp_parser_tx_qualifier_opt
2224 static tree cp_parser_late_return_type_opt
2226 static tree cp_parser_declarator_id
2228 static tree cp_parser_type_id
2230 static tree cp_parser_template_type_arg
2233 static tree cp_parser_type_id_1
2235 static void cp_parser_type_specifier_seq
2237 static tree cp_parser_parameter_declaration_clause
2239 static tree cp_parser_parameter_declaration_list
2243 static tree cp_parser_default_argument
2245 static void cp_parser_function_body
2247 static tree cp_parser_initializer
2249 static cp_expr cp_parser_initializer_clause
2251 static cp_expr cp_parser_braced_list
2256 static void cp_parser_ctor_initializer_opt_and_function_body
2259 static tree cp_parser_late_parsing_omp_declare_simd
2262 static tree cp_parser_late_parsing_oacc_routine
2265 static tree synthesize_implicit_template_parm
2267 static tree finish_fully_implicit_template
2269 static void abort_fully_implicit_template
2272 /* Classes [gram.class] */
2274 static tree cp_parser_class_name
2276 static tree cp_parser_class_specifier
2278 static tree cp_parser_class_head
2280 static enum tag_types cp_parser_class_key
2282 static void cp_parser_type_parameter_key
2284 static void cp_parser_member_specification_opt
2286 static void cp_parser_member_declaration
2288 static tree cp_parser_pure_specifier
2290 static tree cp_parser_constant_initializer
2293 /* Derived classes [gram.class.derived] */
2295 static tree cp_parser_base_clause
2297 static tree cp_parser_base_specifier
2300 /* Special member functions [gram.special] */
2302 static tree cp_parser_conversion_function_id
2304 static tree cp_parser_conversion_type_id
2308 static void cp_parser_ctor_initializer_opt
2310 static void cp_parser_mem_initializer_list
2312 static tree cp_parser_mem_initializer
2314 static tree cp_parser_mem_initializer_id
2317 /* Overloading [gram.over] */
2319 static cp_expr cp_parser_operator_function_id
2321 static cp_expr cp_parser_operator
2324 /* Templates [gram.temp] */
2326 static void cp_parser_template_declaration
2328 static tree cp_parser_template_parameter_list
2330 static tree cp_parser_template_parameter
2332 static tree cp_parser_type_parameter
2334 static tree cp_parser_template_id
2336 static tree cp_parser_template_name
2338 static tree cp_parser_template_argument_list
2340 static tree cp_parser_template_argument
2342 static void cp_parser_explicit_instantiation
2344 static void cp_parser_explicit_specialization
2347 /* Exception handling [gram.exception] */
2349 static tree cp_parser_try_block
2351 static void cp_parser_function_try_block
2353 static void cp_parser_handler_seq
2355 static void cp_parser_handler
2357 static tree cp_parser_exception_declaration
2359 static tree cp_parser_throw_expression
2361 static tree cp_parser_exception_specification_opt
2363 static tree cp_parser_type_id_list
2366 /* GNU Extensions */
2368 static tree cp_parser_asm_specification_opt
2370 static tree cp_parser_asm_operand_list
2372 static tree cp_parser_asm_clobber_list
2374 static tree cp_parser_asm_label_list
2376 static bool cp_next_tokens_can_be_attribute_p
2378 static bool cp_next_tokens_can_be_gnu_attribute_p
2380 static bool cp_next_tokens_can_be_std_attribute_p
2382 static bool cp_nth_tokens_can_be_std_attribute_p
2384 static bool cp_nth_tokens_can_be_gnu_attribute_p
2386 static bool cp_nth_tokens_can_be_attribute_p
2388 static tree cp_parser_attributes_opt
2390 static tree cp_parser_gnu_attributes_opt
2392 static tree cp_parser_gnu_attribute_list
2394 static tree cp_parser_std_attribute
2396 static tree cp_parser_std_attribute_spec
2398 static tree cp_parser_std_attribute_spec_seq
2400 static size_t cp_parser_skip_attributes_opt
2402 static bool cp_parser_extension_opt
2404 static void cp_parser_label_declaration
2407 /* Concept Extensions */
2409 static tree cp_parser_requires_clause
2411 static tree cp_parser_requires_clause_opt
2413 static tree cp_parser_requires_expression
2415 static tree cp_parser_requirement_parameter_list
2417 static tree cp_parser_requirement_body
2419 static tree cp_parser_requirement_list
2421 static tree cp_parser_requirement
2423 static tree cp_parser_simple_requirement
2425 static tree cp_parser_compound_requirement
2427 static tree cp_parser_type_requirement
2429 static tree cp_parser_nested_requirement
2432 /* Transactional Memory Extensions */
2434 static tree cp_parser_transaction
2436 static tree cp_parser_transaction_expression
2438 static void cp_parser_function_transaction
2440 static tree cp_parser_transaction_cancel
2444 pragma_external,
2445 pragma_member,
2446 pragma_objc_icode,
2447 pragma_stmt,
2448 pragma_compound
2449 };
2450 static bool cp_parser_pragma
2453 /* Objective-C++ Productions */
2455 static tree cp_parser_objc_message_receiver
2457 static tree cp_parser_objc_message_args
2459 static tree cp_parser_objc_message_expression
2461 static cp_expr cp_parser_objc_encode_expression
2463 static tree cp_parser_objc_defs_expression
2465 static tree cp_parser_objc_protocol_expression
2467 static tree cp_parser_objc_selector_expression
2469 static cp_expr cp_parser_objc_expression
2471 static bool cp_parser_objc_selector_p
2473 static tree cp_parser_objc_selector
2475 static tree cp_parser_objc_protocol_refs_opt
2477 static void cp_parser_objc_declaration
2479 static tree cp_parser_objc_statement
2481 static bool cp_parser_objc_valid_prefix_attributes
2483 static void cp_parser_objc_at_property_declaration
2485 static void cp_parser_objc_at_synthesize_declaration
2487 static void cp_parser_objc_at_dynamic_declaration
2489 static tree cp_parser_objc_struct_declaration
2492 /* Utility Routines */
2494 static cp_expr cp_parser_lookup_name
2496 static tree cp_parser_lookup_name_simple
2498 static tree cp_parser_maybe_treat_template_as_class
2500 static bool cp_parser_check_declarator_template_parameters
2502 static bool cp_parser_check_template_parameters
2504 static cp_expr cp_parser_simple_cast_expression
2506 static tree cp_parser_global_scope_opt
2508 static bool cp_parser_constructor_declarator_p
2510 static tree cp_parser_function_definition_from_specifiers_and_declarator
2512 static tree cp_parser_function_definition_after_declarator
2514 static bool cp_parser_template_declaration_after_export
2516 static void cp_parser_perform_template_parameter_access_checks
2518 static tree cp_parser_single_declaration
2520 static cp_expr cp_parser_functional_cast
2522 static tree cp_parser_save_member_function_body
2524 static tree cp_parser_save_nsdmi
2526 static tree cp_parser_enclosed_template_argument_list
2528 static void cp_parser_save_default_args
2530 static void cp_parser_late_parsing_for_member
2532 static tree cp_parser_late_parse_one_default_arg
2534 static void cp_parser_late_parsing_nsdmi
2536 static void cp_parser_late_parsing_default_args
2538 static tree cp_parser_sizeof_operand
2540 static cp_expr cp_parser_trait_expr
2542 static bool cp_parser_declares_only_class_p
2544 static void cp_parser_set_storage_class
2546 static void cp_parser_set_decl_spec_type
2548 static void set_and_check_decl_spec_loc
2551 static bool cp_parser_friend_p
2553 static void cp_parser_required_error
2559 static bool cp_parser_token_starts_function_definition_p
2561 static bool cp_parser_next_token_starts_class_definition_p
2563 static bool cp_parser_next_token_ends_template_argument_p
2565 static bool cp_parser_nth_token_starts_template_argument_list_p
2567 static enum tag_types cp_parser_token_is_class_key
2569 static enum tag_types cp_parser_token_is_type_parameter_key
2571 static void cp_parser_check_class_key
2573 static void cp_parser_check_access_in_redeclaration
2575 static bool cp_parser_optional_template_keyword
2577 static void cp_parser_pre_parsed_nested_name_specifier
2579 static bool cp_parser_cache_group
2581 static tree cp_parser_cache_defarg
2583 static void cp_parser_parse_tentatively
2585 static void cp_parser_commit_to_tentative_parse
2587 static void cp_parser_commit_to_topmost_tentative_parse
2589 static void cp_parser_abort_tentative_parse
2591 static bool cp_parser_parse_definitely
2595 static bool cp_parser_uncommitted_to_tentative_parse_p
2597 static void cp_parser_error
2599 static void cp_parser_name_lookup_error
2601 static bool cp_parser_simulate_error
2603 static bool cp_parser_check_type_definition
2605 static void cp_parser_check_for_definition_in_return_type
2607 static void cp_parser_check_for_invalid_template_id
2609 static bool cp_parser_non_integral_constant_expression
2611 static void cp_parser_diagnose_invalid_type_name
2613 static bool cp_parser_parse_and_diagnose_invalid_type_name
2615 static int cp_parser_skip_to_closing_parenthesis
2617 static void cp_parser_skip_to_end_of_statement
2619 static void cp_parser_consume_semicolon_at_end_of_statement
2621 static void cp_parser_skip_to_end_of_block_or_statement
2623 static bool cp_parser_skip_to_closing_brace
2625 static void cp_parser_skip_to_end_of_template_parameter_list
2627 static void cp_parser_skip_to_pragma_eol
2629 static bool cp_parser_error_occurred
2631 static bool cp_parser_allow_gnu_extensions_p
2633 static bool cp_parser_is_pure_string_literal
2635 static bool cp_parser_is_string_literal
2637 static bool cp_parser_is_keyword
2639 static tree cp_parser_make_typename_type
2643 static bool cp_parser_compound_literal_p
2645 static bool cp_parser_array_designator_p
2647 static bool cp_parser_init_statement_p
2649 static bool cp_parser_skip_to_closing_square_bracket
2652 /* Concept-related syntactic transformations */
2657 // -------------------------------------------------------------------------- //
2658 // Unevaluated Operand Guard
2659 //
2660 // Implementation of an RAII helper for unevaluated operand parsing.
2662 {
2665 }
2668 {
2671 }
2673 // -------------------------------------------------------------------------- //
2674 // Tentative Parsing
2676 /* Returns nonzero if we are parsing tentatively. */
2680 {
2682 }
2684 /* Returns nonzero if TOKEN is a string literal. */
2686 static bool
2688 {
2694 }
2696 /* Returns nonzero if TOKEN is a string literal
2697 of a user-defined string literal. */
2699 static bool
2701 {
2708 }
2710 /* Returns nonzero if TOKEN is the indicated KEYWORD. */
2712 static bool
2714 {
2716 }
2718 /* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
2719 PRAGMA_NONE. */
2721 static enum pragma_kind
2723 {
2726 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
2728 }
2730 /* Helper function for cp_parser_error.
2731 Having peeked a token of kind TOK1_KIND that might signify
2732 a conflict marker, peek successor tokens to determine
2733 if we actually do have a conflict marker.
2734 Specifically, we consider a run of 7 '<', '=' or '>' characters
2735 at the start of a line as a conflict marker.
2736 These come through the lexer as three pairs and a single,
2737 e.g. three CPP_LSHIFT tokens ("<<") and a CPP_LESS token ('<').
2738 If it returns true, *OUT_LOC is written to with the location/range
2739 of the marker. */
2741 static bool
2744 {
2755 /* It must be at the start of the line. */
2760 /* We have a conflict marker. Construct a location of the form:
2761 <<<<<<<
2762 ^~~~~~~
2763 with start == caret, finishing at the end of the marker. */
2768 }
2770 /* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
2771 RT_CLOSE_PAREN. */
2775 {
2777 {
2785 }
2786 }
2788 /* Attempt to convert TOKEN_DESC from a required_token to an
2789 enum cpp_ttype, returning CPP_EOF if there is no good conversion. */
2791 static enum cpp_ttype
2793 {
2795 {
2816 /* Use CPP_EOF as a "no completions possible" code. */
2818 }
2819 }
2822 /* Subroutine of cp_parser_error and cp_parser_required_error.
2824 Issue a diagnostic of the form
2825 FILE:LINE: MESSAGE before TOKEN
2826 where TOKEN is the next token in the input stream. MESSAGE
2827 (specified by the caller) is usually of the form "expected
2828 OTHER-TOKEN".
2830 This bypasses the check for tentative passing, and potentially
2831 adds material needed by cp_parser_required_error.
2833 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
2834 suggesting insertion of the missing token.
2836 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
2837 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
2838 location. */
2840 static void
2842 required_token missing_token_desc,
2843 location_t matching_location)
2844 {
2846 /* This diagnostic makes more sense if it is tagged to the line
2847 of the token we just peeked at. */
2851 {
2856 }
2858 /* If this is actually a conflict marker, report it as such. */
2862 {
2863 location_t loc;
2865 {
2868 /* Consume tokens until the end of the source line. */
2870 {
2880 }
2882 }
2883 }
2890 {
2891 /* Potentially supply a fix-it hint, suggesting to add the
2892 missing token immediately after the *previous* token.
2893 This may move the primary location within richloc. */
2895 location_t prev_token_loc
2899 /* If matching_location != UNKNOWN_LOCATION, highlight it.
2900 Attempt to consolidate diagnostics by printing it as a
2901 secondary range within the main diagnostic. */
2903 added_matching_location
2905 }
2907 /* Actually emit the error. */
2909 /* Because c_parser_error does not understand
2910 CPP_KEYWORD, keywords are treated like
2911 identifiers. */
2916 {
2917 /* If we weren't able to consolidate matching_location, then
2918 print it as a secondary diagnostic. */
2923 }
2924 }
2926 /* If not parsing tentatively, issue a diagnostic of the form
2927 FILE:LINE: MESSAGE before TOKEN
2928 where TOKEN is the next token in the input stream. MESSAGE
2929 (specified by the caller) is usually of the form "expected
2930 OTHER-TOKEN". */
2932 static void
2934 {
2937 }
2939 /* Issue an error about name-lookup failing. NAME is the
2940 IDENTIFIER_NODE DECL is the result of
2941 the lookup (as returned from cp_parser_lookup_name). DESIRED is
2942 the thing that we hoped to find. */
2944 static void
2946 tree name,
2947 tree decl,
2948 name_lookup_error desired,
2949 location_t location)
2950 {
2951 /* If name lookup completely failed, tell the user that NAME was not
2952 declared. */
2954 {
2967 else
2969 }
2971 {
2973 {
2990 }
2991 }
2993 {
2995 {
3005 name);
3009 }
3010 }
3011 else
3012 {
3014 {
3027 }
3028 }
3029 }
3031 /* If we are parsing tentatively, remember that an error has occurred
3032 during this tentative parse. Returns true if the error was
3033 simulated; false if a message should be issued by the caller. */
3035 static bool
3037 {
3039 {
3042 }
3044 }
3046 /* This function is called when a type is defined. If type
3047 definitions are forbidden at this point, an error message is
3048 issued. */
3050 static bool
3052 {
3053 /* If types are forbidden here, issue a message. */
3055 {
3056 /* Don't use `%s' to print the string, because quotations (`%<', `%>')
3057 in the message need to be interpreted. */
3060 }
3062 }
3064 /* This function is called when the DECLARATOR is processed. The TYPE
3065 was a type defined in the decl-specifiers. If it is invalid to
3066 define a type in the decl-specifiers for DECLARATOR, an error is
3067 issued. TYPE_LOCATION is the location of TYPE and is used
3068 for error reporting. */
3070 static void
3073 {
3074 /* [dcl.fct] forbids type definitions in return types.
3075 Unfortunately, it's not easy to know whether or not we are
3076 processing a return type until after the fact. */
3084 {
3089 type);
3090 }
3091 }
3093 /* A type-specifier (TYPE) has been parsed which cannot be followed by
3094 "<" in any valid C++ program. If the next token is indeed "<",
3095 issue a message warning the user about what appears to be an
3096 invalid attempt to form a template-id. LOCATION is the location
3097 of the type-specifier (TYPE) */
3099 static void
3101 tree type,
3103 location_t location)
3104 {
3108 {
3114 {
3117 else
3119 }
3120 else
3122 /* Remember the location of the invalid "<". */
3125 /* Consume the "<". */
3127 /* Parse the template arguments. */
3129 /* Permanently remove the invalid template arguments so that
3130 this error message is not issued again. */
3133 }
3134 }
3136 /* If parsing an integral constant-expression, issue an error message
3137 about the fact that THING appeared and return true. Otherwise,
3138 return false. In either case, set
3139 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P. */
3141 static bool
3143 non_integral_constant thing)
3144 {
3147 {
3149 {
3152 {
3155 "ISO C++ forbids using a floating-point literal "
3160 "enumeration type cannot appear in a "
3251 }
3255 }
3256 }
3258 }
3260 /* Emit a diagnostic for an invalid type name. This function commits
3261 to the current active tentative parse, if any. (Otherwise, the
3262 problematic construct might be encountered again later, resulting
3263 in duplicate error messages.) LOCATION is the location of ID. */
3265 static void
3267 location_t location)
3268 {
3271 /* Try to lookup the identifier. */
3278 /* If the lookup was ambiguous, an error will already have
3279 been issued. */
3281 /* If the lookup found a template-name, it means that the user forgot
3282 to specify an argument list. Emit a useful error message. */
3284 {
3285 auto_diagnostic_group d;
3288 decl);
3293 }
3297 /* Something like 'unsigned A a;' */
3300 {
3301 /* Issue an error message. */
3302 auto_diagnostic_group d;
3303 name_hint hint;
3307 {
3313 }
3314 else
3316 /* If we're in a template class, it's possible that the user was
3317 referring to a type from a base class. For example:
3319 template <typename T> struct A { typedef T X; };
3320 template <typename T> struct B : public A<T> { X x; };
3322 The user should have said "typename A<T>::X". */
3338 {
3339 tree b;
3342 b;
3344 {
3348 {
3349 tree field;
3350 /* Go from a particular instantiation of the
3351 template (which will have an empty TYPE_FIELDs),
3352 to the main version. */
3355 field;
3359 {
3364 }
3367 }
3368 }
3369 }
3370 }
3371 /* Here we diagnose qualified-ids where the scope is actually correct,
3372 but the identifier does not resolve to a valid type name. */
3374 {
3376 {
3377 auto_diagnostic_group d;
3378 name_hint hint;
3387 {
3390 "%qE in namespace %qE does not name a template"
3393 else
3397 }
3399 {
3402 "%qE in namespace %qE does not name a template"
3405 else
3407 "%qE in namespace %qE does not name a template"
3410 }
3411 else
3412 {
3415 "%qE in namespace %qE does not name a type"
3418 else
3422 }
3425 }
3428 {
3429 /* A<T>::A<T>() */
3430 auto_diagnostic_group d;
3436 }
3439 {
3444 "need %<typename%> before %<%T::%D::%E%> because "
3448 id,
3451 else
3455 }
3457 {
3458 auto_diagnostic_group d;
3470 else
3476 }
3477 else
3479 }
3480 }
3482 /* Check for a common situation where a type-name should be present,
3483 but is not, and issue a sensible error message. Returns true if an
3484 invalid type-name was detected.
3486 The situation handled by this function are variable declarations of the
3487 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
3488 Usually, `ID' should name a type, but if we got here it means that it
3489 does not. We try to emit the best possible error message depending on
3490 how exactly the id-expression looks like. */
3492 static bool
3494 {
3495 tree id;
3498 /* Avoid duplicate error about ambiguous lookup. */
3500 {
3504 }
3513 /* If the next token is a (, this is a function with no explicit return
3514 type, i.e. constructor, destructor or conversion op. */
3517 {
3520 }
3524 /* Emit a diagnostic for the invalid type. */
3526 out:
3527 /* If we aren't in the middle of a declarator (i.e. in a
3528 parameter-declaration-clause), skip to the end of the declaration;
3529 there's no point in trying to process it. */
3533 }
3535 /* Consume tokens up to, and including, the next non-nested closing `)'.
3536 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3537 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
3538 found an unnested token of that type. */
3540 static int
3543 cpp_ttype or_ttype,
3545 {
3556 {
3559 /* Have we found what we're looking for before the closing paren? */
3565 {
3569 /* FALLTHRU */
3571 /* If we've run out of tokens, then there is no closing `)'. */
3574 /* This is good for lambda expression capture-lists. */
3584 /* This matches the processing in skip_to_end_of_statement. */
3604 {
3608 }
3618 condop_depth--;
3623 }
3625 /* Consume the token. */
3627 }
3628 }
3630 /* Consume tokens up to, and including, the next non-nested closing `)'.
3631 Returns 1 iff we found a closing `)'. RECOVERING is true, if we
3632 are doing error recovery. Returns -1 if OR_COMMA is true and we
3633 found an unnested token of that type. */
3635 static int
3640 {
3644 }
3646 /* Consume tokens until we reach the end of the current statement.
3647 Normally, that will be just before consuming a `;'. However, if a
3648 non-nested `}' comes first, then we stop before consuming that. */
3650 static void
3652 {
3655 /* Unwind generic function template scope if necessary. */
3660 {
3664 {
3668 /* FALLTHRU */
3670 /* If we've run out of tokens, stop. */
3674 /* If the next token is a `;', we have reached the end of the
3675 statement. */
3681 /* If this is a non-nested '}', stop before consuming it.
3682 That way, when confronted with something like:
3684 { 3 + }
3686 we stop before consuming the closing '}', even though we
3687 have not yet reached a `;'. */
3691 /* If it is the closing '}' for a block that we have
3692 scanned, stop -- but only after consuming the token.
3693 That way given:
3695 void f g () { ... }
3696 typedef int I;
3698 we will stop after the body of the erroneously declared
3699 function, but before consuming the following `typedef'
3700 declaration. */
3702 {
3705 }
3714 }
3716 /* Consume the token. */
3718 }
3719 }
3721 /* This function is called at the end of a statement or declaration.
3722 If the next token is a semicolon, it is consumed; otherwise, error
3723 recovery is attempted. */
3725 static void
3727 {
3728 /* Look for the trailing `;'. */
3730 {
3731 /* If there is additional (erroneous) input, skip to the end of
3732 the statement. */
3734 /* If the next token is now a `;', consume it. */
3737 }
3738 }
3740 /* Skip tokens until we have consumed an entire block, or until we
3741 have consumed a non-nested `;'. */
3743 static void
3745 {
3748 /* Unwind generic function template scope if necessary. */
3753 {
3757 {
3761 /* FALLTHRU */
3763 /* If we've run out of tokens, stop. */
3767 /* Stop if this is an unnested ';'. */
3773 /* Stop if this is an unnested '}', or closes the outermost
3774 nesting level. */
3775 nesting_depth--;
3783 /* Nest. */
3784 nesting_depth++;
3789 }
3791 /* Consume the token. */
3793 }
3794 }
3796 /* Skip tokens until a non-nested closing curly brace is the next
3797 token, or there are no more tokens. Return true in the first case,
3798 false otherwise. */
3800 static bool
3802 {
3806 {
3810 {
3814 /* FALLTHRU */
3816 /* If we've run out of tokens, stop. */
3820 /* If the next token is a non-nested `}', then we have reached
3821 the end of the current block. */
3827 /* If it the next token is a `{', then we are entering a new
3828 block. Consume the entire block. */
3834 }
3836 /* Consume the token. */
3838 }
3839 }
3841 /* Consume tokens until we reach the end of the pragma. The PRAGMA_TOK
3842 parameter is the PRAGMA token, allowing us to purge the entire pragma
3843 sequence. */
3845 static void
3847 {
3852 do
3856 /* Ensure that the pragma is not parsed again. */
3858 }
3860 /* Require pragma end of line, resyncing with it as necessary. The
3861 arguments are as for cp_parser_skip_to_pragma_eol. */
3863 static void
3865 {
3869 }
3871 /* This is a simple wrapper around make_typename_type. When the id is
3872 an unresolved identifier node, we can provide a superior diagnostic
3873 using cp_parser_diagnose_invalid_type_name. */
3875 static tree
3877 location_t id_location)
3878 {
3879 tree result;
3881 {
3887 }
3889 }
3891 /* This is a wrapper around the
3892 make_{pointer,ptrmem,reference}_declarator functions that decides
3893 which one to call based on the CODE and CLASS_TYPE arguments. The
3894 CODE argument should be one of the values returned by
3895 cp_parser_ptr_operator. ATTRIBUTES represent the attributes that
3896 appertain to the pointer or reference. */
3900 cp_cv_quals cv_qualifiers,
3902 tree attributes)
3903 {
3910 else
3920 }
3922 /* Create a new C++ parser. */
3926 {
3931 /* cp_lexer_new_main is called before doing GC allocation because
3932 cp_lexer_new_main might load a PCH file. */
3935 /* Initialize the binops_by_token so that we can get the tree
3936 directly from the token. */
3944 /* For now, we always accept GNU extensions. */
3947 /* The `>' token is a greater-than operator, not the end of a
3948 template-id. */
3953 /* We are not parsing a constant-expression. */
3958 /* Local variable names are not forbidden. */
3961 /* We are not processing an `extern "C"' declaration. */
3964 /* We are not processing a declarator. */
3967 /* We are not processing a template-argument-list. */
3970 /* We are not in an iteration statement. */
3973 /* We are not in a switch statement. */
3976 /* We are not parsing a type-id inside an expression. */
3979 /* String literals should be translated to the execution character set. */
3982 /* We are not parsing a function body. */
3985 /* We can correct until told otherwise. */
3988 /* The unparsed function queue is empty. */
3991 /* There are no classes being defined. */
3994 /* No template parameters apply. */
3997 /* Special parsing data structures. */
4001 /* Not declaring an implicit function template. */
4007 /* Allow constrained-type-specifiers. */
4010 /* We haven't yet seen an 'extern "C"'. */
4014 }
4016 /* Create a cp_lexer structure which will emit the tokens in CACHE
4017 and push it onto the parser's lexer stack. This is used for delayed
4018 parsing of in-class method bodies and default arguments, and should
4019 not be confused with tentative parsing. */
4020 static void
4022 {
4027 /* Move the current source position to that of the first token in the
4028 new lexer. */
4030 }
4032 /* Pop the top lexer off the parser stack. This is never used for the
4033 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens. */
4034 static void
4036 {
4041 /* Put the current source position back where it was before this
4042 lexer was pushed. */
4044 }
4046 /* Lexical conventions [gram.lex] */
4048 /* Parse an identifier. Returns an IDENTIFIER_NODE representing the
4049 identifier. */
4051 static cp_expr
4053 {
4056 /* Look for the identifier. */
4058 /* Return the value. */
4061 else
4063 }
4065 /* Parse a sequence of adjacent string constants. Returns a
4066 TREE_STRING representing the combined, nul-terminated string
4067 constant. If TRANSLATE is true, translate the string to the
4068 execution character set. If WIDE_OK is true, a wide string is
4069 invalid here.
4071 C++98 [lex.string] says that if a narrow string literal token is
4072 adjacent to a wide string literal token, the behavior is undefined.
4073 However, C99 6.4.5p4 says that this results in a wide string literal.
4074 We follow C99 here, for consistency with the C front end.
4076 This code is largely lifted from lex_string() in c-lex.c.
4078 FUTURE: ObjC++ will need to handle @-strings here. */
4079 static cp_expr
4082 {
4083 tree value;
4091 tree string_tree;
4097 {
4100 }
4105 {
4109 }
4110 else
4111 {
4114 }
4117 /* Try to avoid the overhead of creating and destroying an obstack
4118 for the common case of just one string. */
4121 {
4129 {
4133 }
4134 else
4138 }
4139 else
4140 {
4146 do
4147 {
4149 count++;
4154 {
4157 {
4160 }
4163 {
4168 }
4170 }
4171 else
4175 {
4179 {
4183 "unsupported non-standard concatenation "
4185 }
4186 }
4195 {
4199 }
4200 else
4201 {
4205 }
4206 }
4209 /* A string literal built by concatenation has its caret=start at
4210 the start of the initial string, and its finish at the finish of
4211 the final string literal. */
4215 }
4218 {
4221 }
4225 {
4229 {
4233 }
4236 {
4244 else
4256 }
4261 {
4266 else
4268 }
4269 }
4270 else
4271 /* cpp_interpret_string has issued an error. */
4275 {
4278 }
4281 }
4283 /* Look up a literal operator with the name and the exact arguments. */
4285 static tree
4287 {
4293 {
4297 {
4304 {
4314 }
4318 /* May be this should be sufficient_parms_p instead,
4319 depending on how exactly should user-defined literals
4320 work in presence of default arguments on the literal
4321 operator parameters. */
4324 }
4325 }
4328 }
4330 /* Parse a user-defined char constant. Returns a call to a user-defined
4331 literal operator taking the character as an argument. */
4333 static cp_expr
4335 {
4343 /* Build up a call to the user-defined operator */
4344 /* Lookup the name we got back from the id-expression. */
4349 {
4354 }
4358 }
4360 /* A subroutine of cp_parser_userdef_numeric_literal to
4361 create a char... template parameter pack from a string node. */
4363 static tree
4365 {
4366 tree charvec;
4372 /* Fill in CHARVEC with all of the parameters. */
4375 {
4384 }
4386 /* Build the argument packs. */
4392 }
4394 /* A subroutine of cp_parser_userdef_numeric_literal to
4395 create a char... template parameter pack from a string node. */
4397 static tree
4399 {
4400 tree charvec;
4411 /* First template parm is character type. */
4414 /* Fill in CHARVEC with all of the parameters. */
4421 /* Build the argument packs. */
4427 }
4429 /* Parse a user-defined numeric constant. returns a call to a user-defined
4430 literal operator. */
4432 static cp_expr
4434 {
4445 /* Look for a literal operator taking the exact type of numeric argument
4446 as the literal value. */
4451 {
4453 tf_warning_or_error);
4456 {
4459 long_long_unsigned_type_node);
4460 }
4461 else
4462 {
4466 long_double_type_node);
4470 }
4474 }
4477 /* If the numeric argument didn't work, look for a raw literal
4478 operator taking a const char* argument consisting of the number
4479 in string format. */
4484 {
4486 tf_warning_or_error);
4489 }
4492 /* If the raw literal didn't work, look for a non-type template
4493 function with parameter pack char.... Call the function with
4494 template parameter characters representing the number. */
4498 {
4501 {
4503 num_string);
4505 }
4508 tf_warning_or_error);
4511 }
4515 /* In C++14 the standard library defines complex number suffixes that
4516 conflict with GNU extensions. Prefer them if <complex> is #included. */
4526 {
4531 {
4532 /* No <complex>, so pedwarn and use GNU semantics. */
4535 }
4536 }
4538 bool complained
4545 {
4547 "(from <complex>) to enable the C++14 user-defined literal "
4552 }
4559 else
4560 {
4561 /* Use the built-in semantics. */
4562 tree type;
4564 {
4567 else
4569 }
4578 }
4581 /* Avoid repeated diagnostics. */
4584 }
4586 /* Parse a user-defined string constant. Returns a call to a user-defined
4587 literal operator taking a character pointer and the length of the string
4588 as arguments. */
4590 static tree
4592 {
4598 tree decl;
4600 /* Build up a call to the user-defined operator. */
4601 /* Lookup the name we got back from the id-expression. */
4602 releasing_vec rargs;
4610 tf_warning_or_error);
4612 /* Look for a suitable template function, either (C++20) with a single
4613 parameter of class type, or (N3599) with typename parameter CharT and
4614 parameter pack CharT... */
4618 {
4619 /* Use resolve_nondeduced_context to try to choose one form of template
4620 or the other. */
4627 else
4628 {
4633 }
4637 tf_warning_or_error);
4638 }
4643 }
4646 /* Basic concepts [gram.basic] */
4648 /* Parse a translation-unit.
4650 translation-unit:
4651 declaration-seq [opt] */
4653 static void
4655 {
4658 /* Create the declarator obstack. */
4660 /* Create the error declarator. */
4662 /* Create the empty parameter list. */
4664 UNKNOWN_LOCATION);
4665 /* Remember where the base of the declarator obstack lies. */
4671 {
4674 /* If we're entering or exiting a region that's implicitly
4675 extern "C", modify the lang context appropriately. */
4678 {
4682 else
4684 }
4690 {
4693 /* If the next token is now a `;', consume it. */
4696 }
4697 else
4699 }
4701 /* Get rid of the token array; we don't need it any more. */
4705 /* The EOF should have reset this. */
4708 /* Make sure the declarator obstack was fully cleaned up. */
4711 }
4713 /* Return the appropriate tsubst flags for parsing, possibly in N3276
4714 decltype context. */
4718 {
4723 }
4725 /* We're about to parse a collection of statements. If we're currently
4726 parsing tentatively, set up a firewall so that any nested
4727 cp_parser_commit_to_tentative_parse won't affect the current context. */
4729 static cp_token_position
4731 {
4738 }
4740 /* We've finished parsing the collection of statements. Wrap up the
4741 firewall and replace the relevant tokens with the parsed form. */
4743 static void
4745 tree expr)
4746 {
4750 /* Finish the firewall level. */
4752 /* And remember the result of the parse for when we try again. */
4758 }
4760 /* Like the above functions, but let the user modify the tokens. Used by
4761 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
4762 later parses, so it makes sense to localize the effects of
4763 cp_parser_commit_to_tentative_parse. */
4765 struct tentative_firewall
4766 {
4771 {
4772 /* If we're currently parsing tentatively, start a committed level as a
4773 firewall and then an inner tentative parse. */
4775 {
4779 }
4780 }
4783 {
4785 {
4786 /* Finish the inner tentative parse and the firewall, propagating any
4787 uncommitted error state to the outer tentative parse. */
4793 }
4794 }
4795 };
4797 /* Some tokens naturally come in pairs e.g.'(' and ')'.
4798 This class is for tracking such a matching pair of symbols.
4799 In particular, it tracks the location of the first token,
4800 so that if the second token is missing, we can highlight the
4801 location of the first token when notifying the user about the
4802 problem. */
4805 class token_pair
4806 {
4808 /* token_pair's ctor. */
4811 /* If the next token is the opening symbol for this pair, consume it and
4812 return true.
4813 Otherwise, issue an error and return false.
4814 In either case, record the location of the opening token. */
4817 {
4821 }
4823 /* Consume the next token from PARSER, recording its location as
4824 that of the opening token within the pair. */
4827 {
4832 }
4834 /* If the next token is the closing symbol for this pair, consume it
4835 and return it.
4836 Otherwise, issue an error, highlighting the location of the
4837 corresponding opening token, and return NULL. */
4840 {
4843 m_open_loc);
4844 }
4847 location_t m_open_loc;
4848 };
4850 /* Traits for token_pair<T> for tracking matching pairs of parentheses. */
4852 struct matching_paren_traits
4853 {
4858 };
4860 /* "matching_parens" is a token_pair<T> class for tracking matching
4861 pairs of parentheses. */
4865 /* Traits for token_pair<T> for tracking matching pairs of braces. */
4867 struct matching_brace_traits
4868 {
4873 };
4875 /* "matching_braces" is a token_pair<T> class for tracking matching
4876 pairs of braces. */
4881 /* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
4882 enclosing parentheses. */
4884 static cp_expr
4886 {
4889 /* Consume the '('. */
4891 matching_parens parens;
4893 /* Start the statement-expression. */
4895 /* Parse the compound-statement. */
4897 /* Finish up. */
4899 /* Consume the ')'. */
4907 }
4909 /* Expressions [gram.expr] */
4911 /* Parse a fold-operator.
4913 fold-operator:
4914 - * / % ^ & | = < > << >>
4915 = -= *= /= %= ^= &= |= <<= >>=
4916 == != <= >= && || , .* ->*
4918 This returns the tree code corresponding to the matched operator
4919 as an int. When the current token matches a compound assignment
4920 opertor, the resulting tree code is the negative value of the
4921 non-assignment operator. */
4923 static int
4925 {
4927 {
4967 }
4968 }
4970 /* Returns true if CODE indicates a binary expression, which is not allowed in
4971 the LHS of a fold-expression. More codes will need to be added to use this
4972 function in other contexts. */
4974 static bool
4976 {
4978 {
5011 }
5012 }
5014 /* If the next token is a suitable fold operator, consume it and return as
5015 the function above. */
5017 static int
5019 {
5025 }
5027 /* Parse a fold-expression.
5029 fold-expression:
5030 ( ... folding-operator cast-expression)
5031 ( cast-expression folding-operator ... )
5032 ( cast-expression folding operator ... folding-operator cast-expression)
5034 Note that the '(' and ')' are matched in primary expression. */
5036 static cp_expr
5038 {
5039 cp_id_kind pidk;
5041 // Left fold.
5043 {
5047 {
5050 }
5057 }
5062 {
5065 }
5068 {
5071 }
5074 /* The operands of a fold-expression are cast-expressions, so binary or
5075 conditional expressions are not allowed. We check this here to avoid
5076 tentative parsing. */
5088 // Right fold.
5093 {
5096 }
5099 // Binary left or right fold.
5104 }
5106 /* Parse a primary-expression.
5108 primary-expression:
5109 literal
5110 this
5111 ( expression )
5112 id-expression
5113 lambda-expression (C++11)
5115 GNU Extensions:
5117 primary-expression:
5118 ( compound-statement )
5119 __builtin_va_arg ( assignment-expression , type-id )
5120 __builtin_offsetof ( type-id , offsetof-expression )
5122 C++ Extensions:
5123 __has_nothrow_assign ( type-id )
5124 __has_nothrow_constructor ( type-id )
5125 __has_nothrow_copy ( type-id )
5126 __has_trivial_assign ( type-id )
5127 __has_trivial_constructor ( type-id )
5128 __has_trivial_copy ( type-id )
5129 __has_trivial_destructor ( type-id )
5130 __has_virtual_destructor ( type-id )
5131 __is_abstract ( type-id )
5132 __is_base_of ( type-id , type-id )
5133 __is_class ( type-id )
5134 __is_empty ( type-id )
5135 __is_enum ( type-id )
5136 __is_final ( type-id )
5137 __is_literal_type ( type-id )
5138 __is_pod ( type-id )
5139 __is_polymorphic ( type-id )
5140 __is_std_layout ( type-id )
5141 __is_trivial ( type-id )
5142 __is_union ( type-id )
5144 Objective-C++ Extension:
5146 primary-expression:
5147 objc-expression
5149 literal:
5150 __null
5152 ADDRESS_P is true iff this expression was immediately preceded by
5153 "&" and therefore might denote a pointer-to-member. CAST_P is true
5154 iff this expression is the target of a cast. TEMPLATE_ARG_P is
5155 true iff this expression is a template argument.
5157 Returns a representation of the expression. Upon return, *IDK
5158 indicates what kind of id-expression (if any) was present. */
5160 static cp_expr
5167 {
5170 /* Assume the primary expression is not an id-expression. */
5173 /* Peek at the next token. */
5176 {
5177 /* literal:
5178 integer-literal
5179 character-literal
5180 floating-literal
5181 string-literal
5182 boolean-literal
5183 pointer-literal
5184 user-defined-literal */
5196 {
5200 }
5201 /* Floating-point literals are only allowed in an integral
5202 constant expression if they are cast to an integral or
5203 enumeration type. */
5207 {
5208 /* CAST_P will be set even in invalid code like "int(2.7 +
5209 ...)". Therefore, we have to check that the next token
5210 is sure to end the cast. */
5212 {
5217 enumerator-definition. */
5219 /* The curly brace at the end of an enum-specifier. */
5221 /* The end of a statement. */
5223 /* The end of the cast-expression. */
5225 /* The end of an array bound. */
5227 /* The closing ">" in a template-argument-list. */
5230 /* C++0x only: A ">>" treated like two ">" tokens,
5231 in a template-argument-list. */
5236 }
5238 /* If we are within a cast, then the constraint that the
5239 cast is to an integral or enumeration type will be
5240 checked at that point. If we are not within a cast, then
5241 this code is invalid. */
5244 }
5265 /* ??? Should wide strings be allowed when parser->translate_strings_p
5266 is false (i.e. in attributes)? If not, we can kill the third
5267 argument to cp_parser_string_literal. */
5274 /* If we see `( { ' then we are looking at the beginning of
5275 a GNU statement-expression. */
5278 {
5279 /* Statement-expressions are not allowed by the standard. */
5283 /* And they're not allowed outside of a function-body; you
5284 cannot, for example, write:
5286 int i = ({ int j = 3; j + 1; });
5288 at class or namespace scope. */
5291 {
5293 "statement-expressions are not allowed outside "
5299 }
5300 else
5302 }
5303 /* Otherwise it's a normal parenthesized expression. */
5304 {
5305 cp_expr expr;
5310 /* Consume the `('. */
5311 matching_parens parens;
5313 /* Within a parenthesized expression, a `>' token is always
5314 the greater-than operator. */
5315 saved_greater_than_is_operator_p
5320 /* Left fold expression. */
5322 else
5323 /* Parse the parenthesized expression. */
5328 {
5335 }
5336 else
5337 /* Let the front end know that this expression was
5338 enclosed in parentheses. This matters in case, for
5339 example, the expression is of the form `A::B', since
5340 `&A::B' might be a pointer-to-member, but `&(A::B)' is
5341 not. */
5344 /* DR 705: Wrapping an unqualified name in parentheses
5345 suppresses arg-dependent lookup. We want to pass back
5346 CP_ID_KIND_QUALIFIED for suppressing vtable lookup
5347 (c++/37862), but none of the others. */
5351 /* The `>' token might be the end of a template-id or
5352 template-parameter-list now. */
5353 parser->greater_than_is_operator_p
5356 /* Consume the `)'. */
5365 }
5368 {
5370 {
5371 /* We might have an Objective-C++ message. */
5374 /* If that works out, we're done ... */
5377 /* ... else, fall though to see if it's a lambda. */
5378 }
5380 /* Don't warn about a failed tentative parse. */
5385 }
5389 /* We have an Objective-C++ string literal. */
5396 {
5397 /* These two are the boolean literals. */
5405 /* The `__null' literal. */
5410 /* The `nullptr' literal. */
5415 /* Recognize the `this' keyword. */
5419 {
5423 }
5424 /* Pointers cannot appear in constant-expressions. */
5429 /* The `operator' keyword can be the beginning of an
5430 id-expression. */
5437 {
5438 non_integral_constant name;
5440 /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
5441 __func__ are the names of variables -- but they are
5442 treated specially. Therefore, they are handled here,
5443 rather than relying on the generic id-expression logic
5444 below. Grammatically, these names are id-expressions.
5446 Consume the token. */
5450 {
5462 }
5467 /* Look up the name. */
5469 }
5472 {
5473 tree expression;
5474 tree type;
5475 location_t type_location;
5476 location_t start_loc
5478 /* The `__builtin_va_arg' construct is used to handle
5479 `va_arg'. Consume the `__builtin_va_arg' token. */
5481 /* Look for the opening `('. */
5482 matching_parens parens;
5484 /* Now, parse the assignment-expression. */
5486 /* Look for the `,'. */
5489 /* Parse the type-id. */
5490 {
5493 }
5494 /* Look for the closing `)'. */
5495 location_t finish_loc
5498 /* Using `va_arg' in a constant-expression is not
5499 allowed. */
5501 NIC_VA_ARG))
5503 /* Construct a location of the form:
5504 __builtin_va_arg (v, int)
5505 ~~~~~~~~~~~~~~~~~~~~~^~~~
5506 with the caret at the type, ranging from the start of the
5507 "__builtin_va_arg" token to the close paren. */
5508 location_t combined_loc
5511 }
5546 // C++ concepts
5550 /* Objective-C++ expressions. */
5560 {
5565 }
5566 /* FALLTHRU */
5570 }
5572 /* An id-expression can start with either an identifier, a
5573 `::' as the beginning of a qualified-id, or the "operator"
5574 keyword. */
5579 {
5580 id_expression:
5581 cp_expr id_expression;
5582 cp_expr decl;
5588 /* Parse the id-expression. */
5589 id_expression
5606 /* If we have a template-id, then no further lookup is
5607 required. If the template-id was for a template-class, we
5608 will sometimes have a TYPE_DECL at this point. */
5612 /* Look up the name. */
5613 else
5614 {
5615 tree ambiguous_decls;
5617 /* If we already know that this lookup is ambiguous, then
5618 we've already issued an error message; there's no reason
5619 to check again. */
5622 {
5625 }
5628 none_type,
5629 template_p,
5634 /* If the lookup was ambiguous, an error will already have
5635 been issued. */
5639 /* In Objective-C++, we may have an Objective-C 2.0
5640 dot-syntax for classes here. */
5645 {
5646 tree component;
5653 component);
5654 /* Build a location of the form:
5655 expr.component
5656 ~~~~~^~~~~~~~~
5657 with caret at the start of the component name (at
5658 input_location), ranging from the start of the id_expression
5659 to the end of the component name. */
5660 location_t combined_loc
5665 }
5667 /* In Objective-C++, an instance variable (ivar) may be preferred
5668 to whatever cp_parser_lookup_name() found.
5669 Call objc_lookup_ivar. To avoid exposing cp_expr to the
5670 rest of c-family, we have to do a little extra work to preserve
5671 any location information in cp_expr "decl". Given that
5672 objc_lookup_ivar is implemented in "c-family" and "objc", we
5673 have a trip through the pure "tree" type, rather than cp_expr.
5674 Naively copying it back to "decl" would implicitly give the
5675 new cp_expr value an UNKNOWN_LOCATION for nodes that don't
5676 store an EXPR_LOCATION. Hence we only update "decl" (and
5677 hence its location_t) if we get back a different tree node. */
5679 id_expression);
5683 /* If name lookup gives us a SCOPE_REF, then the
5684 qualifying scope was dependent. */
5686 {
5687 /* At this point, we do not know if DECL is a valid
5688 integral constant expression. We assume that it is
5689 in fact such an expression, so that code like:
5691 template <int N> struct A {
5692 int a[B<N>::i];
5693 };
5695 is accepted. At template-instantiation time, we
5696 will check that B<N>::i is actually a constant. */
5698 }
5699 /* Check to see if DECL is a local variable in a context
5700 where that is forbidden. */
5703 {
5708 }
5709 }
5711 decl = (finish_id_expression
5713 idk,
5718 template_arg_p,
5723 /* Build a location for an id-expression of the form:
5724 ::ns::id
5725 ~~~~~~^~
5726 or:
5727 id
5728 ^~
5729 i.e. from the start of the first token to the end of the final
5730 token, with the caret at the start of the unqualified-id. */
5734 location_t combined_loc
5739 }
5741 /* Anything else is an error. */
5745 }
5746 }
5754 {
5757 }
5759 /* Parse an id-expression.
5761 id-expression:
5762 unqualified-id
5763 qualified-id
5765 qualified-id:
5766 :: [opt] nested-name-specifier template [opt] unqualified-id
5767 :: identifier
5768 :: operator-function-id
5769 :: template-id
5771 Return a representation of the unqualified portion of the
5772 identifier. Sets PARSER->SCOPE to the qualifying scope if there is
5773 a `::' or nested-name-specifier.
5775 Often, if the id-expression was a qualified-id, the caller will
5776 want to make a SCOPE_REF to represent the qualified-id. This
5777 function does not do this in order to avoid wastefully creating
5778 SCOPE_REFs when they are not required.
5780 If TEMPLATE_KEYWORD_P is true, then we have just seen the
5781 `template' keyword.
5783 If CHECK_DEPENDENCY_P is false, then names are looked up inside
5784 uninstantiated templates.
5786 If *TEMPLATE_P is non-NULL, it is set to true iff the
5787 `template' keyword is used to explicitly indicate that the entity
5788 named is a template.
5790 If DECLARATOR_P is true, the id-expression is appearing as part of
5791 a declarator, rather than as part of an expression. */
5793 static cp_expr
5800 {
5804 /* Assume the `template' keyword was not used. */
5808 /* Look for the optional `::' operator. */
5809 global_scope_p
5810 = (!template_keyword_p
5815 /* Look for the optional nested-name-specifier. */
5816 nested_name_specifier_p
5819 check_dependency_p,
5821 declarator_p,
5822 template_keyword_p)
5825 /* If there is a nested-name-specifier, then we are looking at
5826 the first qualified-id production. */
5828 {
5829 tree saved_scope;
5830 tree saved_object_scope;
5831 tree saved_qualifying_scope;
5832 cp_expr unqualified_id;
5835 /* See if the next token is the `template' keyword. */
5839 /* Name lookup we do during the processing of the
5840 unqualified-id might obliterate SCOPE. */
5844 /* Process the final unqualified-id. */
5846 check_dependency_p,
5847 declarator_p,
5849 /* Restore the SAVED_SCOPE for our caller. */
5855 }
5856 /* Otherwise, if we are in global scope, then we are looking at one
5857 of the other qualified-id productions. */
5859 {
5861 tree id;
5863 /* Peek at the next token. */
5866 /* If it's an identifier, and the next token is not a "<", then
5867 we can avoid the template-id case. This is an optimization
5868 for this common case. */
5870 && !cp_parser_nth_token_starts_template_argument_list_p
5875 /* Try a template-id. */
5879 none_type,
5880 declarator_p);
5881 /* If that worked, we're done. */
5885 /* Peek at the next token. (Changes in the token buffer may
5886 have invalidated the pointer obtained above.) */
5890 {
5897 /* Fall through. */
5902 }
5903 }
5904 else
5907 declarator_p,
5908 optional_p);
5909 }
5911 /* Parse an unqualified-id.
5913 unqualified-id:
5914 identifier
5915 operator-function-id
5916 conversion-function-id
5917 ~ class-name
5918 template-id
5920 If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template'
5921 keyword, in a construct like `A::template ...'.
5923 Returns a representation of unqualified-id. For the `identifier'
5924 production, an IDENTIFIER_NODE is returned. For the `~ class-name'
5925 production a BIT_NOT_EXPR is returned; the operand of the
5926 BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the
5927 other productions, see the documentation accompanying the
5928 corresponding parsing functions. If CHECK_DEPENDENCY_P is false,
5929 names are looked up in uninstantiated templates. If DECLARATOR_P
5930 is true, the unqualified-id is appearing as part of a declarator,
5931 rather than as part of an expression. */
5933 static cp_expr
5939 {
5942 /* Peek at the next token. */
5946 {
5948 {
5949 tree id;
5951 /* We don't know yet whether or not this will be a
5952 template-id. */
5954 /* Try a template-id. */
5956 check_dependency_p,
5957 none_type,
5958 declarator_p);
5959 /* If it worked, we're done. */
5962 /* Otherwise, it's an ordinary identifier. */
5964 }
5968 check_dependency_p,
5969 none_type,
5970 declarator_p);
5973 {
5974 tree type_decl;
5975 tree qualifying_scope;
5976 tree object_scope;
5977 tree scope;
5981 /* Consume the `~' token. */
5983 /* Parse the class-name. The standard, as written, seems to
5984 say that:
5986 template <typename T> struct S { ~S (); };
5987 template <typename T> S<T>::~S() {}
5989 is invalid, since `~' must be followed by a class-name, but
5990 `S<T>' is dependent, and so not known to be a class.
5991 That's not right; we need to look in uninstantiated
5992 templates. A further complication arises from:
5994 template <typename T> void f(T t) {
5995 t.T::~T();
5996 }
5998 Here, it is not possible to look up `T' in the scope of `T'
5999 itself. We must look in both the current scope, and the
6000 scope of the containing complete expression.
6002 Yet another issue is:
6004 struct S {
6005 int S;
6006 ~S();
6007 };
6009 S::~S() {}
6011 The standard does not seem to say that the `S' in `~S'
6012 should refer to the type `S' and not the data member
6013 `S::S'. */
6015 /* DR 244 says that we look up the name after the "~" in the
6016 same scope as we looked up the qualifying name. That idea
6017 isn't fully worked out; it's more complicated than that. */
6022 /* Check for invalid scopes. */
6024 {
6028 }
6030 {
6034 scope);
6039 }
6044 /* Create a location with caret == start at the tilde,
6045 finishing at the end of the peeked token, e.g:
6046 ~token
6047 ^~~~~~. */
6048 location_t loc
6051 /* If the name is of the form "X::~X" it's OK even if X is a
6052 typedef. */
6061 {
6064 }
6066 /* ~auto means the destructor of whatever the object is. */
6068 {
6071 "%<~auto%> only available with "
6075 }
6077 /* If there was an explicit qualification (S::~T), first look
6078 in the scope given by the qualification (i.e., S).
6080 Note: in the calls to cp_parser_class_name below we pass
6081 typename_type so that lookup finds the injected-class-name
6082 rather than the constructor. */
6086 {
6091 typename_type,
6094 declarator_p);
6097 }
6098 /* In "N::S::~S", look in "N" as well. */
6100 {
6105 type_decl
6109 typename_type,
6112 declarator_p);
6115 }
6116 /* In "p->S::~T", look in the scope given by "*p" as well. */
6118 {
6123 type_decl
6127 typename_type,
6130 declarator_p);
6133 }
6134 /* Look in the surrounding context. */
6136 {
6142 type_decl
6146 typename_type,
6149 declarator_p);
6152 {
6153 /* We couldn't find a type with this name. If we're parsing
6154 tentatively, fail and try something else. */
6156 {
6159 }
6160 /* Otherwise, accept it and check for a match at instantiation
6161 time. */
6166 }
6167 }
6168 /* If an error occurred, assume that the name of the
6169 destructor is the same as the name of the qualifying
6170 class. That allows us to keep parsing after running
6171 into ill-formed destructor names. */
6177 /* Check that destructor name and scope match. */
6179 {
6186 }
6188 /* [class.dtor]
6190 A typedef-name that names a class shall not be used as the
6191 identifier in the declarator for a destructor declaration. */
6198 type_decl);
6201 }
6205 {
6206 cp_expr id;
6208 /* This could be a template-id, so we try that first. */
6210 /* Try a template-id. */
6213 none_type,
6214 declarator_p);
6215 /* If that worked, we're done. */
6218 /* We still don't know whether we're looking at an
6219 operator-function-id or a conversion-function-id. */
6221 /* Try an operator-function-id. */
6223 /* If that didn't work, try a conversion-function-id. */
6228 }
6229 /* Fall through. */
6236 }
6237 }
6239 /* Parse an (optional) nested-name-specifier.
6241 nested-name-specifier: [C++98]
6242 class-or-namespace-name :: nested-name-specifier [opt]
6243 class-or-namespace-name :: template nested-name-specifier [opt]
6245 nested-name-specifier: [C++0x]
6246 type-name ::
6247 namespace-name ::
6248 nested-name-specifier identifier ::
6249 nested-name-specifier template [opt] simple-template-id ::
6251 PARSER->SCOPE should be set appropriately before this function is
6252 called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in
6253 effect. TYPE_P is TRUE if we non-type bindings should be ignored
6254 in name lookups.
6256 Sets PARSER->SCOPE to the class (TYPE) or namespace
6257 (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves
6258 it unchanged if there is no nested-name-specifier. Returns the new
6259 scope iff there is a nested-name-specifier, or NULL_TREE otherwise.
6261 If IS_DECLARATION is TRUE, the nested-name-specifier is known to be
6262 part of a declaration and/or decl-specifier. */
6264 static tree
6271 {
6276 /* Remember where the nested-name-specifier starts. */
6278 {
6281 }
6284 {
6285 tree new_scope;
6286 tree old_scope;
6287 tree saved_qualifying_scope;
6289 /* Spot cases that cannot be the beginning of a
6290 nested-name-specifier. */
6293 /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process
6294 the already parsed nested-name-specifier. */
6296 {
6297 /* Grab the nested-name-specifier and continue the loop. */
6299 /* If we originally encountered this nested-name-specifier
6300 with IS_DECLARATION set to false, we will not have
6301 resolved TYPENAME_TYPEs, so we must do so here. */
6304 {
6309 }
6312 }
6314 /* Spot cases that cannot be the beginning of a
6315 nested-name-specifier. On the second and subsequent times
6316 through the loop, we look for the `template' keyword. */
6318 ;
6319 /* A template-id can start a nested-name-specifier. */
6321 ;
6322 /* DR 743: decltype can be used in a nested-name-specifier. */
6324 ;
6325 else
6326 {
6327 /* If the next token is not an identifier, then it is
6328 definitely not a type-name or namespace-name. */
6331 /* If the following token is neither a `<' (to begin a
6332 template-id), nor a `::', then we are not looking at a
6333 nested-name-specifier. */
6339 {
6343 "found %<:%> in nested-name-specifier, "
6346 }
6349 && !cp_parser_nth_token_starts_template_argument_list_p
6352 }
6354 /* The nested-name-specifier is optional, so we parse
6355 tentatively. */
6358 /* Look for the optional `template' keyword, if this isn't the
6359 first time through the loop. */
6363 /* Save the old scope since the name lookup we are about to do
6364 might destroy it. */
6367 /* In a declarator-id like "X<T>::I::Y<T>" we must be able to
6368 look up names in "X<T>::I" in order to determine that "Y" is
6369 a template. So, if we have a typename at this point, we make
6370 an effort to look through it. */
6372 && !typename_keyword_p
6377 /* Parse the qualifying entity. */
6378 new_scope
6380 typename_keyword_p,
6381 template_keyword_p,
6382 check_dependency_p,
6383 type_p,
6384 is_declaration);
6385 /* Look for the `::' token. */
6388 /* If we found what we wanted, we keep going; otherwise, we're
6389 done. */
6391 {
6394 /* Restore the OLD_SCOPE since it was valid before the
6395 failed attempt at finding the last
6396 class-or-namespace-name. */
6400 /* If the next token is a decltype, and the one after that is a
6401 `::', then the decltype has failed to resolve to a class or
6402 enumeration type. Give this error even when parsing
6403 tentatively since it can't possibly be valid--and we're going
6404 to replace it with a CPP_NESTED_NAME_SPECIFIER below, so we
6405 won't get another chance.*/
6409 {
6416 /* As below. */
6419 }
6423 {
6424 /* If we have a non-type template-id followed by ::, it can't
6425 possibly be valid. */
6430 {
6433 {
6439 }
6440 else
6441 {
6442 /* Variable template. */
6447 }
6454 /* As below. */
6458 }
6459 }
6463 /* If the next token is an identifier, and the one after
6464 that is a `::', then any valid interpretation would have
6465 found a class-or-namespace-name. */
6471 {
6474 {
6476 {
6477 tree decl;
6478 tree ambiguous_decls;
6481 none_type,
6490 decl);
6492 {
6493 // cp_parser_lookup_name has the same diagnostic,
6494 // thus make sure to emit it at most once.
6497 {
6502 }
6504 }
6505 else
6506 {
6508 cp_parser_name_lookup_error
6511 else
6512 cp_parser_name_lookup_error
6515 }
6516 }
6519 /* Treat this as a successful nested-name-specifier
6520 due to:
6522 [basic.lookup.qual]
6524 If the name found is not a class-name (clause
6525 _class_) or namespace-name (_namespace.def_), the
6526 program is ill-formed. */
6528 }
6530 }
6532 }
6533 /* We've found one valid nested-name-specifier. */
6535 /* Name lookup always gives us a DECL. */
6538 /* Uses of "template" must be followed by actual templates. */
6550 new_scope);
6551 /* If it is a class scope, try to complete it; we are about to
6552 be looking up names inside the class. */
6554 /* Since checking types for dependency can be expensive,
6555 avoid doing it if the type is already complete. */
6557 /* Do not try to complete dependent types. */
6559 {
6561 /* If it is a typedef to current class, use the current
6562 class instead, as the typedef won't have any names inside
6563 it yet. */
6567 }
6568 /* Make sure we look in the right scope the next time through
6569 the loop. */
6571 }
6573 /* If parsing tentatively, replace the sequence of tokens that makes
6574 up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER
6575 token. That way, should we re-parse the token stream, we will
6576 not have to repeat the effort required to do the parse, nor will
6577 we issue duplicate error messages. */
6579 {
6583 /* Reset the contents of the START token. */
6585 /* Retrieve any deferred checks. Do not pop this access checks yet
6586 so the memory will not be reclaimed during token replacing below. */
6594 /* Purge all subsequent tokens. */
6596 }
6602 }
6604 /* Parse a nested-name-specifier. See
6605 cp_parser_nested_name_specifier_opt for details. This function
6606 behaves identically, except that it will an issue an error if no
6607 nested-name-specifier is present. */
6609 static tree
6615 {
6616 tree scope;
6618 /* Look for the nested-name-specifier. */
6620 typename_keyword_p,
6621 check_dependency_p,
6622 type_p,
6623 is_declaration);
6624 /* If it was not present, issue an error message. */
6626 {
6629 }
6632 }
6634 /* Parse the qualifying entity in a nested-name-specifier. For C++98,
6635 this is either a class-name or a namespace-name (which corresponds
6636 to the class-or-namespace-name production in the grammar). For
6637 C++0x, it can also be a type-name that refers to an enumeration
6638 type or a simple-template-id.
6640 TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect.
6641 TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect.
6642 CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up.
6643 TYPE_P is TRUE iff the next name should be taken as a class-name,
6644 even the same name is declared to be another entity in the same
6645 scope.
6647 Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL)
6648 specified by the class-or-namespace-name. If neither is found the
6649 ERROR_MARK_NODE is returned. */
6651 static tree
6658 {
6659 tree saved_scope;
6660 tree saved_qualifying_scope;
6661 tree saved_object_scope;
6662 tree scope;
6666 /* DR 743: decltype can appear in a nested-name-specifier. */
6668 {
6672 {
6675 }
6679 }
6681 /* Before we try to parse the class-name, we must save away the
6682 current PARSER->SCOPE since cp_parser_class_name will destroy
6683 it. */
6687 /* Try for a class-name first. If the SAVED_SCOPE is a type, then
6688 there is no need to look for a namespace-name. */
6689 only_class_p = template_keyword_p
6694 typename_keyword_p,
6695 template_keyword_p,
6697 check_dependency_p,
6699 is_declaration,
6702 /* If that didn't work, try for a namespace-name. */
6704 {
6705 /* Restore the saved scope. */
6709 /* If we are not looking at an identifier followed by the scope
6710 resolution operator, then this is not part of a
6711 nested-name-specifier. (Note that this function is only used
6712 to parse the components of a nested-name-specifier.) */
6717 }
6720 }
6722 /* Return true if we are looking at a compound-literal, false otherwise. */
6724 static bool
6726 {
6729 /* Skip tokens until the next token is a closing parenthesis.
6730 If we find the closing `)', and the next token is a `{', then
6731 we are looking at a compound-literal. */
6732 bool compound_literal_p
6737 /* Roll back the tokens we skipped. */
6741 }
6743 /* Return true if EXPR is the integer constant zero or a complex constant
6744 of zero, without any folding, but ignoring location wrappers. */
6746 bool
6748 {
6751 }
6753 /* Parse a postfix-expression.
6755 postfix-expression:
6756 primary-expression
6757 postfix-expression [ expression ]
6758 postfix-expression ( expression-list [opt] )
6759 simple-type-specifier ( expression-list [opt] )
6760 typename :: [opt] nested-name-specifier identifier
6761 ( expression-list [opt] )
6762 typename :: [opt] nested-name-specifier template [opt] template-id
6763 ( expression-list [opt] )
6764 postfix-expression . template [opt] id-expression
6765 postfix-expression -> template [opt] id-expression
6766 postfix-expression . pseudo-destructor-name
6767 postfix-expression -> pseudo-destructor-name
6768 postfix-expression ++
6769 postfix-expression --
6770 dynamic_cast < type-id > ( expression )
6771 static_cast < type-id > ( expression )
6772 reinterpret_cast < type-id > ( expression )
6773 const_cast < type-id > ( expression )
6774 typeid ( expression )
6775 typeid ( type-id )
6777 GNU Extension:
6779 postfix-expression:
6780 ( type-id ) { initializer-list , [opt] }
6782 This extension is a GNU version of the C99 compound-literal
6783 construct. (The C99 grammar uses `type-name' instead of `type-id',
6784 but they are essentially the same concept.)
6786 If ADDRESS_P is true, the postfix expression is the operand of the
6787 `&' operator. CAST_P is true if this expression is the target of a
6788 cast.
6790 If MEMBER_ACCESS_ONLY_P, we only allow postfix expressions that are
6791 class member access expressions [expr.ref].
6793 Returns a representation of the expression. */
6795 static cp_expr
6799 {
6801 location_t loc;
6807 /* Peek at the next token. */
6812 /* Some of the productions are determined by keywords. */
6815 {
6820 {
6821 tree type;
6822 cp_expr expression;
6826 /* All of these can be handled in the same way from the point
6827 of view of parsing. Begin by consuming the token
6828 identifying the cast. */
6831 /* New types cannot be defined in the cast. */
6833 parser->type_definition_forbidden_message
6836 /* Look for the opening `<'. */
6838 /* Parse the type to which we are casting. */
6842 NULL);
6844 /* Look for the closing `>'. */
6846 /* Restore the old message. */
6849 bool saved_greater_than_is_operator_p
6853 /* And the expression which is being cast. */
6854 matching_parens parens;
6858 RT_CLOSE_PAREN);
6862 parser->greater_than_is_operator_p
6865 /* Only type conversions to integral or enumeration types
6866 can be used in constant-expressions. */
6869 {
6872 }
6875 {
6877 postfix_expression
6881 postfix_expression
6885 postfix_expression
6887 tf_warning_or_error);
6890 postfix_expression
6895 }
6897 /* Construct a location e.g. :
6898 reinterpret_cast <int *> (expr)
6899 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6900 ranging from the start of the "*_cast" token to the final closing
6901 paren, with the caret at the start. */
6904 }
6908 {
6909 tree type;
6913 /* Consume the `typeid' token. */
6915 /* Look for the `(' token. */
6916 matching_parens parens;
6918 /* Types cannot be defined in a `typeid' expression. */
6920 parser->type_definition_forbidden_message
6922 /* We can't be sure yet whether we're looking at a type-id or an
6923 expression. */
6925 /* Try a type-id first. */
6930 /* Look for the `)' token. Otherwise, we can't be sure that
6931 we're not looking at an expression: consider `typeid (int
6932 (3))', for example. */
6934 /* If all went well, simply lookup the type-id. */
6937 /* Otherwise, fall back to the expression variant. */
6938 else
6939 {
6940 tree expression;
6942 /* Look for an expression. */
6944 /* Compute its typeid. */
6946 /* Look for the `)' token. */
6948 }
6949 /* Restore the saved message. */
6951 /* `typeid' may not appear in an integral constant expression. */
6955 /* Construct a location e.g. :
6956 typeid (expr)
6957 ^~~~~~~~~~~~~
6958 ranging from the start of the "typeid" token to the final closing
6959 paren, with the caret at the start. */
6961 {
6962 location_t typeid_loc
6966 }
6967 }
6971 {
6972 tree type;
6973 /* The syntax permitted here is the same permitted for an
6974 elaborated-type-specifier. */
6981 }
6987 {
6990 tree p;
6997 {
7000 }
7006 {
7009 postfix_expression
7011 else
7012 {
7016 }
7022 tf_warning_or_error);
7023 else
7024 {
7028 }
7033 postfix_expression
7037 postfix_expression
7040 else
7041 {
7045 }
7050 }
7052 }
7055 {
7056 tree expression;
7057 tree type;
7058 /* Consume the `__builtin_convertvector' token. */
7060 /* Look for the opening `('. */
7061 matching_parens parens;
7063 /* Now, parse the assignment-expression. */
7065 /* Look for the `,'. */
7067 location_t type_location
7069 /* Parse the type-id. */
7070 {
7073 }
7074 /* Look for the closing `)'. */
7077 tf_warning_or_error);
7078 }
7081 {
7082 tree type;
7084 /* If the next thing is a simple-type-specifier, we may be
7085 looking at a functional cast. We could also be looking at
7086 an id-expression. So, we try the functional cast, and if
7087 that doesn't work we fall back to the primary-expression. */
7089 /* Look for the simple-type-specifier. */
7093 CP_PARSER_FLAGS_NONE);
7095 /* Parse the cast itself. */
7097 postfix_expression
7099 /* If that worked, we're done. */
7103 /* If the functional-cast didn't work out, try a
7104 compound-literal. */
7107 {
7112 matching_parens parens;
7115 /* Avoid calling cp_parser_type_id pointlessly, see comment
7116 in cp_parser_cast_expression about c++/29234. */
7119 else
7120 {
7121 /* Parse the type. */
7127 }
7129 /* If things aren't going well, there's no need to
7130 keep going. */
7132 {
7134 /* Parse the brace-enclosed initializer list. */
7137 }
7138 /* If that worked, we're definitely looking at a
7139 compound-literal expression. */
7141 {
7142 /* Warn the user that a compound literal is not
7143 allowed in standard C++. */
7146 /* For simplicity, we disallow compound literals in
7147 constant-expressions. We could
7148 allow compound literals of integer type, whose
7149 initializer was a constant, in constant
7150 expressions. Permitting that usage, as a further
7151 extension, would not change the meaning of any
7152 currently accepted programs. (Of course, as
7153 compound literals are not part of ISO C++, the
7154 standard has nothing to say.) */
7156 NIC_NCC))
7157 {
7160 }
7161 /* Form the representation of the compound-literal. */
7162 postfix_expression
7167 }
7168 }
7170 /* It must be a primary-expression. */
7171 postfix_expression
7174 decltype_p,
7176 }
7178 }
7180 /* Note that we don't need to worry about calling build_cplus_new on a
7181 class-valued CALL_EXPR in decltype when it isn't the end of the
7182 postfix-expression; unary_complex_lvalue will take care of that for
7183 all these cases. */
7185 /* Keep looping until the postfix-expression is complete. */
7187 {
7191 /* It is not a Koenig lookup function call. */
7192 postfix_expression
7195 /* Peek at the next token. */
7199 {
7202 {
7204 "two consecutive %<[%> shall "
7207 }
7208 postfix_expression
7210 postfix_expression,
7212 decltype_p);
7221 /* postfix-expression ( expression-list [opt] ) */
7222 {
7233 tree stripped_expression
7235 is_builtin_constant_p
7238 {
7239 /* The whole point of __builtin_constant_p is to allow
7240 non-constant expressions to appear as arguments. */
7241 saved_integral_constant_expression_p
7243 saved_non_integral_constant_expression_p
7246 }
7247 args = (cp_parser_parenthesized_expression_list
7254 {
7255 parser->integral_constant_expression_p
7257 parser->non_integral_constant_expression_p
7259 }
7262 {
7265 }
7267 /* Function calls are not permitted in
7268 constant-expressions. */
7271 NIC_FUNC_CALL))
7272 {
7276 }
7281 {
7283 /* In C++2A, we may need to perform ADL for a template
7284 name. */
7287 {
7289 {
7292 postfix_expression
7294 complain);
7295 }
7296 else
7297 postfix_expression
7299 }
7300 /* We do not perform argument-dependent lookup if
7301 normal lookup finds a non-function, in accordance
7302 with the expected resolution of DR 218. */
7305 {
7306 /* We only need to look at the first function,
7307 because all the fns share the attribute we're
7308 concerned with (all member fns or all local
7309 fns). */
7313 /* Do not do argument dependent lookup if regular
7314 lookup finds a member function or a block-scope
7315 function declaration. [basic.lookup.argdep]/3 */
7319 {
7322 postfix_expression
7324 complain);
7325 }
7326 }
7327 }
7330 {
7340 {
7342 postfix_expression
7346 }
7349 {
7350 postfix_expression
7351 = (build_new_method_call
7357 complain));
7358 }
7359 else
7360 postfix_expression
7364 complain);
7365 }
7369 postfix_expression = (build_offset_ref_call_from_tree
7371 complain));
7373 /* A call to a static class member, or a namespace-scope
7374 function. */
7375 postfix_expression
7378 koenig_p,
7379 complain);
7380 else
7381 /* All other function calls. */
7382 postfix_expression
7385 koenig_p,
7386 complain);
7389 {
7391 start_loc,
7392 close_paren_loc);
7394 }
7396 /* The POSTFIX_EXPRESSION is certainly no longer an id. */
7400 }
7405 /* postfix-expression . template [opt] id-expression
7406 postfix-expression . pseudo-destructor-name
7407 postfix-expression -> template [opt] id-expression
7408 postfix-expression -> pseudo-destructor-name */
7410 /* Consume the `.' or `->' operator. */
7413 postfix_expression
7415 postfix_expression,
7422 /* postfix-expression ++ */
7423 /* Consume the `++' token. */
7425 /* Generate a representation for the complete expression. */
7426 postfix_expression
7428 POSTINCREMENT_EXPR);
7429 /* Increments may not appear in constant-expressions. */
7437 /* postfix-expression -- */
7438 /* Consume the `--' token. */
7440 /* Generate a representation for the complete expression. */
7441 postfix_expression
7443 POSTDECREMENT_EXPR);
7444 /* Decrements may not appear in constant-expressions. */
7455 return is_member_access
7456 ? postfix_expression
7458 else
7460 }
7461 }
7463 /* We should never get here. */
7466 }
7468 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
7469 by cp_parser_builtin_offsetof. We're looking for
7471 postfix-expression [ expression ]
7472 postfix-expression [ braced-init-list ] (C++11)
7474 FOR_OFFSETOF is set if we're being called in that context, which
7475 changes how we deal with integer constant expressions. */
7477 static tree
7479 tree postfix_expression,
7482 {
7487 /* Consume the `[' token. */
7493 /* Parse the index expression. */
7494 /* ??? For offsetof, there is a question of what to allow here. If
7495 offsetof is not being used in an integral constant expression context,
7496 then we *could* get the right answer by computing the value at runtime.
7497 If we are in an integral constant expression context, then we might
7498 could accept any constant expression; hard to say without analysis.
7499 Rather than open the barn door too wide right away, allow only integer
7500 constant expressions here. */
7503 else
7504 {
7506 {
7511 }
7512 else
7514 }
7518 /* Look for the closing `]'. */
7521 /* Build the ARRAY_REF. */
7525 /* When not doing offsetof, array references are not permitted in
7526 constant-expressions. */
7532 }
7534 /* A subroutine of cp_parser_postfix_dot_deref_expression. Handle dot
7535 dereference of incomplete type, returns true if error_mark_node should
7536 be returned from caller, otherwise adjusts *SCOPE, *POSTFIX_EXPRESSION
7537 and *DEPENDENT_P. */
7539 bool
7542 {
7543 /* In a template, be permissive by treating an object expression
7544 of incomplete type as dependent (after a pedwarn). */
7545 diagnostic_t kind = (processing_template_decl
7549 {
7561 /* Don't emit any diagnostic for OVERLOADs. */
7565 /* Avoid clobbering e.g. DECLs. */
7569 }
7581 {
7584 }
7586 }
7588 /* A subroutine of cp_parser_postfix_expression that also gets hijacked
7589 by cp_parser_builtin_offsetof. We're looking for
7591 postfix-expression . template [opt] id-expression
7592 postfix-expression . pseudo-destructor-name
7593 postfix-expression -> template [opt] id-expression
7594 postfix-expression -> pseudo-destructor-name
7596 FOR_OFFSETOF is set if we're being called in that context. That sorta
7597 limits what of the above we'll actually accept, but nevermind.
7598 TOKEN_TYPE is the "." or "->" token, which will already have been
7599 removed from the stream. */
7601 static tree
7604 cp_expr postfix_expression,
7606 location_t location)
7607 {
7608 tree name;
7614 /* If this is a `->' operator, dereference the pointer. */
7617 tf_warning_or_error);
7618 /* Check to see whether or not the expression is type-dependent and
7619 not the current instantiation. */
7621 /* The identifier following the `->' or `.' is not qualified. */
7627 /* Enter the scope corresponding to the type of the object
7628 given by the POSTFIX_EXPRESSION. */
7630 {
7632 /* According to the standard, no expression should ever have
7633 reference type. Unfortunately, we do not currently match
7634 the standard in this respect in that our internal representation
7635 of an expression may have reference type even when the standard
7636 says it does not. Therefore, we have to manually obtain the
7637 underlying type here. */
7639 /* The type of the POSTFIX_EXPRESSION must be complete. */
7640 /* Unlike the object expression in other contexts, *this is not
7641 required to be of complete type for purposes of class member
7642 access (5.2.5) outside the member function body. */
7646 {
7652 }
7655 {
7656 /* Let the name lookup machinery know that we are processing a
7657 class member access expression. */
7659 /* If something went wrong, we want to be able to discern that case,
7660 as opposed to the case where there was no SCOPE due to the type
7661 of expression being dependent. */
7664 /* If the SCOPE was erroneous, make the various semantic analysis
7665 functions exit quickly -- and without issuing additional error
7666 messages. */
7669 }
7670 }
7673 /* Tell cp_parser_lookup_name that there was an object, even though it's
7674 type-dependent. */
7677 /* Assume this expression is not a pseudo-destructor access. */
7680 /* If the SCOPE is a scalar type, then, if this is a valid program,
7681 we must be looking at a pseudo-destructor-name. If POSTFIX_EXPRESSION
7682 is type dependent, it can be pseudo-destructor-name or something else.
7683 Try to parse it as pseudo-destructor-name first. */
7685 {
7686 tree s;
7687 tree type;
7690 /* Parse the pseudo-destructor-name. */
7699 {
7701 postfix_expression
7704 }
7705 }
7708 {
7709 /* If the SCOPE is not a scalar type, we are looking at an
7710 ordinary class member access expression, rather than a
7711 pseudo-destructor-name. */
7714 /* Parse the id-expression. */
7715 name = (cp_parser_id_expression
7722 /* In general, build a SCOPE_REF if the member name is qualified.
7723 However, if the name was not dependent and has already been
7724 resolved; there is no need to build the SCOPE_REF. For example;
7726 struct X { void f(); };
7727 template <typename T> void f(T* t) { t->X::f(); }
7729 Even though "t" is dependent, "X::f" is not and has been resolved
7730 to a BASELINK; there is no need to include scope information. */
7732 /* But we do need to remember that there was an explicit scope for
7733 virtual function calls. */
7737 /* If the name is a template-id that names a type, we will get a
7738 TYPE_DECL here. That is invalid code. */
7740 {
7743 }
7744 else
7745 {
7747 {
7749 {
7753 }
7754 else
7757 name,
7758 template_p);
7762 }
7764 adjust_result_of_qualified_name_lookup
7766 postfix_expression
7768 template_p,
7769 tf_warning_or_error);
7770 /* Build a location e.g.:
7771 ptr->access_expr
7772 ~~~^~~~~~~~~~~~~
7773 where the caret is at the deref token, ranging from
7774 the start of postfix_expression to the end of the access expr. */
7775 location_t end_loc
7777 location_t combined_loc
7780 }
7781 }
7783 /* We no longer need to look up names in the scope of the object on
7784 the left-hand side of the `.' or `->' operator. */
7787 /* Outside of offsetof, these operators may not appear in
7788 constant-expressions. */
7790 && (cp_parser_non_integral_constant_expression
7795 }
7797 /* Parse a parenthesized expression-list.
7799 expression-list:
7800 assignment-expression
7801 expression-list, assignment-expression
7803 attribute-list:
7804 expression-list
7805 identifier
7806 identifier, expression-list
7808 CAST_P is true if this expression is the target of a cast.
7810 ALLOW_EXPANSION_P is true if this expression allows expansion of an
7811 argument pack.
7813 WRAP_LOCATIONS_P is true if expressions within this list for which
7814 CAN_HAVE_LOCATION_P is false should be wrapped with nodes expressing
7815 their source locations.
7817 Returns a vector of trees. Each element is a representation of an
7818 assignment-expression. NULL is returned if the ( and or ) are
7819 missing. An empty, but allocated, vector is returned on no
7820 expressions. The parentheses are eaten. IS_ATTRIBUTE_LIST is id_attr
7821 if we are parsing an attribute list for an attribute that wants a
7822 plain identifier argument, normal_attr for an attribute that wants
7823 an expression, or non_attr if we aren't parsing an attribute list. If
7824 NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P indicates whether or
7825 not all of the expressions in the list were constant.
7826 If CLOSE_PAREN_LOC is non-NULL, and no errors occur, then *CLOSE_PAREN_LOC
7827 will be written to with the location of the closing parenthesis. If
7828 an error occurs, it may or may not be written to. */
7838 {
7844 /* Assume all the expressions will be constant. */
7848 matching_parens parens;
7854 /* Within a parenthesized expression, a `>' token is always
7855 the greater-than operator. */
7856 saved_greater_than_is_operator_p
7862 /* Consume expressions until there are no more. */
7865 {
7866 /* At the beginning of attribute lists, check to see if the
7867 next token is an identifier. */
7870 {
7873 /* Consume the identifier. */
7875 /* Save the identifier. */
7877 }
7878 else
7879 {
7882 /* Parse the next assignment-expression. */
7884 {
7885 /* A braced-init-list. */
7891 }
7893 {
7894 expr = (cp_parser_constant_expression
7899 }
7900 else
7902 cast_p);
7907 /* If we have an ellipsis, then this is an expression
7908 expansion. */
7911 {
7912 /* Consume the `...'. */
7915 /* Build the argument pack. */
7917 }
7922 /* Add it to the list. We add error_mark_node
7923 expressions to the list, so that we can still tell if
7924 the correct form for a parenthesized expression-list
7925 is found. That gives better errors. */
7930 }
7932 /* After the first item, attribute lists look the same as
7933 expression lists. */
7936 get_comma:;
7937 /* If the next token isn't a `,', then we are done. */
7941 /* Otherwise, consume the `,' and keep going. */
7943 }
7949 {
7952 skip_comma:;
7953 /* We try and resync to an unnested comma, as that will give the
7954 user better diagnostics. */
7962 {
7963 parser->greater_than_is_operator_p
7966 }
7967 }
7969 parser->greater_than_is_operator_p
7976 }
7978 /* Parse a pseudo-destructor-name.
7980 pseudo-destructor-name:
7981 :: [opt] nested-name-specifier [opt] type-name :: ~ type-name
7982 :: [opt] nested-name-specifier template template-id :: ~ type-name
7983 :: [opt] nested-name-specifier [opt] ~ type-name
7985 If either of the first two productions is used, sets *SCOPE to the
7986 TYPE specified before the final `::'. Otherwise, *SCOPE is set to
7987 NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name,
7988 or ERROR_MARK_NODE if the parse fails. */
7990 static void
7992 tree object,
7995 {
7998 /* Handle ~auto. */
8002 {
8005 "%<~auto%> only available with "
8012 }
8014 /* Assume that things will not work out. */
8017 /* Look for the optional `::' operator. */
8019 /* Look for the optional nested-name-specifier. */
8020 nested_name_specifier_p
8027 /* Now, if we saw a nested-name-specifier, we might be doing the
8028 second production. */
8031 {
8032 /* Consume the `template' keyword. */
8034 /* Parse the template-id. */
8038 class_type,
8040 /* Look for the `::' token. */
8042 }
8043 /* If the next token is not a `~', then there might be some
8044 additional qualification. */
8046 {
8047 /* At this point, we're looking for "type-name :: ~". The type-name
8048 must not be a class-name, since this is a pseudo-destructor. So,
8049 it must be either an enum-name, or a typedef-name -- both of which
8050 are just identifiers. So, we peek ahead to check that the "::"
8051 and "~" tokens are present; if they are not, then we can avoid
8052 calling type_name. */
8056 {
8059 }
8061 /* Look for the type-name. */
8066 /* Look for the `::' token. */
8068 }
8069 else
8072 /* Look for the `~'. */
8075 /* Once we see the ~, this has to be a pseudo-destructor. */
8079 /* Look for the type-name again. We are not responsible for
8080 checking that it matches the first type-name. */
8082 }
8084 /* Parse a unary-expression.
8086 unary-expression:
8087 postfix-expression
8088 ++ cast-expression
8089 -- cast-expression
8090 unary-operator cast-expression
8091 sizeof unary-expression
8092 sizeof ( type-id )
8093 alignof ( type-id ) [C++0x]
8094 new-expression
8095 delete-expression
8097 GNU Extensions:
8099 unary-expression:
8100 __extension__ cast-expression
8101 __alignof__ unary-expression
8102 __alignof__ ( type-id )
8103 alignof unary-expression [C++0x]
8104 __real__ cast-expression
8105 __imag__ cast-expression
8106 && identifier
8107 sizeof ( type-id ) { initializer-list , [opt] }
8108 alignof ( type-id ) { initializer-list , [opt] } [C++0x]
8109 __alignof__ ( type-id ) { initializer-list , [opt] }
8111 ADDRESS_P is true iff the unary-expression is appearing as the
8112 operand of the `&' operator. CAST_P is true if this expression is
8113 the target of a cast.
8115 Returns a representation of the expression. */
8117 static cp_expr
8120 {
8124 /* Peek at the next token. */
8126 /* Some keywords give away the kind of expression. */
8128 {
8132 {
8135 {
8143 /* Consume the token. */
8145 /* Parse the operand. */
8151 else
8152 {
8153 /* ISO C++ defines alignof only with types, not with
8154 expressions. So pedwarn if alignof is used with a non-
8155 type expression. However, __alignof__ is ok. */
8158 "ISO C++ does not allow %<alignof%> "
8162 }
8163 /* For SIZEOF_EXPR, just issue diagnostics, but keep
8164 SIZEOF_EXPR with the original operand. */
8166 {
8168 {
8170 {
8173 error_mark_node));
8175 }
8176 else
8180 }
8181 }
8183 /* Construct a location e.g. :
8184 alignof (expr)
8185 ^~~~~~~~~~~~~~
8186 with start == caret at the start of the "alignof"/"sizeof"
8187 token, with the endpoint at the final closing paren. */
8188 location_t finish_loc
8190 location_t compound_loc
8197 }
8209 {
8210 /* The saved value of the PEDANTIC flag. */
8212 tree expr;
8214 /* Save away the PEDANTIC flag. */
8216 /* Parse the cast-expression. */
8218 /* Restore the PEDANTIC flag. */
8222 }
8226 {
8227 tree expression;
8229 /* Consume the `__real__' or `__imag__' token. */
8231 /* Parse the cast-expression. */
8233 /* Create the complete representation. */
8237 expression,
8238 tf_warning_or_error);
8239 }
8247 {
8248 tree expr;
8257 matching_parens parens;
8261 parser->type_definition_forbidden_message
8264 saved_integral_constant_expression_p
8266 saved_non_integral_constant_expression_p
8270 saved_greater_than_is_operator_p
8282 parser->greater_than_is_operator_p
8285 parser->integral_constant_expression_p
8287 parser->non_integral_constant_expression_p
8292 location_t finish_loc
8296 /* Construct a location of the form:
8297 noexcept (expr)
8298 ^~~~~~~~~~~~~~~
8299 with start == caret, finishing at the close-paren. */
8300 location_t noexcept_loc
8304 noexcept_loc);
8305 }
8309 }
8310 }
8312 /* Look for the `:: new' and `:: delete', which also signal the
8313 beginning of a new-expression, or delete-expression,
8314 respectively. If the next token is `::', then it might be one of
8315 these. */
8317 {
8320 /* See if the token after the `::' is one of the keywords in
8321 which we're interested. */
8323 /* If it's `new', we have a new-expression. */
8326 /* Similarly, for `delete'. */
8329 }
8331 /* Look for a unary operator. */
8333 /* The `++' and `--' operators can be handled similarly, even though
8334 they are not technically unary-operators in the grammar. */
8336 {
8341 /* Handle the GNU address-of-label extension. */
8344 {
8345 tree identifier;
8346 tree expression;
8349 /* Consume the '&&' token. */
8351 /* Look for the identifier. */
8352 location_t finish_loc
8355 /* Construct a location of the form:
8356 &&label
8357 ^~~~~~~
8358 with caret==start at the "&&", finish at the end of the label. */
8359 location_t combined_loc
8361 /* Create an expression representing the address. */
8364 NIC_ADDR_LABEL))
8367 }
8368 }
8370 {
8371 cp_expr cast_expression;
8377 /* Consume the operator token. */
8381 /* Parse the cast-expression. */
8382 cast_expression
8387 pidk);
8389 /* Make a location:
8390 OP_TOKEN CAST_EXPRESSION
8391 ^~~~~~~~~~~~~~~~~~~~~~~~~
8392 with start==caret at the operator token, and
8393 extending to the end of the cast_expression. */
8396 /* Now, build an appropriate representation. */
8398 {
8402 RO_UNARY_STAR,
8403 complain);
8404 /* TODO: build_x_indirect_ref does not always honor the
8405 location, so ensure it is set. */
8411 /* Fall through. */
8414 cast_expression,
8415 complain);
8416 /* TODO: build_x_unary_op does not always honor the location,
8417 so ensure it is set. */
8425 /* Fall through. */
8427 /* Immediately fold negation of a constant, unless the constant is 0
8428 (since -0 == 0) or it would overflow. */
8430 {
8431 tree stripped_expr
8436 {
8439 stripped_expr);
8441 {
8444 }
8445 }
8446 }
8447 /* Fall through. */
8456 }
8460 non_constant_p))
8464 }
8468 decltype_p,
8469 pidk);
8470 }
8472 /* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a
8473 unary-operator, the corresponding tree code is returned. */
8475 static enum tree_code
8477 {
8479 {
8500 }
8501 }
8503 /* Parse a __builtin_has_attribute([expr|type], attribute-spec) expression.
8504 Returns a representation of the expression. */
8506 static tree
8508 {
8511 /* Consume the __builtin_has_attribute token. */
8514 matching_parens parens;
8518 /* Types cannot be defined in a `sizeof' expression. Save away the
8519 old message. */
8521 /* And create the new one. */
8528 /* The restrictions on constant-expressions do not apply inside
8529 sizeof expressions. */
8530 bool saved_integral_constant_expression_p
8532 bool saved_non_integral_constant_expression_p
8536 /* Do not actually evaluate the expression. */
8542 /* We can't be sure yet whether we're looking at a type-id or an
8543 expression. */
8548 /* Look for the type-id. */
8554 /* If the type-id production did not work out, then we must be
8555 looking at the unary-expression production. */
8561 /* Go back to evaluating expressions. */
8565 /* Free the message we created. */
8567 /* And restore the old one. */
8569 parser->integral_constant_expression_p
8571 parser->non_integral_constant_expression_p
8574 /* Consume the comma if it's there. */
8576 {
8580 }
8582 /* Parse the attribute specification. */
8586 {
8588 {
8589 /* Fold constant expressions used in attributes first. */
8592 /* Finally, see if OPER has been declared with ATTR. */
8594 }
8597 }
8598 else
8599 {
8602 }
8604 /* Construct a location e.g. :
8605 __builtin_has_attribute (oper, attr)
8606 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
8607 with start == caret at the start of the built-in token,
8608 and with the endpoint at the final closing paren. */
8609 location_t finish_loc
8611 location_t compound_loc
8618 }
8620 /* Parse a new-expression.
8622 new-expression:
8623 :: [opt] new new-placement [opt] new-type-id new-initializer [opt]
8624 :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt]
8626 Returns a representation of the expression. */
8628 static tree
8630 {
8633 tree type;
8636 tree ret;
8640 /* Look for the optional `::' operator. */
8641 global_scope_p
8645 /* Look for the `new' operator. */
8647 /* There's no easy way to tell a new-placement from the
8648 `( type-id )' construct. */
8650 /* Look for a new-placement. */
8652 /* If that didn't work out, there's no new-placement. */
8654 {
8658 }
8660 /* If the next token is a `(', then we have a parenthesized
8661 type-id. */
8663 {
8667 /* Consume the `('. */
8668 matching_parens parens;
8671 /* Parse the type-id. */
8672 parser->type_definition_forbidden_message
8674 {
8677 }
8680 /* Look for the closing `)'. */
8683 /* There should not be a direct-new-declarator in this production,
8684 but GCC used to allowed this, so we check and emit a sensible error
8685 message for this case. */
8687 {
8693 }
8694 }
8695 /* Otherwise, there must be a new-type-id. */
8696 else
8699 /* If the next token is a `(' or '{', then we have a new-initializer. */
8704 else
8707 /* A new-expression may not appear in an integral constant
8708 expression. */
8711 /* 5.3.4/2: "If the auto type-specifier appears in the type-specifier-seq
8712 of a new-type-id or type-id of a new-expression, the new-expression shall
8713 contain a new-initializer of the form ( assignment-expression )".
8714 Additionally, consistently with the spirit of DR 1467, we want to accept
8715 'new auto { 2 }' too. */
8721 {
8723 "initialization of new-expression for type %<auto%> "
8726 }
8727 else
8728 {
8729 /* Construct a location e.g.:
8730 ptr = new int[100]
8731 ^~~~~~~~~~~~
8732 with caret == start at the start of the "new" token, and the end
8733 at the end of the final token we consumed. */
8738 /* Create a representation of the new-expression. */
8740 tf_warning_or_error);
8742 }
8750 }
8752 /* Parse a new-placement.
8754 new-placement:
8755 ( expression-list )
8757 Returns the same representation as for an expression-list. */
8761 {
8764 /* Parse the expression-list. */
8765 expression_list = (cp_parser_parenthesized_expression_list
8774 }
8776 /* Parse a new-type-id.
8778 new-type-id:
8779 type-specifier-seq new-declarator [opt]
8781 Returns the TYPE allocated. If the new-type-id indicates an array
8782 type, *NELTS is set to the number of elements in the last array
8783 bound; the TYPE will not include the last array bound. */
8785 static tree
8787 {
8788 cp_decl_specifier_seq type_specifier_seq;
8794 /* The type-specifier sequence must not contain type definitions.
8795 (It cannot contain declarations of new types either, but if they
8796 are not definitions we will catch that because they are not
8797 complete.) */
8799 parser->type_definition_forbidden_message
8801 /* Parse the type-specifier-seq. */
8806 /* Restore the old message. */
8812 /* Parse the new-declarator. */
8815 /* Determine the number of elements in the last array dimension, if
8816 any. */
8818 /* Skip down to the last array dimension. */
8823 {
8826 }
8831 {
8834 }
8837 {
8844 else
8846 }
8849 }
8851 /* Parse an (optional) new-declarator.
8853 new-declarator:
8854 ptr-operator new-declarator [opt]
8855 direct-new-declarator
8857 Returns the declarator. */
8861 {
8864 cp_cv_quals cv_quals;
8866 /* We don't know if there's a ptr-operator next, or not. */
8868 /* Look for a ptr-operator. */
8870 /* If that worked, look for more new-declarators. */
8872 {
8875 /* Parse another optional declarator. */
8878 declarator = cp_parser_make_indirect_declarator
8882 }
8884 /* If the next token is a `[', there is a direct-new-declarator. */
8889 }
8891 /* Parse a direct-new-declarator.
8893 direct-new-declarator:
8894 [ expression ]
8895 direct-new-declarator [constant-expression]
8897 */
8901 {
8905 {
8906 tree expression;
8909 /* Look for the opening `['. */
8914 /* The standard requires that the expression have integral
8915 type. DR 74 adds enumeration types. We believe that the
8916 real intent is that these expressions be handled like the
8917 expression in a `switch' condition, which also allows
8918 classes with a single conversion to integral or
8919 enumeration type. */
8921 {
8922 expression
8924 expression,
8927 {
8929 "expression in new-declarator must have integral "
8932 }
8933 }
8935 /* Look for the closing `]'. */
8938 /* Add this bound to the declarator. */
8941 /* If the next token is not a `[', then there are no more
8942 bounds. */
8945 }
8948 }
8950 /* Parse a new-initializer.
8952 new-initializer:
8953 ( expression-list [opt] )
8954 braced-init-list
8956 Returns a representation of the expression-list. */
8960 {
8964 {
8965 tree t;
8972 }
8973 else
8974 expression_list = (cp_parser_parenthesized_expression_list
8980 }
8982 /* Parse a delete-expression.
8984 delete-expression:
8985 :: [opt] delete cast-expression
8986 :: [opt] delete [ ] cast-expression
8988 Returns a representation of the expression. */
8990 static tree
8992 {
8995 tree expression;
8997 /* Look for the optional `::' operator. */
8998 global_scope_p
9002 /* Look for the `delete' keyword. */
9004 /* See if the array syntax is in use. */
9006 {
9007 /* Consume the `[' token. */
9009 /* Look for the `]' token. */
9011 /* Remember that this is the `[]' construct. */
9013 }
9014 else
9017 /* Parse the cast-expression. */
9020 /* A delete-expression may not appear in an integral constant
9021 expression. */
9026 tf_warning_or_error);
9027 }
9029 /* Returns 1 if TOKEN may start a cast-expression and isn't '++', '--',
9030 neither '[' in C++11; -1 if TOKEN is '++', '--', or '[' in C++11;
9031 0 otherwise. */
9033 static int
9035 {
9038 {
9080 /* In ((type ()) () the last () isn't a valid cast-expression,
9081 so the whole must be parsed as postfix-expression. */
9086 /* '[' may start a primary-expression in obj-c++ and in C++11,
9087 as a lambda-expression, eg, '(void)[]{}'. */
9094 /* '++' and '--' may or may not start a cast-expression:
9096 struct T { void operator++(int); };
9097 void f() { (T())++; }
9099 vs
9101 int a;
9102 (int)++a; */
9107 }
9108 }
9110 /* Try to find a legal C++-style cast to DST_TYPE for ORIG_EXPR, trying them
9111 in the order: const_cast, static_cast, reinterpret_cast.
9113 Don't suggest dynamic_cast.
9115 Return the first legal cast kind found, or NULL otherwise. */
9119 {
9120 tree trial;
9122 /* Reuse the parser logic by attempting to build the various kinds of
9123 cast, with "complain" disabled.
9124 Identify the first such cast that is valid. */
9126 /* Don't attempt to run such logic within template processing. */
9130 /* First try const_cast. */
9135 /* If that fails, try static_cast. */
9140 /* Finally, try reinterpret_cast. */
9145 /* No such cast possible. */
9147 }
9149 /* If -Wold-style-cast is enabled, add fix-its to RICHLOC,
9150 suggesting how to convert a C-style cast of the form:
9152 (DST_TYPE)ORIG_EXPR
9154 to a C++-style cast.
9156 The primary range of RICHLOC is asssumed to be that of the original
9157 expression. OPEN_PAREN_LOC and CLOSE_PAREN_LOC give the locations
9158 of the parens in the C-style cast. */
9160 static void
9163 tree dst_type)
9164 {
9165 /* This function is non-trivial, so bail out now if the warning isn't
9166 going to be emitted. */
9170 /* Try to find a legal C++ cast, trying them in order:
9171 const_cast, static_cast, reinterpret_cast. */
9176 /* Replace the open paren with "CAST_SUGGESTION<". */
9177 pretty_printer pp;
9181 /* Replace the close paren with "> (". */
9184 /* Add a closing paren after the expr (the primary range of RICH_LOC). */
9186 }
9189 /* Parse a cast-expression.
9191 cast-expression:
9192 unary-expression
9193 ( type-id ) cast-expression
9195 ADDRESS_P is true iff the unary-expression is appearing as the
9196 operand of the `&' operator. CAST_P is true if this expression is
9197 the target of a cast.
9199 Returns a representation of the expression. */
9201 static cp_expr
9204 {
9205 /* If it's a `(', then we might be looking at a cast. */
9207 {
9213 /* There's no way to know yet whether or not this is a cast.
9214 For example, `(int (3))' is a unary-expression, while `(int)
9215 3' is a cast. So, we resort to parsing tentatively. */
9217 /* Types may not be defined in a cast. */
9219 parser->type_definition_forbidden_message
9221 /* Consume the `('. */
9222 matching_parens parens;
9227 /* A very tricky bit is that `(struct S) { 3 }' is a
9228 compound-literal (which we permit in C++ as an extension).
9229 But, that construct is not a cast-expression -- it is a
9230 postfix-expression. (The reason is that `(struct S) { 3 }.i'
9231 is legal; if the compound-literal were a cast-expression,
9232 you'd need an extra set of parentheses.) But, if we parse
9233 the type-id, and it happens to be a class-specifier, then we
9234 will commit to the parse at that point, because we cannot
9235 undo the action that is done when creating a new class. So,
9236 then we cannot back up and do a postfix-expression.
9238 Another tricky case is the following (c++/29234):
9240 struct S { void operator () (); };
9242 void foo ()
9243 {
9244 ( S()() );
9245 }
9247 As a type-id we parse the parenthesized S()() as a function
9248 returning a function, groktypename complains and we cannot
9249 back up in this case either.
9251 Therefore, we scan ahead to the closing `)', and check to see
9252 if the tokens after the `)' can start a cast-expression. Otherwise
9253 we are dealing with an unary-expression, a postfix-expression
9254 or something else.
9256 Yet another tricky case, in C++11, is the following (c++/54891):
9258 (void)[]{};
9260 The issue is that usually, besides the case of lambda-expressions,
9261 the parenthesized type-id cannot be followed by '[', and, eg, we
9262 want to parse '(C ())[2];' in parse/pr26997.C as unary-expression.
9263 Thus, if cp_parser_tokens_start_cast_expression returns -1, below
9264 we don't commit, we try a cast-expression, then an unary-expression.
9266 Save tokens so that we can put them back. */
9269 /* We may be looking at a cast-expression. */
9272 cast_expression
9275 /* Roll back the tokens we skipped. */
9277 /* If we aren't looking at a cast-expression, simulate an error so
9278 that the call to cp_parser_error_occurred below returns true. */
9281 else
9282 {
9285 /* Look for the type-id. */
9287 /* Look for the closing `)'. */
9292 }
9294 /* Restore the saved message. */
9297 /* At this point this can only be either a cast or a
9298 parenthesized ctor such as `(T ())' that looks like a cast to
9299 function returning T. */
9301 {
9302 /* Only commit if the cast-expression doesn't start with
9303 '++', '--', or '[' in C++11. */
9311 pidk);
9314 {
9315 /* Warn about old-style casts, if so requested. */
9320 {
9326 }
9328 /* Only type conversions to integral or enumeration types
9329 can be used in constant-expressions. */
9332 NIC_CAST))
9335 /* Perform the cast. */
9336 /* Make a location:
9337 (TYPE) EXPR
9338 ^~~~~~~~~~~
9339 with start==caret at the open paren, extending to the
9340 end of "expr". */
9342 open_paren_loc,
9346 }
9347 }
9348 else
9350 }
9352 /* If we get here, then it's not a cast, so it must be a
9353 unary-expression. */
9356 }
9358 /* Parse a binary expression of the general form:
9360 pm-expression:
9361 cast-expression
9362 pm-expression .* cast-expression
9363 pm-expression ->* cast-expression
9365 multiplicative-expression:
9366 pm-expression
9367 multiplicative-expression * pm-expression
9368 multiplicative-expression / pm-expression
9369 multiplicative-expression % pm-expression
9371 additive-expression:
9372 multiplicative-expression
9373 additive-expression + multiplicative-expression
9374 additive-expression - multiplicative-expression
9376 shift-expression:
9377 additive-expression
9378 shift-expression << additive-expression
9379 shift-expression >> additive-expression
9381 relational-expression:
9382 shift-expression
9383 relational-expression < shift-expression
9384 relational-expression > shift-expression
9385 relational-expression <= shift-expression
9386 relational-expression >= shift-expression
9388 GNU Extension:
9390 relational-expression:
9391 relational-expression <? shift-expression
9392 relational-expression >? shift-expression
9394 equality-expression:
9395 relational-expression
9396 equality-expression == relational-expression
9397 equality-expression != relational-expression
9399 and-expression:
9400 equality-expression
9401 and-expression & equality-expression
9403 exclusive-or-expression:
9404 and-expression
9405 exclusive-or-expression ^ and-expression
9407 inclusive-or-expression:
9408 exclusive-or-expression
9409 inclusive-or-expression | exclusive-or-expression
9411 logical-and-expression:
9412 inclusive-or-expression
9413 logical-and-expression && inclusive-or-expression
9415 logical-or-expression:
9416 logical-and-expression
9417 logical-or-expression || logical-and-expression
9419 All these are implemented with a single function like:
9421 binary-expression:
9422 simple-cast-expression
9423 binary-expression <token> binary-expression
9425 CAST_P is true if this expression is the target of a cast.
9427 The binops_by_token map is used to get the tree codes for each <token> type.
9428 binary-expressions are associated according to a precedence table. */
9430 #define TOKEN_PRECEDENCE(token) \
9431 (((token->type == CPP_GREATER \
9432 || ((cxx_dialect != cxx98) && token->type == CPP_RSHIFT)) \
9433 && !parser->greater_than_is_operator_p) \
9434 ? PREC_NOT_OPERATOR \
9435 : binops_by_token[token->type].prec)
9437 static cp_expr
9443 {
9444 cp_parser_expression_stack stack;
9446 cp_parser_expression_stack_entry current;
9447 cp_expr rhs;
9451 tree overload;
9453 /* Parse the first expression. */
9464 {
9465 /* Get an operator token. */
9471 {
9473 "%<>>%> operator is treated"
9477 }
9482 /* This is a fold-expression; handle it later. */
9485 /* Popping an entry off the stack means we completed a subexpression:
9486 - either we found a token which is not an operator (`>' where it is not
9487 an operator, or prec == PREC_NOT_OPERATOR), in which case popping
9488 will happen repeatedly;
9489 - or, we found an operator which has lower priority. This is the case
9490 where the recursive descent *ascends*, as in `3 * 4 + 5' after
9491 parsing `3 * 4'. */
9493 {
9496 else
9498 }
9500 get_rhs:
9504 /* We used the operator token. */
9507 /* For "false && x" or "true || x", x will never be executed;
9508 disable warnings while evaluating it. */
9510 c_inhibit_evaluation_warnings +=
9513 c_inhibit_evaluation_warnings +=
9516 /* Extract another operand. It may be the RHS of this expression
9517 or the LHS of a new, higher priority expression. */
9522 /* Get another operator token. Look up its precedence to avoid
9523 building a useless (immediately popped) stack entry for common
9524 cases such as 3 + 4 + 5 or 3 * 4 + 5. */
9531 {
9532 /* ... and prepare to parse the RHS of the new, higher priority
9533 expression. Since precedence levels on the stack are
9534 monotonically increasing, we do not have to care about
9535 stack overflows. */
9544 pop:
9546 /* If the stack is not empty, we have parsed into LHS the right side
9547 (`4' in the example above) of an expression we had suspended.
9548 We can use the information on the stack to recover the LHS (`3')
9549 from the stack together with the tree code (`MULT_EXPR'), and
9550 the precedence of the higher level subexpression
9551 (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token,
9552 which will be used to actually build the additive expression. */
9557 }
9559 /* Undo the disabling of warnings done above. */
9561 c_inhibit_evaluation_warnings -=
9564 c_inhibit_evaluation_warnings -=
9570 /* Avoid warning for !!x == y. */
9575 /* Avoid warning for !b == y where b is boolean. */
9579 /* Avoid warning for !!b == y where b is boolean. */
9592 /* ??? Currently we pass lhs_type == ERROR_MARK and rhs_type ==
9593 ERROR_MARK for everything that is not a binary expression.
9594 This makes warn_about_parentheses miss some warnings that
9595 involve unary operators. For unary expressions we should
9596 pass the correct tree_code unless the unary expression was
9597 surrounded by parentheses.
9598 */
9602 {
9605 else
9606 {
9607 current.lhs
9610 == tcc_comparison
9614 }
9615 }
9616 else
9617 {
9623 /* TODO: build_x_binary_op doesn't always honor the location. */
9625 }
9628 /* If the binary operator required the use of an overloaded operator,
9629 then this expression cannot be an integral constant-expression.
9630 An overloaded operator can be used even if both operands are
9631 otherwise permissible in an integral constant-expression if at
9632 least one of the operands is of enumeration type. */
9636 NIC_OVERLOADED))
9638 }
9641 }
9643 static cp_expr
9648 {
9651 }
9653 /* Parse the `? expression : assignment-expression' part of a
9654 conditional-expression. The LOGICAL_OR_EXPR is the
9655 logical-or-expression that started the conditional-expression.
9656 Returns a representation of the entire conditional-expression.
9658 This routine is used by cp_parser_assignment_expression.
9660 ? expression : assignment-expression
9662 GNU Extensions:
9664 ? : assignment-expression */
9666 static tree
9668 {
9670 cp_expr assignment_expr;
9674 /* Consume the `?' token. */
9679 {
9682 /* Implicit true clause. */
9684 c_inhibit_evaluation_warnings +=
9687 }
9688 else
9689 {
9692 /* Parse the expression. */
9693 c_inhibit_evaluation_warnings +=
9696 c_inhibit_evaluation_warnings +=
9700 }
9702 /* The next token should be a `:'. */
9704 /* Parse the assignment-expression. */
9706 c_inhibit_evaluation_warnings -=
9709 /* Make a location:
9710 LOGICAL_OR_EXPR ? EXPR : ASSIGNMENT_EXPR
9711 ~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
9712 with the caret at the "?", ranging from the start of
9713 the logical_or_expr to the end of the assignment_expr. */
9718 /* Build the conditional-expression. */
9720 expr,
9721 assignment_expr,
9722 tf_warning_or_error);
9723 }
9725 /* Parse an assignment-expression.
9727 assignment-expression:
9728 conditional-expression
9729 logical-or-expression assignment-operator assignment_expression
9730 throw-expression
9732 CAST_P is true if this expression is the target of a cast.
9733 DECLTYPE_P is true if this expression is the operand of decltype.
9735 Returns a representation for the expression. */
9737 static cp_expr
9740 {
9741 cp_expr expr;
9743 /* If the next token is the `throw' keyword, then we're looking at
9744 a throw-expression. */
9747 /* Otherwise, it must be that we are looking at a
9748 logical-or-expression. */
9749 else
9750 {
9751 /* Parse the binary expressions (logical-or-expression). */
9753 decltype_p,
9755 /* If the next token is a `?' then we're actually looking at a
9756 conditional-expression. */
9759 else
9760 {
9763 /* If it's an assignment-operator, we're using the second
9764 production. */
9765 enum tree_code assignment_operator
9768 {
9771 /* Parse the right-hand side of the assignment. */
9778 /* An assignment may not appear in a
9779 constant-expression. */
9781 NIC_ASSIGNMENT))
9783 /* Build the assignment expression. Its default
9784 location:
9785 LHS = RHS
9786 ~~~~^~~~~
9787 is the location of the '=' token as the
9788 caret, ranging from the start of the lhs to the
9789 end of the rhs. */
9794 assignment_operator,
9795 rhs,
9797 /* TODO: build_x_modify_expr doesn't honor the location,
9798 so we must set it here. */
9800 }
9801 }
9802 }
9805 }
9807 /* Parse an (optional) assignment-operator.
9809 assignment-operator: one of
9810 = *= /= %= += -= >>= <<= &= ^= |=
9812 GNU Extension:
9814 assignment-operator: one of
9815 <?= >?=
9817 If the next token is an assignment operator, the corresponding tree
9818 code is returned, and the token is consumed. For example, for
9819 `+=', PLUS_EXPR is returned. For `=' itself, the code returned is
9820 NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%',
9821 TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment
9822 operator, ERROR_MARK is returned. */
9824 static enum tree_code
9826 {
9830 /* Peek at the next token. */
9834 {
9880 /* Nothing else is an assignment operator. */
9882 }
9884 /* An operator followed by ... is a fold-expression, handled elsewhere. */
9889 /* If it was an assignment operator, consume it. */
9894 }
9896 /* Parse an expression.
9898 expression:
9899 assignment-expression
9900 expression , assignment-expression
9902 CAST_P is true if this expression is the target of a cast.
9903 DECLTYPE_P is true if this expression is the immediate operand of decltype,
9904 except possibly parenthesized or on the RHS of a comma (N3276).
9906 Returns a representation of the expression. */
9908 static cp_expr
9911 {
9916 {
9917 cp_expr assignment_expression;
9919 /* Parse the next assignment-expression. */
9920 assignment_expression
9923 /* We don't create a temporary for a call that is the immediate operand
9924 of decltype or on the RHS of a comma. But when we see a comma, we
9925 need to create a temporary for a call on the LHS. */
9930 assignment_expression
9934 /* If this is the first assignment-expression, we can just
9935 save it away. */
9938 else
9939 {
9940 /* Create a location with caret at the comma, ranging
9941 from the start of the LHS to the end of the RHS. */
9946 assignment_expression,
9949 }
9950 /* If the next token is not a comma, or we're in a fold-expression, then
9951 we are done with the expression. */
9955 /* Consume the `,'. */
9958 /* A comma operator cannot appear in a constant-expression. */
9961 }
9964 }
9966 /* Parse a constant-expression.
9968 constant-expression:
9969 conditional-expression
9971 If ALLOW_NON_CONSTANT_P a non-constant expression is silently
9972 accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not
9973 constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P
9974 is false, NON_CONSTANT_P should be NULL. If STRICT_P is true,
9975 only parse a conditional-expression, otherwise parse an
9976 assignment-expression. See below for rationale. */
9978 static cp_expr
9983 {
9987 cp_expr expression;
9989 /* It might seem that we could simply parse the
9990 conditional-expression, and then check to see if it were
9991 TREE_CONSTANT. However, an expression that is TREE_CONSTANT is
9992 one that the compiler can figure out is constant, possibly after
9993 doing some simplifications or optimizations. The standard has a
9994 precise definition of constant-expression, and we must honor
9995 that, even though it is somewhat more restrictive.
9997 For example:
9999 int i[(2, 3)];
10001 is not a legal declaration, because `(2, 3)' is not a
10002 constant-expression. The `,' operator is forbidden in a
10003 constant-expression. However, GCC's constant-folding machinery
10004 will fold this operation to an INTEGER_CST for `3'. */
10006 /* Save the old settings. */
10008 saved_allow_non_integral_constant_expression_p
10011 /* We are now parsing a constant-expression. */
10013 parser->allow_non_integral_constant_expression_p
10016 /* Although the grammar says "conditional-expression", when not STRICT_P,
10017 we parse an "assignment-expression", which also permits
10018 "throw-expression" and the use of assignment operators. In the case
10019 that ALLOW_NON_CONSTANT_P is false, we get better errors than we would
10020 otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is
10021 actually essential that we look for an assignment-expression.
10022 For example, cp_parser_initializer_clauses uses this function to
10023 determine whether a particular assignment-expression is in fact
10024 constant. */
10026 {
10027 /* Parse the binary expressions (logical-or-expression). */
10030 /* If the next token is a `?' then we're actually looking at
10031 a conditional-expression; otherwise we're done. */
10034 }
10035 else
10037 /* Restore the old settings. */
10038 parser->integral_constant_expression_p
10040 parser->allow_non_integral_constant_expression_p
10043 {
10044 /* Require an rvalue constant expression here; that's what our
10045 callers expect. Reference constant expressions are handled
10046 separately in e.g. cp_parser_template_argument. */
10055 }
10058 parser->non_integral_constant_expression_p
10062 }
10064 /* Parse __builtin_offsetof.
10066 offsetof-expression:
10067 "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")"
10069 offsetof-member-designator:
10070 id-expression
10071 | offsetof-member-designator "." id-expression
10072 | offsetof-member-designator "[" expression "]"
10073 | offsetof-member-designator "->" id-expression */
10075 static cp_expr
10077 {
10079 tree type;
10080 cp_expr expr;
10081 cp_id_kind dummy;
10083 location_t finish_loc;
10085 /* We're about to accept non-integral-constant things, but will
10086 definitely yield an integral constant expression. Save and
10087 restore these values around our local parsing. */
10093 /* Consume the "__builtin_offsetof" token. */
10095 /* Consume the opening `('. */
10096 matching_parens parens;
10098 /* Parse the type-id. */
10100 {
10102 parser->type_definition_forbidden_message
10106 }
10107 /* Look for the `,'. */
10111 /* Build the (type *)null that begins the traditional offsetof macro. */
10112 tree object_ptr
10114 tf_warning_or_error);
10116 /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */
10120 {
10123 {
10125 /* offsetof-member-designator "[" expression "]" */
10131 /* offsetof-member-designator "->" identifier */
10134 /* FALLTHRU */
10137 /* offsetof-member-designator "." identifier */
10145 /* Consume the ")" token. */
10151 /* Error. We know the following require will fail, but
10152 that gives the proper error message. */
10157 }
10158 }
10160 success:
10161 /* Make a location of the form:
10162 __builtin_offsetof (struct s, f)
10163 ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~
10164 with caret at the type-id, ranging from the start of the
10165 "_builtin_offsetof" token to the close paren. */
10167 /* The result will be an INTEGER_CST, so we need to explicitly
10168 preserve the location. */
10171 failure:
10177 }
10179 /* Parse a trait expression.
10181 Returns a representation of the expression, the underlying type
10182 of the type at issue when KEYWORD is RID_UNDERLYING_TYPE. */
10184 static cp_expr
10186 {
10187 cp_trait_kind kind;
10193 {
10295 }
10297 /* Get location of initial token. */
10300 /* Consume the token. */
10303 matching_parens parens;
10306 {
10309 }
10315 {
10318 {
10321 }
10325 }
10327 {
10329 {
10333 {
10336 }
10340 }
10341 }
10346 /* Construct a location of the form:
10347 __is_trivially_copyable(_Tp)
10348 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
10349 with start == caret, finishing at the close-paren. */
10352 /* Complete the trait expression, which may mean either processing
10353 the trait expr now or saving it for template instantiation. */
10355 {
10364 }
10365 }
10367 /* Parse a lambda expression.
10369 lambda-expression:
10370 lambda-introducer lambda-declarator [opt] compound-statement
10372 Returns a representation of the expression. */
10374 static cp_expr
10376 {
10378 tree type;
10388 {
10390 {
10392 "lambda-expression in unevaluated context"
10395 }
10397 }
10399 {
10401 {
10405 }
10407 }
10409 /* We may be in the middle of deferred access check. Disable
10410 it now. */
10423 /* Do this again now that LAMBDA_EXPR_EXTRA_SCOPE is set. */
10426 /* Now that we've started the type, add the capture fields for any
10427 explicit captures. */
10430 {
10431 /* Inside the class, surrounding template-parameter-lists do not apply. */
10432 unsigned int saved_num_template_parameter_lists
10436 bool fully_implicit_function_template_p
10440 bool auto_is_implicit_function_template_parm_p
10451 /* By virtue of defining a local class, a lambda expression has access to
10452 the private variables of enclosing classes. */
10463 {
10465 }
10467 {
10470 }
10472 /* The capture list was built up in reverse order; fix that now. */
10484 parser->fully_implicit_function_template_p
10488 parser->auto_is_implicit_function_template_parm_p
10490 }
10492 /* This field is only used during parsing of the lambda. */
10495 /* This lambda shouldn't have any proxies left at this point. */
10497 /* And now that we're done, push proxies for an enclosing lambda. */
10500 /* Update the lambda expression to a range. */
10508 else
10516 }
10518 /* Parse the beginning of a lambda expression.
10520 lambda-introducer:
10521 [ lambda-capture [opt] ]
10523 LAMBDA_EXPR is the current representation of the lambda expression. */
10525 static void
10527 {
10528 /* Need commas after the first capture. */
10531 /* Eat the leading `['. */
10534 /* Record default capture mode. "[&" "[=" "[&," "[=," */
10542 {
10548 }
10551 {
10553 tree capture_id;
10554 tree capture_init_expr;
10558 enum capture_kind_type
10559 {
10560 BY_COPY,
10561 BY_REFERENCE
10562 };
10566 {
10569 }
10573 else
10576 /* Possibly capture `this'. */
10578 {
10589 explicit_init_p);
10591 }
10593 /* Possibly capture `*this'. */
10596 {
10607 explicit_init_p);
10609 }
10613 {
10620 }
10622 /* Remember whether we want to capture as a reference or not. */
10624 {
10627 }
10629 /* Get the identifier. */
10634 /* Would be nice to have a cp_parser_skip_to_closing_x for general
10635 delimiters, but I modified this to stop on unnested ']' as well. It
10636 was already changed to stop on unnested '}', so the
10637 "closing_parenthesis" name is no more misleading with my change. */
10638 {
10644 }
10646 /* Find the initializer for this capture. */
10650 {
10652 /* An explicit initializer exists. */
10655 "lambda capture initializers "
10661 {
10664 }
10667 }
10668 else
10669 {
10672 /* Turn the identifier into an id-expression. */
10673 capture_init_expr
10678 {
10681 }
10684 {
10687 capture_init_expr);
10692 }
10695 {
10698 capture_init_expr))
10702 }
10704 capture_init_expr
10705 = finish_id_expression
10707 capture_init_expr,
10721 {
10724 }
10725 }
10729 {
10734 capture_id);
10738 "capture of %qD redundant with by-reference capture "
10740 }
10743 capture_id,
10744 capture_init_expr,
10746 explicit_init_p);
10748 /* If there is any qualification still in effect, clear it
10749 now; we will be starting fresh with the next capture. */
10753 }
10756 }
10758 /* Parse the (optional) middle of a lambda expression.
10760 lambda-declarator:
10761 < template-parameter-list [opt] >
10762 ( parameter-declaration-clause [opt] )
10763 attribute-specifier [opt]
10764 decl-specifier-seq [opt]
10765 exception-specification [opt]
10766 lambda-return-type-clause [opt]
10768 LAMBDA_EXPR is the current representation of the lambda expression. */
10770 static bool
10772 {
10773 /* 5.1.1.4 of the standard says:
10774 If a lambda-expression does not include a lambda-declarator, it is as if
10775 the lambda-declarator were ().
10776 This means an empty parameter list, no attributes, and no exception
10777 specification. */
10784 cp_decl_specifier_seq lambda_specs;
10787 /* The template-parameter-list is optional, but must begin with
10788 an opening angle if present. */
10790 {
10793 "lambda templates are only available with "
10797 "lambda templates are only available with "
10806 /* We just processed one more parameter list. */
10808 }
10810 /* The parameter-declaration-clause is optional (unless
10811 template-parameter-list was given), but must begin with an
10812 opening parenthesis if present. */
10814 {
10815 matching_parens parens;
10820 /* Parse parameters. */
10821 param_list
10822 = cp_parser_parameter_declaration_clause
10825 /* Default arguments shall not be specified in the
10826 parameter-declaration-clause of a lambda-declarator. */
10835 /* In the decl-specifier-seq of the lambda-declarator, each
10836 decl-specifier shall either be mutable or constexpr. */
10840 CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR,
10843 {
10848 }
10852 /* Parse optional exception specification. */
10857 /* Parse optional trailing return type. */
10859 {
10862 }
10864 /* The function parameters must be in scope all the way until after the
10865 trailing-return-type in case of decltype. */
10867 }
10871 /* Create the function call operator.
10873 Messing with declarators like this is no uglier than building up the
10874 FUNCTION_DECL by hand, and this is less likely to get out of sync with
10875 other code. */
10876 {
10877 cp_decl_specifier_seq return_type_specs;
10879 tree fco;
10887 {
10891 else
10894 }
10904 VIRT_SPEC_UNSPECIFIED,
10905 REF_QUAL_NONE,
10906 tx_qual,
10907 exception_spec,
10908 return_type,
10913 declarator,
10914 NULL_TREE);
10916 {
10919 /* Give the object parameter a different name. */
10922 }
10924 {
10928 }
10937 }
10938 }
10940 /* Parse the body of a lambda expression, which is simply
10942 compound-statement
10944 but which requires special handling.
10945 LAMBDA_EXPR is the current representation of the lambda expression. */
10947 static void
10949 {
10951 unsigned char local_variables_forbidden_p
10955 /* The body of a lambda-expression is not a subexpression of the enclosing
10956 expression. */
10957 cp_evaluated ev;
10961 else
10962 /* Still increment function_depth so that we don't GC in the
10963 middle of an expression. */
10968 /* Clear this in case we're in the middle of a default argument. */
10972 {
10976 matching_braces braces;
10979 {
10982 /* Originally C++11 required us to peek for 'return expr'; and
10983 process it specially here to deduce the return type. N3638
10984 removed the need for that. */
10992 }
10995 }
11002 else
11004 }
11006 /* Statements [gram.stmt.stmt] */
11008 /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */
11010 static void
11012 {
11016 /* A concept is never expanded normally. */
11022 }
11024 /* Parse a statement.
11026 statement:
11027 labeled-statement
11028 expression-statement
11029 compound-statement
11030 selection-statement
11031 iteration-statement
11032 jump-statement
11033 declaration-statement
11034 try-block
11036 C++11:
11038 statement:
11039 labeled-statement
11040 attribute-specifier-seq (opt) expression-statement
11041 attribute-specifier-seq (opt) compound-statement
11042 attribute-specifier-seq (opt) selection-statement
11043 attribute-specifier-seq (opt) iteration-statement
11044 attribute-specifier-seq (opt) jump-statement
11045 declaration-statement
11046 attribute-specifier-seq (opt) try-block
11048 init-statement:
11049 expression-statement
11050 simple-declaration
11052 TM Extension:
11054 statement:
11055 atomic-statement
11057 IN_COMPOUND is true when the statement is nested inside a
11058 cp_parser_compound_statement; this matters for certain pragmas.
11060 If IF_P is not NULL, *IF_P is set to indicate whether the statement
11061 is a (possibly labeled) if statement which is not enclosed in braces
11062 and has an else clause. This is used to implement -Wparentheses.
11064 CHAIN is a vector of if-else-if conditions. */
11066 static void
11070 {
11075 restart:
11078 /* There is no statement yet. */
11084 /* In obj-c++, seeing '[[' might be the either the beginning of
11085 c++11 attributes, or a nested objc-message-expression. So
11086 let's parse the c++11 attributes tentatively. */
11090 {
11091 location_t end_loc
11094 }
11096 {
11099 }
11101 /* Peek at the next token. */
11103 /* Remember the location of the first token in the statement. */
11107 /* If this is a keyword, then that will often determine what kind of
11108 statement we have. */
11110 {
11114 {
11117 /* Looks like a labeled-statement with a case label.
11118 Parse the label, and then use tail recursion to parse
11119 the statement. */
11145 /* Objective-C++ exception-handling constructs. */
11161 /* This must be a namespace alias definition. */
11163 {
11164 /* Attributes should be parsed as part of the the
11165 declaration, so let's un-parse them. */
11168 }
11186 /* It might be a keyword like `int' that can start a
11187 declaration-statement. */
11189 }
11190 }
11192 {
11193 /* If the next token is a `:', then we are looking at a
11194 labeled-statement. */
11197 {
11198 /* Looks like a labeled-statement with an ordinary label.
11199 Parse the label, and then use tail recursion to parse
11200 the statement. */
11205 }
11206 }
11207 /* Anything that starts with a `{' must be a compound-statement. */
11210 /* CPP_PRAGMA is a #pragma inside a function body, which constitutes
11211 a statement all its own. */
11213 {
11214 /* Only certain OpenMP pragmas are attached to statements, and thus
11215 are considered statements themselves. All others are not. In
11216 the context of a compound, accept the pragma as a "statement" and
11217 return so that we can check for a close brace. Otherwise we
11218 require a real statement and must go back and read one. */
11224 }
11226 {
11229 }
11231 /* Everything else must be a declaration-statement or an
11232 expression-statement. Try for the declaration-statement
11233 first, unless we are looking at a `;', in which case we know that
11234 we have an expression-statement. */
11236 {
11238 {
11240 /* Attributes should be parsed as part of the declaration,
11241 so let's un-parse them. */
11245 /* Try to parse the declaration-statement. */
11247 /* If that worked, we're done. */
11250 /* It didn't work, restore the post-attribute position. */
11253 }
11254 /* All preceding labels have been parsed at this point. */
11260 /* Look for an expression-statement instead. */
11263 /* Handle [[fallthrough]];. */
11265 {
11266 /* The next token after the fallthrough attribute is ';'. */
11268 {
11269 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
11271 IFN_FALLTHROUGH,
11274 }
11275 else
11279 }
11280 }
11282 /* Set the line number for the statement. */
11286 /* Allow "[[fallthrough]];", but warn otherwise. */
11289 OPT_Wattributes,
11291 }
11293 /* Append ATTR to attribute list ATTRS. */
11295 static tree
11297 {
11303 }
11305 /* Parse the label for a labeled-statement, i.e.
11307 identifier :
11308 case constant-expression :
11309 default :
11311 GNU Extension:
11312 case constant-expression ... constant-expression : statement
11314 When a label is parsed without errors, the label is added to the
11315 parse tree by the finish_* functions, so this function doesn't
11316 have to return the label. */
11318 static void
11320 {
11325 /* The next token should be an identifier. */
11329 {
11332 }
11334 /* Remember whether this case or a user-defined label is allowed to fall
11335 through to. */
11340 {
11342 {
11346 /* Consume the `case' token. */
11348 /* Parse the constant-expression. */
11355 {
11356 /* Consume the `...' token. */
11362 /* We don't need to emit warnings here, as the common code
11363 will do this for us. */
11364 }
11365 else
11369 {
11372 {
11375 }
11376 }
11377 else
11380 expr);
11381 }
11385 /* Consume the `default' token. */
11389 {
11392 {
11395 }
11396 }
11397 else
11402 /* Anything else must be an ordinary label. */
11407 }
11409 /* Require the `:' token. */
11412 /* An ordinary label may optionally be followed by attributes.
11413 However, this is only permitted if the attributes are then
11414 followed by a semicolon. This is because, for backward
11415 compatibility, when parsing
11416 lab: __attribute__ ((unused)) int i;
11417 we want the attribute to attach to "i", not "lab". */
11420 {
11421 tree attrs;
11425 /* And fallthrough always binds to the expression-statement. */
11430 ;
11431 else
11433 }
11439 }
11441 /* Parse an expression-statement.
11443 expression-statement:
11444 expression [opt] ;
11446 Returns the new EXPR_STMT -- or NULL_TREE if the expression
11447 statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P
11448 indicates whether this expression-statement is part of an
11449 expression statement. */
11451 static tree
11453 {
11458 /* There might be attribute fallthrough. */
11461 /* If the next token is a ';', then there is no expression
11462 statement. */
11464 {
11468 {
11471 }
11472 }
11474 /* Handle [[fallthrough]];. */
11476 {
11477 /* The next token after the fallthrough attribute is ';'. */
11479 /* Turn [[fallthrough]]; into FALLTHROUGH ();. */
11482 else
11486 }
11488 /* Allow "[[fallthrough]];", but warn otherwise. */
11493 /* Give a helpful message for "A<T>::type t;" and the like. */
11496 {
11503 {
11504 /* A::A a; */
11509 }
11510 }
11512 /* Consume the final `;'. */
11517 /* This is the final expression statement of a statement
11518 expression. */
11524 }
11526 /* Parse a compound-statement.
11528 compound-statement:
11529 { statement-seq [opt] }
11531 GNU extension:
11533 compound-statement:
11534 { label-declaration-seq [opt] statement-seq [opt] }
11536 label-declaration-seq:
11537 label-declaration
11538 label-declaration-seq label-declaration
11540 Returns a tree representing the statement. */
11542 static tree
11545 {
11546 tree compound_stmt;
11547 matching_braces braces;
11549 /* Consume the `{'. */
11556 /* Begin the compound-statement. */
11558 /* If the next keyword is `__label__' we have a label declaration. */
11561 /* Parse an (optional) statement-seq. */
11563 /* Finish the compound-statement. */
11565 /* Consume the `}'. */
11569 }
11571 /* Parse an (optional) statement-seq.
11573 statement-seq:
11574 statement
11575 statement-seq [opt] statement */
11577 static void
11579 {
11580 /* Scan statements until there aren't any more. */
11582 {
11585 /* If we are looking at a `}', then we have run out of
11586 statements; the same is true if we have reached the end
11587 of file, or have stumbled upon a stray '@end'. */
11594 /* If we are in a compound statement and find 'else' then
11595 something went wrong. */
11597 {
11600 else
11601 {
11604 }
11605 }
11607 /* Parse the statement. */
11609 }
11610 }
11612 /* Return true if this is the C++20 version of range-based-for with
11613 init-statement. */
11615 static bool
11617 {
11620 /* Save tokens so that we can put them back. */
11623 /* There has to be an unnested ; followed by an unnested :. */
11626 CPP_SEMICOLON,
11630 /* We found the semicolon, eat it now. */
11633 /* Now look for ':' that is not nested in () or {}. */
11636 CPP_COLON,
11639 out:
11640 /* Roll back the tokens we skipped. */
11644 }
11646 /* Return true if we're looking at (init; cond), false otherwise. */
11648 static bool
11650 {
11651 /* Save tokens so that we can put them back. */
11654 /* Look for ';' that is not nested in () or {}. */
11657 CPP_SEMICOLON,
11660 /* Roll back the tokens we skipped. */
11664 }
11666 /* Parse a selection-statement.
11668 selection-statement:
11669 if ( init-statement [opt] condition ) statement
11670 if ( init-statement [opt] condition ) statement else statement
11671 switch ( init-statement [opt] condition ) statement
11673 Returns the new IF_STMT or SWITCH_STMT.
11675 If IF_P is not NULL, *IF_P is set to indicate whether the statement
11676 is a (possibly labeled) if statement which is not enclosed in
11677 braces and has an else clause. This is used to implement
11678 -Wparentheses.
11680 CHAIN is a vector of if-else-if conditions. This is used to implement
11681 -Wduplicated-cond. */
11683 static tree
11686 {
11689 token_indent_info guard_tinfo;
11694 /* Peek at the next token. */
11698 /* See what kind of keyword it is. */
11701 {
11704 {
11705 tree statement;
11706 tree condition;
11711 RID_CONSTEXPR))
11712 {
11718 }
11720 /* Look for the `('. */
11721 matching_parens parens;
11723 {
11726 }
11728 /* Begin the selection-statement. */
11730 {
11733 }
11734 else
11737 /* Parse the optional init-statement. */
11739 {
11740 tree decl;
11743 "init-statement in selection statements only available "
11746 }
11748 /* Parse the condition. */
11750 /* Look for the `)'. */
11756 {
11760 /* Add the condition. */
11767 /* Parse the then-clause. */
11771 /* Outside a template, the non-selected branch of a constexpr
11772 if is a 'discarded statement', i.e. unevaluated. */
11777 {
11780 }
11783 guard_tinfo);
11790 {
11794 }
11796 /* If the next token is `else', parse the else-clause. */
11798 RID_ELSE))
11799 {
11803 {
11806 }
11808 guard_tinfo
11810 /* Consume the `else' keyword. */
11813 {
11815 RID_IF)
11817 {
11818 /* We've got "if (COND) else if (COND2)". Start
11819 the condition chain and add COND as the first
11820 element. */
11824 {
11825 /* Wrap it in a NOP_EXPR so that we can set the
11826 location of the condition. */
11828 condition);
11831 }
11832 }
11834 RID_IF))
11835 {
11836 /* This is if-else without subsequent if. Zap the
11837 condition chain; we would have already warned at
11838 this point. */
11841 }
11842 }
11844 /* Parse the else-clause. */
11850 /* If we are currently parsing a then-clause, then
11851 IF_P will not be NULL. We set it to true to
11852 indicate that this if statement has an else clause.
11853 This may trigger the Wparentheses warning below
11854 when we get back up to the parent if statement. */
11859 {
11863 }
11864 }
11865 else
11866 {
11867 /* This if statement does not have an else clause. If
11868 NESTED_IF is true, then the then-clause has an if
11869 statement which does have an else clause. We warn
11870 about the potential ambiguity. */
11873 "suggest explicit braces to avoid ambiguous"
11876 {
11877 /* We don't need the condition chain anymore. */
11880 }
11881 }
11883 /* Now we're all done with the if-statement. */
11885 }
11886 else
11887 {
11891 /* Add the condition. */
11894 /* Parse the body of the switch-statement. */
11900 guard_tinfo);
11904 /* Now we're all done with the switch-statement. */
11906 }
11909 }
11915 }
11916 }
11918 /* Helper function for cp_parser_condition and cp_parser_simple_declaration.
11919 If we have seen at least one decl-specifier, and the next token
11920 is not a parenthesis, then we must be looking at a declaration.
11921 (After "int (" we might be looking at a functional cast.) */
11923 static void
11926 {
11932 }
11934 /* Helper function for cp_parser_condition. Enforces [stmt.stmt]/2:
11935 The declarator shall not specify a function or an array. Returns
11936 TRUE if the declarator is valid, FALSE otherwise. */
11938 static bool
11941 location_t loc)
11942 {
11946 {
11951 else
11959 }
11960 else
11962 }
11964 /* Parse a condition.
11966 condition:
11967 expression
11968 type-specifier-seq declarator = initializer-clause
11969 type-specifier-seq declarator braced-init-list
11971 GNU Extension:
11973 condition:
11974 type-specifier-seq declarator asm-specification [opt]
11975 attributes [opt] = assignment-expression
11977 Returns the expression that should be tested. */
11979 static tree
11981 {
11982 cp_decl_specifier_seq type_specifiers;
11986 /* Try the declaration first. */
11988 /* New types are not allowed in the type-specifier-seq for a
11989 condition. */
11991 parser->type_definition_forbidden_message
11993 /* Parse the type-specifier-seq. */
11995 CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR,
11998 /* Restore the saved message. */
12004 /* If all is well, we might be looking at a declaration. */
12006 {
12007 tree decl;
12008 tree asm_specification;
12009 tree attributes;
12014 /* Parse the declarator. */
12016 CP_PARSER_FLAGS_NONE,
12022 /* Parse the attributes. */
12024 /* Parse the asm-specification. */
12026 /* If the next token is not an `=' or '{', then we might still be
12027 looking at an expression. For example:
12029 if (A(a).x)
12031 looks like a decl-specifier-seq and a declarator -- but then
12032 there is no `=', so this is an expression. */
12037 /* If we did see an `=' or '{', then we are looking at a declaration
12038 for sure. */
12040 {
12041 tree pushed_scope;
12048 /* Create the declaration. */
12054 /* Parse the initializer. */
12056 {
12060 }
12062 {
12063 /* Consume the `='. */
12067 }
12068 else
12069 {
12072 }
12076 /* Process the initializer. */
12079 asm_specification,
12080 flags);
12086 }
12087 }
12088 /* If we didn't even get past the declarator successfully, we are
12089 definitely not looking at a declaration. */
12090 else
12093 /* Otherwise, we are looking at an expression. */
12095 }
12097 /* Parses a for-statement or range-for-statement until the closing ')',
12098 not included. */
12100 static tree
12102 {
12106 /* Begin the for-statement. */
12109 /* Parse the initialization. */
12115 else
12117 }
12119 static tree
12122 {
12123 /* Normal for loop */
12126 tree stmt;
12129 /* The init-statement has already been parsed in
12130 cp_parser_init_statement, so no work is needed here. */
12133 /* If there's a condition, process it. */
12137 {
12141 }
12143 {
12147 }
12149 /* Look for the `;'. */
12152 /* If there's an expression, process it. */
12158 }
12160 /* Tries to parse a range-based for-statement:
12162 range-based-for:
12163 decl-specifier-seq declarator : expression
12165 The decl-specifier-seq declarator and the `:' are already parsed by
12166 cp_parser_init_statement. If processing_template_decl it returns a
12167 newly created RANGE_FOR_STMT; if not, it is converted to a
12168 regular FOR_STMT. */
12170 static tree
12173 {
12180 /* Get the range declaration momentarily out of the way so that
12181 the range expression doesn't clash with it. */
12183 {
12185 {
12187 /* For decomposition declaration get all of the corresponding
12188 declarations out of the way. */
12192 {
12198 {
12204 }
12205 }
12206 }
12208 {
12213 }
12214 }
12217 {
12220 }
12221 else
12224 /* Put the range declaration(s) back into scope. */
12226 {
12230 }
12232 /* finish_omp_for has its own code for the following, so just
12233 return the range_expr instead. */
12237 /* If in template, STMT is converted to a normal for-statement
12238 at instantiation. If not, it is done just ahead. */
12240 {
12250 /* do_auto_deduction doesn't mess with template init-lists. */
12253 }
12254 else
12255 {
12259 unroll);
12260 }
12262 }
12264 /* Subroutine of cp_convert_range_for: given the initializer expression,
12265 builds up the range temporary. */
12267 static tree
12269 {
12272 /* Find out the type deduced by the declaration
12273 `auto &&__range = range_expr'. */
12278 /* Create the __range variable. */
12280 range_type);
12285 }
12287 /* Used by cp_parser_range_for in template context: we aren't going to
12288 do a full conversion yet, but we still need to resolve auto in the
12289 type of the for-range-declaration if present. This is basically
12290 a shortcut version of cp_convert_range_for. */
12292 static void
12294 {
12297 {
12300 iter_type = (cp_parser_perform_range_for_lookup
12303 {
12305 iter_type);
12307 RO_UNARY_STAR,
12308 tf_warning_or_error);
12311 }
12312 }
12313 }
12315 /* Converts a range-based for-statement into a normal
12316 for-statement, as per the definition.
12318 for (RANGE_DECL : RANGE_EXPR)
12319 BLOCK
12321 should be equivalent to:
12323 {
12324 auto &&__range = RANGE_EXPR;
12325 for (auto __begin = BEGIN_EXPR, end = END_EXPR;
12326 __begin != __end;
12327 ++__begin)
12328 {
12329 RANGE_DECL = *__begin;
12330 BLOCK
12331 }
12332 }
12334 If RANGE_EXPR is an array:
12335 BEGIN_EXPR = __range
12336 END_EXPR = __range + ARRAY_SIZE(__range)
12337 Else if RANGE_EXPR has a member 'begin' or 'end':
12338 BEGIN_EXPR = __range.begin()
12339 END_EXPR = __range.end()
12340 Else:
12341 BEGIN_EXPR = begin(__range)
12342 END_EXPR = end(__range);
12344 If __range has a member 'begin' but not 'end', or vice versa, we must
12345 still use the second alternative (it will surely fail, however).
12346 When calling begin()/end() in the third alternative we must use
12347 argument dependent lookup, but always considering 'std' as an associated
12348 namespace. */
12350 tree
12354 {
12362 /* If an error happened previously do nothing or else a lot of
12363 unhelpful errors would be issued. */
12365 else
12366 {
12367 tree range_temp;
12371 /* Can't bind a reference to an array of runtime bound. */
12373 else
12374 {
12379 LOOKUP_ONLYCONVERTING);
12381 }
12384 }
12386 /* The new for initialization statement. */
12388 iter_type);
12394 LOOKUP_ONLYCONVERTING);
12404 LOOKUP_ONLYCONVERTING);
12408 /* The new for condition. */
12415 /* The new increment expression. */
12418 tf_warning_or_error);
12424 /* The declaration is initialized with *__begin inside the loop body. */
12427 tf_warning_or_error),
12429 LOOKUP_ONLYCONVERTING);
12434 }
12436 /* Solves BEGIN_EXPR and END_EXPR as described in cp_convert_range_for.
12437 We need to solve both at the same time because the method used
12438 depends on the existence of members begin or end.
12439 Returns the type deduced for the iterator expression. */
12441 static tree
12443 {
12445 {
12448 }
12451 {
12456 }
12458 {
12459 /* If RANGE is an array, we will use pointer arithmetic. */
12462 range,
12466 }
12467 else
12468 {
12469 /* If it is not an array, we must do a bit of magic. */
12479 tf_warning_or_error);
12482 tf_warning_or_error);
12485 {
12486 /* Use the member functions. */
12489 }
12490 else
12491 {
12492 /* Use global functions with ADL. */
12499 tf_warning_or_error);
12501 tf_warning_or_error);
12503 tf_warning_or_error);
12505 tf_warning_or_error);
12508 }
12510 /* Last common checks. */
12512 {
12513 /* If one of the expressions is an error do no more checks. */
12516 }
12519 /* Can happen, when, eg, in a template context, Koenig lookup
12520 can't resolve begin/end (c++/58503). */
12522 else
12523 {
12525 /* The unqualified type of the __begin and __end temporaries should
12526 be the same, as required by the multiple auto declaration. */
12528 {
12535 /* P0184R0 allows __begin and __end to have different types,
12536 but make sure they are comparable so we can give a better
12538 else
12542 }
12544 }
12545 }
12546 }
12548 /* Helper function for cp_parser_perform_range_for_lookup.
12549 Builds a tree for RANGE.IDENTIFIER(). */
12551 static tree
12553 {
12566 tf_warning_or_error);
12569 }
12571 /* Parse an iteration-statement.
12573 iteration-statement:
12574 while ( condition ) statement
12575 do statement while ( expression ) ;
12576 for ( init-statement condition [opt] ; expression [opt] )
12577 statement
12579 Returns the new WHILE_STMT, DO_STMT, FOR_STMT or RANGE_FOR_STMT. */
12581 static tree
12584 {
12587 tree statement;
12589 token_indent_info guard_tinfo;
12591 /* Peek at the next token. */
12598 /* Remember whether or not we are already within an iteration
12599 statement. */
12602 /* See what kind of keyword it is. */
12605 {
12607 {
12608 tree condition;
12610 /* Begin the while-statement. */
12612 /* Look for the `('. */
12613 matching_parens parens;
12615 /* Parse the condition. */
12618 /* Look for the `)'. */
12620 /* Parse the dependent statement. */
12626 /* We're done with the while-statement. */
12628 }
12632 {
12633 tree expression;
12635 /* Begin the do-statement. */
12637 /* Parse the body of the do-statement. */
12644 /* Look for the `while' keyword. */
12646 /* Look for the `('. */
12647 matching_parens parens;
12649 /* Parse the expression. */
12651 /* We're done with the do-statement. */
12653 /* Look for the `)'. */
12655 /* Look for the `;'. */
12657 }
12661 {
12662 /* Look for the `('. */
12663 matching_parens parens;
12668 /* Look for the `)'. */
12671 /* Parse the body of the for-statement. */
12678 /* We're done with the for-statement. */
12680 }
12687 }
12690 }
12692 /* Parse a init-statement or the declarator of a range-based-for.
12693 Returns true if a range-based-for declaration is seen.
12695 init-statement:
12696 expression-statement
12697 simple-declaration */
12699 static bool
12701 {
12702 /* If the next token is a `;', then we have an empty
12703 expression-statement. Grammatically, this is also a
12704 simple-declaration, but an invalid one, because it does not
12705 declare anything. Therefore, if we did not handle this case
12706 specially, we would issue an error message about an invalid
12707 declaration. */
12709 {
12713 /* Try to parse the init-statement. */
12715 {
12716 tree dummy;
12718 /* Parse the declaration. */
12724 /* That didn't work, try to parse it as an expression-statement. */
12728 {
12730 "range-based %<for%> loops with initializer only "
12733 }
12734 }
12736 /* A colon is used in range-based for. */
12739 /* We're going to speculatively look for a declaration, falling back
12740 to an expression, if necessary. */
12742 /* Parse the declaration. */
12745 decl);
12748 {
12749 /* It is a range-for, consume the ':'. */
12754 "range-based %<for%> loops only available with "
12756 }
12757 else
12758 /* The ';' is not consumed yet because we told
12759 cp_parser_simple_declaration not to. */
12764 /* If the tentative parse failed, then we shall need to look for an
12765 expression-statement. */
12766 }
12767 /* If we are here, it is an expression-statement. */
12770 }
12772 /* Parse a jump-statement.
12774 jump-statement:
12775 break ;
12776 continue ;
12777 return expression [opt] ;
12778 return braced-init-list ;
12779 goto identifier ;
12781 GNU extension:
12783 jump-statement:
12784 goto * expression ;
12786 Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */
12788 static tree
12790 {
12796 /* Peek at the next token. */
12801 /* See what kind of keyword it is. */
12804 {
12808 {
12825 }
12831 {
12835 /* Fall through. */
12845 }
12850 {
12851 tree expr;
12855 {
12859 }
12862 else
12863 /* If the next token is a `;', then there is no
12864 expression. */
12866 /* Build the return-statement. */
12869 else
12871 /* Look for the final `;'. */
12873 }
12879 {
12882 }
12884 /* Create the goto-statement. */
12886 {
12887 /* Issue a warning about this use of a GNU extension. */
12889 /* Consume the '*' token. */
12891 /* Parse the dependent expression. */
12893 }
12894 else
12896 /* Look for the final `;'. */
12903 }
12906 }
12908 /* Parse a declaration-statement.
12910 declaration-statement:
12911 block-declaration */
12913 static void
12915 {
12918 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
12921 /* Parse the block-declaration. */
12924 /* Free any declarators allocated. */
12926 }
12928 /* Some dependent statements (like `if (cond) statement'), are
12929 implicitly in their own scope. In other words, if the statement is
12930 a single statement (as opposed to a compound-statement), it is
12931 none-the-less treated as if it were enclosed in braces. Any
12932 declarations appearing in the dependent statement are out of scope
12933 after control passes that point. This function parses a statement,
12934 but ensures that is in its own scope, even if it is not a
12935 compound-statement.
12937 If IF_P is not NULL, *IF_P is set to indicate whether the statement
12938 is a (possibly labeled) if statement which is not enclosed in
12939 braces and has an else clause. This is used to implement
12940 -Wparentheses.
12942 CHAIN is a vector of if-else-if conditions. This is used to implement
12943 -Wduplicated-cond.
12945 Returns the new statement. */
12947 static tree
12951 {
12952 tree statement;
12955 token_indent_info body_tinfo
12961 /* Mark if () ; with a special NOP_EXPR. */
12963 {
12974 }
12975 /* if a compound is opened, we simply parse the statement directly. */
12978 /* If the token is not a `{', then we must take special action. */
12979 else
12980 {
12981 /* Create a compound-statement. */
12983 /* Parse the dependent-statement. */
12986 /* Finish the dummy compound-statement. */
12988 }
12990 token_indent_info next_tinfo
12999 /* Return the statement. */
13001 }
13003 /* For some dependent statements (like `while (cond) statement'), we
13004 have already created a scope. Therefore, even if the dependent
13005 statement is a compound-statement, we do not want to create another
13006 scope. */
13008 static void
13011 {
13012 /* If the token is a `{', then we must take special action. */
13014 {
13015 token_indent_info body_tinfo
13021 token_indent_info next_tinfo
13030 }
13031 else
13032 {
13033 /* Avoid calling cp_parser_compound_statement, so that we
13034 don't create a new scope. Do everything else by hand. */
13035 matching_braces braces;
13037 /* If the next keyword is `__label__' we have a label declaration. */
13040 /* Parse an (optional) statement-seq. */
13043 }
13044 }
13046 /* Declarations [gram.dcl.dcl] */
13048 /* Parse an optional declaration-sequence.
13050 declaration-seq:
13051 declaration
13052 declaration-seq declaration */
13054 static void
13056 {
13058 {
13064 else
13066 }
13067 }
13069 /* Parse a declaration.
13071 declaration:
13072 block-declaration
13073 function-definition
13074 template-declaration
13075 explicit-instantiation
13076 explicit-specialization
13077 linkage-specification
13078 namespace-definition
13080 C++17:
13081 deduction-guide
13083 GNU extension:
13085 declaration:
13086 __extension__ declaration */
13088 static void
13090 {
13091 cp_token token1;
13092 cp_token token2;
13097 /* Check for the `__extension__' keyword. */
13099 {
13100 /* Parse the qualified declaration. */
13102 /* Restore the PEDANTIC flag. */
13106 }
13108 /* Try to figure out what kind of declaration is present. */
13113 else
13114 {
13117 }
13119 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
13122 /* If the next token is `extern' and the following token is a string
13123 literal, then we have a linkage specification. */
13127 /* If the next token is `template', then we have either a template
13128 declaration, an explicit instantiation, or an explicit
13129 specialization. */
13131 {
13132 /* `template <>' indicates a template specialization. */
13136 /* `template <' indicates a template declaration. */
13139 /* Anything else must be an explicit instantiation. */
13140 else
13142 }
13143 /* If the next token is `export', then we have a template
13144 declaration. */
13147 /* If the next token is `extern', 'static' or 'inline' and the one
13148 after that is `template', we have a GNU extended explicit
13149 instantiation directive. */
13156 /* If the next token is `namespace', check for a named or unnamed
13157 namespace definition. */
13166 /* An unnamed namespace definition. */
13170 /* An inline (associated) namespace definition. */
13174 /* Objective-C++ declaration/definition. */
13181 /* At this point we may have a template declared by a concept
13182 introduction. */
13187 else
13188 /* Try to parse a block-declaration, or a function-definition. */
13191 /* Free any declarators allocated. */
13193 }
13195 /* Parse a namespace-scope declaration. */
13197 static void
13199 {
13203 /* A top-level declaration can consist solely of a #pragma. A
13204 nested declaration cannot, so this is done here and not in
13205 cp_parser_declaration. (A #pragma at block scope is
13206 handled in cp_parser_statement.) */
13209 {
13210 /* A declaration consisting of a single semicolon is
13211 invalid. Allow it unless we're being pedantic. */
13215 }
13216 else
13217 /* Parse the declaration itself. */
13219 }
13221 /* Parse a block-declaration.
13223 block-declaration:
13224 simple-declaration
13225 asm-definition
13226 namespace-alias-definition
13227 using-declaration
13228 using-directive
13230 GNU Extension:
13232 block-declaration:
13233 __extension__ block-declaration
13235 C++0x Extension:
13237 block-declaration:
13238 static_assert-declaration
13240 If STATEMENT_P is TRUE, then this block-declaration is occurring as
13241 part of a declaration-statement. */
13243 static void
13246 {
13250 /* Check for the `__extension__' keyword. */
13252 {
13253 /* Parse the qualified declaration. */
13255 /* Restore the PEDANTIC flag. */
13259 }
13261 /* Peek at the next token to figure out which kind of declaration is
13262 present. */
13265 /* If the next keyword is `asm', we have an asm-definition. */
13267 {
13271 }
13272 /* If the next keyword is `namespace', we have a
13273 namespace-alias-definition. */
13276 /* If the next keyword is `using', we have a
13277 using-declaration, a using-directive, or an alias-declaration. */
13279 {
13284 /* If the token after `using' is `namespace', then we have a
13285 using-directive. */
13289 /* If the second token after 'using' is '=', then we have an
13290 alias-declaration. */
13296 /* Otherwise, it's a using-declaration. */
13297 else
13300 }
13301 /* If the next keyword is `__label__' we have a misplaced label
13302 declaration. */
13304 {
13308 /* If the next token is now a `;', consume it. */
13311 }
13312 /* If the next token is `static_assert' we have a static assertion. */
13315 /* Anything else must be a simple-declaration. */
13316 else
13319 }
13321 /* Parse a simple-declaration.
13323 simple-declaration:
13324 decl-specifier-seq [opt] init-declarator-list [opt] ;
13325 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
13326 brace-or-equal-initializer ;
13328 init-declarator-list:
13329 init-declarator
13330 init-declarator-list , init-declarator
13332 If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
13333 function-definition as a simple-declaration.
13335 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
13336 parsed declaration if it is an uninitialized single declarator not followed
13337 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
13338 if present, will not be consumed. */
13340 static void
13344 {
13345 cp_decl_specifier_seq decl_specifiers;
13354 /* Defer access checks until we know what is being declared; the
13355 checks for names appearing in the decl-specifier-seq should be
13356 done as if we were in the scope of the thing being declared. */
13359 /* Parse the decl-specifier-seq. We have to keep track of whether
13360 or not the decl-specifier-seq declares a named class or
13361 enumeration type, since that is the only case in which the
13362 init-declarator-list is allowed to be empty.
13364 [dcl.dcl]
13366 In a simple-declaration, the optional init-declarator-list can be
13367 omitted only when declaring a class or enumeration, that is when
13368 the decl-specifier-seq contains either a class-specifier, an
13369 elaborated-type-specifier, or an enum-specifier. */
13371 CP_PARSER_FLAGS_OPTIONAL,
13374 /* We no longer need to defer access checks. */
13377 /* In a block scope, a valid declaration must always have a
13378 decl-specifier-seq. By not trying to parse declarators, we can
13379 resolve the declaration/expression ambiguity more quickly. */
13382 {
13385 }
13387 /* If the next two tokens are both identifiers, the code is
13388 erroneous. The usual cause of this situation is code like:
13390 T t;
13392 where "T" should name a type -- but does not. */
13395 {
13396 /* If parsing tentatively, we should commit; we really are
13397 looking at a declaration. */
13399 /* Give up. */
13401 }
13406 /* Look for C++17 decomposition declaration. */
13414 {
13415 tree decl
13417 maybe_range_for_decl,
13420 /* The next token should be either a `,' or a `;'. */
13422 /* If it's a `;', we are done. */
13426 {
13430 }
13431 /* Anything else is an error. */
13432 else
13433 {
13434 /* If we have already issued an error message we don't need
13435 to issue another one. */
13440 /* Skip tokens until we reach the end of the statement. */
13442 /* If the next token is now a `;', consume it. */
13446 }
13447 }
13448 else
13451 tree last_type;
13453 /* NULL_TREE if both variable and function declaration are allowed,
13454 error_mark_node if function declaration are not allowed and
13455 a FUNCTION_DECL that should be diagnosed if it is followed by
13456 variable declarations. */
13457 tree auto_function_declaration;
13460 auto_specifier_p
13464 /* Keep going until we hit the `;' at the end of the simple
13465 declaration. */
13468 CPP_SEMICOLON))
13469 {
13472 tree decl;
13476 {
13477 /* If we are processing next declarator, comma is expected */
13482 {
13486 }
13487 }
13488 else
13491 /* Parse the init-declarator. */
13493 CP_PARSER_FLAGS_NONE,
13496 function_definition_allowed_p,
13498 declares_class_or_enum,
13500 maybe_range_for_decl,
13503 /* If an error occurred while parsing tentatively, exit quickly.
13504 (That usually happens when in the body of a function; each
13505 statement is treated as a declaration-statement until proven
13506 otherwise.) */
13511 {
13512 /* If the init-declarator-list contains more than one
13513 init-declarator, they shall all form declarations of
13514 variables. */
13516 auto_function_declaration
13520 {
13522 "non-variable %qD in declaration with more than one "
13527 }
13528 }
13532 {
13536 {
13537 /* If the list of declarators contains more than one declarator,
13538 the type of each declared variable is determined as described
13539 above. If the type deduced for the template parameter U is not
13540 the same in each deduction, the program is ill-formed. */
13545 }
13546 else
13548 }
13550 /* Handle function definitions specially. */
13552 {
13553 /* If the next token is a `,', then we are probably
13554 processing something like:
13556 void f() {}, *p;
13558 which is erroneous. */
13560 {
13563 "mixing"
13565 }
13566 /* Otherwise, we're done with the list of declarators. */
13567 else
13568 {
13571 }
13572 }
13575 /* The next token should be either a `,' or a `;'. */
13577 /* If it's a `,', there are more declarators to come. */
13580 /* If it's a `;', we are done. */
13584 {
13589 }
13590 /* Anything else is an error. */
13591 else
13592 {
13593 /* If we have already issued an error message we don't need
13594 to issue another one. */
13599 /* Skip tokens until we reach the end of the statement. */
13601 /* If the next token is now a `;', consume it. */
13605 }
13606 /* After the first time around, a function-definition is not
13607 allowed -- even if it was OK at first. For example:
13609 int i, f() {}
13611 is not valid. */
13613 }
13615 /* Issue an error message if no declarators are present, and the
13616 decl-specifier-seq does not itself declare a class or
13617 enumeration: [dcl.dcl]/3. */
13619 {
13621 {
13625 /* Ensure an error is issued anyway when finish_decltype_type,
13626 called via cp_parser_decl_specifier_seq, returns a class or
13627 an enumeration (c++/51786). */
13630 }
13631 /* Perform any deferred access checks. */
13633 }
13635 /* Consume the `;'. */
13636 finish:
13640 {
13646 }
13648 done:
13650 }
13652 /* Helper of cp_parser_simple_declaration, parse a decomposition declaration.
13653 decl-specifier-seq ref-qualifier [opt] [ identifier-list ]
13654 initializer ; */
13656 static tree
13661 {
13666 /* Parse the identifier-list. */
13670 {
13678 }
13682 {
13688 else
13689 {
13692 }
13693 }
13699 tree pushed_scope;
13706 NULL_TREE);
13713 cp_expr e;
13714 cp_decl_specifier_seq decl_specs;
13719 {
13723 else
13724 {
13727 }
13728 tree elt_pushed_scope;
13734 {
13735 /* Ensure we've diagnosed redeclaration if we aren't creating
13736 a new VAR_DECL. */
13739 }
13740 else
13744 }
13747 {
13750 }
13754 {
13762 || (is_direct_init
13765 {
13769 }
13772 {
13777 }
13778 }
13780 {
13782 /* Ensure DECL_VALUE_EXPR is created for all the decls but
13783 the underlying DECL. */
13785 }
13791 {
13794 }
13797 }
13799 /* Parse a decl-specifier-seq.
13801 decl-specifier-seq:
13802 decl-specifier-seq [opt] decl-specifier
13803 decl-specifier attribute-specifier-seq [opt] (C++11)
13805 decl-specifier:
13806 storage-class-specifier
13807 type-specifier
13808 function-specifier
13809 friend
13810 typedef
13812 GNU Extension:
13814 decl-specifier:
13815 attributes
13817 Concepts Extension:
13819 decl-specifier:
13820 concept
13822 Set *DECL_SPECS to a representation of the decl-specifier-seq.
13824 The parser flags FLAGS is used to control type-specifier parsing.
13826 *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following
13827 flags:
13829 1: one of the decl-specifiers is an elaborated-type-specifier
13830 (i.e., a type declaration)
13831 2: one of the decl-specifiers is an enum-specifier or a
13832 class-specifier (i.e., a type definition)
13834 */
13836 static void
13838 cp_parser_flags flags,
13841 {
13845 cp_decl_spec ds;
13847 /* Clear DECL_SPECS. */
13850 /* Assume no class or enumeration type is declared. */
13853 /* Keep reading specifiers until there are no more to read. */
13855 {
13860 /* Peek at the next token. */
13863 /* Save the first token of the decl spec list for error
13864 reporting. */
13867 /* Handle attributes. */
13869 {
13870 /* Parse the attributes. */
13873 /* In a sequence of declaration specifiers, c++11 attributes
13874 appertain to the type that precede them. In that case
13875 [dcl.spec]/1 says:
13877 The attribute-specifier-seq affects the type only for
13878 the declaration it appears in, not other declarations
13879 involving the same type.
13881 But for now let's force the user to position the
13882 attribute either at the beginning of the declaration or
13883 after the declarator-id, which would clearly mean that it
13884 applies to the declarator. */
13886 {
13888 /* The c++11 attribute is at the beginning of the
13889 declaration. It appertains to the entity being
13891 else
13892 {
13894 {
13895 /* This is an attribute following a
13896 class-specifier. */
13901 }
13902 else
13903 {
13904 decl_specs->std_attributes
13908 }
13910 }
13911 }
13913 decl_specs->attributes
13918 }
13919 /* Assume we will find a decl-specifier keyword. */
13921 /* If the next token is an appropriate keyword, we can simply
13922 add it to the list. */
13924 {
13925 /* decl-specifier:
13926 friend
13927 constexpr */
13930 {
13935 }
13936 else
13937 {
13939 /* Consume the token. */
13941 }
13954 /* function-specifier:
13955 inline
13956 virtual
13957 explicit */
13964 /* decl-specifier:
13965 typedef */
13968 /* Consume the token. */
13970 /* A constructor declarator cannot appear in a typedef. */
13972 /* The "typedef" keyword can only occur in a declaration; we
13973 may as well commit at this point. */
13980 /* storage-class-specifier:
13981 auto
13982 register
13983 static
13984 extern
13985 mutable
13987 GNU Extension:
13988 thread */
13991 {
13992 /* Consume the token. */
13995 /* Complain about `auto' as a storage specifier, if
13996 we're complaining about C++0x compatibility. */
14000 "%<auto%> changes meaning in C++11; "
14003 /* Set the storage class anyway. */
14005 token);
14006 }
14007 else
14008 /* C++0x auto type-specifier. */
14016 /* Consume the token. */
14019 token);
14022 /* Consume the token. */
14028 /* We did not yet find a decl-specifier yet. */
14031 }
14048 /* Constructors are a special case. The `S' in `S()' is not a
14049 decl-specifier; it is the beginning of the declarator. */
14050 constructor_p
14051 = (!found_decl_spec
14052 && constructor_possible_p
14053 && (cp_parser_constructor_declarator_p
14056 /* If we don't have a DECL_SPEC yet, then we must be looking at
14057 a type-specifier. */
14059 {
14062 tree type_spec;
14064 type_spec
14066 decl_specs,
14072 /* If this type-specifier referenced a user-defined type
14073 (a typedef, class-name, etc.), then we can't allow any
14074 more such type-specifiers henceforth.
14076 [dcl.spec]
14078 The longest sequence of decl-specifiers that could
14079 possibly be a type name is taken as the
14080 decl-specifier-seq of a declaration. The sequence shall
14081 be self-consistent as described below.
14083 [dcl.type]
14085 As a general rule, at most one type-specifier is allowed
14086 in the complete decl-specifier-seq of a declaration. The
14087 only exceptions are the following:
14089 -- const or volatile can be combined with any other
14090 type-specifier.
14092 -- signed or unsigned can be combined with char, long,
14093 short, or int.
14095 -- ..
14097 Example:
14099 typedef char* Pc;
14100 void g (const int Pc);
14102 Here, Pc is *not* part of the decl-specifier seq; it's
14103 the declarator. Therefore, once we see a type-specifier
14104 (other than a cv-qualifier), we forbid any additional
14105 user-defined types. We *do* still allow things like `int
14106 int' to be considered a decl-specifier-seq, and issue the
14107 error message later. */
14110 /* A constructor declarator cannot follow a type-specifier. */
14112 {
14120 }
14121 }
14123 /* If we still do not have a DECL_SPEC, then there are no more
14124 decl-specifiers. */
14129 /* After we see one decl-specifier, further decl-specifiers are
14130 always optional. */
14132 }
14134 /* Don't allow a friend specifier with a class definition. */
14139 }
14141 /* Parse an (optional) storage-class-specifier.
14143 storage-class-specifier:
14144 auto
14145 register
14146 static
14147 extern
14148 mutable
14150 GNU Extension:
14152 storage-class-specifier:
14153 thread
14155 Returns an IDENTIFIER_NODE corresponding to the keyword used. */
14157 static tree
14159 {
14161 {
14165 /* Fall through for C++98. */
14173 /* Consume the token. */
14178 }
14179 }
14181 /* Parse an (optional) function-specifier.
14183 function-specifier:
14184 inline
14185 virtual
14186 explicit
14188 C++2A Extension:
14189 explicit(constant-expression)
14191 Returns an IDENTIFIER_NODE corresponding to the keyword used.
14192 Updates DECL_SPECS, if it is non-NULL. */
14194 static tree
14197 {
14200 {
14206 /* 14.5.2.3 [temp.mem]
14208 A member function template shall not be virtual. */
14212 else
14217 {
14219 /* If we see '(', it's C++20 explicit(bool). */
14220 tree expr;
14222 {
14223 matching_parens parens;
14226 /* New types are not allowed in an explicit-specifier. */
14229 parser->type_definition_forbidden_message
14234 "%<explicit(bool)%> only available with -std=c++2a "
14237 /* Parse the constant-expression. */
14240 /* Restore the saved message. */
14243 }
14244 else
14245 /* The explicit-specifier explicit without a constant-expression is
14246 equivalent to the explicit-specifier explicit(true). */
14249 /* [dcl.fct.spec]
14250 "the constant-expression, if supplied, shall be a contextually
14251 converted constant expression of type bool." */
14253 /* We could evaluate it -- mark the decl as appropriate. */
14259 /* The expression was value-dependent. Remember it so that we can
14260 substitute it later. */
14263 }
14267 }
14269 /* Consume the token. */
14271 }
14273 /* Parse a linkage-specification.
14275 linkage-specification:
14276 extern string-literal { declaration-seq [opt] }
14277 extern string-literal declaration */
14279 static void
14281 {
14282 tree linkage;
14284 /* Look for the `extern' keyword. */
14285 cp_token *extern_token
14288 /* Look for the string-literal. */
14292 /* Transform the literal into an identifier. If the literal is a
14293 wide-character string, or contains embedded NULs, then we can't
14294 handle it as the user wants. */
14297 {
14299 /* Assume C++ linkage. */
14301 }
14302 else
14305 /* We're now using the new linkage. */
14308 /* Preserve the location of the the innermost linkage specification,
14309 tracking the locations of nested specifications via a local. */
14310 location_t saved_location
14312 /* Construct a location ranging from the start of the "extern" to
14313 the end of the string-literal, with the caret at the start, e.g.:
14314 extern "C" {
14315 ^~~~~~~~~~
14316 */
14317 parser->innermost_linkage_specification_location
14322 /* If the next token is a `{', then we're using the first
14323 production. */
14325 {
14329 /* Consume the `{' token. */
14330 matching_braces braces;
14332 /* Parse the declarations. */
14334 /* Look for the closing `}'. */
14336 }
14337 /* Otherwise, there's just one declaration. */
14338 else
14339 {
14342 saved_in_unbraced_linkage_specification_p
14346 parser->in_unbraced_linkage_specification_p
14348 }
14350 /* We're done with the linkage-specification. */
14353 /* Restore location of parent linkage specification, if any. */
14355 }
14357 /* Parse a static_assert-declaration.
14359 static_assert-declaration:
14360 static_assert ( constant-expression , string-literal ) ;
14361 static_assert ( constant-expression ) ; (C++17)
14363 If MEMBER_P, this static_assert is a class member. */
14365 static void
14367 {
14368 cp_expr condition;
14369 location_t token_loc;
14370 tree message;
14373 /* Peek at the `static_assert' token so we can keep track of exactly
14374 where the static assertion started. */
14377 /* Look for the `static_assert' keyword. */
14379 RT_STATIC_ASSERT))
14382 /* We know we are in a static assertion; commit to any tentative
14383 parse. */
14387 /* Parse the `(' starting the static assertion condition. */
14388 matching_parens parens;
14391 /* Parse the constant-expression. Allow a non-constant expression
14392 here in order to give better diagnostics in finish_static_assert. */
14393 condition =
14399 {
14402 "static_assert without a message "
14404 /* Eat the ')' */
14409 }
14410 else
14411 {
14412 /* Parse the separating `,'. */
14415 /* Parse the string-literal message. */
14420 /* A `)' completes the static assertion. */
14426 }
14428 /* A semicolon terminates the declaration. */
14431 /* Get the location for the static assertion. Use that of the
14432 condition if available, otherwise, use that of the "static_assert"
14433 token. */
14438 /* Complete the static assertion, which may mean either processing
14439 the static assert now or saving it for template instantiation. */
14441 }
14443 /* Parse the expression in decltype ( expression ). */
14445 static tree
14448 {
14450 tree expr;
14452 /* Since we're going to preserve any side-effects from this parse, set up a
14453 firewall to protect our callers from cp_parser_commit_to_tentative_parse
14454 in the expression. */
14457 /* First, try parsing an id-expression. */
14468 {
14471 cp_id_kind idk;
14475 /* Lookup the name we got back from the id-expression. */
14480 /* A template without args is not a complete id-expression. */
14489 {
14490 /* Complete lookup of the id-expression. */
14491 expr = (finish_id_expression
14504 /* We found an id-expression, but it was something that we
14505 should not have found. This is an error, not something
14506 we can recover from, so note that we found an
14507 id-expression and we'll recover as gracefully as
14508 possible. */
14510 }
14515 /* We have an id-expression. */
14517 }
14520 {
14521 /* Abort the id-expression parse. */
14524 /* Parsing tentatively, again. */
14527 /* Parse a class member access. */
14535 /* We have an id-expression. */
14537 }
14540 /* We have parsed the complete id-expression or member access. */
14542 else
14543 {
14544 /* Abort our attempt to parse an id-expression or member access
14545 expression. */
14548 /* Commit to the tentative_firewall so we get syntax errors. */
14551 /* Parse a full expression. */
14554 }
14557 }
14559 /* Parse a `decltype' type. Returns the type.
14561 simple-type-specifier:
14562 decltype ( expression )
14563 C++14 proposal:
14564 decltype ( auto ) */
14566 static tree
14568 {
14573 {
14574 /* Already parsed. */
14577 }
14579 /* Look for the `decltype' token. */
14583 /* Parse the opening `('. */
14584 matching_parens parens;
14594 /* decltype (auto) */
14596 else
14597 {
14598 /* decltype (expression) */
14600 /* Types cannot be defined in a `decltype' expression. Save away the
14601 old message and set the new one. */
14603 parser->type_definition_forbidden_message
14606 /* The restrictions on constant-expressions do not apply inside
14607 decltype expressions. */
14608 bool saved_integral_constant_expression_p
14610 bool saved_non_integral_constant_expression_p
14614 /* Within a parenthesized expression, a `>' token is always
14615 the greater-than operator. */
14616 bool saved_greater_than_is_operator_p
14620 /* Do not actually evaluate the expression. */
14623 /* Do not warn about problems with the expression. */
14629 /* Go back to evaluating expressions. */
14633 /* The `>' token might be the end of a template-id or
14634 template-parameter-list now. */
14635 parser->greater_than_is_operator_p
14638 /* Restore the old message and the integral constant expression
14639 flags. */
14641 parser->integral_constant_expression_p
14643 parser->non_integral_constant_expression_p
14645 }
14647 /* Parse to the closing `)'. */
14649 {
14654 }
14657 {
14658 /* Build auto. */
14661 }
14662 else
14664 tf_warning_or_error);
14666 /* Replace the decltype with a CPP_DECLTYPE so we don't need to parse
14667 it again. */
14678 }
14680 /* Special member functions [gram.special] */
14682 /* Parse a conversion-function-id.
14684 conversion-function-id:
14685 operator conversion-type-id
14687 Returns an IDENTIFIER_NODE representing the operator. */
14689 static tree
14691 {
14692 tree type;
14693 tree saved_scope;
14694 tree saved_qualifying_scope;
14695 tree saved_object_scope;
14698 /* Look for the `operator' token. */
14701 /* When we parse the conversion-type-id, the current scope will be
14702 reset. However, we need that information in able to look up the
14703 conversion function later, so we save it here. */
14707 /* We must enter the scope of the class so that the names of
14708 entities declared within the class are available in the
14709 conversion-type-id. For example, consider:
14711 struct S {
14712 typedef int I;
14713 operator I();
14714 };
14716 S::operator I() { ... }
14718 In order to see that `I' is a type-name in the definition, we
14719 must be in the scope of `S'. */
14722 /* Parse the conversion-type-id. */
14724 /* Leave the scope of the class, if any. */
14727 /* Restore the saved scope. */
14731 /* If the TYPE is invalid, indicate failure. */
14735 }
14737 /* Parse a conversion-type-id:
14739 conversion-type-id:
14740 type-specifier-seq conversion-declarator [opt]
14742 Returns the TYPE specified. */
14744 static tree
14746 {
14747 tree attributes;
14748 cp_decl_specifier_seq type_specifiers;
14750 tree type_specified;
14753 /* Parse the attributes. */
14757 parser->type_definition_forbidden_message
14760 /* Parse the type-specifiers. */
14768 /* If that didn't work, stop. */
14771 /* Parse the conversion-declarator. */
14779 /* Don't give this error when parsing tentatively. This happens to
14780 work because we always parse this definitively once. */
14783 {
14785 {
14788 }
14792 }
14795 }
14797 /* Parse an (optional) conversion-declarator.
14799 conversion-declarator:
14800 ptr-operator conversion-declarator [opt]
14802 */
14806 {
14809 cp_cv_quals cv_quals;
14811 /* We don't know if there's a ptr-operator next, or not. */
14813 /* Try the ptr-operator. */
14816 /* If it worked, look for more conversion-declarators. */
14818 {
14821 /* Parse another optional declarator. */
14824 declarator = cp_parser_make_indirect_declarator
14828 }
14831 }
14833 /* Parse an (optional) ctor-initializer.
14835 ctor-initializer:
14836 : mem-initializer-list */
14838 static void
14840 {
14841 /* If the next token is not a `:', then there is no
14842 ctor-initializer. */
14844 {
14845 /* Do default initialization of any bases and members. */
14849 }
14851 /* Consume the `:' token. */
14853 /* And the mem-initializer-list. */
14855 }
14857 /* Parse a mem-initializer-list.
14859 mem-initializer-list:
14860 mem-initializer ... [opt]
14861 mem-initializer ... [opt] , mem-initializer-list */
14863 static void
14865 {
14870 /* Let the semantic analysis code know that we are starting the
14871 mem-initializer-list. */
14876 /* Loop through the list. */
14878 {
14879 tree mem_initializer;
14882 /* Parse the mem-initializer. */
14884 /* If the next token is a `...', we're expanding member initializers. */
14890 {
14891 /* Consume the `...'. */
14895 /* The TREE_PURPOSE must be a _TYPE, because base-specifiers
14896 can be expanded but members cannot. */
14899 {
14904 }
14906 /* Construct the pack expansion type. */
14909 }
14912 {
14916 }
14917 /* Look for a target constructor. */
14921 {
14924 {
14928 }
14930 }
14931 /* Add it to the list, unless it was erroneous. */
14933 {
14936 }
14937 /* If the next token is not a `,', we're done. */
14940 /* Consume the `,' token. */
14942 }
14944 /* Perform semantic analysis. */
14947 }
14949 /* Parse a mem-initializer.
14951 mem-initializer:
14952 mem-initializer-id ( expression-list [opt] )
14953 mem-initializer-id braced-init-list
14955 GNU extension:
14957 mem-initializer:
14958 ( expression-list [opt] )
14960 Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base
14961 class) or FIELD_DECL (for a non-static data member) to initialize;
14962 the TREE_VALUE is the expression-list. An empty initialization
14963 list is represented by void_list_node. */
14965 static tree
14967 {
14968 tree mem_initializer_id;
14969 tree expression_list;
14970 tree member;
14973 /* Find out what is being initialized. */
14975 {
14979 }
14980 else
14981 {
14985 }
14991 {
14998 }
14999 else
15000 {
15012 }
15022 }
15024 /* Parse a mem-initializer-id.
15026 mem-initializer-id:
15027 :: [opt] nested-name-specifier [opt] class-name
15028 decltype-specifier (C++11)
15029 identifier
15031 Returns a TYPE indicating the class to be initialized for the first
15032 production (and the second in C++11). Returns an IDENTIFIER_NODE
15033 indicating the data member to be initialized for the last production. */
15035 static tree
15037 {
15041 tree id;
15045 /* `typename' is not allowed in this context ([temp.res]). */
15047 {
15049 "keyword %<typename%> not allowed in this context (a qualified "
15052 }
15053 /* Look for the optional `::' operator. */
15054 global_scope_p
15058 /* Look for the optional nested-name-specifier. The simplest way to
15059 implement:
15061 [temp.res]
15063 The keyword `typename' is not permitted in a base-specifier or
15064 mem-initializer; in these contexts a qualified name that
15065 depends on a template-parameter is implicitly assumed to be a
15066 type name.
15068 is to assume that we have seen the `typename' keyword at this
15069 point. */
15070 nested_name_specifier_p
15079 /* If there is a `::' operator or a nested-name-specifier, then we
15080 are definitely looking for a class-name. */
15085 typename_type,
15089 /* Otherwise, we could also be looking for an ordinary identifier. */
15092 /* Try a decltype-specifier. */
15094 else
15095 /* Otherwise, try a class-name. */
15099 none_type,
15103 /* If we found one, we're done. */
15106 /* Otherwise, look for an ordinary identifier. */
15108 }
15110 /* Overloading [gram.over] */
15112 /* Parse an operator-function-id.
15114 operator-function-id:
15115 operator operator
15117 Returns an IDENTIFIER_NODE for the operator which is a
15118 human-readable spelling of the identifier, e.g., `operator +'. */
15120 static cp_expr
15122 {
15124 /* Look for the `operator' keyword. */
15127 /* And then the name of the operator itself. */
15129 }
15131 /* Return an identifier node for a user-defined literal operator.
15132 The suffix identifier is chained to the operator name identifier. */
15134 tree
15136 {
15137 tree identifier;
15144 }
15146 /* Parse an operator.
15148 operator:
15149 new delete new[] delete[] + - * / % ^ & | ~ ! = < >
15150 += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= &&
15151 || ++ -- , ->* -> () []
15153 GNU Extensions:
15155 operator:
15156 <? >? <?= >?=
15158 Returns an IDENTIFIER_NODE for the operator which is a
15159 human-readable spelling of the identifier, e.g., `operator +'. */
15161 static cp_expr
15163 {
15168 /* Peek at the next token. */
15173 /* Figure out which operator we have. */
15178 {
15180 {
15181 /* The keyword should be either `new' or `delete'. */
15186 else
15189 /* Consume the `new' or `delete' token. */
15192 /* Peek at the next token. */
15194 /* If it's a `[' token then this is the array variant of the
15195 operator. */
15197 {
15198 /* Consume the `[' token. */
15200 /* Look for the `]' token. */
15205 }
15208 }
15366 {
15367 /* Consume the `('. */
15368 matching_parens parens;
15370 /* Look for the matching `)'. */
15377 }
15380 /* Consume the `['. */
15382 /* Look for the matching `]'. */
15393 /* FALLTHRU */
15402 {
15403 cp_expr str;
15404 tree string_tree;
15410 /* Consume the string. */
15416 {
15420 }
15421 else
15422 {
15424 /* Look for the suffix identifier. */
15427 {
15430 }
15432 {
15436 }
15437 else
15438 {
15441 }
15442 }
15447 {
15450 }
15453 {
15456 }
15458 {
15461 }
15462 /* Generate a location of the form:
15463 "" _suffix_identifier
15464 ^~~~~~~~~~~~~~~~~~~~~
15465 with caret == start at the start token, finish at the end of the
15466 suffix identifier. */
15467 location_t finish_loc
15469 location_t combined_loc
15472 }
15475 /* Anything else is an error. */
15477 }
15479 /* If we have selected an identifier, we need to consume the
15480 operator token. */
15482 {
15486 }
15487 /* Otherwise, no valid operator name was present. */
15488 else
15489 {
15492 }
15496 }
15498 /* Parse a template-declaration.
15500 template-declaration:
15501 export [opt] template < template-parameter-list > declaration
15503 If MEMBER_P is TRUE, this template-declaration occurs within a
15504 class-specifier.
15506 The grammar rule given by the standard isn't correct. What
15507 is really meant is:
15509 template-declaration:
15510 export [opt] template-parameter-list-seq
15511 decl-specifier-seq [opt] init-declarator [opt] ;
15512 export [opt] template-parameter-list-seq
15513 function-definition
15515 template-parameter-list-seq:
15516 template-parameter-list-seq [opt]
15517 template < template-parameter-list >
15519 Concept Extensions:
15521 template-parameter-list-seq:
15522 template < template-parameter-list > requires-clause [opt]
15524 requires-clause:
15525 requires logical-or-expression */
15527 static void
15529 {
15530 /* Check for `export'. */
15532 {
15533 /* Consume the `export' token. */
15535 /* Warn that we do not support `export'. */
15537 }
15540 }
15542 /* Parse a template-parameter-list.
15544 template-parameter-list:
15545 template-parameter
15546 template-parameter-list , template-parameter
15548 Returns a TREE_LIST. Each node represents a template parameter.
15549 The nodes are connected via their TREE_CHAINs. */
15551 static tree
15553 {
15556 /* Don't create wrapper nodes within a template-parameter-list,
15557 since we don't want to have different types based on the
15558 spelling location of constants and decls within them. */
15559 auto_suppress_location_wrappers sentinel;
15563 /* The loop below parses the template parms. We first need to know
15564 the total number of template parms to be able to compute proper
15565 canonical types of each dependent type. So after the loop, when
15566 we know the total number of template parms,
15567 end_template_parm_list computes the proper canonical types and
15568 fixes up the dependent types accordingly. */
15570 {
15571 tree parameter;
15574 location_t parm_loc;
15576 /* Parse the template-parameter. */
15581 /* Add it to the list. */
15584 parm_loc,
15585 parameter,
15586 is_non_type,
15587 is_parameter_pack);
15588 else
15589 {
15592 }
15594 /* If the next token is not a `,', we're done. */
15597 /* Otherwise, consume the `,' token. */
15599 }
15602 }
15604 /* Parse a introduction-list.
15606 introduction-list:
15607 introduced-parameter
15608 introduction-list , introduced-parameter
15610 introduced-parameter:
15611 ...[opt] identifier
15613 Returns a TREE_VEC of WILDCARD_DECLs. If the parameter is a pack
15614 then the introduced parm will have WILDCARD_PACK_P set. In addition, the
15615 WILDCARD_DECL will also have DECL_NAME set and token location in
15616 DECL_SOURCE_LOCATION. */
15618 static tree
15620 {
15624 {
15633 /* Build placeholder. */
15641 /* If the next token is not a `,', we're done. */
15644 /* Otherwise, consume the `,' token. */
15646 }
15648 /* Convert the vec into a TREE_VEC. */
15651 tree parm;
15657 }
15659 /* Given a declarator, get the declarator-id part, or NULL_TREE if this
15660 is an abstract declarator. */
15664 {
15669 }
15671 /* Get the unqualified-id from the DECLARATOR or NULL_TREE if this
15672 is an abstract declarator. */
15676 {
15680 else
15682 }
15684 /* Returns true if DECL represents a constrained-parameter. */
15688 {
15693 }
15695 /* Returns true if PARM declares a constrained-parameter. */
15699 {
15701 }
15703 /* Check that the type parameter is only a declarator-id, and that its
15704 type is not cv-qualified. */
15706 bool
15709 {
15714 {
15717 }
15719 /* Don't allow cv-qualified type parameters. */
15722 {
15725 }
15728 }
15730 /* Finish parsing/processing a template type parameter and checking
15731 various restrictions. */
15735 tree id,
15737 {
15740 else
15742 }
15744 static tree
15746 {
15747 /* FIXME: This should probably be copied, and we may need to adjust
15748 the template parameter depths. */
15758 }
15760 /* Finish parsing/processing a template template parameter by borrowing
15761 the template parameter list from the prototype parameter. */
15763 static tree
15765 tree proto,
15766 tree id,
15768 {
15772 }
15774 /* Create a new non-type template parameter from the given PARM
15775 declarator. */
15777 static tree
15780 {
15786 }
15788 /* Build a constrained template parameter based on the PARMDECL
15789 declarator. The type of PARMDECL is the constrained type, which
15790 refers to the prototype template parameter that ultimately
15791 specifies the type of the declared parameter. */
15793 static tree
15798 {
15804 /* A template parameter constrained by a variadic concept shall also
15805 be declared as a template parameter pack. */
15810 /* Build the parameter. Return an error if the declarator was invalid. */
15811 tree parm;
15816 parmdecl);
15817 else
15822 /* Finish the parameter decl and create a node attaching the
15823 default argument and constraint. */
15828 }
15830 /* Returns true if the parsed type actually represents the declaration
15831 of a type template-parameter. */
15835 {
15838 }
15841 /* Returns true if the parsed type actually represents the declaration of
15842 a template template-parameter. */
15844 static bool
15846 {
15849 }
15851 /* Parse a default argument for a type template-parameter.
15852 Note that diagnostics are handled in cp_parser_template_parameter. */
15854 static tree
15856 {
15859 /* Consume the `=' token. */
15864 /* Parse the default-argument. */
15867 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
15868 NULL);
15872 {
15876 }
15879 }
15881 /* Parse a default argument for a template template-parameter. */
15883 static tree
15885 {
15890 /* Consume the `='. */
15892 /* Parse the id-expression. */
15894 /* save token before parsing the id-expression, for error
15895 reporting */
15897 tree default_argument
15905 /* If the id-expression was a template-id that refers to
15906 a template-class, we already have the declaration here,
15907 so no further lookup is needed. */
15908 ;
15909 else
15910 /* Look up the name. */
15911 default_argument
15913 none_type,
15919 /* See if the default argument is valid. */
15923 }
15925 /* Parse a template-parameter.
15927 template-parameter:
15928 type-parameter
15929 parameter-declaration
15931 If all goes well, returns a TREE_LIST. The TREE_VALUE represents
15932 the parameter. The TREE_PURPOSE is the default value, if any.
15933 Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true
15934 iff this parameter is a non-type parameter. *IS_PARAMETER_PACK is
15935 set to true iff this parameter is a parameter pack. */
15937 static tree
15940 {
15943 tree parm;
15945 /* Assume it is a type parameter or a template parameter. */
15947 /* Assume it not a parameter pack. */
15949 /* Peek at the next token. */
15951 /* If it is `template', we have a type-parameter. */
15954 /* If it is `class' or `typename' we do not know yet whether it is a
15955 type parameter or a non-type parameter. Consider:
15957 template <typename T, typename T::X X> ...
15959 or:
15961 template <class C, class D*> ...
15963 Here, the first parameter is a type parameter, and the second is
15964 a non-type parameter. We can tell by looking at the token after
15965 the identifier -- if it is a `,', `=', or `>' then we have a type
15966 parameter. */
15968 {
15969 /* Peek at the token after `class' or `typename'. */
15971 /* If it's an ellipsis, we have a template type parameter
15972 pack. */
15975 /* If it's an identifier, skip it. */
15978 /* Now, see if the token looks like the end of a template
15979 parameter. */
15984 }
15986 /* Otherwise, it is a non-type parameter or a constrained parameter.
15988 [temp.param]
15990 When parsing a default template-argument for a non-type
15991 template-parameter, the first non-nested `>' is taken as the end
15992 of the template parameter-list rather than a greater-than
15993 operator. */
15994 parameter_declarator
15996 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
16003 /* If the parameter declaration is marked as a parameter pack, set
16004 *IS_PARAMETER_PACK to notify the caller. */
16009 {
16010 /* Can happen in some cases of erroneous input (c++/34892). */
16012 /* Consume the `...' for better error recovery. */
16014 }
16016 // The parameter may have been constrained.
16019 parameter_declarator,
16020 is_non_type,
16021 is_parameter_pack);
16023 // Now we're sure that the parameter is a non-type parameter.
16034 }
16036 /* Parse a type-parameter.
16038 type-parameter:
16039 class identifier [opt]
16040 class identifier [opt] = type-id
16041 typename identifier [opt]
16042 typename identifier [opt] = type-id
16043 template < template-parameter-list > class identifier [opt]
16044 template < template-parameter-list > class identifier [opt]
16045 = id-expression
16047 GNU Extension (variadic templates):
16049 type-parameter:
16050 class ... identifier [opt]
16051 typename ... identifier [opt]
16053 Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The
16054 TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is
16055 the declaration of the parameter.
16057 Sets *IS_PARAMETER_PACK if this is a template parameter pack. */
16059 static tree
16061 {
16063 tree parameter;
16065 /* Look for a keyword to tell us what kind of parameter this is. */
16071 {
16074 {
16075 tree identifier;
16076 tree default_argument;
16078 /* If the next token is an ellipsis, we have a template
16079 argument pack. */
16081 {
16082 /* Consume the `...' token. */
16087 }
16089 /* If the next token is an identifier, then it names the
16090 parameter. */
16093 else
16096 /* Create the parameter. */
16099 /* If the next token is an `=', we have a default argument. */
16101 {
16102 default_argument
16105 /* Template parameter packs cannot have default
16106 arguments. */
16108 {
16111 "template parameter pack %qD cannot have a "
16113 else
16115 "template parameter packs cannot have "
16118 }
16121 }
16122 else
16125 /* Create the combined representation of the parameter and the
16126 default argument. */
16128 }
16132 {
16133 tree identifier;
16134 tree default_argument;
16136 /* Look for the `<'. */
16138 /* Parse the template-parameter-list. */
16140 /* Look for the `>'. */
16143 // If template requirements are present, parse them.
16145 {
16150 }
16152 /* Look for the `class' or 'typename' keywords. */
16154 /* If the next token is an ellipsis, we have a template
16155 argument pack. */
16157 {
16158 /* Consume the `...' token. */
16163 }
16164 /* If the next token is an `=', then there is a
16165 default-argument. If the next token is a `>', we are at
16166 the end of the parameter-list. If the next token is a `,',
16167 then we are at the end of this parameter. */
16171 {
16173 /* Treat invalid names as if the parameter were nameless. */
16176 }
16177 else
16180 /* Create the template parameter. */
16182 identifier);
16184 /* If the next token is an `=', then there is a
16185 default-argument. */
16187 {
16188 default_argument
16191 /* Template parameter packs cannot have default
16192 arguments. */
16194 {
16197 "template parameter pack %qD cannot "
16199 identifier);
16200 else
16204 }
16205 }
16206 else
16209 /* Create the combined representation of the parameter and the
16210 default argument. */
16212 }
16218 }
16221 }
16223 /* Parse a template-id.
16225 template-id:
16226 template-name < template-argument-list [opt] >
16228 If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the
16229 `template' keyword. In this case, a TEMPLATE_ID_EXPR will be
16230 returned. Otherwise, if the template-name names a function, or set
16231 of functions, returns a TEMPLATE_ID_EXPR. If the template-name
16232 names a class, returns a TYPE_DECL for the specialization.
16234 If CHECK_DEPENDENCY_P is FALSE, names are looked up in
16235 uninstantiated templates. */
16237 static tree
16243 {
16244 tree templ;
16245 tree arguments;
16246 tree template_id;
16251 /* If the next token corresponds to a template-id, there is no need
16252 to reparse it. */
16255 {
16258 }
16260 /* Avoid performing name lookup if there is no possibility of
16261 finding a template-id. */
16264 && !cp_parser_nth_token_starts_template_argument_list_p
16266 {
16269 }
16271 /* Remember where the template-id starts. */
16277 /* Parse the template-name. */
16280 check_dependency_p,
16281 is_declaration,
16282 tag_type,
16285 /* Push any access checks inside the firewall we're about to create. */
16291 /* Since we're going to preserve any side-effects from this parse, set up a
16292 firewall to protect our callers from cp_parser_commit_to_tentative_parse
16293 in the template arguments. */
16297 /* If we find the sequence `[:' after a template-name, it's probably
16298 a digraph-typo for `< ::'. Substitute the tokens and check if we can
16299 parse correctly the argument list. */
16306 {
16308 /* Change `:' into `::'. */
16310 /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is
16311 CPP_LESS. */
16314 /* Parse the arguments. */
16317 {
16318 /* If we couldn't parse an argument list, then we revert our changes
16319 and return simply an error. Maybe this is not a template-id
16320 after all. */
16325 }
16326 /* Otherwise, emit an error about the invalid digraph, but continue
16327 parsing because we got our argument list. */
16330 {
16333 "%<<:%> is an alternate spelling for %<[%>."
16336 {
16338 "or %<-std=c++11%>, or %<-std=gnu++11%> G++ will "
16341 }
16342 }
16343 }
16344 else
16345 {
16346 /* Look for the `<' that starts the template-argument-list. */
16348 {
16351 }
16352 /* Parse the arguments. */
16357 && !template_keyword_p
16360 {
16361 /* This didn't go well. */
16363 {
16364 /* C++2A says that "function-name < a;" is now ill-formed. */
16366 {
16369 "operand of %<<%> is ill-formed in C++2a; wrap the "
16371 }
16372 else
16373 /* We expect "f<targs>" to be followed by "(args)". */
16377 /* Purge all subsequent tokens. */
16379 }
16380 else
16384 }
16385 }
16387 /* Set the location to be of the form:
16388 template-name < template-argument-list [opt] >
16389 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
16390 with caret == start at the start of the template-name,
16391 ranging until the closing '>'. */
16392 location_t finish_loc
16394 location_t combined_loc
16397 /* Check for concepts autos where they don't belong. We could
16398 identify types in some cases of idnetifier TEMPL, looking ahead
16399 for a CPP_SCOPE, but that would buy us nothing: we accept auto in
16400 types. We reject them in functions, but if what we have is an
16401 identifier, even with none_type we can't conclude it's NOT a
16402 type, we have to wait for template substitution. */
16405 /* Build a representation of the specialization. */
16408 TEMPLATE_ID_EXPR,
16412 {
16413 /* In "template <typename T> ... A<T>::", A<T> is the abstract A
16414 template (rather than some instantiation thereof) only if
16415 is not nested within some other construct. For example, in
16416 "template <typename T> void f(T) { A<T>::", A<T> is just an
16417 instantiation of A. */
16418 bool entering_scope
16421 template_id
16423 }
16424 /* A template-like identifier may be a partial concept id. */
16430 {
16434 }
16435 else
16436 {
16437 /* If it's not a class-template or a template-template, it should be
16438 a function-template. */
16447 }
16449 /* If parsing tentatively, replace the sequence of tokens that makes
16450 up the template-id with a CPP_TEMPLATE_ID token. That way,
16451 should we re-parse the token stream, we will not have to repeat
16452 the effort required to do the parse, nor will we issue duplicate
16453 error messages about problems during instantiation of the
16454 template. */
16456 /* Don't do this if we had a parse error in a declarator; re-parsing
16457 might succeed if a name changes meaning (60361). */
16461 {
16462 /* Reset the contents of the START_OF_ID token. */
16466 /* Retrieve any deferred checks. Do not pop this access checks yet
16467 so the memory will not be reclaimed during token replacing below. */
16473 /* Purge all subsequent tokens. */
16476 /* ??? Can we actually assume that, if template_id ==
16477 error_mark_node, we will have issued a diagnostic to the
16478 user, as opposed to simply marking the tentative parse as
16479 failed? */
16482 }
16486 }
16488 /* Parse a template-name.
16490 template-name:
16491 identifier
16493 The standard should actually say:
16495 template-name:
16496 identifier
16497 operator-function-id
16499 A defect report has been filed about this issue.
16501 A conversion-function-id cannot be a template name because they cannot
16502 be part of a template-id. In fact, looking at this code:
16504 a.operator K<int>()
16506 the conversion-function-id is "operator K<int>", and K<int> is a type-id.
16507 It is impossible to call a templated conversion-function-id with an
16508 explicit argument list, since the only allowed template parameter is
16509 the type to which it is converting.
16511 If TEMPLATE_KEYWORD_P is true, then we have just seen the
16512 `template' keyword, in a construction like:
16514 T::template f<3>()
16516 In that case `f' is taken to be a template-name, even though there
16517 is no way of knowing for sure.
16519 Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the
16520 name refers to a set of overloaded functions, at least one of which
16521 is a template, or an IDENTIFIER_NODE with the name of the template,
16522 if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE,
16523 names are looked up inside uninstantiated templates. */
16525 static tree
16532 {
16533 tree identifier;
16534 tree decl;
16537 /* If the next token is `operator', then we have either an
16538 operator-function-id or a conversion-function-id. */
16540 {
16541 /* We don't know whether we're looking at an
16542 operator-function-id or a conversion-function-id. */
16544 /* Try an operator-function-id. */
16546 /* If that didn't work, try a conversion-function-id. */
16548 {
16551 }
16552 }
16553 /* Look for the identifier. */
16554 else
16557 /* If we didn't find an identifier, we don't have a template-id. */
16561 /* If the name immediately followed the `template' keyword, then it
16562 is a template-name. However, if the next token is not `<', then
16563 we do not treat it as a template-name, since it is not being used
16564 as part of a template-id. This enables us to handle constructs
16565 like:
16567 template <typename T> struct S { S(); };
16568 template <typename T> S<T>::S();
16570 correctly. We would treat `S' as a template -- if it were `S<T>'
16571 -- but we do not if there is no `<'. */
16575 {
16576 /* In a declaration, in a dependent context, we pretend that the
16577 "template" keyword was present in order to improve error
16578 recovery. For example, given:
16580 template <typename T> void f(T::X<int>);
16582 we want to treat "X<int>" as a template-id. */
16584 && !template_keyword_p
16586 && check_dependency_p
16588 /* Do not do this for dtors (or ctors), since they never
16589 need the template keyword before their name. */
16591 {
16594 /* Explain what went wrong. */
16596 identifier);
16599 /* If parsing tentatively, find the location of the "<" token. */
16602 /* Parse the template arguments so that we can issue error
16603 messages about them. */
16606 /* Skip tokens until we find a good place from which to
16607 continue parsing. */
16612 /* If parsing tentatively, permanently remove the
16613 template argument list. That will prevent duplicate
16614 error messages from being issued about the missing
16615 "template" keyword. */
16622 }
16624 /* If the "template" keyword is present, then there is generally
16625 no point in doing name-lookup, so we just return IDENTIFIER.
16626 But, if the qualifying scope is non-dependent then we can
16627 (and must) do name-lookup normally. */
16629 {
16635 {
16636 /* We're optimizing away the call to cp_parser_lookup_name, but
16637 we still need to do this. */
16640 }
16641 }
16642 }
16644 /* cp_parser_lookup_name clears OBJECT_TYPE. */
16648 /* Look up the name. */
16650 tag_type,
16653 check_dependency_p,
16659 /* If DECL is a template, then the name was a template-name. */
16661 {
16665 }
16666 else
16667 {
16668 /* The standard does not explicitly indicate whether a name that
16669 names a set of overloaded declarations, some of which are
16670 templates, is a template-name. However, such a name should
16671 be a template-name; otherwise, there is no way to form a
16672 template-id for the overloaded templates. */
16682 && !scoped_p
16685 {
16686 /* [temp.names] says "A name is also considered to refer to a template
16687 if it is an unqualified-id followed by a < and name lookup finds
16688 either one or more functions or finds nothing." */
16690 /* The "more functions" case. Just use the OVERLOAD as normally.
16691 We don't use is_overloaded_fn here to avoid considering
16692 BASELINKs. */
16694 /* Name lookup found one function. */
16697 /* Name lookup found nothing. */
16700 }
16703 {
16704 /* The name does not name a template. */
16707 }
16708 }
16711 }
16713 /* Parse a template-argument-list.
16715 template-argument-list:
16716 template-argument ... [opt]
16717 template-argument-list , template-argument ... [opt]
16719 Returns a TREE_VEC containing the arguments. */
16721 static tree
16723 {
16728 tree vec;
16733 /* Don't create location wrapper nodes within a template-argument-list. */
16734 auto_suppress_location_wrappers sentinel;
16738 /* Even if the template-id appears in an integral
16739 constant-expression, the contents of the argument list do
16740 not. */
16746 /* Parse the arguments. */
16747 do
16748 {
16749 tree argument;
16752 /* Consume the comma. */
16755 /* Parse the template-argument. */
16758 /* If the next token is an ellipsis, we're expanding a template
16759 argument pack. */
16761 {
16763 {
16767 }
16768 /* Consume the `...' token. */
16771 /* Make the argument into a TYPE_PACK_EXPANSION or
16772 EXPR_PACK_EXPANSION. */
16774 }
16777 {
16781 {
16784 }
16785 else
16787 }
16789 }
16805 }
16807 /* Parse a template-argument.
16809 template-argument:
16810 assignment-expression
16811 type-id
16812 id-expression
16814 The representation is that of an assignment-expression, type-id, or
16815 id-expression -- except that the qualified id-expression is
16816 evaluated, so that the value returned is either a DECL or an
16817 OVERLOAD.
16819 Although the standard says "assignment-expression", it forbids
16820 throw-expressions or assignments in the template argument.
16821 Therefore, we use "conditional-expression" instead. */
16823 static tree
16825 {
16826 tree argument;
16832 cp_id_kind idk;
16834 /* There's really no way to know what we're looking at, so we just
16835 try each alternative in order.
16837 [temp.arg]
16839 In a template-argument, an ambiguity between a type-id and an
16840 expression is resolved to a type-id, regardless of the form of
16841 the corresponding template-parameter.
16843 Therefore, we try a type-id first. */
16846 /* If there was no error parsing the type-id but the next token is a
16847 '>>', our behavior depends on which dialect of C++ we're
16848 parsing. In C++98, we probably found a typo for '> >'. But there
16849 are type-id which are also valid expressions. For instance:
16851 struct X { int operator >> (int); };
16852 template <int V> struct Foo {};
16853 Foo<X () >> 5> r;
16855 Here 'X()' is a valid type-id of a function type, but the user just
16856 wanted to write the expression "X() >> 5". Thus, we remember that we
16857 found a valid type-id, but we still try to parse the argument as an
16858 expression to see what happens.
16860 In C++0x, the '>>' will be considered two separate '>'
16861 tokens. */
16865 {
16868 }
16869 else
16870 {
16871 /* If the next token isn't a `,' or a `>', then this argument wasn't
16872 really finished. This means that the argument is not a valid
16873 type-id. */
16876 /* If that worked, we're done. */
16879 }
16880 /* We're still not sure what the argument will be. */
16882 /* Try a template. */
16890 /* If the next token isn't a `,' or a `>', then this argument wasn't
16891 really finished. */
16895 {
16896 /* Figure out what is being referred to. If the id-expression
16897 was for a class template specialization, then we will have a
16898 TYPE_DECL at this point. There is no need to do name lookup
16899 at this point in that case. */
16902 none_type,
16908 /* Handle a constrained-type-specifier for a non-type template
16909 parameter. */
16915 }
16917 {
16921 }
16922 /* It must be a non-type argument. In C++17 any constant-expression is
16923 allowed. */
16927 /* Otherwise, the permitted cases are given in [temp.arg.nontype]:
16929 -- an integral constant-expression of integral or enumeration
16930 type; or
16932 -- the name of a non-type template-parameter; or
16934 -- the name of an object or function with external linkage...
16936 -- the address of an object or function with external linkage...
16938 -- a pointer to member... */
16939 /* Look for a non-type template parameter. */
16941 {
16953 }
16955 /* If the next token is "&", the argument must be the address of an
16956 object or function with external linkage. */
16959 {
16962 }
16963 /* See if we might have an id-expression. */
16970 {
16973 address_p,
16980 else
16981 {
16982 tree probe;
16985 {
16986 /* Strip the dereference temporarily. */
16989 }
16991 /* If we're in a template, we represent a qualified-id referring
16992 to a static data member as a SCOPE_REF even if the scope isn't
16993 dependent so that we can check access control later. */
16998 {
16999 /* A variable without external linkage might still be a
17000 valid constant-expression, so no error is issued here
17001 if the external-linkage check fails. */
17004 }
17006 /* All overloaded functions are allowed; if the external
17007 linkage test does not pass, an error will be issued
17008 later. */
17009 ;
17013 /* A pointer-to-member. */
17014 ;
17016 ;
17017 else
17021 {
17024 tf_warning_or_error);
17025 else
17028 }
17029 }
17030 }
17031 /* If the argument started with "&", there are no other valid
17032 alternatives at this point. */
17034 {
17037 }
17039 general_expr:
17040 /* If the argument wasn't successfully parsed as a type-id followed
17041 by '>>', the argument can only be a constant expression now.
17042 Otherwise, we try parsing the constant-expression tentatively,
17043 because the argument could really be a type-id. */
17049 else
17050 {
17051 /* In C++20, we can encounter a braced-init-list. */
17054 {
17057 }
17059 /* With C++17 generalized non-type template arguments we need to handle
17060 lvalue constant expressions, too. */
17063 }
17071 /* We did our best to parse the argument as a non type-id, but that
17072 was the only alternative that matched (albeit with a '>' after
17073 it). We can assume it's just a typo from the user, and a
17074 diagnostic will then be issued. */
17076 }
17078 /* Parse an explicit-instantiation.
17080 explicit-instantiation:
17081 template declaration
17083 Although the standard says `declaration', what it really means is:
17085 explicit-instantiation:
17086 template decl-specifier-seq [opt] declarator [opt] ;
17088 Things like `template int S<int>::i = 5, int S<double>::j;' are not
17089 supposed to be allowed. A defect report has been filed about this
17090 issue.
17092 GNU Extension:
17094 explicit-instantiation:
17095 storage-class-specifier template
17096 decl-specifier-seq [opt] declarator [opt] ;
17097 function-specifier template
17098 decl-specifier-seq [opt] declarator [opt] ; */
17100 static void
17102 {
17104 cp_decl_specifier_seq decl_specifiers;
17109 /* Look for an (optional) storage-class-specifier or
17110 function-specifier. */
17112 {
17113 extension_specifier
17116 extension_specifier
17119 }
17121 /* Look for the `template' keyword. */
17123 /* Let the front end know that we are processing an explicit
17124 instantiation. */
17126 /* [temp.explicit] says that we are supposed to ignore access
17127 control while processing explicit instantiation directives. */
17129 /* Parse a decl-specifier-seq. */
17131 CP_PARSER_FLAGS_OPTIONAL,
17134 /* If there was exactly one decl-specifier, and it declared a class,
17135 and there's no declarator, then we have an explicit type
17136 instantiation. */
17138 {
17139 tree type;
17143 /* Turn access control back on for names used during
17144 template instantiation. */
17149 }
17150 else
17151 {
17153 tree decl;
17155 /* Parse the declarator. */
17156 declarator
17158 CP_PARSER_FLAGS_NONE,
17169 {
17172 "explicit instantiation shall not use"
17176 "explicit instantiation shall not use"
17181 /* Turn access control back on for names used during
17182 template instantiation. */
17184 /* Do the explicit instantiation. */
17186 }
17187 else
17188 {
17190 /* Skip the body of the explicit instantiation. */
17192 }
17193 }
17194 /* We're done with the instantiation. */
17200 }
17202 /* Parse an explicit-specialization.
17204 explicit-specialization:
17205 template < > declaration
17207 Although the standard says `declaration', what it really means is:
17209 explicit-specialization:
17210 template <> decl-specifier [opt] init-declarator [opt] ;
17211 template <> function-definition
17212 template <> explicit-specialization
17213 template <> template-declaration */
17215 static void
17217 {
17221 /* Look for the `template' keyword. */
17223 /* Look for the `<'. */
17225 /* Look for the `>'. */
17227 /* We have processed another parameter list. */
17229 /* [temp]
17231 A template ... explicit specialization ... shall not have C
17232 linkage. */
17234 {
17237 /* Give it C++ linkage to avoid confusing other parts of the
17238 front end. */
17241 }
17242 else
17244 /* Let the front end know that we are beginning a specialization. */
17246 {
17249 }
17251 /* If the next keyword is `template', we need to figure out whether
17252 or not we're looking a template-declaration. */
17254 {
17259 else
17261 }
17262 else
17263 /* Parse the dependent declaration. */
17269 /* We're done with the specialization. */
17271 /* For the erroneous case of a template with C linkage, we pushed an
17272 implicit C++ linkage scope; exit that scope now. */
17275 /* We're done with this parameter list. */
17277 }
17279 /* Parse a type-specifier.
17281 type-specifier:
17282 simple-type-specifier
17283 class-specifier
17284 enum-specifier
17285 elaborated-type-specifier
17286 cv-qualifier
17288 GNU Extension:
17290 type-specifier:
17291 __complex__
17293 Returns a representation of the type-specifier. For a
17294 class-specifier, enum-specifier, or elaborated-type-specifier, a
17295 TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
17297 The parser flags FLAGS is used to control type-specifier parsing.
17299 If IS_DECLARATION is TRUE, then this type-specifier is appearing
17300 in a decl-specifier-seq.
17302 If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a
17303 class-specifier, enum-specifier, or elaborated-type-specifier, then
17304 *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1
17305 if a type is declared; 2 if it is defined. Otherwise, it is set to
17306 zero.
17308 If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a
17309 cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it
17310 is set to FALSE. */
17312 static tree
17314 cp_parser_flags flags,
17319 {
17325 /* Assume this type-specifier does not declare a new type. */
17328 /* And that it does not specify a cv-qualifier. */
17331 /* Peek at the next token. */
17334 /* If we're looking at a keyword, we can use that to guide the
17335 production we choose. */
17338 {
17343 /* Look for the enum-specifier. */
17345 /* If that worked, we're done. */
17347 {
17352 type_spec,
17353 token,
17356 }
17357 else
17360 /* Any of these indicate either a class-specifier, or an
17361 elaborated-type-specifier. */
17368 /* Parse tentatively so that we can back up if we don't find a
17369 class-specifier. */
17371 /* Look for the class-specifier. */
17374 /* If that worked, we're done. */
17376 {
17381 type_spec,
17382 token,
17385 }
17387 /* Fall through. */
17388 elaborated_type_specifier:
17389 /* We're declaring (not defining) a class or enum. */
17393 /* Fall through. */
17395 /* Look for an elaborated-type-specifier. */
17396 type_spec
17397 = (cp_parser_elaborated_type_specifier
17400 is_declaration));
17403 type_spec,
17404 token,
17427 /* The `__complex__' keyword is a GNU extension. */
17433 }
17435 /* Handle simple keywords. */
17437 {
17439 {
17442 }
17444 }
17446 /* If we do not already have a type-specifier, assume we are looking
17447 at a simple-type-specifier. */
17449 decl_specs,
17450 flags);
17452 /* If we didn't find a type-specifier, and a type-specifier was not
17453 optional in this context, issue an error message. */
17455 {
17458 }
17461 }
17463 /* Parse a simple-type-specifier.
17465 simple-type-specifier:
17466 :: [opt] nested-name-specifier [opt] type-name
17467 :: [opt] nested-name-specifier template template-id
17468 char
17469 wchar_t
17470 bool
17471 short
17472 int
17473 long
17474 signed
17475 unsigned
17476 float
17477 double
17478 void
17480 C++11 Extension:
17482 simple-type-specifier:
17483 auto
17484 decltype ( expression )
17485 char16_t
17486 char32_t
17487 __underlying_type ( type-id )
17489 C++17 extension:
17491 nested-name-specifier(opt) template-name
17493 GNU Extension:
17495 simple-type-specifier:
17496 __int128
17497 __typeof__ unary-expression
17498 __typeof__ ( type-id )
17499 __typeof__ ( type-id ) { initializer-list , [opt] }
17501 Concepts Extension:
17503 simple-type-specifier:
17504 constrained-type-specifier
17506 Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is
17507 appropriately updated. */
17509 static tree
17512 cp_parser_flags flags)
17513 {
17518 /* Peek at the next token. */
17521 /* If we're looking at a keyword, things are easy. */
17523 {
17561 {
17564 }
17593 {
17594 /* The 'auto' might be the placeholder return type for a function decl
17595 with trailing return type. */
17604 {
17606 {
17613 }
17616 {
17619 }
17622 }
17626 {
17629 }
17632 {
17635 }
17636 else
17640 {
17643 "use of %<auto%> in lambda parameter declaration "
17644 "only available with "
17646 }
17649 "use of %<auto%> in parameter declaration "
17650 "only available with "
17654 "use of %<auto%> in parameter declaration "
17656 }
17657 else
17662 /* Since DR 743, decltype can either be a simple-type-specifier by
17663 itself or begin a nested-name-specifier. Parsing it will replace
17664 it with a CPP_DECLTYPE, so just rewind and let the CPP_DECLTYPE
17665 handling below decide what to do. */
17671 /* Consume the `typeof' token. */
17673 /* Parse the operand to `typeof'. */
17675 /* If it is not already a TYPE, take its type. */
17681 token,
17690 token,
17700 token,
17705 }
17707 /* If token is an already-parsed decltype not followed by ::,
17708 it's a simple-type-specifier. */
17711 {
17714 {
17716 token,
17718 /* Remember that we are handling a decltype in order to
17719 implement the resolution of DR 1510 when the argument
17720 isn't instantiation dependent. */
17722 }
17725 }
17727 /* If the type-specifier was for a built-in type, we're done. */
17729 {
17730 /* Record the type. */
17737 type,
17738 token,
17743 /* Consume the token. */
17749 /* There is no valid C++ program where a non-template type is
17750 followed by a "<". That usually indicates that the user thought
17751 that the type was a template. */
17756 }
17758 /* The type-specifier must be a user-defined type. */
17760 {
17766 /* Don't gobble tokens or issue error messages if this is an
17767 optional type-specifier. */
17773 /* Look for the optional `::' operator. */
17774 global_p
17778 /* Look for the nested-name specifier. */
17779 qualified_p
17786 /* If we have seen a nested-name-specifier, and the next token
17787 is `template', then we are using the template-id production. */
17790 {
17791 /* Look for the template-id. */
17795 none_type,
17797 /* If the template-id did not name a type, we are out of
17798 luck. */
17800 {
17801 /* ...unless we pretend we have seen 'typename'. */
17805 else
17806 {
17809 }
17810 }
17811 }
17812 /* Otherwise, look for a type-name. */
17813 else
17816 /* Keep track of all name-lookups performed in class scopes. */
17818 && !global_p
17819 && !qualified_p
17823 /* If it didn't work out, we don't have a TYPE. */
17828 {
17842 {
17844 none_type,
17854 else
17855 {
17860 }
17861 }
17862 else
17868 }
17871 token,
17873 }
17875 /* If we didn't get a type-name, issue an error message. */
17877 {
17880 }
17883 {
17884 /* See if TYPE is an Objective-C type, and if so, parse and
17885 accept any protocol references following it. Do this before
17886 the cp_parser_check_for_invalid_template_id() call, because
17887 Objective-C types can be followed by '<...>' which would
17888 enclose protocol names rather than template arguments, and so
17889 everything is fine. */
17892 {
17896 /* Clobber the "unqualified" type previously entered into
17897 DECL_SPECS with the new, improved protocol-qualified version. */
17902 }
17904 /* There is no valid C++ program where a non-template type is
17905 followed by a "<". That usually indicates that the user
17906 thought that the type was a template. */
17908 none_type,
17910 }
17913 }
17915 /* Parse a type-name.
17917 type-name:
17918 class-name
17919 enum-name
17920 typedef-name
17921 simple-template-id [in c++0x]
17923 enum-name:
17924 identifier
17926 typedef-name:
17927 identifier
17929 Concepts:
17931 type-name:
17932 concept-name
17933 partial-concept-id
17935 concept-name:
17936 identifier
17938 Returns a TYPE_DECL for the type. */
17940 static tree
17942 {
17943 tree type_decl;
17945 /* We can't know yet whether it is a class-name or not. */
17947 /* Try a class-name. */
17949 typename_keyword_p,
17951 none_type,
17955 /* If it's not a class-name, keep looking. */
17957 {
17959 /* It must be a typedef-name or an enum-name. */
17963 /* It is either a simple-template-id representing an
17964 instantiation of an alias template... */
17968 none_type,
17970 /* Note that this must be an instantiation of an alias template
17971 because [temp.names]/6 says:
17973 A template-id that names an alias template specialization
17974 is a type-name.
17976 Whereas [temp.names]/7 says:
17978 A simple-template-id that names a class template
17979 specialization is a class-name.
17981 With concepts, this could also be a partial-concept-id that
17982 declares a non-type template parameter. */
17989 else
17993 /* ... Or a typedef-name or an enum-name. */
17995 }
17998 }
18000 /* Check if DECL and ARGS can form a constrained-type-specifier.
18001 If ARGS is non-null, we try to form a concept check of the
18002 form DECL<?, ARGS> where ? is a wildcard that matches any
18003 kind of template argument. If ARGS is NULL, then we try to
18004 form a concept check of the form DECL<?>. */
18006 static tree
18009 {
18012 /* If we a constrained-type-specifier cannot be deduced. */
18016 /* A constrained type specifier can only be found in an
18017 overload set or as a reference to a template declaration.
18019 FIXME: This might be masking a bug. It's possible that
18020 that the deduction below is causing template specializations
18021 to be formed with the wildcard as an argument. */
18025 /* Try to build a call expression that evaluates the
18026 concept. This can fail if the overload set refers
18027 only to non-templates. */
18033 /* Deduce the checked constraint and the prototype parameter.
18035 FIXME: In certain cases, failure to deduce should be a
18036 diagnosable error. */
18037 tree conc;
18038 tree proto;
18042 /* In template parameter scope, this results in a constrained
18043 parameter. Return a descriptor of that parm. */
18047 /* In a parameter-declaration-clause, constrained-type
18048 specifiers result in invented template parameters. */
18050 {
18053 }
18054 else
18055 {
18056 /* Otherwise, we're in a context where the constrained
18057 type name is deduced and the constraint applies
18058 after deduction. */
18060 }
18063 }
18065 /* If DECL refers to a concept, return a TYPE_DECL representing
18066 the result of using the constrained type specifier in the
18067 current context. DECL refers to a concept if
18069 - it is an overload set containing a function concept taking a single
18070 type argument, or
18072 - it is a variable concept taking a single type argument. */
18074 static tree
18076 {
18082 else
18084 }
18086 /* Check if DECL and ARGS form a partial-concept-id. If so,
18087 assign ID to the resulting constrained placeholder.
18089 Returns true if the partial-concept-id designates a placeholder
18090 and false otherwise. Note that *id is set to NULL_TREE in
18091 this case. */
18093 static tree
18095 {
18097 }
18099 /* Parse a non-class type-name, that is, either an enum-name, a typedef-name,
18100 or a concept-name.
18102 enum-name:
18103 identifier
18105 typedef-name:
18106 identifier
18108 concept-name:
18109 identifier
18111 Returns a TYPE_DECL for the type. */
18113 static tree
18115 {
18116 tree type_decl;
18117 tree identifier;
18124 /* Look up the type-name. */
18129 /* If we found an overload set, then it may refer to a concept-name. */
18135 {
18136 /* See if this is an Objective-C type. */
18141 }
18143 /* Issue an error if we did not find a type-name. */
18145 /* In Objective-C, we have the complication that class names are
18146 normally type names and start declarations (eg, the
18147 "NSObject" in "NSObject *object;"), but can be used in an
18148 Objective-C 2.0 dot-syntax (as in "NSObject.version") which
18149 is an expression. So, a classname followed by a dot is not a
18150 valid type-name. */
18153 {
18158 }
18159 /* Remember that the name was used in the definition of the
18160 current class so that we can check later to see if the
18161 meaning would have been different after the class was
18162 entirely defined. */
18168 }
18170 /* Parse an elaborated-type-specifier. Note that the grammar given
18171 here incorporates the resolution to DR68.
18173 elaborated-type-specifier:
18174 class-key :: [opt] nested-name-specifier [opt] identifier
18175 class-key :: [opt] nested-name-specifier [opt] template [opt] template-id
18176 enum-key :: [opt] nested-name-specifier [opt] identifier
18177 typename :: [opt] nested-name-specifier identifier
18178 typename :: [opt] nested-name-specifier template [opt]
18179 template-id
18181 GNU extension:
18183 elaborated-type-specifier:
18184 class-key attributes :: [opt] nested-name-specifier [opt] identifier
18185 class-key attributes :: [opt] nested-name-specifier [opt]
18186 template [opt] template-id
18187 enum attributes :: [opt] nested-name-specifier [opt] identifier
18189 If IS_FRIEND is TRUE, then this elaborated-type-specifier is being
18190 declared `friend'. If IS_DECLARATION is TRUE, then this
18191 elaborated-type-specifier appears in a decl-specifiers-seq, i.e.,
18192 something is being declared.
18194 Returns the TYPE specified. */
18196 static tree
18200 {
18202 tree identifier;
18205 tree globalscope;
18208 /* See if we're looking at the `enum' keyword. */
18210 {
18211 /* Consume the `enum' token. */
18213 /* Remember that it's an enumeration type. */
18215 /* Issue a warning if the `struct' or `class' key (for C++0x scoped
18216 enums) is used here. */
18220 {
18227 /* Consume the `struct' or `class' and parse it anyway. */
18229 }
18230 /* Parse the attributes. */
18232 }
18233 /* Or, it might be `typename'. */
18235 RID_TYPENAME))
18236 {
18237 /* Consume the `typename' token. */
18239 /* Remember that it's a `typename' type. */
18241 }
18242 /* Otherwise it must be a class-key. */
18243 else
18244 {
18248 /* Parse the attributes. */
18250 }
18252 /* Look for the `::' operator. */
18255 /* Look for the nested-name-specifier. */
18256 tree nested_name_specifier;
18258 {
18259 nested_name_specifier
18264 is_declaration);
18267 }
18268 else
18269 /* Even though `typename' is not present, the proposed resolution
18270 to Core Issue 180 says that in `class A<T>::B', `B' should be
18271 considered a type-name, even if `A<T>' is dependent. */
18272 nested_name_specifier
18277 is_declaration);
18278 /* For everything but enumeration types, consider a template-id.
18279 For an enumeration type, consider only a plain identifier. */
18281 {
18283 tree decl;
18285 /* Allow the `template' keyword. */
18287 /* If we didn't see `template', we don't know if there's a
18288 template-id or not. */
18291 /* The `template' keyword must follow a nested-name-specifier. */
18293 {
18297 }
18299 /* Parse the template-id. */
18303 tag_type,
18304 is_declaration);
18305 /* If we didn't find a template-id, look for an ordinary
18306 identifier. */
18308 ;
18309 /* We can get here when cp_parser_template_id, called by
18310 cp_parser_class_name with tag_type == none_type, succeeds
18311 and caches a BASELINK. Then, when called again here,
18312 instead of failing and returning an error_mark_node
18313 returns it (see template/typename17.C in C++11).
18314 ??? Could we diagnose this earlier? */
18316 {
18319 }
18320 /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is
18321 in effect, then we must assume that, upon instantiation, the
18322 template will correspond to a class. */
18326 typename_type,
18328 /* If the `typename' keyword is in effect and DECL is not a type
18329 decl, then type is non existent. */
18331 ;
18333 {
18337 /* If the next token is a semicolon, this must be a specialization,
18338 instantiation, or friend declaration. Check the scope while we
18339 still know whether or not we had a nested-name-specifier. */
18344 }
18347 }
18350 {
18355 {
18358 }
18360 /* For a `typename', we needn't call xref_tag. */
18366 /* Template parameter lists apply only if we are not within a
18367 function parameter list. */
18368 bool template_parm_lists_apply
18377 /* Look up a qualified name in the usual way. */
18379 {
18380 tree decl;
18381 tree ambiguous_decls;
18384 tag_type,
18391 /* If the lookup was ambiguous, an error will already have been
18392 issued. */
18396 /* If we are parsing friend declaration, DECL may be a
18397 TEMPLATE_DECL tree node here. However, we need to check
18398 whether this TEMPLATE_DECL results in valid code. Consider
18399 the following example:
18401 namespace N {
18402 template <class T> class C {};
18403 }
18404 class X {
18405 template <class T> friend class N::C; // #1, valid code
18406 };
18407 template <class T> class Y {
18408 friend class N::C; // #2, invalid code
18409 };
18411 For both case #1 and #2, we arrive at a TEMPLATE_DECL after
18412 name lookup of `N::C'. We see that friend declaration must
18413 be template for the code to be valid. Note that
18414 processing_template_decl does not work here since it is
18415 always 1 for the above two cases. */
18417 decl = (cp_parser_maybe_treat_template_as_class
18422 {
18424 identifier,
18427 }
18430 {
18434 allow_template);
18438 }
18440 /* Forward declarations of nested types, such as
18442 class C1::C2;
18443 class C1::C2::C3;
18445 are invalid unless all components preceding the final '::'
18446 are complete. If all enclosing types are complete, these
18447 declarations become merely pointless.
18449 Invalid forward declarations of nested types are errors
18450 caught elsewhere in parsing. Those that are pointless arrive
18451 here. */
18458 }
18459 else
18460 {
18461 /* An elaborated-type-specifier sometimes introduces a new type and
18462 sometimes names an existing type. Normally, the rule is that it
18463 introduces a new type only if there is not an existing type of
18464 the same name already in scope. For example, given:
18466 struct S {};
18467 void f() { struct S s; }
18469 the `struct S' in the body of `f' is the same `struct S' as in
18470 the global scope; the existing definition is used. However, if
18471 there were no global declaration, this would introduce a new
18472 local class named `S'.
18474 An exception to this rule applies to the following code:
18476 namespace N { struct S; }
18478 Here, the elaborated-type-specifier names a new type
18479 unconditionally; even if there is already an `S' in the
18480 containing scope this declaration names a new type.
18481 This exception only applies if the elaborated-type-specifier
18482 forms the complete declaration:
18484 [class.name]
18486 A declaration consisting solely of `class-key identifier ;' is
18487 either a redeclaration of the name in the current scope or a
18488 forward declaration of the identifier as a class name. It
18489 introduces the name into the current scope.
18491 We are in this situation precisely when the next token is a `;'.
18493 An exception to the exception is that a `friend' declaration does
18494 *not* name a new type; i.e., given:
18496 struct S { friend struct T; };
18498 `T' is not a new type in the scope of `S'.
18500 Also, `new struct S' or `sizeof (struct S)' never results in the
18501 definition of a new type; a new type can only be declared in a
18502 declaration context. */
18504 tag_scope ts;
18508 /* Friends have special name lookup rules. */
18512 CPP_SEMICOLON))
18513 /* This is a `class-key identifier ;' */
18515 else
18518 template_p =
18519 (template_parm_lists_apply
18522 /* An unqualified name was used to reference this type, so
18523 there were no qualifying templates. */
18532 }
18533 }
18538 /* Allow attributes on forward declarations of classes. */
18540 {
18550 else
18553 }
18556 {
18557 /* Indicate whether this class was declared as a `class' or as a
18558 `struct'. */
18562 }
18564 /* A "<" cannot follow an elaborated type specifier. If that
18565 happens, the user was probably trying to form a template-id. */
18570 }
18572 /* Parse an enum-specifier.
18574 enum-specifier:
18575 enum-head { enumerator-list [opt] }
18576 enum-head { enumerator-list , } [C++0x]
18578 enum-head:
18579 enum-key identifier [opt] enum-base [opt]
18580 enum-key nested-name-specifier identifier enum-base [opt]
18582 enum-key:
18583 enum
18584 enum class [C++0x]
18585 enum struct [C++0x]
18587 enum-base: [C++0x]
18588 : type-specifier-seq
18590 opaque-enum-specifier:
18591 enum-key identifier enum-base [opt] ;
18593 GNU Extensions:
18594 enum-key attributes[opt] identifier [opt] enum-base [opt]
18595 { enumerator-list [opt] }attributes[opt]
18596 enum-key attributes[opt] identifier [opt] enum-base [opt]
18597 { enumerator-list, }attributes[opt] [C++0x]
18599 Returns an ENUM_TYPE representing the enumeration, or NULL_TREE
18600 if the token stream isn't an enum-specifier after all. */
18602 static tree
18604 {
18605 tree identifier;
18607 tree prev_scope;
18609 tree attributes;
18622 /* Parse tentatively so that we can back up if we don't find a
18623 enum-specifier. */
18626 /* Caller guarantees that the current token is 'enum', an identifier
18627 possibly follows, and the token after that is an opening brace.
18628 If we don't have an identifier, fabricate an anonymous name for
18629 the enumeration being defined. */
18632 /* Parse the "class" or "struct", which indicates a scoped
18633 enumeration type in C++0x. */
18636 {
18640 /* Consume the `struct' or `class' token. */
18644 }
18648 /* Clear the qualification. */
18653 /* Figure out in what scope the declaration is being placed. */
18659 nested_name_specifier
18667 {
18668 tree name;
18672 enum_type,
18677 input_location);
18679 {
18682 {
18683 /* Are template enums allowed in ISO? */
18687 /* ignore a typename reference, for it will be solved by name
18688 in start_enum. */
18690 }
18691 }
18694 else
18695 {
18700 }
18701 }
18702 else
18703 {
18706 else
18707 {
18713 }
18714 }
18717 /* Check for the `:' that denotes a specified underlying type in C++0x.
18718 Note that a ':' could also indicate a bitfield width, however. */
18720 {
18721 cp_decl_specifier_seq type_specifiers;
18723 /* Consume the `:'. */
18726 /* Parse the type-specifier-seq. */
18732 /* At this point this is surely not elaborated type specifier. */
18741 /* If that didn't work, stop. */
18743 {
18749 }
18750 }
18752 /* Look for the `{' but don't consume it yet. */
18754 {
18756 {
18759 {
18762 }
18763 }
18764 /* An opaque-enum-specifier must have a ';' here. */
18767 {
18770 {
18773 }
18774 }
18775 }
18781 {
18783 {
18787 }
18789 {
18791 }
18792 }
18794 /* Issue an error message if type-definitions are forbidden here. */
18797 else
18798 /* Create the new type. We do this before consuming the opening
18799 brace so the enum will be recorded as being on the line of its
18800 tag (or the 'enum' keyword, if there is no tag). */
18804 /* If the next token is not '{' it is an opaque-enum-specifier or an
18805 elaborated-type-specifier. */
18807 {
18811 {
18812 /* The following catches invalid code such as:
18813 enum class S<int>::E { A, B, C }; */
18821 {
18825 nested_name_specifier);
18827 }
18830 {
18832 "%qT for enum declaration does not name a class "
18835 }
18836 /* If that scope does not contain the scope in which the
18837 class was originally declared, the program is invalid. */
18839 nested_name_specifier))
18840 {
18843 "declaration of %qD in namespace %qD which does not "
18846 else
18848 "declaration of %qD in %qD which does not "
18852 }
18853 /* If that scope is the scope where the declaration is being placed
18854 the program is invalid. */
18858 {
18862 }
18863 }
18868 /* Consume the opening brace. */
18869 matching_braces braces;
18876 {
18880 }
18881 else
18882 {
18888 }
18892 /* If the next token is not '}', then there are some enumerators. */
18894 {
18898 }
18899 else
18902 /* Consume the final '}'. */
18908 }
18909 else
18910 {
18911 /* If a ';' follows, then it is an opaque-enum-specifier
18912 and additional restrictions apply. */
18914 {
18921 }
18922 }
18924 /* Look for trailing attributes to apply to this enumeration, and
18925 apply them if appropriate. */
18927 {
18930 trailing_attr,
18932 }
18934 /* Finish up the enumeration. */
18936 {
18941 }
18944 {
18946 {
18949 }
18951 {
18953 }
18954 }
18955 out:
18958 }
18960 /* Parse an enumerator-list. The enumerators all have the indicated
18961 TYPE.
18963 enumerator-list:
18964 enumerator-definition
18965 enumerator-list , enumerator-definition */
18967 static void
18969 {
18971 {
18972 /* Parse an enumerator-definition. */
18975 /* If the next token is not a ',', we've reached the end of
18976 the list. */
18979 /* Otherwise, consume the `,' and keep going. */
18981 /* If the next token is a `}', there is a trailing comma. */
18983 {
18988 }
18989 }
18990 }
18992 /* Parse an enumerator-definition. The enumerator has the indicated
18993 TYPE.
18995 enumerator-definition:
18996 enumerator
18997 enumerator = constant-expression
18999 enumerator:
19000 identifier
19002 GNU Extensions:
19004 enumerator-definition:
19005 enumerator attributes [opt]
19006 enumerator attributes [opt] = constant-expression */
19008 static void
19010 {
19011 tree identifier;
19012 tree value;
19013 location_t loc;
19015 /* Save the input location because we are interested in the location
19016 of the identifier and not the location of the explicit value. */
19019 /* Look for the identifier. */
19024 /* Parse any specified attributes. */
19027 /* If the next token is an '=', then there is an explicit value. */
19029 {
19030 /* Consume the `=' token. */
19032 /* Parse the value. */
19034 }
19035 else
19038 /* If we are processing a template, make sure the initializer of the
19039 enumerator doesn't contain any bare template parameter pack. */
19043 /* Create the enumerator. */
19045 }
19047 /* Parse a namespace-name.
19049 namespace-name:
19050 original-namespace-name
19051 namespace-alias
19053 Returns the NAMESPACE_DECL for the namespace. */
19055 static tree
19057 {
19058 tree identifier;
19059 tree namespace_decl;
19063 /* Get the name of the namespace. */
19068 /* Look up the identifier in the currently active scope. Look only
19069 for namespaces, due to:
19071 [basic.lookup.udir]
19073 When looking up a namespace-name in a using-directive or alias
19074 definition, only namespace names are considered.
19076 And:
19078 [basic.lookup.qual]
19080 During the lookup of a name preceding the :: scope resolution
19081 operator, object, function, and enumerator names are ignored.
19083 (Note that cp_parser_qualifying_entity only calls this
19084 function if the token after the name is the scope resolution
19085 operator.) */
19087 none_type,
19093 /* If it's not a namespace, issue an error. */
19096 {
19098 {
19099 auto_diagnostic_group d;
19100 name_hint hint;
19104 identifier,
19107 {
19113 }
19114 else
19116 identifier);
19117 }
19118 else
19121 }
19124 }
19126 /* Parse a namespace-definition.
19128 namespace-definition:
19129 named-namespace-definition
19130 unnamed-namespace-definition
19132 named-namespace-definition:
19133 original-namespace-definition
19134 extension-namespace-definition
19136 original-namespace-definition:
19137 namespace identifier { namespace-body }
19139 extension-namespace-definition:
19140 namespace original-namespace-name { namespace-body }
19142 unnamed-namespace-definition:
19143 namespace { namespace-body } */
19145 static void
19147 {
19148 tree identifier;
19158 {
19161 }
19163 /* Look for the `namespace' keyword. */
19164 cp_token* token
19167 /* Parse any specified attributes before the identifier. */
19171 {
19175 RID_INLINE);
19177 {
19183 }
19186 {
19191 "standard attributes on namespaces must precede "
19194 /* Parse any attributes specified after the identifier. */
19196 }
19199 {
19200 /* Don't forget that the innermost namespace might have been
19201 marked as inline. Use |= because we cannot overwrite
19202 IS_INLINE in case the outermost namespace is inline, but
19203 there are no nested inlines. */
19206 }
19210 "nested namespace definitions only available with "
19213 /* Nested namespace names can create new namespaces (unlike
19214 other qualified-ids). */
19219 else
19222 }
19234 /* Start the namespace. */
19241 /* Look for the `{' to validate starting the namespace. */
19242 matching_braces braces;
19244 {
19245 /* Parse the body of the namespace. */
19248 /* Look for the final `}'. */
19250 }
19255 /* Pop the nested namespace definitions. */
19258 }
19260 /* Parse a namespace-body.
19262 namespace-body:
19263 declaration-seq [opt] */
19265 static void
19267 {
19269 }
19271 /* Parse a namespace-alias-definition.
19273 namespace-alias-definition:
19274 namespace identifier = qualified-namespace-specifier ; */
19276 static void
19278 {
19279 tree identifier;
19280 tree namespace_specifier;
19284 /* Look for the `namespace' keyword. */
19286 /* Look for the identifier. */
19290 /* Look for the `=' token. */
19293 {
19295 /* Skip the definition. */
19300 }
19302 /* Look for the qualified-namespace-specifier. */
19303 namespace_specifier
19305 /* Look for the `;' token. */
19308 /* Register the alias in the symbol table. */
19310 }
19312 /* Parse a qualified-namespace-specifier.
19314 qualified-namespace-specifier:
19315 :: [opt] nested-name-specifier [opt] namespace-name
19317 Returns a NAMESPACE_DECL corresponding to the specified
19318 namespace. */
19320 static tree
19322 {
19323 /* Look for the optional `::'. */
19327 /* Look for the optional nested-name-specifier. */
19335 }
19337 /* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an
19338 access declaration.
19340 using-declaration:
19341 using typename [opt] :: [opt] nested-name-specifier unqualified-id ;
19342 using :: unqualified-id ;
19344 access-declaration:
19345 qualified-id ;
19347 */
19349 static bool
19352 {
19356 tree decl;
19357 tree identifier;
19358 tree qscope;
19363 {
19366 }
19367 else
19368 {
19369 /* Look for the `using' keyword. */
19372 again:
19373 /* Peek at the next token. */
19375 /* See if it's `typename'. */
19377 {
19378 /* Remember that we've seen it. */
19380 /* Consume the `typename' token. */
19382 }
19383 }
19385 /* Look for the optional global scope qualification. */
19386 global_scope_p
19391 /* If we saw `typename', or didn't see `::', then there must be a
19392 nested-name-specifier present. */
19394 {
19400 {
19403 }
19404 }
19405 /* Otherwise, we could be in either of the two productions. In that
19406 case, treat the nested-name-specifier as optional. */
19407 else
19420 /* Something has already gone wrong; there's no need to parse
19421 further. Since an error has occurred, the return value of
19422 cp_parser_parse_definitely will be false, as required. */
19426 /* Parse the unqualified-id. */
19434 {
19439 }
19441 {
19446 "pack expansion in using-declaration only available "
19449 }
19451 /* The function we call to handle a using-declaration is different
19452 depending on what scope we are in. */
19454 ;
19457 /* [namespace.udecl]
19459 A using declaration shall not name a template-id. */
19462 else
19463 {
19465 {
19466 /* Create the USING_DECL. */
19473 {
19476 }
19477 else
19478 /* Add it to the list of members in this class. */
19480 }
19481 else
19482 {
19484 identifier,
19491 {
19494 }
19497 else
19499 }
19500 }
19504 {
19508 "comma-separated list in using-declaration only available "
19511 }
19513 /* Look for the final `;'. */
19518 "access declarations are deprecated "
19519 "in favour of using-declarations; "
19523 }
19525 /* Parse an alias-declaration.
19527 alias-declaration:
19528 using identifier attribute-specifier-seq [opt] = type-id */
19530 static tree
19532 {
19536 cp_decl_specifier_seq decl_specs;
19540 /* Look for the `using' keyword. */
19541 cp_token *using_token
19563 /* Now we are going to parse the type-id of the declaration. */
19565 /*
19566 [dcl.type]/3 says:
19568 "A type-specifier-seq shall not define a class or enumeration
19569 unless it appears in the type-id of an alias-declaration (7.1.3) that
19570 is not the declaration of a template-declaration."
19572 In other words, if we currently are in an alias template, the
19573 type-id should not define a type.
19575 So let's set parser->type_definition_forbidden_message in that
19576 case; cp_parser_check_type_definition (called by
19577 cp_parser_class_specifier) will then emit an error if a type is
19578 defined in the type-id. */
19580 {
19584 }
19589 /* Restore the error message if need be. */
19595 {
19598 }
19600 /* A typedef-name can also be introduced by an alias-declaration. The
19601 identifier following the using keyword becomes a typedef-name. It has
19602 the same semantics as if it were introduced by the typedef
19603 specifier. In particular, it does not define a new type and it shall
19604 not appear in the type-id. */
19609 {
19612 ds_attribute,
19613 attrs_token);
19614 }
19616 ds_typedef,
19617 using_token);
19619 ds_alias,
19620 using_token);
19627 id_location,
19637 else
19643 // Attach constraints to the alias declaration.
19645 {
19649 }
19656 /* If decl is a template, return its TEMPLATE_DECL so that it gets
19657 added into the symbol table; otherwise, return the TYPE_DECL. */
19661 {
19665 }
19668 }
19670 /* Parse a using-directive.
19672 using-directive:
19673 using namespace :: [opt] nested-name-specifier [opt]
19674 namespace-name ; */
19676 static void
19678 {
19679 tree namespace_decl;
19680 tree attribs;
19682 /* Look for the `using' keyword. */
19684 /* And the `namespace' keyword. */
19686 /* Look for the optional `::' operator. */
19688 /* And the optional nested-name-specifier. */
19694 /* Get the namespace being used. */
19696 /* And any specified attributes. */
19699 /* Update the symbol table. */
19702 else
19705 /* Look for the final `;'. */
19707 }
19709 /* Parse an asm-definition.
19711 asm-qualifier:
19712 volatile
19713 inline
19714 goto
19716 asm-qualifier-list:
19717 asm-qualifier
19718 asm-qualifier-list asm-qualifier
19720 asm-definition:
19721 asm ( string-literal ) ;
19723 GNU Extension:
19725 asm-definition:
19726 asm asm-qualifier-list [opt] ( string-literal ) ;
19727 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt] ) ;
19728 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
19729 : asm-operand-list [opt] ) ;
19730 asm asm-qualifier-list [opt] ( string-literal : asm-operand-list [opt]
19731 : asm-operand-list [opt]
19732 : asm-clobber-list [opt] ) ;
19733 asm asm-qualifier-list [opt] ( string-literal : : asm-operand-list [opt]
19734 : asm-clobber-list [opt]
19735 : asm-goto-list ) ;
19737 The form with asm-goto-list is valid if and only if the asm-qualifier-list
19738 contains goto, and is the only allowed form in that case. No duplicates are
19739 allowed in an asm-qualifier-list. */
19741 static void
19743 {
19744 tree string;
19749 tree asm_stmt;
19755 /* Look for the `asm' keyword. */
19760 {
19763 }
19765 /* Handle the asm-qualifier-list. */
19772 {
19776 {
19779 {
19782 }
19783 else
19790 {
19793 }
19794 else
19801 {
19804 }
19805 else
19818 }
19820 }
19826 /* Look for the opening `('. */
19829 /* Look for the string. */
19832 {
19836 }
19838 /* If we're allowing GNU extensions, check for the extended assembly
19839 syntax. Unfortunately, the `:' tokens need not be separated by
19840 a space in C, and so, for compatibility, we tolerate that here
19841 too. Doing that means that we have to treat the `::' operator as
19842 two `:' tokens. */
19847 {
19852 /* The extended syntax was used. */
19855 /* Look for outputs. */
19857 {
19858 /* Consume the `:'. */
19860 /* Parse the output-operands. */
19862 CPP_COLON)
19864 CPP_SCOPE)
19866 CPP_CLOSE_PAREN)
19868 {
19872 }
19873 }
19874 /* If the next token is `::', there are no outputs, and the
19875 next token is the beginning of the inputs. */
19877 /* The inputs are coming next. */
19880 /* Look for inputs. */
19883 {
19884 /* Consume the `:' or `::'. */
19886 /* Parse the output-operands. */
19888 CPP_COLON)
19890 CPP_SCOPE)
19892 CPP_CLOSE_PAREN))
19893 {
19897 }
19898 }
19900 /* The clobbers are coming next. */
19903 /* Look for clobbers. */
19906 {
19908 /* Consume the `:' or `::'. */
19910 /* Parse the clobbers. */
19912 CPP_COLON)
19914 CPP_CLOSE_PAREN))
19916 }
19918 /* The labels are coming next. */
19921 /* Look for labels. */
19924 {
19926 /* Consume the `:' or `::'. */
19928 /* Parse the labels. */
19930 }
19934 }
19938 /* Look for the closing `)'. */
19946 {
19947 /* Create the ASM_EXPR. */
19949 {
19952 /* If the extended syntax was not used, mark the ASM_EXPR. */
19954 {
19960 }
19961 }
19962 else
19964 }
19965 }
19967 /* Given the type TYPE of a declaration with declarator DECLARATOR, return the
19968 type that comes from the decl-specifier-seq. */
19970 static tree
19972 {
19975 {
19988 }
19991 }
19993 /* Declarators [gram.dcl.decl] */
19995 /* Parse an init-declarator.
19997 init-declarator:
19998 declarator initializer [opt]
20000 GNU Extension:
20002 init-declarator:
20003 declarator asm-specification [opt] attributes [opt] initializer [opt]
20005 function-definition:
20006 decl-specifier-seq [opt] declarator ctor-initializer [opt]
20007 function-body
20008 decl-specifier-seq [opt] declarator function-try-block
20010 GNU Extension:
20012 function-definition:
20013 __extension__ function-definition
20015 TM Extension:
20017 function-definition:
20018 decl-specifier-seq [opt] declarator function-transaction-block
20020 The parser flags FLAGS is used to control type-specifier parsing.
20022 The DECL_SPECIFIERS apply to this declarator. Returns a
20023 representation of the entity declared. If MEMBER_P is TRUE, then
20024 this declarator appears in a class scope. The new DECL created by
20025 this declarator is returned.
20027 The CHECKS are access checks that should be performed once we know
20028 what entity is being declared (and, therefore, what classes have
20029 befriended it).
20031 If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and
20032 for a function-definition here as well. If the declarator is a
20033 declarator for a function-definition, *FUNCTION_DEFINITION_P will
20034 be TRUE upon return. By that point, the function-definition will
20035 have been completely parsed.
20037 FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P
20038 is FALSE.
20040 If MAYBE_RANGE_FOR_DECL is not NULL, the pointed tree will be set to the
20041 parsed declaration if it is an uninitialized single declarator not followed
20042 by a `;', or to error_mark_node otherwise. Either way, the trailing `;',
20043 if present, will not be consumed. If returned, this declarator will be
20044 created with SD_INITIALIZED but will not call cp_finish_decl.
20046 If INIT_LOC is not NULL, and *INIT_LOC is equal to UNKNOWN_LOCATION,
20047 and there is an initializer, the pointed location_t is set to the
20048 location of the '=' or `(', or '{' in C++11 token introducing the
20049 initializer. */
20051 static tree
20053 cp_parser_flags flags,
20063 {
20067 tree prefix_attributes;
20069 tree asm_specification;
20070 tree initializer;
20072 tree scope;
20074 /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if
20075 initialized with "= ..", CPP_OPEN_PAREN if initialized with
20076 "(...)". */
20087 /* Gather the attributes that were provided with the
20088 decl-specifiers. */
20091 /* Assume that this is not the declarator for a function
20092 definition. */
20096 /* Default arguments are only permitted for function parameters. */
20100 /* Defer access checks while parsing the declarator; we cannot know
20101 what names are accessible until we know what is being
20102 declared. */
20107 /* Parse the declarator. */
20108 declarator
20113 /* Gather up the deferred checks. */
20118 /* If the DECLARATOR was erroneous, there's no need to go
20119 further. */
20123 /* Check that the number of template-parameter-lists is OK. */
20133 /* Figure out what scope the entity declared by the DECLARATOR is
20134 located in. `grokdeclarator' sometimes changes the scope, so
20135 we compute it now. */
20138 /* Perform any lookups in the declared type which were thought to be
20139 dependent, but are not in the scope of the declarator. */
20140 decl_specifiers->type
20143 /* If we're allowing GNU extensions, look for an
20144 asm-specification. */
20146 {
20147 /* Look for an asm-specification. */
20150 }
20151 else
20154 /* Look for attributes. */
20158 /* Peek at the next token. */
20164 {
20165 /* Handle C++17 deduction guides. */
20169 {
20177 {
20181 }
20182 }
20184 /* Check to see if the token indicates the start of a
20185 function-definition. */
20187 {
20189 {
20190 /* If a function-definition should not appear here, issue an
20191 error message. */
20195 }
20197 location_t func_brace_location
20200 /* Neither attributes nor an asm-specification are allowed
20201 on a function-definition. */
20204 "an asm-specification is not allowed "
20208 "attributes are not allowed "
20210 /* This is a function-definition. */
20213 /* Parse the function definition. */
20216 decl_specifiers,
20217 declarator,
20218 prefix_attributes);
20219 else
20220 decl =
20221 (cp_parser_function_definition_from_specifiers_and_declarator
20225 {
20226 /* This is where the prologue starts... */
20229 }
20232 }
20233 }
20235 {
20236 /* A non-template declaration involving a function parameter list
20237 containing an implicit template parameter will be made into a
20238 template. If the resulting declaration is not going to be an
20239 actual function then finish the template scope here to prevent it.
20240 An error message will be issued once we have a decl to talk about.
20242 FIXME probably we should do type deduction rather than create an
20243 implicit template, but the standard currently doesn't allow it. */
20246 }
20248 /* [dcl.dcl]
20250 Only in function declarations for constructors, destructors, type
20251 conversions, and deduction guides can the decl-specifier-seq be omitted.
20253 We explicitly postpone this check past the point where we handle
20254 function-definitions because we tolerate function-definitions
20255 that are missing their return types in some modes. */
20257 {
20261 }
20263 /* An `=' or an `(', or an '{' in C++0x, indicates an initializer. */
20267 {
20278 {
20284 }
20285 }
20286 else
20287 {
20288 /* If the init-declarator isn't initialized and isn't followed by a
20289 `,' or `;', it's not a valid init-declarator. */
20292 {
20295 else
20296 {
20300 }
20301 }
20304 }
20306 /* Because start_decl has side-effects, we should only call it if we
20307 know we're going ahead. By this point, we know that we cannot
20308 possibly be looking at any other construct. */
20311 /* Enter the newly declared entry in the symbol table. If we're
20312 processing a declaration in a class-specifier, we wait until
20313 after processing the initializer. */
20315 {
20323 /* Adjust location of decl if declarator->id_loc is more appropriate:
20324 set, and decl wasn't merged with another decl, in which case its
20325 location would be different from input_location, and more accurate. */
20330 }
20332 /* Enter the SCOPE. That way unqualified names appearing in the
20333 initializer will be looked up in SCOPE. */
20336 /* Perform deferred access control checks, now that we know in which
20337 SCOPE the declared entity resides. */
20339 {
20342 /* If the entity being declared is a function, pretend that we
20343 are in its scope. If it is a `friend', it may have access to
20344 things that would not otherwise be accessible. */
20346 {
20349 }
20351 /* Perform access checks for template parameters. */
20354 /* Perform the access control checks for the declarator and the
20355 decl-specifiers. */
20358 /* Restore the saved value. */
20361 }
20363 /* Parse the initializer. */
20368 {
20370 {
20373 else
20374 {
20375 /* If the declaration was erroneous, we don't really
20376 know what the user intended, so just silently
20377 consume the initializer. */
20384 }
20385 }
20386 else
20387 {
20388 /* We want to record the extra mangling scope for in-class
20389 initializers of class members and initializers of static data
20390 member templates. The former involves deferring
20391 parsing of the initializer until end of class as with default
20392 arguments. So right here we only handle the latter. */
20402 }
20403 }
20405 /* The old parser allows attributes to appear after a parenthesized
20406 initializer. Mark Mitchell proposed removing this functionality
20407 on the GCC mailing lists on 2002-08-13. This parser accepts the
20408 attributes -- but ignores them. Made a permerror in GCC 8. */
20414 {
20417 {
20421 }
20422 }
20424 /* And now complain about a non-function implicit template. */
20429 /* For an in-class declaration, use `grokfield' to create the
20430 declaration. */
20432 {
20434 {
20437 }
20446 }
20448 /* Finish processing the declaration. But, skip member
20449 declarations. */
20451 {
20454 asm_specification,
20455 /* If the initializer is in parentheses, then this is
20456 a direct-initialization, which means that an
20457 `explicit' constructor is OK. Otherwise, an
20458 `explicit' constructor cannot be used. */
20461 }
20464 /* Core issue #226 (C++0x only): A default template-argument
20465 shall not be specified in a friend class template
20466 declaration. */
20475 {
20478 else
20480 }
20487 }
20489 /* Parse a declarator.
20491 declarator:
20492 direct-declarator
20493 ptr-operator declarator
20495 abstract-declarator:
20496 ptr-operator abstract-declarator [opt]
20497 direct-abstract-declarator
20499 GNU Extensions:
20501 declarator:
20502 attributes [opt] direct-declarator
20503 attributes [opt] ptr-operator declarator
20505 abstract-declarator:
20506 attributes [opt] ptr-operator abstract-declarator [opt]
20507 attributes [opt] direct-abstract-declarator
20509 The parser flags FLAGS is used to control type-specifier parsing.
20511 If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to
20512 detect constructors, destructors, deduction guides, or conversion operators.
20513 It is set to -1 if the declarator is a name, and +1 if it is a
20514 function. Otherwise it is set to zero. Usually you just want to
20515 test for >0, but internally the negative value is used.
20517 (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have
20518 a decl-specifier-seq unless it declares a constructor, destructor,
20519 or conversion. It might seem that we could check this condition in
20520 semantic analysis, rather than parsing, but that makes it difficult
20521 to handle something like `f()'. We want to notice that there are
20522 no decl-specifiers, and therefore realize that this is an
20523 expression, not a declaration.)
20525 If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff
20526 the declarator is a direct-declarator of the form "(...)".
20528 MEMBER_P is true iff this declarator is a member-declarator.
20530 FRIEND_P is true iff this declarator is a friend.
20532 STATIC_P is true iff the keyword static was seen. */
20536 cp_parser_declarator_kind dcl_kind,
20537 cp_parser_flags flags,
20541 {
20544 cp_cv_quals cv_quals;
20545 tree class_type;
20548 /* Assume this is not a constructor, destructor, or type-conversion
20549 operator. */
20556 /* Check for the ptr-operator production. */
20558 /* Parse the ptr-operator. */
20564 /* If that worked, then we have a ptr-operator. */
20566 {
20567 /* If a ptr-operator was found, then this declarator was not
20568 parenthesized. */
20571 /* The dependent declarator is optional if we are parsing an
20572 abstract-declarator. */
20576 /* Parse the dependent declarator. */
20578 CP_PARSER_FLAGS_NONE,
20584 /* If we are parsing an abstract-declarator, we must handle the
20585 case where the dependent declarator is absent. */
20590 declarator = cp_parser_make_indirect_declarator
20592 }
20593 /* Everything else is a direct-declarator. */
20594 else
20595 {
20598 CPP_OPEN_PAREN);
20602 }
20607 }
20609 /* Parse a direct-declarator or direct-abstract-declarator.
20611 direct-declarator:
20612 declarator-id
20613 direct-declarator ( parameter-declaration-clause )
20614 cv-qualifier-seq [opt]
20615 ref-qualifier [opt]
20616 exception-specification [opt]
20617 direct-declarator [ constant-expression [opt] ]
20618 ( declarator )
20620 direct-abstract-declarator:
20621 direct-abstract-declarator [opt]
20622 ( parameter-declaration-clause )
20623 cv-qualifier-seq [opt]
20624 ref-qualifier [opt]
20625 exception-specification [opt]
20626 direct-abstract-declarator [opt] [ constant-expression [opt] ]
20627 ( abstract-declarator )
20629 Returns a representation of the declarator. DCL_KIND is
20630 CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a
20631 direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if
20632 we are parsing a direct-declarator. It is
20633 CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case
20634 of ambiguity we prefer an abstract declarator, as per
20635 [dcl.ambig.res].
20636 The parser flags FLAGS is used to control type-specifier parsing.
20637 CTOR_DTOR_OR_CONV_P, MEMBER_P, FRIEND_P, and STATIC_P are
20638 as for cp_parser_declarator. */
20642 cp_parser_declarator_kind dcl_kind,
20643 cp_parser_flags flags,
20646 {
20657 {
20658 /* Peek at the next token. */
20661 {
20662 /* This is either a parameter-declaration-clause, or a
20663 parenthesized declarator. When we know we are parsing a
20664 named declarator, it must be a parenthesized declarator
20665 if FIRST is true. For instance, `(int)' is a
20666 parameter-declaration-clause, with an omitted
20667 direct-abstract-declarator. But `((*))', is a
20668 parenthesized abstract declarator. Finally, when T is a
20669 template parameter `(T)' is a
20670 parameter-declaration-clause, and not a parenthesized
20671 named declarator.
20673 We first try and parse a parameter-declaration-clause,
20674 and then try a nested declarator (if FIRST is true).
20676 It is not an error for it not to be a
20677 parameter-declaration-clause, even when FIRST is
20678 false. Consider,
20680 int i (int);
20681 int i (3);
20683 The first is the declaration of a function while the
20684 second is the definition of a variable, including its
20685 initializer.
20687 Having seen only the parenthesis, we cannot know which of
20688 these two alternatives should be selected. Even more
20689 complex are examples like:
20691 int i (int (a));
20692 int i (int (3));
20694 The former is a function-declaration; the latter is a
20695 variable initialization.
20697 Thus again, we try a parameter-declaration-clause, and if
20698 that fails, we back out and return. */
20701 {
20702 tree params;
20707 /* In a member-declarator, the only valid interpretation
20708 of a parenthesis is the start of a
20709 parameter-declaration-clause. (It is invalid to
20710 initialize a static data member with a parenthesized
20711 initializer; only the "=" form of initialization is
20712 permitted.) */
20716 /* Consume the `('. */
20717 matching_parens parens;
20720 {
20721 /* If this is going to be an abstract declarator, we're
20722 in a declarator and we can't have default args. */
20725 }
20729 /* Parse the parameter-declaration-clause. */
20730 params
20733 /* Consume the `)'. */
20736 /* If all went well, parse the cv-qualifier-seq,
20737 ref-qualifier and the exception-specification. */
20739 {
20740 cp_cv_quals cv_quals;
20741 cp_virt_specifiers virt_specifiers;
20742 cp_ref_qualifier ref_qual;
20743 tree exception_specification;
20744 tree late_return;
20745 tree attrs;
20748 unsigned char local_variables_forbidden_p
20750 /* 'this' is not allowed in static member functions. */
20760 /* Parse the cv-qualifier-seq. */
20762 /* Parse the ref-qualifier. */
20764 /* Parse the tx-qualifier. */
20766 /* And the exception-specification. */
20767 exception_specification
20772 /* In here, we handle cases where attribute is used after
20773 the function declaration. For example:
20774 void func (int x) __attribute__((vector(..))); */
20777 late_return = (cp_parser_late_return_type_opt
20781 /* Parse the virt-specifier-seq. */
20784 /* Create the function-declarator. */
20786 params,
20787 cv_quals,
20788 virt_specifiers,
20789 ref_qual,
20790 tx_qual,
20791 exception_specification,
20792 late_return,
20793 requires_clause);
20796 /* Any subsequent parameter lists are to do with
20797 return type, so are not those of the declared
20798 function. */
20801 /* Restore the state of local_variables_forbidden_p. */
20802 parser->local_variables_forbidden_p
20804 }
20806 /* Remove the function parms from scope. */
20810 /* Repeat the main loop. */
20812 }
20814 /* If this is the first, we can try a parenthesized
20815 declarator. */
20817 {
20824 /* Consume the `('. */
20825 matching_parens parens;
20827 /* Parse the nested declarator. */
20830 declarator
20832 ctor_dtor_or_conv_p,
20838 /* Expect a `)'. */
20846 }
20847 /* Otherwise, we must be done. */
20848 else
20850 }
20854 {
20855 /* Parse an array-declarator. */
20865 /* Consume the `['. */
20867 /* Peek at the next token. */
20869 /* If the next token is `]', then there is no
20870 constant-expression. */
20872 {
20874 bounds
20884 {
20885 /* Normally, the array bound must be an integral constant
20886 expression. However, as an extension, we allow VLAs
20887 in function scopes as long as they aren't part of a
20888 parameter declaration. */
20892 }
20895 {
20896 /* Remember this wasn't a constant-expression. */
20899 }
20900 }
20901 else
20903 /* Look for the closing `]'. */
20905 {
20908 }
20913 }
20915 {
20916 {
20917 tree qualifying_scope;
20918 tree unqualified_name;
20919 tree attrs;
20920 special_function_kind sfk;
20925 /* Parse a declarator-id */
20928 {
20931 /* If we see an ellipsis, we should be looking at a
20932 parameter pack. */
20934 {
20935 /* Consume the `...' */
20939 }
20940 }
20943 unqualified_name
20947 {
20951 {
20952 /* Check whether an error occurred. */
20955 /* We already consumed the ellipsis to mark a
20956 parameter pack, but we have no way to report it,
20957 so abort the tentative parse. We will be exiting
20958 immediately anyway. */
20960 }
20961 else
20967 && (qualifying_scope
20969 {
20972 }
20973 }
20978 {
20983 }
20989 {
20990 /* In the declaration of a member of a template class
20991 outside of the class itself, the SCOPE will sometimes
20992 be a TYPENAME_TYPE. For example, given:
20994 template <typename T>
20995 int S<T>::R::i = 3;
20997 the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In
20998 this context, we must resolve S<T>::R to an ordinary
20999 type, rather than a typename type.
21001 The reason we normally avoid resolving TYPENAME_TYPEs
21002 is that a specialization of `S' might render
21003 `S<T>::R' not a type. However, if `S' is
21004 specialized, then this `i' will not be used, so there
21005 is no harm in resolving the types here. */
21006 tree type;
21008 /* Resolve the TYPENAME_TYPE. */
21011 /* If that failed, the declarator is invalid. */
21013 {
21016 "cannot define member of dependent typedef "
21018 else
21023 }
21025 }
21030 {
21031 tree class_type;
21036 else
21040 {
21044 {
21045 /* We do not attempt to print the declarator
21046 here because we do not have enough
21047 information about its original syntactic
21048 form. */
21052 }
21055 {
21059 "use %<%T::%D%> instead of %<%T::%D%> to "
21061 class_type,
21066 }
21068 }
21071 {
21078 for an unnamed type, even if the type
21079 got a name for linkage purposes. */
21081 /* Handle correctly (c++/19200):
21083 struct S {
21084 struct T{};
21085 friend void S(T);
21086 };
21088 and also:
21090 namespace N {
21091 void S();
21092 }
21094 struct S {
21095 friend void N::S();
21096 }; */
21099 class_type))
21108 }
21109 }
21111 unqualified_name,
21119 /* We're looking for this case in [temp.res]:
21120 A qualified-id is assumed to name a type if [...]
21121 - it is a decl-specifier of the decl-specifier-seq of a
21122 parameter-declaration in a declarator of a function or
21123 function template declaration, ... */
21129 {
21130 /* ...whose declarator-id is qualified. If it isn't, never
21131 assume the parameters to refer to types. */
21134 else
21135 {
21136 /* Now we have something like
21137 template <typename T> int C::x(S::p);
21138 which can be a function template declaration or a
21139 variable template definition. If name lookup for
21140 the declarator-id C::x finds one or more function
21141 templates, assume S::p to name a type. Otherwise,
21142 don't. */
21143 tree decl
21148 }
21149 }
21150 }
21152 handle_declarator:;
21155 {
21156 /* Any names that appear after the declarator-id for a
21157 member are looked up in the containing scope. */
21159 {
21160 /* But declarations with qualified-ids can't appear in a
21161 function. */
21165 }
21167 }
21171 /* Default args are only allowed on function
21172 declarations. */
21174 else
21178 }
21179 /* We're done. */
21180 else
21182 }
21184 /* For an abstract declarator, we might wind up with nothing at this
21185 point. That's an error; the declarator is not optional. */
21189 {
21190 /* Record overly parenthesized declarator so we can give a
21191 diagnostic about confusing decl/expr disambiguation. */
21193 {
21194 /* If the open and close parens are on different lines, this
21195 is probably a formatting thing, so ignore. */
21200 }
21203 }
21205 /* If we entered a scope, we must exit it now. */
21213 }
21215 /* Parse a ptr-operator.
21217 ptr-operator:
21218 * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
21219 * cv-qualifier-seq [opt]
21220 &
21221 :: [opt] nested-name-specifier * cv-qualifier-seq [opt]
21222 nested-name-specifier * attribute-specifier-seq [opt] cv-qualifier-seq [opt] (C++11)
21224 GNU Extension:
21226 ptr-operator:
21227 & cv-qualifier-seq [opt]
21229 Returns INDIRECT_REF if a pointer, or pointer-to-member, was used.
21230 Returns ADDR_EXPR if a reference was used, or NON_LVALUE_EXPR for
21231 an rvalue reference. In the case of a pointer-to-member, *TYPE is
21232 filled in with the TYPE containing the member. *CV_QUALS is
21233 filled in with the cv-qualifier-seq, or TYPE_UNQUALIFIED, if there
21234 are no cv-qualifiers. Returns ERROR_MARK if an error occurred.
21235 Note that the tree codes returned by this function have nothing
21236 to do with the types of trees that will be eventually be created
21237 to represent the pointer or reference type being parsed. They are
21238 just constants with suggestive names. */
21239 static enum tree_code
21244 {
21249 /* Assume that it's not a pointer-to-member. */
21251 /* And that there are no cv-qualifiers. */
21254 /* Peek at the next token. */
21257 /* If it's a `*', `&' or `&&' we have a pointer or reference. */
21267 {
21268 /* Consume the `*', `&' or `&&'. */
21271 /* A `*' can be followed by a cv-qualifier-seq, and so can a
21272 `&', if we are allowing GNU extensions. (The only qualifier
21273 that can legally appear after `&' is `restrict', but that is
21274 enforced during semantic analysis. */
21282 }
21283 else
21284 {
21285 /* Try the pointer-to-member case. */
21287 /* Look for the optional `::' operator. */
21290 /* Look for the nested-name specifier. */
21297 /* If we found it, and the next token is a `*', then we are
21298 indeed looking at a pointer-to-member operator. */
21301 {
21302 /* Indicate that the `*' operator was used. */
21310 else
21311 {
21312 /* The type of which the member is a member is given by the
21313 current SCOPE. */
21315 /* The next name will not be qualified. */
21319 /* Look for optional c++11 attributes. */
21323 /* Look for the optional cv-qualifier-seq. */
21325 }
21326 }
21327 /* If that didn't work we don't have a ptr-operator. */
21330 }
21333 }
21335 /* Parse an (optional) cv-qualifier-seq.
21337 cv-qualifier-seq:
21338 cv-qualifier cv-qualifier-seq [opt]
21340 cv-qualifier:
21341 const
21342 volatile
21344 GNU Extension:
21346 cv-qualifier:
21347 __restrict__
21349 Returns a bitmask representing the cv-qualifiers. */
21351 static cp_cv_quals
21353 {
21357 {
21359 cp_cv_quals cv_qualifier;
21361 /* Peek at the next token. */
21363 /* See if it's a cv-qualifier. */
21365 {
21381 }
21387 {
21392 }
21393 else
21394 {
21397 }
21398 }
21401 }
21403 /* Parse an (optional) ref-qualifier
21405 ref-qualifier:
21406 &
21407 &&
21409 Returns cp_ref_qualifier representing ref-qualifier. */
21411 static cp_ref_qualifier
21413 {
21416 /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */
21421 {
21426 {
21438 }
21443 {
21446 }
21447 else
21448 {
21451 }
21452 }
21455 }
21457 /* Parse an optional tx-qualifier.
21459 tx-qualifier:
21460 transaction_safe
21461 transaction_safe_dynamic */
21463 static tree
21465 {
21468 {
21473 {
21477 {
21480 {
21483 }
21484 else
21486 }
21487 }
21488 }
21490 }
21492 /* Parse an (optional) virt-specifier-seq.
21494 virt-specifier-seq:
21495 virt-specifier virt-specifier-seq [opt]
21497 virt-specifier:
21498 override
21499 final
21501 Returns a bitmask representing the virt-specifiers. */
21503 static cp_virt_specifiers
21505 {
21509 {
21511 cp_virt_specifiers virt_specifier;
21513 /* Peek at the next token. */
21515 /* See if it's a virt-specifier-qualifier. */
21519 {
21522 }
21524 {
21527 }
21529 {
21531 }
21532 else
21536 {
21541 }
21542 else
21543 {
21546 }
21547 }
21549 }
21551 /* Used by handling of trailing-return-types and NSDMI, in which 'this'
21552 is in scope even though it isn't real. */
21554 void
21556 {
21557 tree this_parm;
21560 {
21561 /* We don't clear this between NSDMIs. Is it already what we want? */
21568 }
21571 /* Clear this first to avoid shortcut in cp_build_indirect_ref. */
21573 current_class_ref
21576 }
21578 /* Return true iff our current scope is a non-static data member
21579 initializer. */
21581 bool
21583 {
21584 /* We recognize NSDMI context by the context-less 'this' pointer set up
21585 by the function above. */
21591 }
21593 /* Parse a late-specified return type, if any. This is not a separate
21594 non-terminal, but part of a function declarator, which looks like
21596 -> trailing-type-specifier-seq abstract-declarator(opt)
21598 Returns the type indicated by the type-id.
21600 In addition to this, parse any queued up #pragma omp declare simd
21601 clauses, and #pragma acc routine clauses.
21603 QUALS is either a bitmask of cv_qualifiers or -1 for a non-member
21604 function. */
21606 static tree
21609 {
21613 && declarator
21617 && declarator
21620 /* Peek at the next token. */
21622 /* A late-specified return type is indicated by an initial '->'. */
21633 {
21634 /* DR 1207: 'this' is in scope in the trailing return type. */
21636 }
21639 {
21640 /* Consume the ->. */
21644 }
21646 /* Function declarations may be followed by a trailing
21647 requires-clause. */
21651 declarator->attributes
21655 declarator->attributes
21660 {
21663 }
21666 }
21668 /* Parse a declarator-id.
21670 declarator-id:
21671 id-expression
21672 :: [opt] nested-name-specifier [opt] type-name
21674 In the `id-expression' case, the value returned is as for
21675 cp_parser_id_expression if the id-expression was an unqualified-id.
21676 If the id-expression was a qualified-id, then a SCOPE_REF is
21677 returned. The first operand is the scope (either a NAMESPACE_DECL
21678 or TREE_TYPE), but the second is still just a representation of an
21679 unqualified-id. */
21681 static tree
21683 {
21684 tree id;
21685 /* The expression must be an id-expression. Assume that qualified
21686 names are the names of types so that:
21688 template <class T>
21689 int S<T>::R::i = 3;
21691 will work; we must treat `S<T>::R' as the name of a type.
21692 Similarly, assume that qualified names are templates, where
21693 required, so that:
21695 template <class T>
21696 int S<T>::R<T>::i = 3;
21698 will work, too. */
21704 optional_p);
21708 }
21710 /* Parse a type-id.
21712 type-id:
21713 type-specifier-seq abstract-declarator [opt]
21715 The parser flags FLAGS is used to control type-specifier parsing.
21717 If IS_TEMPLATE_ARG is true, we are parsing a template argument.
21719 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
21720 i.e. we've just seen "->".
21722 Returns the TYPE specified. */
21724 static tree
21728 {
21729 cp_decl_specifier_seq type_specifier_seq;
21732 /* Parse the type-specifier-seq. */
21735 is_trailing_return,
21743 /* A bare template name as a template argument is a template template
21744 argument, not a placeholder, so fail parsing it as a type argument. */
21745 {
21749 }
21753 /* There might or might not be an abstract declarator. */
21755 /* Look for the declarator. */
21756 abstract_declarator
21763 /* Check to see if there really was a declarator. */
21768 /* The concepts TS allows 'auto' as a type-id. */
21770 /* None of the valid uses of 'auto' in C++14 involve the type-id
21771 nonterminal, but it is valid in a trailing-return-type. */
21774 {
21775 /* A type-id with type 'auto' is only ok if the abstract declarator
21776 is a function declarator with a late-specified return type.
21778 A type-id with 'auto' is also valid in a trailing-return-type
21779 in a compound-requirement. */
21786 else
21787 {
21790 {
21792 auto_node);
21794 tmpl);
21795 }
21796 else
21799 }
21800 }
21803 is_template_arg);
21804 }
21806 /* Wrapper for cp_parser_type_id_1. */
21808 static tree
21811 {
21813 }
21815 /* Wrapper for cp_parser_type_id_1. */
21817 static tree
21819 {
21820 tree r;
21822 parser->type_definition_forbidden_message
21827 {
21830 }
21832 }
21834 /* Wrapper for cp_parser_type_id_1. */
21836 static tree
21838 {
21841 }
21843 /* Parse a type-specifier-seq.
21845 type-specifier-seq:
21846 type-specifier type-specifier-seq [opt]
21848 GNU extension:
21850 type-specifier-seq:
21851 attributes type-specifier-seq [opt]
21853 The parser flags FLAGS is used to control type-specifier parsing.
21855 If IS_DECLARATION is true, we are at the start of a "condition" or
21856 exception-declaration, so we might be followed by a declarator-id.
21858 If IS_TRAILING_RETURN is true, we are in a trailing-return-type,
21859 i.e. we've just seen "->".
21861 Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */
21863 static void
21865 cp_parser_flags flags,
21869 {
21873 /* Clear the TYPE_SPECIFIER_SEQ. */
21877 /* In the context of a trailing return type, enum E { } is an
21878 elaborated-type-specifier followed by a function-body, not an
21879 enum-specifier. */
21883 /* Parse the type-specifiers and attributes. */
21885 {
21886 tree type_specifier;
21889 /* Check for attributes first. */
21891 {
21892 type_specifier_seq->attributes
21896 }
21898 /* record the token of the beginning of the type specifier seq,
21899 for error reporting purposes*/
21903 /* Look for the type-specifier. */
21905 flags,
21906 type_specifier_seq,
21908 NULL,
21911 {
21912 /* If the first type-specifier could not be found, this is not a
21913 type-specifier-seq at all. */
21915 {
21916 /* Set in_declarator_p to avoid skipping to the semicolon. */
21928 }
21929 /* If subsequent type-specifiers could not be found, the
21930 type-specifier-seq is complete. */
21932 }
21935 /* The standard says that a condition can be:
21937 type-specifier-seq declarator = assignment-expression
21939 However, given:
21941 struct S {};
21942 if (int S = ...)
21944 we should treat the "S" as a declarator, not as a
21945 type-specifier. The standard doesn't say that explicitly for
21946 type-specifier-seq, but it does say that for
21947 decl-specifier-seq in an ordinary declaration. Perhaps it
21948 would be clearer just to allow a decl-specifier-seq here, and
21949 then add a semantic restriction that if any decl-specifiers
21950 that are not type-specifiers appear, the program is invalid. */
21953 }
21954 }
21956 /* Return whether the function currently being declared has an associated
21957 template parameter list. */
21959 static bool
21961 {
21974 }
21976 /* Parse a parameter-declaration-clause.
21978 parameter-declaration-clause:
21979 parameter-declaration-list [opt] ... [opt]
21980 parameter-declaration-list , ...
21982 The parser flags FLAGS is used to control type-specifier parsing.
21984 Returns a representation for the parameter declarations. A return
21985 value of NULL indicates a parameter-declaration-clause consisting
21986 only of an ellipsis. */
21988 static tree
21990 cp_parser_flags flags)
21991 {
21992 tree parameters;
22000 && !processing_template_parmlist
22001 && !processing_explicit_instantiation
22002 /* default_arg_ok_p tracks whether this is a parameter-clause for an
22003 actual function or a random abstract declarator. */
22009 /* Peek at the next token. */
22011 /* Check for trivial parameter-declaration-clauses. */
22013 {
22014 /* Consume the `...' token. */
22017 }
22019 /* There are no parameters. */
22021 /* Check for `(void)', too, which is a special case. */
22025 {
22026 /* Consume the `void' token. */
22028 /* There are no parameters. */
22030 }
22032 /* Parse the parameter-declaration-list. */
22034 /* If a parse error occurred while parsing the
22035 parameter-declaration-list, then the entire
22036 parameter-declaration-clause is erroneous. */
22040 /* Peek at the next token. */
22042 /* If it's a `,', the clause should terminate with an ellipsis. */
22044 {
22045 /* Consume the `,'. */
22047 /* Expect an ellipsis. */
22048 ellipsis_p
22050 }
22051 /* It might also be `...' if the optional trailing `,' was
22052 omitted. */
22054 {
22055 /* Consume the `...' token. */
22057 /* And remember that we saw it. */
22059 }
22060 else
22063 /* Finish the parameter list. */
22068 }
22070 /* Parse a parameter-declaration-list.
22072 parameter-declaration-list:
22073 parameter-declaration
22074 parameter-declaration-list , parameter-declaration
22076 The parser flags FLAGS is used to control type-specifier parsing.
22078 Returns a representation of the parameter-declaration-list, as for
22079 cp_parser_parameter_declaration_clause. However, the
22080 `void_list_node' is never appended to the list. */
22082 static tree
22084 {
22090 /* The special considerations that apply to a function within an
22091 unbraced linkage specifications do not apply to the parameters
22092 to the function. */
22093 saved_in_unbraced_linkage_specification_p
22097 /* Look for more parameters. */
22099 {
22104 /* Parse the parameter. */
22105 parameter
22110 /* We don't know yet if the enclosing context is deprecated, so wait
22111 and warn in grokparms if appropriate. */
22115 {
22118 PARM,
22123 }
22127 /* If a parse error occurred parsing the parameter declaration,
22128 then the entire parameter-declaration-list is erroneous. */
22130 {
22133 }
22143 {
22147 }
22149 /* Add the new parameter to the list. */
22153 /* Peek at the next token. */
22156 /* These are for Objective-C++ */
22159 /* The parameter-declaration-list is complete. */
22162 {
22165 /* Peek at the next token. */
22167 /* If it's an ellipsis, then the list is complete. */
22170 /* Otherwise, there must be more parameters. Consume the
22171 `,'. */
22173 /* When parsing something like:
22175 int i(float f, double d)
22177 we can tell after seeing the declaration for "f" that we
22178 are not looking at an initialization of a variable "i",
22179 but rather at the declaration of a function "i".
22181 Due to the fact that the parsing of template arguments
22182 (as specified to a template-id) requires backtracking we
22183 cannot use this technique when inside a template argument
22184 list. */
22188 /* However, a parameter-declaration of the form
22189 "float(f)" (which is a valid declaration of a
22190 parameter "f") can also be interpreted as an
22191 expression (the conversion of "f" to "float"). */
22194 }
22195 else
22196 {
22204 }
22205 }
22207 parser->in_unbraced_linkage_specification_p
22210 /* Reset implicit_template_scope if we are about to leave the function
22211 parameter list that introduced it. Note that for out-of-line member
22212 definitions, there will be one or more class scopes before we get to
22213 the template parameter scope. */
22217 {
22221 {
22224 }
22225 }
22228 }
22230 /* Parse a parameter declaration.
22232 parameter-declaration:
22233 decl-specifier-seq ... [opt] declarator
22234 decl-specifier-seq declarator = assignment-expression
22235 decl-specifier-seq ... [opt] abstract-declarator [opt]
22236 decl-specifier-seq abstract-declarator [opt] = assignment-expression
22238 The parser flags FLAGS is used to control type-specifier parsing.
22240 If TEMPLATE_PARM_P is TRUE, then this parameter-declaration
22241 declares a template parameter. (In that case, a non-nested `>'
22242 token encountered during the parsing of the assignment-expression
22243 is not interpreted as a greater-than operator.)
22245 Returns a representation of the parameter, or NULL if an error
22246 occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to
22247 true iff the declarator is of the form "(p)". */
22251 cp_parser_flags flags,
22254 {
22256 cp_decl_specifier_seq decl_specifiers;
22258 tree default_argument;
22263 /* In a template parameter, `>' is not an operator.
22265 [temp.param]
22267 When parsing a default template-argument for a non-type
22268 template-parameter, the first non-nested `>' is taken as the end
22269 of the template parameter-list rather than a greater-than
22270 operator. */
22272 /* Type definitions may not appear in parameter types. */
22274 parser->type_definition_forbidden_message
22281 /* Parse the declaration-specifiers. */
22284 flags,
22288 /* Complain about missing 'typename' or other invalid type names. */
22293 /* If an error occurred, there's no reason to attempt to parse the
22294 rest of the declaration. */
22296 {
22299 }
22301 /* Peek at the next token. */
22304 /* If the next token is a `)', `,', `=', `>', or `...', then there
22305 is no declarator. However, when variadic templates are enabled,
22306 there may be a declarator following `...'. */
22311 {
22315 }
22316 /* Otherwise, there should be a declarator. */
22317 else
22318 {
22322 /* After seeing a decl-specifier-seq, if the next token is not a
22323 "(", there is no possibility that the code is a valid
22324 expression. Therefore, if parsing tentatively, we commit at
22325 this point. */
22327 /* In an expression context, having seen:
22329 (int((char ...
22331 we cannot be sure whether we are looking at a
22332 function-type (taking a "char" as a parameter) or a cast
22333 of some object of type "char" to "int". */
22339 /* Parse the declarator. */
22342 CP_PARSER_DECLARATOR_EITHER,
22343 CP_PARSER_FLAGS_NONE,
22345 parenthesized_p,
22350 /* After the declarator, allow more attributes. */
22351 decl_specifiers.attributes
22355 /* If the declarator is a template parameter pack, remember that and
22356 clear the flag in the declarator itself so we don't get errors
22357 from grokdeclarator. */
22359 {
22362 }
22363 }
22365 /* If the next token is an ellipsis, and we have not seen a declarator
22366 name, and if either the type of the declarator contains parameter
22367 packs but it is not a TYPE_PACK_EXPANSION or is null (this happens
22368 for, eg, abbreviated integral type names), then we actually have a
22369 parameter pack expansion expression. Otherwise, leave the ellipsis
22370 for a C-style variadic function. */
22373 /* If a function parameter pack was specified and an implicit template
22374 parameter was introduced during cp_parser_parameter_declaration,
22375 change any implicit parameters introduced into packs. */
22380 {
22388 }
22391 {
22402 {
22403 /* Consume the `...'. */
22407 /* Build a pack expansion type */
22412 else
22414 }
22415 }
22417 /* The restriction on defining new types applies only to the type
22418 of the parameter, not to the default argument. */
22421 /* If the next token is `=', then process a default argument. */
22423 {
22426 /* If we are defining a class, then the tokens that make up the
22427 default argument must be saved and processed later. */
22433 // A constrained-type-specifier may declare a type template-parameter.
22435 default_argument
22438 // A constrained-type-specifier may declare a template-template-parameter.
22440 default_argument
22443 /* Outside of a class definition, we can just parse the
22444 assignment-expression. */
22445 else
22446 default_argument
22450 {
22452 "default arguments are only "
22454 }
22456 || template_parameter_pack_p
22459 {
22460 /* Find the name of the parameter pack. */
22467 template_parm_p
22473 else
22475 template_parm_p
22482 }
22483 }
22484 else
22490 /* Generate a location for the parameter, ranging from the start of the
22491 initial token to the end of the final token (using input_location for
22492 the latter, set up by cp_lexer_set_source_position_from_token when
22493 consuming tokens).
22495 If we have a identifier, then use it for the caret location, e.g.
22497 extern int callee (int one, int (*two)(int, int), float three);
22498 ~~~~~~^~~~~~~~~~~~~~
22500 otherwise, reuse the start location for the caret location e.g.:
22502 extern int callee (int one, int (*)(int, int), float three);
22503 ^~~~~~~~~~~~~~~~~
22505 */
22511 input_location);
22514 declarator,
22515 default_argument,
22516 param_loc,
22517 template_parameter_pack_p);
22518 }
22520 /* Parse a default argument and return it.
22522 TEMPLATE_PARM_P is true if this is a default argument for a
22523 non-type template parameter. */
22524 static tree
22526 {
22532 /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is
22533 set correctly. */
22536 /* Local variable names (and the `this' keyword) may not
22537 appear in a default argument. */
22540 /* Parse the assignment-expression. */
22545 /* The "this" pointer is not valid in a default argument. */
22547 {
22552 }
22553 default_argument
22555 /* Restore the "this" pointer. */
22557 {
22560 }
22569 }
22571 /* Parse a function-body.
22573 function-body:
22574 compound_statement */
22576 static void
22578 {
22582 }
22584 /* Parse a ctor-initializer-opt followed by a function-body. Return
22585 true if a ctor-initializer was present. When IN_FUNCTION_TRY_BLOCK
22586 is true we are parsing a function-try-block. */
22588 static void
22591 {
22598 /* Begin the function body. */
22600 /* Parse the optional ctor-initializer. */
22603 /* If we're parsing a constexpr constructor definition, we need
22604 to check that the constructor body is indeed empty. However,
22605 before we get to cp_parser_function_body lot of junk has been
22606 generated, so we can't just check that we have an empty block.
22607 Rather we take a snapshot of the outermost block, and check whether
22608 cp_parser_function_body changed its state. */
22610 {
22614 }
22615 /* Parse the function-body. */
22619 /* Finish the function body. */
22621 }
22623 /* Parse an initializer.
22625 initializer:
22626 = initializer-clause
22627 ( expression-list )
22629 Returns an expression representing the initializer. If no
22630 initializer is present, NULL_TREE is returned.
22632 *IS_DIRECT_INIT is set to FALSE if the `= initializer-clause'
22633 production is used, and TRUE otherwise. *IS_DIRECT_INIT is
22634 set to TRUE if there is no initializer present. If there is an
22635 initializer, and it is not a constant-expression, *NON_CONSTANT_P
22636 is set to true; otherwise it is set to false. */
22638 static tree
22641 {
22643 tree init;
22645 /* Peek at the next token. */
22648 /* Let our caller know whether or not this initializer was
22649 parenthesized. */
22651 /* Assume that the initializer is constant. */
22655 {
22656 /* Consume the `='. */
22658 /* Parse the initializer-clause. */
22660 }
22662 {
22667 non_constant_p);
22672 }
22674 {
22679 }
22680 else
22681 {
22682 /* Anything else is an error. */
22685 }
22691 }
22693 /* Parse an initializer-clause.
22695 initializer-clause:
22696 assignment-expression
22697 braced-init-list
22699 Returns an expression representing the initializer.
22701 If the `assignment-expression' production is used the value
22702 returned is simply a representation for the expression.
22704 Otherwise, calls cp_parser_braced_list. */
22706 static cp_expr
22708 {
22709 cp_expr initializer;
22711 /* Assume the expression is constant. */
22714 /* If it is not a `{', then we are looking at an
22715 assignment-expression. */
22717 {
22718 initializer
22721 non_constant_p);
22722 }
22723 else
22727 }
22729 /* Parse a brace-enclosed initializer list.
22731 braced-init-list:
22732 { initializer-list , [opt] }
22733 { designated-initializer-list , [opt] }
22734 { }
22736 Returns a CONSTRUCTOR. The CONSTRUCTOR_ELTS will be
22737 the elements of the initializer-list (or NULL, if the last
22738 production is used). The TREE_TYPE for the CONSTRUCTOR will be
22739 NULL_TREE. There is no way to detect whether or not the optional
22740 trailing `,' was provided. NON_CONSTANT_P is as for
22741 cp_parser_initializer. */
22743 static cp_expr
22745 {
22746 tree initializer;
22749 /* Consume the `{' token. */
22750 matching_braces braces;
22752 /* Create a CONSTRUCTOR to represent the braced-initializer. */
22754 /* If it's not a `}', then there is a non-trivial initializer. */
22756 {
22757 /* Parse the initializer list. */
22760 /* A trailing `,' token is allowed. */
22763 }
22764 else
22766 /* Now, there should be a trailing `}'. */
22772 /* Build a location of the form:
22773 { ... }
22774 ^~~~~~~
22775 with caret==start at the open brace, finish at the close brace. */
22779 }
22781 /* Consume tokens up to, and including, the next non-nested closing `]'.
22782 Returns true iff we found a closing `]'. */
22784 static bool
22786 {
22790 {
22794 {
22798 /* FALLTHRU */
22800 /* If we've run out of tokens, then there is no closing `]'. */
22809 {
22812 }
22817 }
22819 /* Consume the token. */
22821 }
22822 }
22824 /* Return true if we are looking at an array-designator, false otherwise. */
22826 static bool
22828 {
22829 /* Consume the `['. */
22834 /* Skip tokens until the next token is a closing square bracket.
22835 If we find the closing `]', and the next token is a `=', then
22836 we are looking at an array designator. */
22837 bool array_designator_p
22841 /* Roll back the tokens we skipped. */
22845 }
22847 /* Parse an initializer-list.
22849 initializer-list:
22850 initializer-clause ... [opt]
22851 initializer-list , initializer-clause ... [opt]
22853 C++2A Extension:
22855 designated-initializer-list:
22856 designated-initializer-clause
22857 designated-initializer-list , designated-initializer-clause
22859 designated-initializer-clause:
22860 designator brace-or-equal-initializer
22862 designator:
22863 . identifier
22865 GNU Extension:
22867 initializer-list:
22868 designation initializer-clause ...[opt]
22869 initializer-list , designation initializer-clause ...[opt]
22871 designation:
22872 . identifier =
22873 identifier :
22874 [ constant-expression ] =
22876 Returns a vec of constructor_elt. The VALUE of each elt is an expression
22877 for the initializer. If the INDEX of the elt is non-NULL, it is the
22878 IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is
22879 as for cp_parser_initializer. */
22883 {
22888 /* Assume all of the expressions are constant. */
22891 /* Parse the rest of the list. */
22893 {
22895 tree designator;
22896 tree initializer;
22900 /* Handle the C++2A syntax, '. id ='. */
22908 {
22911 "C++ designated initializers only available with "
22913 /* Consume the `.'. */
22915 /* Consume the identifier. */
22918 /* Consume the `='. */
22920 }
22921 /* Also, if the next token is an identifier and the following one is a
22922 colon, we are looking at the GNU designated-initializer
22923 syntax. */
22928 {
22929 /* Warn the user that they are using an extension. */
22932 /* Consume the identifier. */
22934 /* Consume the `:'. */
22936 }
22937 /* Also handle C99 array designators, '[ const ] ='. */
22941 {
22942 /* In C++11, [ could start a lambda-introducer. */
22948 {
22951 }
22952 else
22953 {
22958 }
22963 && (!require_potential_rvalue_constant_expression
22967 /* Warn the user that they are using an extension. */
22970 }
22971 else
22975 {
22978 }
22982 {
22986 }
22990 /* Parse the initializer. */
22993 /* If any clause is non-constant, so is the entire initializer. */
22997 /* If we have an ellipsis, this is an initializer pack
22998 expansion. */
23000 {
23003 /* Consume the `...'. */
23010 /* Turn the initializer into an initializer expansion. */
23012 }
23014 /* Add it to the vector. */
23017 /* If the next token is not a comma, we have reached the end of
23018 the list. */
23022 /* Peek at the next token. */
23024 /* If the next token is a `}', then we're still done. An
23025 initializer-clause can have a trailing `,' after the
23026 initializer-list and before the closing `}'. */
23030 /* Consume the `,' token. */
23032 }
23034 /* The same identifier shall not appear in multiple designators
23035 of a designated-initializer-list. */
23037 {
23042 {
23044 {
23046 "%<.%s%> designator used multiple times in "
23050 }
23051 else
23053 }
23057 }
23060 }
23062 /* Classes [gram.class] */
23064 /* Parse a class-name.
23066 class-name:
23067 identifier
23068 template-id
23070 TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used
23071 to indicate that names looked up in dependent types should be
23072 assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template'
23073 keyword has been used to indicate that the name that appears next
23074 is a template. TAG_TYPE indicates the explicit tag given before
23075 the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are
23076 looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class
23077 is the class being defined in a class-head. If ENUM_OK is TRUE,
23078 enum-names are also accepted.
23080 Returns the TYPE_DECL representing the class. */
23082 static tree
23091 {
23092 tree decl;
23093 tree scope;
23098 /* All class-names start with an identifier. */
23101 {
23104 }
23106 /* PARSER->SCOPE can be cleared when parsing the template-arguments
23107 to a template-id, so we save it here. */
23112 /* Any name names a type if we're following the `typename' keyword
23113 in a qualified name where the enclosing scope is type-dependent. */
23116 /* Handle the common case (an identifier, but not a template-id)
23117 efficiently. */
23120 {
23124 /* Look for the identifier. */
23128 /* If the next token isn't an identifier, we are certainly not
23129 looking at a class-name. */
23132 /* If we know this is a type-name, there's no need to look it
23133 up. */
23136 else
23137 {
23138 tree ambiguous_decls;
23139 /* If we already know that this lookup is ambiguous, then
23140 we've already issued an error message; there's no reason
23141 to check again. */
23143 {
23146 }
23147 /* If the next token is a `::', then the name must be a type
23148 name.
23150 [basic.lookup.qual]
23152 During the lookup for a name preceding the :: scope
23153 resolution operator, object, function, and enumerator
23154 names are ignored. */
23157 /* Look up the name. */
23159 tag_type,
23162 check_dependency_p,
23166 {
23170 }
23171 }
23172 }
23173 else
23174 {
23175 /* Try a template-id. */
23177 check_dependency_p,
23178 tag_type,
23179 is_declaration);
23182 }
23186 /* If this is a typename, create a TYPENAME_TYPE. */
23190 {
23195 }
23199 /* Check to see that it is really the name of a class. */
23203 /* Situations like this:
23205 template <typename T> struct A {
23206 typename T::template X<int>::I i;
23207 };
23209 are problematic. Is `T::template X<int>' a class-name? The
23210 standard does not seem to be definitive, but there is no other
23211 valid interpretation of the following `::'. Therefore, those
23212 names are considered class-names. */
23213 {
23217 }
23222 /* In Objective-C 2.0, a classname followed by '.' starts a
23223 dot-syntax expression, and it's not a type-name. */
23235 }
23237 /* Parse a class-specifier.
23239 class-specifier:
23240 class-head { member-specification [opt] }
23242 Returns the TREE_TYPE representing the class. */
23244 static tree
23246 {
23247 tree type;
23261 /* Parse the class-head. */
23264 /* If the class-head was a semantic disaster, skip the entire body
23265 of the class. */
23267 {
23271 }
23273 /* Look for the `{'. */
23274 matching_braces braces;
23276 {
23279 }
23284 /* Issue an error message if type-definitions are forbidden here. */
23286 /* Remember that we are defining one more class. */
23288 /* Inside the class, surrounding template-parameter-lists do not
23289 apply. */
23290 saved_num_template_parameter_lists
23293 /* We are not in a function body. */
23296 /* Or in a loop. */
23299 /* Or in a switch. */
23302 /* We are not immediately inside an extern "lang" block. */
23303 saved_in_unbraced_linkage_specification_p
23307 // Associate constraints with the type.
23311 /* Start the class. */
23313 {
23316 }
23320 /* If the type is erroneous, skip the entire body of the class. */
23322 else
23323 /* Parse the member-specification. */
23326 /* Look for the trailing `}'. */
23328 /* Look for trailing attributes to apply to this class. */
23336 /* We've finished a type definition. Check for the common syntax
23337 error of forgetting a semicolon after the definition. We need to
23338 be careful, as we can't just check for not-a-semicolon and be done
23339 with it; the user might have typed:
23341 class X { } c = ...;
23342 class X { } *p = ...;
23344 and so forth. Instead, enumerate all the possible tokens that
23345 might follow this production; if we don't see one of them, then
23346 complain and silently insert the semicolon. */
23347 {
23352 /* Don't try to parse c++11 attributes here. As per the
23353 grammar, that should be a task for
23354 cp_parser_decl_specifier_seq. */
23358 {
23369 /* While it's legal for type qualifiers and storage class
23370 specifiers to follow type definitions in the grammar, only
23371 compiler testsuites contain code like that. Assume that if
23372 we see such code, then what we're really seeing is a case
23373 like:
23375 class X { }
23376 const <type> var = ...;
23378 or
23380 class Y { }
23381 static <type> func (...) ...
23383 i.e. the qualifier or specifier applies to the next
23384 declaration. To do so, however, we need to look ahead one
23385 more token to see if *that* token is a type specifier.
23387 This code could be improved to handle:
23389 class Z { }
23390 static const <type> var = ...; */
23393 {
23396 /* Handling user-defined types here would be nice, but very
23397 tricky. */
23398 want_semicolon
23401 }
23405 }
23407 /* If we don't have a type, then something is very wrong and we
23408 shouldn't try to do anything clever. Likewise for not seeing the
23409 closing brace. */
23411 {
23412 /* Locate the closing brace. */
23413 cp_token_position prev
23418 /* We want to suggest insertion of a ';' immediately *after* the
23419 closing brace, so, if we can, offset the location by 1 column. */
23426 /* If we successfully offset the location, suggest the fix-it. */
23439 else
23442 /* Unget one token and smash it to look as though we encountered
23443 a semicolon in the input stream. */
23448 }
23449 }
23451 /* If this class is not itself within the scope of another class,
23452 then we need to parse the bodies of all of the queued function
23453 definitions. Note that the queued functions defined in a class
23454 are not always processed immediately following the
23455 class-specifier for that class. Consider:
23457 struct A {
23458 struct B { void f() { sizeof (A); } };
23459 };
23461 If `f' were processed before the processing of `A' were
23462 completed, there would be no way to compute the size of `A'.
23463 Note that the nesting we are interested in here is lexical --
23464 not the semantic nesting given by TYPE_CONTEXT. In particular,
23465 for:
23467 struct A { struct B; };
23468 struct A::B { void f() { } };
23470 there is no need to delay the parsing of `A::B::f'. */
23472 {
23473 tree decl;
23481 {
23482 /* Skip default arguments, NSDMIs, etc, in order to improve
23483 error recovery (c++/71169, c++/71832). */
23488 }
23490 /* In a first pass, parse default arguments to the functions.
23491 Then, in a second pass, parse the bodies of the functions.
23492 This two-phased approach handles cases like:
23494 struct S {
23495 void f() { g(); }
23496 void g(int i = 3);
23497 };
23499 */
23501 {
23503 /* If there are default arguments that have not yet been processed,
23504 take care of them now. */
23506 {
23511 }
23512 /* Make sure that any template parameters are in scope. */
23514 /* Parse the default argument expressions. */
23516 /* Remove any template parameters from the symbol table. */
23518 }
23520 /* Now parse any NSDMIs. */
23524 {
23526 {
23531 }
23534 }
23541 /* Now do some post-NSDMI bookkeeping. */
23547 /* Now parse the body of the functions. */
23549 {
23550 /* OpenMP UDRs need to be parsed before all other functions. */
23557 }
23558 else
23562 }
23563 else
23566 /* Put back any saved access checks. */
23569 /* Restore saved state. */
23573 parser->num_template_parameter_lists
23575 parser->in_unbraced_linkage_specification_p
23579 }
23581 static tree
23583 {
23584 tree ret;
23589 }
23591 /* Parse a class-head.
23593 class-head:
23594 class-key identifier [opt] base-clause [opt]
23595 class-key nested-name-specifier identifier class-virt-specifier [opt] base-clause [opt]
23596 class-key nested-name-specifier [opt] template-id
23597 base-clause [opt]
23599 class-virt-specifier:
23600 final
23602 GNU Extensions:
23603 class-key attributes identifier [opt] base-clause [opt]
23604 class-key attributes nested-name-specifier identifier base-clause [opt]
23605 class-key attributes nested-name-specifier [opt] template-id
23606 base-clause [opt]
23608 Upon return BASES is initialized to the list of base classes (or
23609 NULL, if there are none) in the same form returned by
23610 cp_parser_base_clause.
23612 Returns the TYPE of the indicated class. Sets
23613 *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions
23614 involving a nested-name-specifier was used, and FALSE otherwise.
23616 Returns error_mark_node if this is not a class-head.
23618 Returns NULL_TREE if the class-head is syntactically valid, but
23619 semantically invalid in a way that means we should skip the entire
23620 body of the class. */
23622 static tree
23625 {
23626 tree nested_name_specifier;
23630 tree attributes;
23631 tree bases;
23641 /* Assume no nested-name-specifier will be present. */
23643 /* Assume no template parameter lists will be used in defining the
23644 type. */
23648 /* Look for the class-key. */
23655 /* Parse the attributes. */
23658 /* If the next token is `::', that is invalid -- but sometimes
23659 people do try to write:
23661 struct ::S {};
23663 Handle this gracefully by accepting the extra qualifier, and then
23664 issuing an error about it later if this really is a
23665 class-head. If it turns out just to be an elaborated type
23666 specifier, remain silent. */
23672 /* Determine the name of the class. Begin by looking for an
23673 optional nested-name-specifier. */
23675 nested_name_specifier
23681 /* If there was a nested-name-specifier, then there *must* be an
23682 identifier. */
23687 {
23689 /* Although the grammar says `identifier', it really means
23690 `class-name' or `template-name'. You are only allowed to
23691 define a class that has already been declared with this
23692 syntax.
23694 The proposed resolution for Core Issue 180 says that wherever
23695 you see `class T::X' you should treat `X' as a type-name.
23697 It is OK to define an inaccessible class; for example:
23699 class A { class B; };
23700 class A::B {};
23702 We do not know if we will see a class-name, or a
23703 template-name. We look for a class-name first, in case the
23704 class-name is a template-id; if we looked for the
23705 template-name first we would stop after the template-name. */
23712 class_type,
23716 /* If that didn't work, ignore the nested-name-specifier. */
23718 {
23724 }
23725 /* If we could not find a corresponding TYPE, treat this
23726 declaration like an unqualified declaration. */
23729 /* Otherwise, count the number of templates used in TYPE and its
23730 containing scopes. */
23731 else
23733 }
23734 /* Otherwise, the identifier is optional. */
23735 else
23736 {
23737 /* We don't know whether what comes next is a template-id,
23738 an identifier, or nothing at all. */
23740 /* Check for a template-id. */
23745 class_key,
23747 /* If that didn't work, it could still be an identifier. */
23749 {
23751 {
23754 }
23755 else
23757 }
23758 else
23759 {
23762 }
23763 }
23768 {
23770 class_key,
23772 }
23775 /* If it's not a `:' or a `{' then we can't really be looking at a
23776 class-head, since a class-head only appears as part of a
23777 class-specifier. We have to detect this situation before calling
23778 xref_tag, since that has irreversible side-effects. */
23780 {
23784 }
23786 /* At this point, we're going ahead with the class-specifier, even
23787 if some other problem occurs. */
23790 {
23795 }
23796 /* Issue the error about the overly-qualified name now. */
23798 {
23803 }
23805 {
23810 }
23812 {
23813 tree scope;
23816 /* [temp.names]: in a qualified-id formed by a class-head-name, the
23817 keyword template shall not appear at the top level. */
23821 /* Reject typedef-names in class heads. */
23823 {
23826 type);
23829 }
23831 /* Figure out in what scope the declaration is being placed. */
23833 /* If that scope does not contain the scope in which the
23834 class was originally declared, the program is invalid. */
23836 {
23839 "declaration of %qD in namespace %qD which does not "
23842 else
23848 }
23849 /* [dcl.meaning]
23851 A declarator-id shall not be qualified except for the
23852 definition of a ... nested class outside of its class
23853 ... [or] the definition or explicit instantiation of a
23854 class member of a namespace outside of its namespace. */
23856 {
23861 }
23862 }
23863 /* An explicit-specialization must be preceded by "template <>". If
23864 it is not, try to recover gracefully. */
23867 && !processing_template_parmlist
23869 {
23870 /* Build a location of this form:
23871 struct typename <ARGS>
23872 ^~~~~~~~~~~~~~~~~~~~~~
23873 with caret==start at the start token, and
23874 finishing at the end of the type. */
23875 location_t reported_loc
23877 class_head_start_location,
23883 "an explicit specialization must be preceded by"
23886 /* Take the same action that would have been taken by
23887 cp_parser_explicit_specialization. */
23890 }
23891 /* There must be no "return" statements between this point and the
23892 end of this function; set "type "to the correct return value and
23893 use "goto done;" to return. */
23894 /* Make sure that the right number of template parameters were
23895 present. */
23897 template_id_p,
23900 {
23901 /* If something went wrong, there is no point in even trying to
23902 process the class-definition. */
23905 }
23907 /* Look up the type. */
23909 {
23913 {
23917 }
23918 else
23919 {
23923 /* Check the scope while we still know whether or not we had a
23924 nested-name-specifier. */
23927 }
23930 }
23932 {
23933 tree class_type;
23935 /* Given:
23937 template <typename T> struct S { struct T };
23938 template <typename T> struct S<T>::T { };
23940 we will get a TYPENAME_TYPE when processing the definition of
23941 `S::T'. We need to resolve it to the actual type before we
23942 try to define it. */
23944 {
23949 else
23950 {
23953 }
23954 }
23958 {
23961 }
23964 /* Enter the scope indicated by the nested-name-specifier. */
23966 /* Get the canonical version of this type. */
23968 /* Call push_template_decl if it seems like we should be defining a
23969 template either from the template headers or the type we're
23970 defining, so that we diagnose both extra and missing headers. */
23974 {
23977 {
23980 }
23981 }
23985 }
23987 {
23988 /* If the class was unnamed, create a dummy name. */
23992 ? ts_within_enclosing_non_class
23996 }
23998 /* Indicate whether this class was declared as a `class' or as a
23999 `struct'. */
24004 /* If this type was already complete, and we see another definition,
24005 that's an error. */
24007 {
24009 type);
24011 type);
24014 }
24019 {
24020 /* Apply attributes now, before any use of the class as a template
24021 argument in its base list. */
24024 }
24026 /* We will have entered the scope containing the class; the names of
24027 base classes should be looked up in that context. For example:
24029 struct A { struct B {}; struct C; };
24030 struct A::C : B {};
24032 is valid. */
24034 /* Get the list of base-classes, if there is one. */
24036 {
24037 /* PR59482: enter the class scope so that base-specifiers are looked
24038 up correctly. */
24042 /* PR59482: get out of the previously pushed class scope so that the
24043 subsequent pops pop the right thing. */
24046 }
24047 else
24050 /* If we're really defining a class, process the base classes.
24051 If they're invalid, fail. */
24055 done:
24056 /* Leave the scope given by the nested-name-specifier. We will
24057 enter the class scope itself while processing the members. */
24062 {
24065 }
24071 out:
24074 }
24076 /* Parse a class-key.
24078 class-key:
24079 class
24080 struct
24081 union
24083 Returns the kind of class-key specified, or none_type to indicate
24084 error. */
24086 static enum tag_types
24088 {
24092 /* Look for the class-key. */
24097 /* Check to see if the TOKEN is a class-key. */
24102 }
24104 /* Parse a type-parameter-key.
24106 type-parameter-key:
24107 class
24108 typename
24109 */
24111 static void
24113 {
24114 /* Look for the type-parameter-key. */
24118 {
24121 /* typename is not allowed in a template template parameter
24122 by the standard until C++17. */
24124 "ISO C++ forbids typename key in template template parameter;"
24126 }
24127 else
24131 }
24133 /* Parse an (optional) member-specification.
24135 member-specification:
24136 member-declaration member-specification [opt]
24137 access-specifier : member-specification [opt] */
24139 static void
24141 {
24143 {
24147 /* Peek at the next token. */
24149 /* If it's a `}', or EOF then we've seen all the members. */
24155 /* See if this token is a keyword. */
24158 {
24162 /* Consume the access-specifier. */
24164 /* Remember which access-specifier is active. */
24166 /* Look for the `:'. */
24171 /* Accept #pragmas at class scope. */
24173 {
24176 }
24178 /* Otherwise, the next construction must be a
24179 member-declaration. */
24181 }
24182 }
24183 }
24185 /* Parse a member-declaration.
24187 member-declaration:
24188 decl-specifier-seq [opt] member-declarator-list [opt] ;
24189 function-definition ; [opt]
24190 :: [opt] nested-name-specifier template [opt] unqualified-id ;
24191 using-declaration
24192 template-declaration
24193 alias-declaration
24195 member-declarator-list:
24196 member-declarator
24197 member-declarator-list , member-declarator
24199 member-declarator:
24200 declarator pure-specifier [opt]
24201 declarator constant-initializer [opt]
24202 identifier [opt] : constant-expression
24204 GNU Extensions:
24206 member-declaration:
24207 __extension__ member-declaration
24209 member-declarator:
24210 declarator attributes [opt] pure-specifier [opt]
24211 declarator attributes [opt] constant-initializer [opt]
24212 identifier [opt] attributes [opt] : constant-expression
24214 C++0x Extensions:
24216 member-declaration:
24217 static_assert-declaration */
24219 static void
24221 {
24222 cp_decl_specifier_seq decl_specifiers;
24223 tree prefix_attributes;
24224 tree decl;
24233 /* Check for the `__extension__' keyword. */
24235 {
24236 /* Recurse. */
24238 /* Restore the old value of the PEDANTIC flag. */
24242 }
24244 /* Check for a template-declaration. */
24246 {
24247 /* An explicit specialization here is an error condition, and we
24248 expect the specialization handler to detect and report this. */
24252 else
24256 }
24257 /* Check for a template introduction. */
24261 /* Check for a using-declaration. */
24263 {
24265 {
24266 /* Parse the using-declaration. */
24270 }
24271 else
24272 {
24273 tree decl;
24277 /* Note that if we actually see the '=' token after the
24278 identifier, cp_parser_alias_declaration commits the
24279 tentative parse. In that case, we really expect an
24280 alias-declaration. Otherwise, we expect a using
24281 declaration. */
24282 alias_decl_expected =
24288 else
24292 }
24293 }
24295 /* Check for @defs. */
24297 {
24302 {
24307 }
24309 }
24311 /* If the next token is `static_assert' we have a static assertion. */
24313 {
24316 }
24323 /* Parse the decl-specifier-seq. */
24326 (CP_PARSER_FLAGS_OPTIONAL
24330 /* Check for an invalid type-name. */
24334 /* If there is no declarator, then the decl-specifier-seq should
24335 specify a type. */
24337 {
24338 /* If there was no decl-specifier-seq, and the next token is a
24339 `;', then we have something like:
24341 struct S { ; };
24343 [class.mem]
24345 Each member-declaration shall declare at least one member
24346 name of the class. */
24348 {
24351 {
24355 }
24356 }
24357 else
24358 {
24359 tree type;
24361 /* See if this declaration is a friend. */
24363 /* If there were decl-specifiers, check to see if there was
24364 a class-declaration. */
24367 /* Nested classes have already been added to the class, but
24368 a `friend' needs to be explicitly registered. */
24370 {
24371 /* If the `friend' keyword was present, the friend must
24372 be introduced with a class-key. */
24375 "in C++03 a class-key must be used "
24377 /* In this case:
24379 template <typename T> struct A {
24380 friend struct A<T>::B;
24381 };
24383 A<T>::B will be represented by a TYPENAME_TYPE, and
24384 therefore not recognized by check_tag_decl. */
24386 {
24390 }
24393 "friend declaration does not name a class or "
24395 else
24398 }
24399 /* If there is no TYPE, an error message will already have
24400 been issued. */
24402 ;
24403 /* An anonymous aggregate has to be handled specially; such
24404 a declaration really declares a data member (with a
24405 particular type), as opposed to a nested class. */
24407 {
24408 /* C++11 9.5/6. */
24411 "a storage class on an anonymous aggregate "
24414 /* Remove constructors and such from TYPE, now that we
24415 know it is an anonymous aggregate. */
24417 /* And make the corresponding data member. */
24420 /* Add it to the class. */
24422 }
24423 else
24424 cp_parser_check_access_in_redeclaration
24427 }
24428 }
24429 else
24430 {
24433 /* Clear attributes from the decl_specifiers but keep them
24434 around as prefix attributes that apply them to the entity
24435 being declared. */
24439 /* See if these declarations will be friends. */
24442 /* Keep going until we hit the `;' at the end of the
24443 declaration. */
24445 {
24447 tree first_attribute;
24448 tree initializer;
24451 /* Peek at the next token. */
24454 /* The following code wants to know early if it is a bit-field
24455 or some other declaration. Attributes can appear before
24456 the `:' token. Skip over them without consuming any tokens
24457 to peek if they are followed by `:'. */
24462 {
24463 size_t n
24466 }
24468 /* Check for a bitfield declaration. */
24474 {
24475 tree identifier;
24476 tree width;
24478 location_t id_location
24483 else
24486 /* Look for attributes that apply to the bitfield. */
24489 /* Consume the `:' token. */
24492 /* Get the width of the bitfield. */
24496 /* In C++2A and as extension for C++11 and above we allow
24497 default member initializers for bit-fields. */
24502 CPP_OPEN_BRACE)))
24503 {
24504 location_t loc
24510 "default member initializers for bit-fields "
24511 "only available with -std=c++2a or "
24516 {
24520 }
24521 }
24522 else
24523 {
24524 /* Look for attributes that apply to the bitfield after
24525 the `:' token and width. This is where GCC used to
24526 parse attributes in the past, pedwarn if there is
24527 a std attribute. */
24530 "ISO C++ allows bit-field attributes only "
24534 }
24538 /* Remember which attributes are prefix attributes and
24539 which are not. */
24541 /* Combine the attributes. */
24544 /* Create the bitfield declaration. */
24547 identifier,
24548 sfk_none,
24549 id_location)
24553 attributes);
24554 }
24555 else
24556 {
24558 tree asm_specification;
24562 /* Parse the declarator. */
24563 declarator
24565 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
24571 /* If something went wrong parsing the declarator, make sure
24572 that we at least consume some tokens. */
24574 {
24575 /* Skip to the end of the statement. */
24577 /* If the next token is not a semicolon, that is
24578 probably because we just skipped over the body of
24579 a function. So, we consume a semicolon if
24580 present, but do not issue an error message if it
24581 is not present. */
24583 CPP_SEMICOLON))
24586 }
24589 cp_parser_check_for_definition_in_return_type
24593 /* Look for an asm-specification. */
24595 /* Look for attributes that apply to the declaration. */
24597 /* Remember which attributes are prefix attributes and
24598 which are not. */
24600 /* Combine the attributes. */
24603 /* If it's an `=', then we have a constant-initializer or a
24604 pure-specifier. It is not correct to parse the
24605 initializer before registering the member declaration
24606 since the member declaration should be in scope while
24607 its initializer is processed. However, the rest of the
24608 front end does not yet provide an interface that allows
24609 us to handle this correctly. */
24611 {
24612 /* In [class.mem]:
24614 A pure-specifier shall be used only in the declaration of
24615 a virtual function.
24617 A member-declarator can contain a constant-initializer
24618 only if it declares a static member of integral or
24619 enumeration type.
24621 Therefore, if the DECLARATOR is for a function, we look
24622 for a pure-specifier; otherwise, we look for a
24623 constant-initializer. When we call `grokfield', it will
24624 perform more stringent semantics checks. */
24636 {
24638 /* Don't require a constant rvalue in C++11, since we
24639 might want a reference constant. We'll enforce
24640 constancy later. */
24642 /* Parse the initializer. */
24645 }
24646 else
24647 /* Parse the initializer. */
24649 }
24652 {
24656 else
24658 }
24659 /* Otherwise, there is no initializer. */
24660 else
24663 /* See if we are probably looking at a function
24664 definition. We are certainly not looking at a
24665 member-declarator. Calling `grokfield' has
24666 side-effects, so we must not do it unless we are sure
24667 that we are looking at a member-declarator. */
24670 {
24671 /* The grammar does not allow a pure-specifier to be
24672 used when a member function is defined. (It is
24673 possible that this fact is an oversight in the
24674 standard, since a pure function may be defined
24675 outside of the class-specifier. */
24681 declarator,
24682 attributes);
24685 /* If the member was not a friend, declare it here. */
24688 /* Peek at the next token. */
24690 /* If the next token is a semicolon, consume it. */
24692 {
24693 location_t semicolon_loc
24698 "extra %<;%> after in-class "
24700 }
24702 }
24703 else
24706 /* Create the declaration. */
24711 {
24714 else
24716 }
24717 }
24722 /* Reset PREFIX_ATTRIBUTES. */
24724 {
24729 }
24731 /* If there is any qualification still in effect, clear it
24732 now; we will be starting fresh with the next declarator. */
24736 /* If it's a `,', then there are more declarators. */
24738 {
24741 {
24747 }
24748 }
24749 /* If the next token isn't a `;', then we have a parse error. */
24751 CPP_SEMICOLON))
24752 {
24753 /* The next token might be a ways away from where the
24754 actual semicolon is missing. Find the previous token
24755 and use that for our error position. */
24762 /* Assume that the user meant to provide a semicolon. If
24763 we were to cp_parser_skip_to_end_of_statement, we might
24764 skip to a semicolon inside a member function definition
24765 and issue nonsensical error messages. */
24767 }
24770 {
24771 /* Add DECL to the list of members. */
24773 /* Explicitly include, eg, NSDMIs, for better error
24774 recovery (c++/58650). */
24782 /* Add DECL to the queue of NSDMI to be parsed later. */
24784 }
24788 }
24789 }
24792 out:
24794 }
24796 /* Parse a pure-specifier.
24798 pure-specifier:
24799 = 0
24801 Returns INTEGER_ZERO_NODE if a pure specifier is found.
24802 Otherwise, ERROR_MARK_NODE is returned. */
24804 static tree
24806 {
24809 /* Look for the `=' token. */
24812 /* Look for the `0' token. */
24821 /* Accept = default or = delete in c++0x mode. */
24824 {
24827 }
24829 /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */
24831 {
24836 }
24838 {
24841 }
24844 }
24846 /* Parse a constant-initializer.
24848 constant-initializer:
24849 = constant-expression
24851 Returns a representation of the constant-expression. */
24853 static tree
24855 {
24856 /* Look for the `=' token. */
24860 /* It is invalid to write:
24862 struct S { static const int i = { 7 }; };
24864 */
24866 {
24869 /* Consume the opening brace. */
24870 matching_braces braces;
24872 /* Skip the initializer. */
24874 /* Look for the trailing `}'. */
24878 }
24881 }
24883 /* Derived classes [gram.class.derived] */
24885 /* Parse a base-clause.
24887 base-clause:
24888 : base-specifier-list
24890 base-specifier-list:
24891 base-specifier ... [opt]
24892 base-specifier-list , base-specifier ... [opt]
24894 Returns a TREE_LIST representing the base-classes, in the order in
24895 which they were declared. The representation of each node is as
24896 described by cp_parser_base_specifier.
24898 In the case that no bases are specified, this function will return
24899 NULL_TREE, not ERROR_MARK_NODE. */
24901 static tree
24903 {
24906 /* Look for the `:' that begins the list. */
24909 /* Scan the base-specifier-list. */
24911 {
24913 tree base;
24916 /* Look for the base-specifier. */
24918 /* Look for the (optional) ellipsis. */
24920 {
24921 /* Consume the `...'. */
24925 }
24927 /* Add BASE to the front of the list. */
24929 {
24931 /* Make this a pack expansion type. */
24935 {
24938 }
24939 }
24940 /* Peek at the next token. */
24942 /* If it's not a comma, then the list is complete. */
24945 /* Consume the `,'. */
24947 }
24949 /* PARSER->SCOPE may still be non-NULL at this point, if the last
24950 base class had a qualified name. However, the next name that
24951 appears is certainly not qualified. */
24957 }
24959 /* Parse a base-specifier.
24961 base-specifier:
24962 :: [opt] nested-name-specifier [opt] class-name
24963 virtual access-specifier [opt] :: [opt] nested-name-specifier
24964 [opt] class-name
24965 access-specifier virtual [opt] :: [opt] nested-name-specifier
24966 [opt] class-name
24968 Returns a TREE_LIST. The TREE_PURPOSE will be one of
24969 ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to
24970 indicate the specifiers provided. The TREE_VALUE will be a TYPE
24971 (or the ERROR_MARK_NODE) indicating the type that was specified. */
24973 static tree
24975 {
24983 tree type;
24985 /* Process the optional `virtual' and `access-specifier'. */
24987 {
24988 /* Peek at the next token. */
24990 /* Process `virtual'. */
24992 {
24994 /* If `virtual' appears more than once, issue an error. */
24996 {
25000 }
25004 /* Consume the `virtual' token. */
25012 /* If more than one access specifier appears, issue an
25013 error. */
25016 {
25020 }
25024 /* Consume the access-specifier. */
25032 }
25033 }
25034 /* It is not uncommon to see programs mechanically, erroneously, use
25035 the 'typename' keyword to denote (dependent) qualified types
25036 as base classes. */
25038 {
25043 else
25045 "keyword %<typename%> not allowed in this context "
25048 }
25050 /* Look for the optional `::' operator. */
25052 /* Look for the nested-name-specifier. The simplest way to
25053 implement:
25055 [temp.res]
25057 The keyword `typename' is not permitted in a base-specifier or
25058 mem-initializer; in these contexts a qualified name that
25059 depends on a template-parameter is implicitly assumed to be a
25060 type name.
25062 is to pretend that we have seen the `typename' keyword at this
25063 point. */
25069 /* If the base class is given by a qualified name, assume that names
25070 we see are type names or templates, as appropriate. */
25076 /* DR 950 allows decltype as a base-specifier. */
25078 else
25079 {
25080 /* Otherwise, look for the class-name. */
25082 class_scope_p,
25083 template_p,
25084 typename_type,
25089 }
25095 }
25097 /* Exception handling [gram.exception] */
25099 /* Parse an (optional) noexcept-specification.
25101 noexcept-specification:
25102 noexcept ( constant-expression ) [opt]
25104 If no noexcept-specification is present, returns NULL_TREE.
25105 Otherwise, if REQUIRE_CONSTEXPR is false, then either parse and return any
25106 expression if parentheses follow noexcept, or return BOOLEAN_TRUE_NODE if
25107 there are no parentheses. CONSUMED_EXPR will be set accordingly.
25108 Otherwise, returns a noexcept specification unless RETURN_COND is true,
25109 in which case a boolean condition is returned instead. */
25111 static tree
25116 {
25120 /* Peek at the next token. */
25123 /* Is it a noexcept-specification? */
25125 {
25126 tree expr;
25130 {
25131 matching_parens parens;
25141 {
25142 /* Types may not be defined in an exception-specification. */
25144 parser->type_definition_forbidden_message
25148 expr
25154 {
25157 }
25159 /* Restore the saved message. */
25161 }
25162 else
25163 {
25166 }
25172 }
25173 else
25174 {
25178 }
25180 /* We cannot build a noexcept-spec right away because this will check
25181 that expr is a constexpr. */
25184 else
25186 }
25187 else
25189 }
25191 /* Parse an (optional) exception-specification.
25193 exception-specification:
25194 throw ( type-id-list [opt] )
25196 Returns a TREE_LIST representing the exception-specification. The
25197 TREE_VALUE of each node is a type. */
25199 static tree
25201 {
25203 tree type_id_list;
25206 /* Peek at the next token. */
25209 /* Is it a noexcept-specification? */
25215 /* If it's not `throw', then there's no exception-specification. */
25221 /* Consume the `throw'. */
25224 /* Look for the `('. */
25225 matching_parens parens;
25228 /* Peek at the next token. */
25230 /* If it's not a `)', then there is a type-id-list. */
25232 {
25233 /* Types may not be defined in an exception-specification. */
25235 parser->type_definition_forbidden_message
25237 /* Parse the type-id-list. */
25239 /* Restore the saved message. */
25243 {
25247 }
25250 "dynamic exception specifications are deprecated in "
25252 }
25253 /* In C++17, throw() is equivalent to noexcept (true). throw()
25254 is deprecated in C++11 and above as well, but is still widely used,
25255 so don't warn about it yet. */
25258 else
25261 /* Look for the `)'. */
25265 }
25267 /* Parse an (optional) type-id-list.
25269 type-id-list:
25270 type-id ... [opt]
25271 type-id-list , type-id ... [opt]
25273 Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE,
25274 in the order that the types were presented. */
25276 static tree
25278 {
25282 {
25284 tree type;
25288 /* Get the next type-id. */
25290 /* Check for invalid 'auto'. */
25292 {
25296 }
25297 /* Parse the optional ellipsis. */
25299 {
25300 /* Consume the `...'. */
25303 /* Turn the type into a pack expansion expression. */
25305 }
25306 /* Add it to the list. */
25308 /* Peek at the next token. */
25310 /* If it is not a `,', we are done. */
25313 /* Consume the `,'. */
25315 }
25318 }
25320 /* Parse a try-block.
25322 try-block:
25323 try compound-statement handler-seq */
25325 static tree
25327 {
25328 tree try_block;
25342 }
25344 /* Parse a function-try-block.
25346 function-try-block:
25347 try ctor-initializer [opt] function-body handler-seq */
25349 static void
25351 {
25352 tree compound_stmt;
25353 tree try_block;
25355 /* Look for the `try' keyword. */
25358 /* Let the rest of the front end know where we are. */
25360 /* Parse the function-body. */
25361 cp_parser_ctor_initializer_opt_and_function_body
25363 /* We're done with the `try' part. */
25365 /* Parse the handlers. */
25367 /* We're done with the handlers. */
25369 }
25371 /* Parse a handler-seq.
25373 handler-seq:
25374 handler handler-seq [opt] */
25376 static void
25378 {
25380 {
25383 /* Parse the handler. */
25385 /* Peek at the next token. */
25387 /* If it's not `catch' then there are no more handlers. */
25390 }
25391 }
25393 /* Parse a handler.
25395 handler:
25396 catch ( exception-declaration ) compound-statement */
25398 static void
25400 {
25401 tree handler;
25402 tree declaration;
25406 matching_parens parens;
25413 }
25415 /* Parse an exception-declaration.
25417 exception-declaration:
25418 type-specifier-seq declarator
25419 type-specifier-seq abstract-declarator
25420 type-specifier-seq
25421 ...
25423 Returns a VAR_DECL for the declaration, or NULL_TREE if the
25424 ellipsis variant is used. */
25426 static tree
25428 {
25429 cp_decl_specifier_seq type_specifiers;
25433 /* If it's an ellipsis, it's easy to handle. */
25435 {
25436 /* Consume the `...' token. */
25439 }
25441 /* Types may not be defined in exception-declarations. */
25443 parser->type_definition_forbidden_message
25446 /* Parse the type-specifier-seq. */
25451 /* If it's a `)', then there is no declarator. */
25454 else
25456 CP_PARSER_FLAGS_NONE,
25463 /* Restore the saved message. */
25470 }
25472 /* Parse a throw-expression.
25474 throw-expression:
25475 throw assignment-expression [opt]
25477 Returns a THROW_EXPR representing the throw-expression. */
25479 static tree
25481 {
25482 tree expression;
25487 /* Figure out whether or not there is an assignment-expression
25488 following the "throw" keyword. */
25496 else
25500 }
25502 /* GNU Extensions */
25504 /* Parse an (optional) asm-specification.
25506 asm-specification:
25507 asm ( string-literal )
25509 If the asm-specification is present, returns a STRING_CST
25510 corresponding to the string-literal. Otherwise, returns
25511 NULL_TREE. */
25513 static tree
25515 {
25517 tree asm_specification;
25519 /* Peek at the next token. */
25521 /* If the next token isn't the `asm' keyword, then there's no
25522 asm-specification. */
25526 /* Consume the `asm' token. */
25528 /* Look for the `('. */
25529 matching_parens parens;
25532 /* Look for the string-literal. */
25535 /* Look for the `)'. */
25539 }
25541 /* Parse an asm-operand-list.
25543 asm-operand-list:
25544 asm-operand
25545 asm-operand-list , asm-operand
25547 asm-operand:
25548 string-literal ( expression )
25549 [ string-literal ] string-literal ( expression )
25551 Returns a TREE_LIST representing the operands. The TREE_VALUE of
25552 each node is the expression. The TREE_PURPOSE is itself a
25553 TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed
25554 string-literal (or NULL_TREE if not present) and whose TREE_VALUE
25555 is a STRING_CST for the string literal before the parenthesis. Returns
25556 ERROR_MARK_NODE if any of the operands are invalid. */
25558 static tree
25560 {
25565 {
25566 tree string_literal;
25567 tree expression;
25568 tree name;
25571 {
25572 /* Consume the `[' token. */
25574 /* Read the operand name. */
25579 /* Look for the closing `]'. */
25581 }
25582 else
25584 /* Look for the string-literal. */
25587 /* Look for the `('. */
25588 matching_parens parens;
25590 /* Parse the expression. */
25592 /* Look for the `)'. */
25600 /* Add this operand to the list. */
25602 expression,
25603 asm_operands);
25604 /* If the next token is not a `,', there are no more
25605 operands. */
25608 /* Consume the `,'. */
25610 }
25613 }
25615 /* Parse an asm-clobber-list.
25617 asm-clobber-list:
25618 string-literal
25619 asm-clobber-list , string-literal
25621 Returns a TREE_LIST, indicating the clobbers in the order that they
25622 appeared. The TREE_VALUE of each node is a STRING_CST. */
25624 static tree
25626 {
25630 {
25631 tree string_literal;
25633 /* Look for the string literal. */
25635 /* Add it to the list. */
25637 /* If the next token is not a `,', then the list is
25638 complete. */
25641 /* Consume the `,' token. */
25643 }
25646 }
25648 /* Parse an asm-label-list.
25650 asm-label-list:
25651 identifier
25652 asm-label-list , identifier
25654 Returns a TREE_LIST, indicating the labels in the order that they
25655 appeared. The TREE_VALUE of each node is a label. */
25657 static tree
25659 {
25663 {
25666 /* Look for the identifier. */
25669 {
25672 {
25678 }
25679 }
25680 /* If the next token is not a `,', then the list is
25681 complete. */
25684 /* Consume the `,' token. */
25686 }
25689 }
25691 /* Return TRUE iff the next tokens in the stream are possibly the
25692 beginning of a GNU extension attribute. */
25694 static bool
25696 {
25698 }
25700 /* Return TRUE iff the next tokens in the stream are possibly the
25701 beginning of a standard C++-11 attribute specifier. */
25703 static bool
25705 {
25707 }
25709 /* Return TRUE iff the next Nth tokens in the stream are possibly the
25710 beginning of a standard C++-11 attribute specifier. */
25712 static bool
25714 {
25722 }
25724 /* Return TRUE iff the next Nth tokens in the stream are possibly the
25725 beginning of a GNU extension attribute. */
25727 static bool
25729 {
25733 }
25735 /* Return true iff the next tokens can be the beginning of either a
25736 GNU attribute list, or a standard C++11 attribute sequence. */
25738 static bool
25740 {
25743 }
25745 /* Return true iff the next Nth tokens can be the beginning of either
25746 a GNU attribute list, or a standard C++11 attribute sequence. */
25748 static bool
25750 {
25753 }
25755 /* Parse either a standard C++-11 attribute-specifier-seq, or a series
25756 of GNU attributes, or return NULL. */
25758 static tree
25760 {
25764 }
25766 /* Parse an (optional) series of attributes.
25768 attributes:
25769 attributes attribute
25771 attribute:
25772 __attribute__ (( attribute-list [opt] ))
25774 The return value is as for cp_parser_gnu_attribute_list. */
25776 static tree
25778 {
25785 {
25787 tree attribute_list;
25790 /* Peek at the next token. */
25792 /* If it's not `__attribute__', then we're done. */
25796 /* Consume the `__attribute__' keyword. */
25798 /* Look for the two `(' tokens. */
25799 matching_parens outer_parens;
25802 matching_parens inner_parens;
25806 /* Peek at the next token. */
25809 /* Parse the attribute-list. */
25811 else
25812 /* If the next token is a `)', then there is no attribute
25813 list. */
25816 /* Look for the two `)' tokens. */
25824 /* Add these new attributes to the list. */
25826 }
25829 }
25831 /* Parse a GNU attribute-list.
25833 attribute-list:
25834 attribute
25835 attribute-list , attribute
25837 attribute:
25838 identifier
25839 identifier ( identifier )
25840 identifier ( identifier , expression-list )
25841 identifier ( expression-list )
25843 Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds
25844 to an attribute. The TREE_PURPOSE of each node is the identifier
25845 indicating which attribute is in use. The TREE_VALUE represents
25846 the arguments, if any. */
25848 static tree
25850 {
25854 /* Don't create wrapper nodes within attributes: the
25855 handlers don't know how to handle them. */
25856 auto_suppress_location_wrappers sentinel;
25860 {
25862 tree identifier;
25863 tree attribute;
25865 /* Look for the identifier. We also allow keywords here; for
25866 example `__attribute__ ((const))' is legal. */
25870 {
25873 /* Consume the token, but save it since we need it for the
25874 SIMD enabled function parsing. */
25877 /* Save away the identifier that indicates which attribute
25878 this is. */
25880 /* For keywords, use the canonical spelling, not the
25881 parsed identifier. */
25888 /* Peek at the next token. */
25890 /* If it's an `(', then parse the attribute arguments. */
25892 {
25896 vec = cp_parser_parenthesized_expression_list
25902 else
25903 {
25906 }
25907 /* Save the arguments away. */
25909 }
25912 {
25913 /* Add this attribute to the list. */
25916 }
25919 }
25920 /* Unless EXACTLY_ONE is set look for more attributes.
25921 If the next token isn't a `,', we're done. */
25925 /* Consume the comma and keep going. */
25927 }
25930 /* We built up the list in reverse order. */
25932 }
25934 /* Parse a standard C++11 attribute.
25936 The returned representation is a TREE_LIST which TREE_PURPOSE is
25937 the scoped name of the attribute, and the TREE_VALUE is its
25938 arguments list.
25940 Note that the scoped name of the attribute is itself a TREE_LIST
25941 which TREE_PURPOSE is the namespace of the attribute, and
25942 TREE_VALUE its name. This is unlike a GNU attribute -- as parsed
25943 by cp_parser_gnu_attribute_list -- that doesn't have any namespace
25944 and which TREE_PURPOSE is directly the attribute name.
25946 Clients of the attribute code should use get_attribute_namespace
25947 and get_attribute_name to get the actual namespace and name of
25948 attributes, regardless of their being GNU or C++11 attributes.
25950 attribute:
25951 attribute-token attribute-argument-clause [opt]
25953 attribute-token:
25954 identifier
25955 attribute-scoped-token
25957 attribute-scoped-token:
25958 attribute-namespace :: identifier
25960 attribute-namespace:
25961 identifier
25963 attribute-argument-clause:
25964 ( balanced-token-seq )
25966 balanced-token-seq:
25967 balanced-token [opt]
25968 balanced-token-seq balanced-token
25970 balanced-token:
25971 ( balanced-token-seq )
25972 [ balanced-token-seq ]
25973 { balanced-token-seq }. */
25975 static tree
25977 {
25984 /* First, parse name of the attribute, a.k.a attribute-token. */
26001 {
26002 /* We are seeing a scoped attribute token. */
26017 else
26018 {
26022 }
26027 NULL_TREE);
26029 }
26031 {
26035 NULL_TREE);
26036 }
26037 else
26038 {
26041 NULL_TREE);
26042 /* C++11 noreturn attribute is equivalent to GNU's. */
26045 /* C++14 deprecated attribute is equivalent to GNU's. */
26048 /* C++17 fallthrough attribute is equivalent to GNU's. */
26051 /* Transactional Memory TS optimize_for_synchronized attribute is
26052 equivalent to GNU transaction_callable. */
26056 /* Transactional Memory attributes are GNU attributes. */
26059 }
26061 /* Now parse the optional argument clause of the attribute. */
26066 {
26072 /* A GNU attribute that takes an identifier in parameter. */
26075 vec = cp_parser_parenthesized_expression_list
26081 else
26082 {
26085 }
26089 else
26091 }
26094 }
26096 /* Check that the attribute ATTRIBUTE appears at most once in the
26097 attribute-list ATTRIBUTES. This is enforced for noreturn (7.6.3)
26098 and deprecated (7.6.5). Note that carries_dependency (7.6.4)
26099 isn't implemented yet in GCC. */
26101 static void
26103 {
26105 {
26115 }
26116 }
26118 /* Parse a list of standard C++-11 attributes.
26120 attribute-list:
26121 attribute [opt]
26122 attribute-list , attribute[opt]
26123 attribute ...
26124 attribute-list , attribute ...
26125 */
26127 static tree
26129 {
26134 {
26139 {
26143 }
26146 {
26151 else
26152 {
26157 }
26159 }
26163 }
26166 }
26168 /* Parse a standard C++-11 attribute specifier.
26170 attribute-specifier:
26171 [ [ attribute-using-prefix [opt] attribute-list ] ]
26172 alignment-specifier
26174 attribute-using-prefix:
26175 using attribute-namespace :
26177 alignment-specifier:
26178 alignas ( type-id ... [opt] )
26179 alignas ( alignment-expression ... [opt] ). */
26181 static tree
26183 {
26189 {
26196 {
26207 {
26211 "attribute using prefix only available "
26217 }
26218 else
26220 }
26227 else
26228 /* Warn about parsing c++11 attribute in non-c++11 mode, only
26229 when we are sure that we have actually parsed them. */
26231 }
26232 else
26233 {
26234 tree alignas_expr;
26236 /* Look for an alignment-specifier. */
26247 matching_parens parens;
26255 {
26262 }
26267 /* Handle alignas (pack...). */
26269 {
26272 }
26274 /* Something went wrong, so don't build the attribute. */
26281 /* Build the C++-11 representation of an 'aligned'
26282 attribute. */
26283 attributes
26286 }
26289 }
26291 /* Parse a standard C++-11 attribute-specifier-seq.
26293 attribute-specifier-seq:
26294 attribute-specifier-seq [opt] attribute-specifier
26295 */
26297 static tree
26299 {
26303 /* Don't create wrapper nodes within attributes: the
26304 handlers don't know how to handle them. */
26305 auto_suppress_location_wrappers sentinel;
26308 {
26317 else
26320 }
26323 }
26325 /* Skip a balanced-token starting at Nth token (with 1 as the next token),
26326 return index of the first token after balanced-token, or N on failure. */
26328 static size_t
26330 {
26333 do
26335 {
26339 /* FALLTHRU */
26341 /* Ran out of tokens. */
26363 }
26366 }
26368 /* Skip GNU attribute tokens starting at Nth token (with 1 as the next token),
26369 return index of the first token after the GNU attribute tokens, or N on
26370 failure. */
26372 static size_t
26374 {
26376 {
26388 }
26390 }
26392 /* Skip standard C++11 attribute tokens starting at Nth token (with 1 as the
26393 next token), return index of the first token after the standard C++11
26394 attribute tokens, or N on failure. */
26396 static size_t
26398 {
26400 {
26403 {
26410 }
26413 {
26418 }
26419 else
26421 }
26423 }
26425 /* Skip standard C++11 or GNU attribute tokens starting at Nth token (with 1
26426 as the next token), return index of the first token after the attribute
26427 tokens, or N on failure. */
26429 static size_t
26431 {
26435 }
26437 /* Parse an optional `__extension__' keyword. Returns TRUE if it is
26438 present, and FALSE otherwise. *SAVED_PEDANTIC is set to the
26439 current value of the PEDANTIC flag, regardless of whether or not
26440 the `__extension__' keyword is present. The caller is responsible
26441 for restoring the value of the PEDANTIC flag. */
26443 static bool
26445 {
26446 /* Save the old value of the PEDANTIC flag. */
26450 {
26451 /* Consume the `__extension__' token. */
26453 /* We're not being pedantic while the `__extension__' keyword is
26454 in effect. */
26458 }
26461 }
26463 /* Parse a label declaration.
26465 label-declaration:
26466 __label__ label-declarator-seq ;
26468 label-declarator-seq:
26469 identifier , label-declarator-seq
26470 identifier */
26472 static void
26474 {
26475 /* Look for the `__label__' keyword. */
26479 {
26480 tree identifier;
26482 /* Look for an identifier. */
26484 /* If we failed, stop. */
26487 /* Declare it as a label. */
26489 /* If the next token is a `;', stop. */
26492 /* Look for the `,' separating the label declarations. */
26494 }
26496 /* Look for the final `;'. */
26498 }
26500 // -------------------------------------------------------------------------- //
26501 // Requires Clause
26503 // Parse a requires clause.
26504 //
26505 // requires-clause:
26506 // 'requires' logical-or-expression
26507 //
26508 // The required logical-or-expression must be a constant expression. Note
26509 // that we don't check that the expression is constepxr here. We defer until
26510 // we analyze constraints and then, we only check atomic constraints.
26511 static tree
26513 {
26514 // Parse the requires clause so that it is not automatically folded.
26522 }
26524 // Optionally parse a requires clause:
26525 static tree
26527 {
26530 {
26533 {
26536 /* Parse and discard the requires-clause. */
26539 }
26541 }
26544 }
26547 /*---------------------------------------------------------------------------
26548 Requires expressions
26549 ---------------------------------------------------------------------------*/
26551 /* Parse a requires expression
26553 requirement-expression:
26554 'requires' requirement-parameter-list [opt] requirement-body */
26555 static tree
26557 {
26561 /* A requires-expression shall appear only within a concept
26562 definition or a requires-clause.
26564 TODO: Implement this diagnostic correctly. */
26566 {
26570 }
26573 {
26574 /* Local parameters are delared as variables within the scope
26575 of the expression. They are not visible past the end of
26576 the expression. Expressions within the requires-expression
26577 are unevaluated. */
26578 struct scope_sentinel
26579 {
26581 {
26584 }
26587 {
26590 }
26593 /* Parse the optional parameter list. */
26595 {
26599 }
26600 else
26603 /* Parse the requirement body. */
26607 }
26609 /* This needs to happen after pop_bindings_and_leave_scope, as it reverses
26610 the parm chain. */
26613 }
26615 /* Parse a parameterized requirement.
26617 requirement-parameter-list:
26618 '(' parameter-declaration-clause ')' */
26619 static tree
26621 {
26622 matching_parens parens;
26626 tree parms
26633 }
26635 /* Parse the body of a requirement.
26637 requirement-body:
26638 '{' requirement-list '}' */
26639 static tree
26641 {
26642 matching_braces braces;
26652 }
26654 /* Parse a list of requirements.
26656 requirement-list:
26657 requirement
26658 requirement-list ';' requirement[opt] */
26659 static tree
26661 {
26664 {
26671 /* If we see a semi-colon, consume it. */
26675 /* Stop processing at the end of the list. */
26678 }
26680 /* Reverse the order of requirements so they are analyzed in
26681 declaration order. */
26683 }
26685 /* Parse a syntactic requirement or type requirement.
26687 requirement:
26688 simple-requirement
26689 compound-requirement
26690 type-requirement
26691 nested-requirement */
26692 static tree
26694 {
26701 else
26703 }
26705 /* Parse a simple requirement.
26707 simple-requirement:
26708 expression ';' */
26709 static tree
26711 {
26720 }
26722 /* Parse a type requirement
26724 type-requirement
26725 nested-name-specifier [opt] required-type-name ';'
26727 required-type-name:
26728 type-name
26729 'template' [opt] simple-template-id */
26730 static tree
26732 {
26735 // Save the scope before parsing name specifiers.
26746 tree type;
26748 {
26757 }
26758 else
26777 }
26779 /* Parse a compound requirement
26781 compound-requirement:
26782 '{' expression '}' 'noexcept' [opt] trailing-return-type [opt] ';' */
26783 static tree
26785 {
26786 /* Parse an expression enclosed in '{ }'s. */
26787 matching_braces braces;
26798 /* Parse the optional noexcept. */
26801 {
26804 }
26806 /* Parse the optional trailing return type. */
26809 {
26817 }
26820 }
26822 /* Parse a nested requirement. This is the same as a requires clause.
26824 nested-requirement:
26825 requires-clause */
26826 static tree
26828 {
26834 }
26836 /* Support Functions */
26838 /* Return the appropriate prefer_type argument for lookup_name_real based on
26839 tag_type and template_mem_access. */
26843 {
26844 /* DR 141: When looking in the current enclosing context for a template-name
26845 after -> or ., only consider class templates. */
26849 {
26853 }
26854 }
26856 /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
26857 NAME should have one of the representations used for an
26858 id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
26859 is returned. If PARSER->SCOPE is a dependent type, then a
26860 SCOPE_REF is returned.
26862 If NAME is a TEMPLATE_ID_EXPR, then it will be immediately
26863 returned; the name was already resolved when the TEMPLATE_ID_EXPR
26864 was formed. Abstractly, such entities should not be passed to this
26865 function, because they do not need to be looked up, but it is
26866 simpler to check for this special case here, rather than at the
26867 call-sites.
26869 In cases not explicitly covered above, this function returns a
26870 DECL, OVERLOAD, or baselink representing the result of the lookup.
26871 If there was no entity with the indicated NAME, the ERROR_MARK_NODE
26872 is returned.
26874 If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword
26875 (e.g., "struct") that was used. In that case bindings that do not
26876 refer to types are ignored.
26878 If IS_TEMPLATE is TRUE, bindings that do not refer to templates are
26879 ignored.
26881 If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces
26882 are ignored.
26884 If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent
26885 types.
26887 If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a
26888 TREE_LIST of candidates if name-lookup results in an ambiguity, and
26889 NULL_TREE otherwise. */
26891 static cp_expr
26898 location_t name_location)
26899 {
26900 tree decl;
26903 /* Assume that the lookup will be unambiguous. */
26907 /* Now that we have looked up the name, the OBJECT_TYPE (if any) is
26908 no longer valid. Note that if we are parsing tentatively, and
26909 the parse fails, OBJECT_TYPE will be automatically restored. */
26915 /* A template-id has already been resolved; there is no lookup to
26916 do. */
26920 {
26924 }
26926 /* A BIT_NOT_EXPR is used to represent a destructor. By this point,
26927 it should already have been checked to make sure that the name
26928 used matches the type being destroyed. */
26930 {
26931 tree type;
26933 /* Figure out to which type this destructor applies. */
26938 else
26940 /* If that's not a class type, there is no destructor. */
26951 }
26953 /* By this point, the NAME should be an ordinary identifier. If
26954 the id-expression was a qualified name, the qualifying scope is
26955 stored in PARSER->SCOPE at this point. */
26958 /* Perform the lookup. */
26960 {
26966 /* If the SCOPE is dependent, the lookup must be deferred until
26967 the template is instantiated -- unless we are explicitly
26968 looking up names in uninstantiated templates. Even then, we
26969 cannot look up the name if the scope is not a class type; it
26970 might, for example, be a template type parameter. */
26975 /* Defer lookup. */
26977 else
26978 {
26981 /* If PARSER->SCOPE is a dependent type, then it must be a
26982 class type, and we must not be checking dependencies;
26983 otherwise, we would have processed this lookup above. So
26984 that PARSER->SCOPE is not considered a dependent base by
26985 lookup_member, we must enter the scope here. */
26989 /* If the PARSER->SCOPE is a template specialization, it
26990 may be instantiated during name lookup. In that case,
26991 errors may be issued. Even if we rollback the current
26992 tentative parse, those errors are valid. */
26997 /* 3.4.3.1: In a lookup in which the constructor is an acceptable
26998 lookup result and the nested-name-specifier nominates a class C:
26999 * if the name specified after the nested-name-specifier, when
27000 looked up in C, is the injected-class-name of C (Clause 9), or
27001 * if the name specified after the nested-name-specifier is the
27002 same as the identifier or the simple-template-id's template-
27003 name in the last component of the nested-name-specifier,
27004 the name is instead considered to name the constructor of
27005 class C. [ Note: for example, the constructor is not an
27006 acceptable lookup result in an elaborated-type-specifier so
27007 the constructor would not be used in place of the
27008 injected-class-name. --end note ] Such a constructor name
27009 shall be used only in the declarator-id of a declaration that
27010 names a constructor or in a using-declaration. */
27018 /* If we have a single function from a using decl, pull it out. */
27025 }
27027 /* If the scope is a dependent type and either we deferred lookup or
27028 we did lookup but didn't find the name, rememeber the name. */
27031 {
27033 {
27034 tree type;
27036 /* The resolution to Core Issue 180 says that `struct
27037 A::B' should be considered a type-name, even if `A'
27038 is dependent. */
27043 }
27047 CPP_CLOSE_PAREN)))
27051 else
27054 is_template);
27055 }
27058 }
27060 {
27061 /* Look up the name in the scope of the OBJECT_TYPE, unless the
27062 OBJECT_TYPE is not a class. */
27064 /* If the OBJECT_TYPE is a template specialization, it may
27065 be instantiated during name lookup. In that case, errors
27066 may be issued. Even if we rollback the current tentative
27067 parse, those errors are valid. */
27069 name,
27072 tf_warning_or_error);
27073 else
27077 /* Look it up in the enclosing context. DR 141: When looking for a
27078 template-name after -> or ., only consider class templates. */
27083 /* The object is type-dependent, so we can't look anything up; we used
27084 this to get the DR 141 behavior. */
27088 }
27089 else
27090 {
27096 }
27098 /* If the lookup failed, let our caller know. */
27102 /* Pull out the template from an injected-class-name (or multiple). */
27106 /* If it's a TREE_LIST, the result of the lookup was ambiguous. */
27108 {
27111 /* The error message we have to print is too complicated for
27112 cp_parser_error, so we incorporate its actions directly. */
27114 {
27116 name);
27118 }
27120 }
27128 /* If we have resolved the name of a member declaration, check to
27129 see if the declaration is accessible. When the name resolves to
27130 set of overloaded functions, accessibility is checked when
27131 overload resolution is done.
27133 During an explicit instantiation, access is not checked at all,
27134 as per [temp.explicit]. */
27141 }
27143 /* Like cp_parser_lookup_name, but for use in the typical case where
27144 CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE,
27145 IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */
27147 static tree
27149 {
27151 none_type,
27156 location);
27157 }
27159 /* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in
27160 the current context, return the TYPE_DECL. If TAG_NAME_P is
27161 true, the DECL indicates the class being defined in a class-head,
27162 or declared in an elaborated-type-specifier.
27164 Otherwise, return DECL. */
27166 static tree
27168 {
27169 /* If the TEMPLATE_DECL is being declared as part of a class-head,
27170 the translation from TEMPLATE_DECL to TYPE_DECL occurs:
27172 struct A {
27173 template <typename T> struct B;
27174 };
27176 template <typename T> struct A::B {};
27178 Similarly, in an elaborated-type-specifier:
27180 namespace N { struct X{}; }
27182 struct A {
27183 template <typename T> friend struct N::X;
27184 };
27186 However, if the DECL refers to a class type, and we are in
27187 the scope of the class, then the name lookup automatically
27188 finds the TYPE_DECL created by build_self_reference rather
27189 than a TEMPLATE_DECL. For example, in:
27191 template <class T> struct S {
27192 S s;
27193 };
27195 there is no need to handle such case. */
27201 }
27203 /* If too many, or too few, template-parameter lists apply to the
27204 declarator, issue an error message. Returns TRUE if all went well,
27205 and FALSE otherwise. */
27207 static bool
27210 location_t declarator_location)
27211 {
27213 {
27215 {
27224 {
27225 /* If the DECLARATOR has the form `X<y>' then it uses one
27226 additional level of template parameters. */
27229 }
27231 return cp_parser_check_template_parameters
27233 declarator);
27234 }
27250 }
27252 }
27254 /* NUM_TEMPLATES were used in the current declaration. If that is
27255 invalid, return FALSE and issue an error messages. Otherwise,
27256 return TRUE. If DECLARATOR is non-NULL, then we are checking a
27257 declarator and we can print more accurate diagnostics. */
27259 static bool
27263 location_t location,
27265 {
27266 /* If there are the same number of template classes and parameter
27267 lists, that's OK. */
27270 /* If there are more, but only one more, and the name ends in an identifier,
27271 then we are declaring a primary template. That's OK too. */
27275 /* If there are more template classes than parameter lists, we have
27276 something like:
27278 template <class T> void S<T>::R<T>::f (); */
27280 {
27290 else
27293 }
27294 /* Otherwise, there are too many template parameter lists. We have
27295 something like:
27297 template <class T> template <class U> void S::f(); */
27300 }
27302 /* Parse an optional `::' token indicating that the following name is
27303 from the global namespace. If so, PARSER->SCOPE is set to the
27304 GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE,
27305 unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone.
27306 Returns the new value of PARSER->SCOPE, if the `::' token is
27307 present, and NULL_TREE otherwise. */
27309 static tree
27311 {
27314 /* Peek at the next token. */
27316 /* If we're looking at a `::' token then we're starting from the
27317 global namespace, not our current location. */
27319 {
27320 /* Consume the `::' token. */
27322 /* Set the SCOPE so that we know where to start the lookup. */
27328 }
27330 {
27334 }
27337 }
27339 /* Returns TRUE if the upcoming token sequence is the start of a
27340 constructor declarator or C++17 deduction guide. If FRIEND_P is true, the
27341 declarator is preceded by the `friend' specifier. */
27343 static bool
27345 {
27348 tree nested_name_specifier;
27351 /* The common case is that this is not a constructor declarator, so
27352 try to avoid doing lots of work if at all possible. It's not
27353 valid declare a constructor at function scope. */
27356 /* And only certain tokens can begin a constructor declarator. */
27364 /* Parse tentatively; we are going to roll back all of the tokens
27365 consumed here. */
27367 /* Assume that we are looking at a constructor declarator. */
27370 /* Look for the optional `::' operator. */
27373 /* Look for the nested-name-specifier. */
27374 nested_name_specifier
27381 /* Resolve the TYPENAME_TYPE, because the call above didn't do it. */
27384 {
27389 }
27395 /* Outside of a class-specifier, there must be a
27396 nested-name-specifier. Except in C++17 mode, where we
27397 might be declaring a guiding declaration. */
27404 /* If we have a class scope, this is easy; DR 147 says that S::S always
27405 names the constructor, and no other qualified name could. */
27408 {
27418 }
27419 /* If we still think that this might be a constructor-declarator,
27420 look for a class-name. */
27422 {
27423 /* If we have:
27425 template <typename T> struct S {
27426 S();
27427 };
27429 we must recognize that the nested `S' names a class. */
27433 tree type_decl;
27437 none_type,
27444 {
27450 none_type,
27455 else
27457 }
27459 /* If there was no class-name, then this is not a constructor.
27460 Otherwise, if we are in a class-specifier and we aren't
27461 handling a friend declaration, check that its type matches
27462 current_class_type (c++/38313). Note: error_mark_node
27463 is left alone for error recovery purposes. */
27465 && (outside_class_specifier_p
27471 /* If we're still considering a constructor, we have to see a `(',
27472 to begin the parameter-declaration-clause, followed by either a
27473 `)', an `...', or a decl-specifier. We need to check for a
27474 type-specifier to avoid being fooled into thinking that:
27476 S (f) (int);
27478 is a constructor. (It is actually a function named `f' that
27479 takes one parameter (of type `int') and returns a value of type
27480 `S'. */
27488 /* A parameter declaration begins with a decl-specifier,
27489 which is either the "attribute" keyword, a storage class
27490 specifier, or (usually) a type-specifier. */
27492 {
27493 tree type;
27497 /* Names appearing in the type-specifier should be looked up
27498 in the scope of the class. */
27502 {
27505 {
27509 {
27512 }
27513 }
27515 }
27517 /* Inside the constructor parameter list, surrounding
27518 template-parameter-lists do not apply. */
27519 saved_num_template_parameter_lists
27523 /* Look for the type-specifier. */
27525 CP_PARSER_FLAGS_NONE,
27531 parser->num_template_parameter_lists
27534 /* Leave the scope of the class. */
27539 }
27540 }
27542 /* We did not really want to consume any tokens. */
27546 }
27548 /* Parse the definition of the function given by the DECL_SPECIFIERS,
27549 ATTRIBUTES, and DECLARATOR. The access checks have been deferred;
27550 they must be performed once we are in the scope of the function.
27552 Returns the function defined. */
27554 static tree
27555 cp_parser_function_definition_from_specifiers_and_declarator
27558 tree attributes,
27560 {
27561 tree fn;
27564 /* Begin the function-definition. */
27567 /* The things we're about to see are not directly qualified by any
27568 template headers we've seen thus far. */
27571 /* If there were names looked up in the decl-specifier-seq that we
27572 did not check, check them now. We must wait until we are in the
27573 scope of the function to perform the checks, since the function
27574 might be a friend. */
27578 {
27583 }
27586 {
27587 /* Skip the entire function. */
27590 }
27592 {
27593 /* Seen already, skip it. An error message has already been output. */
27597 /* If this is a function from a class, pop the nested class. */
27600 }
27601 else
27602 {
27603 timevar_id_t tv;
27606 else
27612 }
27615 }
27617 /* Parse the part of a function-definition that follows the
27618 declarator. INLINE_P is TRUE iff this function is an inline
27619 function defined within a class-specifier.
27621 Returns the function defined. */
27623 static tree
27626 {
27627 tree fn;
27632 bool fully_implicit_function_template_p
27635 tree implicit_template_parms
27638 cp_binding_level* implicit_template_scope
27644 /* If the next token is `return', then the code may be trying to
27645 make use of the "named return value" extension that G++ used to
27646 support. */
27649 {
27650 /* Consume the `return' keyword. */
27652 /* Look for the identifier that indicates what value is to be
27653 returned. */
27655 /* Issue an error message. */
27658 /* Skip tokens until we reach the start of the function body. */
27660 {
27667 }
27668 }
27669 /* The `extern' in `extern "C" void f () { ... }' does not apply to
27670 anything declared inside `f'. */
27671 saved_in_unbraced_linkage_specification_p
27674 /* Inside the function, surrounding template-parameter-lists do not
27675 apply. */
27676 saved_num_template_parameter_lists
27680 /* If the next token is `try', `__transaction_atomic', or
27681 `__transaction_relaxed`, then we are looking at either function-try-block
27682 or function-transaction-block. Note that all of these include the
27683 function-body. */
27687 RID_TRANSACTION_RELAXED))
27691 else
27692 cp_parser_ctor_initializer_opt_and_function_body
27695 /* Finish the function. */
27697 /* Generate code for it, if necessary. */
27699 /* Restore the saved values. */
27700 parser->in_unbraced_linkage_specification_p
27702 parser->num_template_parameter_lists
27706 parser->fully_implicit_function_template_p
27708 parser->implicit_template_parms
27710 parser->implicit_template_scope
27717 }
27719 /* Parse a template-declaration body (following argument list). */
27721 static void
27723 tree parameter_list,
27725 {
27729 /* We just processed one more parameter list. */
27732 /* Get the deferred access checks from the parameter list. These
27733 will be checked once we know what is being declared, as for a
27734 member template the checks must be performed in the scope of the
27735 class containing the member. */
27738 /* Tentatively parse for a new template parameter list, which can either be
27739 the template keyword or a template introduction. */
27745 else
27746 {
27747 /* There are no access checks when parsing a template, as we do not
27748 know if a specialization will be a friend. */
27752 checks,
27753 member_p,
27758 /* If this is a member template declaration, let the front
27759 end know. */
27761 {
27766 }
27771 }
27772 /* We are done with the current parameter list. */
27777 /* Finish up. */
27780 /* Check the template arguments for a literal operator template. */
27784 {
27788 else
27789 {
27792 {
27796 /* OK, C++20 string literal operator template. We don't need
27797 to warn in lower dialects here because we will have already
27802 }
27804 {
27813 else
27814 /* http://cplusplus.github.io/EWG/ewg-active.html#66 */
27816 "ISO C++ did not adopt string literal operator templa"
27818 }
27819 else
27821 }
27823 {
27826 " Expected non-type template parameter pack <char...> "
27828 decl);
27829 else
27832 decl);
27833 }
27834 }
27836 /* Register member declarations. */
27839 /* If DECL is a function template, we must return to parse it later.
27840 (Even though there is no definition, there might be default
27841 arguments that need handling.) */
27845 }
27847 /* Parse a template introduction header for a template-declaration. Returns
27848 false if tentative parse fails. */
27850 static bool
27852 {
27859 /* Look for the optional `::' operator. */
27862 /* Look for the nested-name-specifier. */
27872 /* Look up the concept for which we will be matching
27873 template parameters. */
27883 /* Look for opening brace for introduction. */
27884 matching_braces braces;
27892 /* Build vector of placeholder parameters and grab
27893 matching identifiers. */
27896 /* Look for closing brace for introduction. */
27900 /* The introduction-list shall not be empty. */
27903 {
27904 /* In cp_parser_introduction_list we have already issued an error. */
27906 }
27909 {
27913 }
27915 /* Build and associate the constraint. */
27918 {
27920 member_p);
27922 }
27926 }
27928 /* Parse a normal template-declaration following the template keyword. */
27930 static void
27932 {
27933 tree parameter_list;
27937 /* Look for the `<' token. */
27941 {
27942 /* 14.5.2.2 [temp.mem]
27944 A local class shall not have member templates. */
27949 }
27950 /* [temp]
27952 A template ... shall not have C linkage. */
27954 {
27957 /* Give it C++ linkage to avoid confusing other parts of the
27958 front end. */
27961 }
27962 else
27965 /* We cannot perform access checks on the template parameter
27966 declarations until we know what is being declared, just as we
27967 cannot check the decl-specifier list. */
27970 /* If the next token is `>', then we have an invalid
27971 specialization. Rather than complain about an invalid template
27972 parameter, issue an error message here. */
27974 {
27978 }
27979 else
27980 {
27981 /* Parse the template parameters. */
27983 }
27985 /* Look for the `>'. */
27988 /* Manage template requirements */
27990 {
27995 }
27998 member_p);
28000 /* For the erroneous case of a template with C linkage, we pushed an
28001 implicit C++ linkage scope; exit that scope now. */
28004 }
28006 /* Parse a template-declaration, assuming that the `export' (and
28007 `extern') keywords, if present, has already been scanned. MEMBER_P
28008 is as for cp_parser_template_declaration. */
28010 static bool
28012 {
28014 {
28018 }
28023 }
28025 /* Perform the deferred access checks from a template-parameter-list.
28026 CHECKS is a TREE_LIST of access checks, as returned by
28027 get_deferred_access_checks. */
28029 static void
28030 cp_parser_perform_template_parameter_access_checks (vec<deferred_access_check, va_gc> *checks)
28031 {
28035 }
28037 /* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or
28038 `function-definition' sequence that follows a template header.
28039 If MEMBER_P is true, this declaration appears in a class scope.
28041 Returns the DECL for the declared entity. If FRIEND_P is non-NULL,
28042 *FRIEND_P is set to TRUE iff the declaration is a friend. */
28044 static tree
28050 {
28053 cp_decl_specifier_seq decl_specifiers;
28057 /* This function is only used when processing a template
28058 declaration. */
28062 /* Defer access checks until we know what is being declared. */
28065 /* Try the `decl-specifier-seq [opt] init-declarator [opt]'
28066 alternative. */
28069 (CP_PARSER_FLAGS_OPTIONAL
28076 /* There are no template typedefs. */
28078 {
28082 }
28084 /* Gather up the access checks that occurred the
28085 decl-specifier-seq. */
28088 /* Check for the declaration of a template class. */
28090 {
28093 {
28094 // If this is a declaration, but not a definition, associate
28095 // any constraints with the type declaration. Constraints
28096 // are associated with definitions in cp_parser_class_specifier.
28102 /* In this case:
28104 struct C {
28105 friend template <typename T> struct A<T>::B;
28106 };
28108 A<T>::B will be represented by a TYPENAME_TYPE, and
28109 therefore not recognized by shadow_tag. */
28111 && !decl
28118 else
28121 /* Perform access checks for template parameters. */
28124 /* Give a helpful diagnostic for
28125 template <class T> struct A { } a;
28126 if we aren't already recovering from an error. */
28129 {
28131 "a class template declaration must not declare "
28135 }
28136 }
28137 }
28139 /* Complain about missing 'typename' or other invalid type names. */
28142 {
28143 /* cp_parser_parse_and_diagnose_invalid_type_name calls
28144 cp_parser_skip_to_end_of_block_or_statement, so don't try to parse
28145 the rest of this declaration. */
28148 }
28150 /* If it's not a template class, try for a template function. If
28151 the next token is a `;', then this declaration does not declare
28152 anything. But, if there were errors in the decl-specifiers, then
28153 the error might well have come from an attempted class-specifier.
28154 In that case, there's no need to warn about a missing declarator. */
28158 {
28160 CP_PARSER_FLAGS_TYPENAME_OPTIONAL,
28162 checks,
28164 member_p,
28165 declares_class_or_enum,
28169 /* 7.1.1-1 [dcl.stc]
28171 A storage-class-specifier shall not be specified in an explicit
28172 specialization... */
28174 && explicit_specialization_p
28176 {
28180 }
28184 }
28186 /* Look for a trailing `;' after the declaration. */
28192 out:
28195 /* Clear any current qualification; whatever comes next is the start
28196 of something new. */
28202 }
28204 /* Parse a cast-expression that is not the operand of a unary "&". */
28206 static cp_expr
28208 {
28211 }
28213 /* Parse a functional cast to TYPE. Returns an expression
28214 representing the cast. */
28216 static cp_expr
28218 {
28220 tree expression_list;
28221 cp_expr cast;
28230 {
28240 /* Create a location of the form:
28241 type_name{i, f}
28242 ^~~~~~~~~~~~~~~
28243 with caret == start at the start of the type name,
28244 finishing at the closing brace. */
28245 location_t finish_loc
28248 finish_loc);
28251 }
28260 else
28261 {
28264 }
28267 tf_warning_or_error);
28268 /* [expr.const]/1: In an integral constant expression "only type
28269 conversions to integral or enumeration type can be used". */
28275 NIC_CONSTRUCTOR))
28278 /* Create a location of the form:
28279 float(i)
28280 ^~~~~~~~
28281 with caret == start at the start of the type name,
28282 finishing at the closing paren. */
28283 location_t finish_loc
28288 }
28290 /* Save the tokens that make up the body of a member function defined
28291 in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have
28292 already been parsed. The ATTRIBUTES are any GNU "__attribute__"
28293 specifiers applied to the declaration. Returns the FUNCTION_DECL
28294 for the member function. */
28296 static tree
28300 tree attributes)
28301 {
28304 tree fn;
28307 /* Create the FUNCTION_DECL. */
28311 /* If something went badly wrong, bail out now. */
28313 {
28314 /* If there's a function-body, skip it. */
28319 }
28321 /* Remember it, if there default args to post process. */
28324 /* Save away the tokens that make up the body of the
28325 function. */
28331 RID_TRANSACTION_ATOMIC))
28332 {
28334 /* Match cp_parser_txn_attribute_opt [[ identifier ]]. */
28341 {
28347 }
28348 else
28351 {
28355 }
28356 }
28358 /* Handle function try blocks. */
28360 {
28363 }
28364 /* We can have braced-init-list mem-initializers before the fn body. */
28366 {
28369 {
28370 /* cache_group will stop after an un-nested { } pair, too. */
28374 /* variadic mem-inits have ... after the ')'. */
28377 }
28378 }
28380 /* Handle function try blocks. */
28386 /* Save away the inline definition; we will process it when the
28387 class is complete. */
28391 /* We need to know that this was defined in the class, so that
28392 friend templates are handled correctly. */
28395 /* Add FN to the queue of functions to be parsed later. */
28399 }
28401 /* Save the tokens that make up the in-class initializer for a non-static
28402 data member. Returns a DEFAULT_ARG. */
28404 static tree
28406 {
28408 }
28410 /* Parse a template-argument-list, as well as the trailing ">" (but
28411 not the opening "<"). See cp_parser_template_argument_list for the
28412 return value. */
28414 static tree
28416 {
28417 tree arguments;
28418 tree saved_scope;
28419 tree saved_qualifying_scope;
28420 tree saved_object_scope;
28423 /* [temp.names]
28425 When parsing a template-id, the first non-nested `>' is taken as
28426 the end of the template-argument-list rather than a greater-than
28427 operator. */
28428 saved_greater_than_is_operator_p
28431 /* Parsing the argument list may modify SCOPE, so we save it
28432 here. */
28436 /* We need to evaluate the template arguments, even though this
28437 template-id may be nested within a "sizeof". */
28438 cp_evaluated ev;
28439 /* Parse the template-argument-list itself. */
28443 else
28445 /* Look for the `>' that ends the template-argument-list. If we find
28446 a '>>' instead, it's probably just a typo. */
28448 {
28450 {
28451 /* In C++0x, a `>>' in a template argument list or cast
28452 expression is considered to be two separate `>'
28453 tokens. So, change the current token to a `>', but don't
28454 consume it: it will be consumed later when the outer
28455 template argument list (or cast expression) is parsed.
28456 Note that this replacement of `>' for `>>' is necessary
28457 even if we are parsing tentatively: in the tentative
28458 case, after calling
28459 cp_parser_enclosed_template_argument_list we will always
28460 throw away all of the template arguments and the first
28461 closing `>', either because the template argument list
28462 was erroneous or because we are replacing those tokens
28463 with a CPP_TEMPLATE_ID token. The second `>' (which will
28464 not have been thrown away) is needed either to close an
28465 outer template argument list or to complete a new-style
28466 cast. */
28469 }
28471 {
28472 /* If we're in a nested template argument list, the '>>' has
28473 to be a typo for '> >'. We emit the error message, but we
28474 continue parsing and we push a '>' as next token, so that
28475 the argument list will be parsed correctly. Note that the
28476 global source location is still on the token before the
28477 '>>', so we need to say explicitly where we want it. */
28485 }
28486 else
28487 {
28488 /* If this is not a nested template argument list, the '>>'
28489 is a typo for '>'. Emit an error message and continue.
28490 Same deal about the token location, but here we can get it
28491 right by consuming the '>>' before issuing the diagnostic. */
28494 "spurious %<>>%>, use %<>%> to terminate "
28496 }
28497 }
28498 else
28500 /* The `>' token might be a greater-than operator again now. */
28501 parser->greater_than_is_operator_p
28503 /* Restore the SAVED_SCOPE. */
28509 }
28511 /* MEMBER_FUNCTION is a member function, or a friend. If default
28512 arguments, or the body of the function have not yet been parsed,
28513 parse them now. */
28515 static void
28517 {
28519 /* If this member is a template, get the underlying
28520 FUNCTION_DECL. */
28524 /* There should not be any class definitions in progress at this
28525 point; the bodies of members are only parsed outside of all class
28526 definitions. */
28528 /* While we're parsing the member functions we might encounter more
28529 classes. We want to handle them right away, but we don't want
28530 them getting mixed up with functions that are currently in the
28531 queue. */
28534 /* Make sure that any template parameters are in scope. */
28537 /* If the body of the function has not yet been parsed, parse it
28538 now. */
28540 {
28541 tree function_scope;
28544 /* The function is no longer pending; we are processing it. */
28549 /* If this is a local class, enter the scope of the containing
28550 function. */
28555 /* Push the body of the function onto the lexer stack. */
28558 /* Let the front end know that we going to be defining this
28559 function. */
28563 /* Don't do access checking if it is a templated function. */
28567 /* #pragma omp declare reduction needs special parsing. */
28569 {
28574 }
28575 else
28576 /* Now, parse the body of the function. */
28583 /* Leave the scope of the containing function. */
28587 }
28589 /* Remove any template parameters from the symbol table. */
28592 /* Restore the queue. */
28595 }
28597 /* If DECL contains any default args, remember it on the unparsed
28598 functions queue. */
28600 static void
28602 {
28603 tree probe;
28606 probe;
28609 {
28613 }
28614 }
28616 /* DEFAULT_ARG contains the saved tokens for the initializer of DECL,
28617 which is either a FIELD_DECL or PARM_DECL. Parse it and return
28618 the result. For a PARM_DECL, PARMTYPE is the corresponding type
28619 from the parameter-type-list. */
28621 static tree
28624 {
28626 tree parsed_arg;
28632 /* Push the saved tokens for the default argument onto the parser's
28633 lexer stack. */
28639 /* Parse the default argument. */
28650 {
28651 /* In a non-template class, check conversions now. In a template,
28652 we'll wait and instantiate these as needed. */
28655 tf_warning_or_error);
28658 else
28660 }
28662 /* If the token stream has not been completely used up, then
28663 there was extra junk after the end of the default
28664 argument. */
28666 {
28669 else
28671 }
28673 /* Revert to the main lexer. */
28677 }
28679 /* FIELD is a non-static data member with an initializer which we saved for
28680 later; parse it now. */
28682 static void
28684 {
28685 tree def;
28692 NULL_TREE);
28698 }
28700 /* FN is a FUNCTION_DECL which may contains a parameter with an
28701 unparsed DEFAULT_ARG. Parse the default args now. This function
28702 assumes that the current scope is the scope in which the default
28703 argument should be processed. */
28705 static void
28707 {
28711 /* While we're parsing the default args, we might (due to the
28712 statement expression extension) encounter more classes. We want
28713 to handle them right away, but we don't want them getting mixed
28714 up with default args that are currently in the queue. */
28717 /* Local variable names (and the `this' keyword) may not appear
28718 in a default argument. */
28729 {
28731 tree parsed_arg;
28733 tree copy;
28740 /* This can happen for a friend declaration for a function
28741 already declared with default arguments. */
28744 parsed_arg
28746 default_arg,
28750 /* Update any instantiations we've already created. */
28754 }
28758 /* Make sure no default arg is missing. */
28761 /* Restore the state of local_variables_forbidden_p. */
28764 /* Restore the queue. */
28766 }
28768 /* Subroutine of cp_parser_sizeof_operand, for handling C++11
28770 sizeof ... ( identifier )
28772 where the 'sizeof' token has already been consumed. */
28774 static tree
28776 {
28777 /* Consume the `...'. */
28781 matching_parens parens;
28785 else
28793 /* The name is not qualified. */
28812 }
28814 /* Parse the operand of `sizeof' (or a similar operator). Returns
28815 either a TYPE or an expression, depending on the form of the
28816 input. The KEYWORD indicates which kind of expression we have
28817 encountered. */
28819 static tree
28821 {
28828 /* If it's a `...', then we are computing the length of a parameter
28829 pack. */
28834 /* Types cannot be defined in a `sizeof' expression. Save away the
28835 old message. */
28837 /* And create the new one. */
28843 /* The restrictions on constant-expressions do not apply inside
28844 sizeof expressions. */
28845 saved_integral_constant_expression_p
28847 saved_non_integral_constant_expression_p
28851 /* Do not actually evaluate the expression. */
28854 /* If it's a `(', then we might be looking at the type-id
28855 construction. */
28857 {
28860 /* We can't be sure yet whether we're looking at a type-id or an
28861 expression. */
28864 matching_parens parens;
28867 /* Note: as a GNU Extension, compound literals are considered
28868 postfix-expressions as they are in C99, so they are valid
28869 arguments to sizeof. See comment in cp_parser_cast_expression
28870 for details. */
28873 else
28874 {
28877 /* Look for the type-id. */
28879 /* Look for the closing `)'. */
28882 }
28884 /* If all went well, then we're done. */
28887 }
28889 /* If the type-id production did not work out, then we must be
28890 looking at the unary-expression production. */
28894 /* Go back to evaluating expressions. */
28898 /* Free the message we created. */
28900 /* And restore the old one. */
28902 parser->integral_constant_expression_p
28904 parser->non_integral_constant_expression_p
28908 }
28910 /* If the current declaration has no declarator, return true. */
28912 static bool
28914 {
28915 /* If the next token is a `;' or a `,' then there is no
28916 declarator. */
28919 }
28921 /* Update the DECL_SPECS to reflect the storage class indicated by
28922 KEYWORD. */
28924 static void
28929 {
28930 cp_storage_class storage_class;
28933 {
28937 }
28939 {
28942 }
28947 {
28950 }
28953 {
28971 }
28975 /* A storage class specifier cannot be applied alongside a typedef
28976 specifier. If there is a typedef specifier present then set
28977 conflicting_specifiers_p which will trigger an error later
28978 on in grokdeclarator. */
28981 }
28983 /* Update the DECL_SPECS to reflect the TYPE_SPEC. If TYPE_DEFINITION_P
28984 is true, the type is a class or enum definition. */
28986 static void
28988 tree type_spec,
28991 {
28994 /* If the user tries to redeclare bool, char8_t, char16_t, char32_t, or
28995 wchar_t (with, for example, in "typedef int wchar_t;") we remember that
28996 this is what happened. In system headers, we ignore these
28997 declarations so that G++ can work with system headers that are not
28998 C++-safe. */
29000 && !type_definition_p
29011 {
29014 ds_redefined_builtin_type_spec,
29015 token);
29017 {
29021 }
29022 }
29025 else
29026 {
29031 }
29032 }
29034 /* True iff TOKEN is the GNU keyword __thread. */
29036 static bool
29038 {
29041 }
29043 /* Set the location for a declarator specifier and check if it is
29044 duplicated.
29046 DECL_SPECS is the sequence of declarator specifiers onto which to
29047 set the location.
29049 DS is the single declarator specifier to set which location is to
29050 be set onto the existing sequence of declarators.
29052 LOCATION is the location for the declarator specifier to
29053 consider. */
29055 static void
29058 {
29067 {
29071 }
29072 else
29073 {
29075 {
29079 else
29080 {
29083 OPT_Wlong_long,
29085 }
29086 }
29088 {
29092 {
29096 }
29097 else
29098 {
29101 }
29102 }
29103 else
29104 {
29120 "__complex"
29121 };
29125 }
29126 }
29127 }
29129 /* Return true iff the declarator specifier DS is present in the
29130 sequence of declarator specifiers DECL_SPECS. */
29132 bool
29134 cp_decl_spec ds)
29135 {
29142 }
29144 /* DECL_SPECIFIERS is the representation of a decl-specifier-seq.
29145 Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */
29147 static bool
29149 {
29151 }
29153 /* Issue an error message indicating that TOKEN_DESC was expected.
29154 If KEYWORD is true, it indicated this function is called by
29155 cp_parser_require_keword and the required token can only be
29156 a indicated keyword.
29158 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
29159 within any error as the location of an "opening" token matching
29160 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
29161 RT_CLOSE_PAREN). */
29163 static void
29165 required_token token_desc,
29167 location_t matching_location)
29168 {
29174 {
29243 }
29246 {
29248 {
29326 }
29327 }
29331 }
29334 /* If the next token is of the indicated TYPE, consume it. Otherwise,
29335 issue an error message indicating that TOKEN_DESC was expected.
29337 Returns the token consumed, if the token had the appropriate type.
29338 Otherwise, returns NULL.
29340 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
29341 within any error as the location of an "opening" token matching
29342 the close token TYPE (e.g. the location of the '(' when TOKEN_DESC is
29343 RT_CLOSE_PAREN). */
29348 required_token token_desc,
29349 location_t matching_location)
29350 {
29353 else
29354 {
29355 /* Output the MESSAGE -- unless we're parsing tentatively. */
29358 matching_location);
29360 }
29361 }
29363 /* An error message is produced if the next token is not '>'.
29364 All further tokens are skipped until the desired token is
29365 found or '{', '}', ';' or an unbalanced ')' or ']'. */
29367 static void
29369 {
29370 /* Current level of '< ... >'. */
29372 /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */
29375 /* Are we ready, yet? If not, issue error message. */
29379 /* Skip tokens until the desired token is found. */
29381 {
29382 /* Peek at the next token. */
29384 {
29392 /* C++0x views the `>>' operator as two `>' tokens, but
29393 C++98 does not. */
29396 {
29397 /* We've hit a `>>' where the first `>' closes the
29398 template argument list, and the second `>' is
29399 spurious. Just consume the `>>' and stop; we've
29400 already produced at least one error. */
29403 }
29404 /* Fall through for C++0x, so we handle the second `>' in
29405 the `>>'. */
29410 {
29411 /* We've reached the token we want, consume it and stop. */
29414 }
29433 /* The '>' was probably forgotten, don't look further. */
29438 }
29440 /* Consume this token. */
29442 }
29443 }
29445 /* If the next token is the indicated keyword, consume it. Otherwise,
29446 issue an error message indicating that TOKEN_DESC was expected.
29448 Returns the token consumed, if the token had the appropriate type.
29449 Otherwise, returns NULL. */
29454 required_token token_desc)
29455 {
29459 {
29461 UNKNOWN_LOCATION);
29463 }
29466 }
29468 /* Returns TRUE iff TOKEN is a token that can begin the body of a
29469 function-definition. */
29471 static bool
29473 {
29476 /* A ctor-initializer begins with a `:'. */
29478 /* A function-try-block begins with `try'. */
29480 /* A function-transaction-block begins with `__transaction_atomic'
29481 or `__transaction_relaxed'. */
29484 /* The named return value extension begins with `return'. */
29486 }
29488 /* Returns TRUE iff the next token is the ":" or "{" beginning a class
29489 definition. */
29491 static bool
29493 {
29500 }
29502 /* Returns TRUE iff the next token is the "," or ">" (or `>>', in
29503 C++0x) ending a template-argument. */
29505 static bool
29507 {
29515 }
29517 /* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the
29518 (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */
29520 static bool
29523 {
29529 /* Check for the sequence `<::' in the original code. It would be lexed as
29530 `[:', where `[' is a digraph, and there is no whitespace before
29531 `:'. */
29533 {
29538 }
29540 }
29542 /* Returns the kind of tag indicated by TOKEN, if it is a class-key,
29543 or none_type otherwise. */
29545 static enum tag_types
29547 {
29549 {
29559 }
29560 }
29562 /* Returns the kind of tag indicated by TOKEN, if it is a type-parameter-key,
29563 or none_type otherwise or if the token is null. */
29565 static enum tag_types
29567 {
29572 {
29580 }
29581 }
29583 /* Issue an error message if the CLASS_KEY does not match the TYPE. */
29585 static void
29587 {
29591 {
29595 type))
29598 }
29599 }
29601 /* Issue an error message if DECL is redeclared with different
29602 access than its original declaration [class.access.spec/3].
29603 This applies to nested classes, nested class templates and
29604 enumerations [class.mem/1]. */
29606 static void
29608 {
29619 }
29621 /* Look for the `template' keyword, as a syntactic disambiguator.
29622 Return TRUE iff it is present, in which case it will be
29623 consumed. */
29625 static bool
29627 {
29629 {
29630 /* In C++98 the `template' keyword can only be used within templates;
29631 outside templates the parser can always figure out what is a
29632 template and what is not. In C++11, per the resolution of DR 468,
29633 `template' is allowed in cases where it is not strictly necessary. */
29636 {
29639 "in C++98 %<template%> (as a disambiguator) is only "
29641 /* If this part of the token stream is rescanned, the same
29642 error message would be generated. So, we purge the token
29643 from the stream. */
29646 }
29647 else
29648 {
29649 /* Consume the `template' keyword. */
29652 }
29653 }
29655 }
29657 /* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token,
29658 set PARSER->SCOPE, and perform other related actions. */
29660 static void
29662 {
29665 /* Get the stored value. */
29667 /* Set the scope from the stored value. */
29671 }
29673 /* Consume tokens up through a non-nested END token. Returns TRUE if we
29674 encounter the end of a block before what we were looking for. */
29676 static bool
29680 {
29682 {
29685 /* Abort a parenthesized expression if we encounter a semicolon. */
29689 /* If we've reached the end of the file, stop. */
29695 /* We've hit the end of an enclosing block, so there's been some
29696 kind of syntax error. */
29699 /* Consume the token. */
29701 /* See if it starts a new group. */
29703 {
29705 /* In theory this should probably check end == '}', but
29706 cp_parser_save_member_function_body needs it to exit
29707 after either '}' or ')' when called with ')'. */
29710 }
29712 {
29716 }
29721 }
29722 }
29724 /* Like above, for caching a default argument or NSDMI. Both of these are
29725 terminated by a non-nested comma, but it can be unclear whether or not a
29726 comma is nested in a template argument list unless we do more parsing.
29727 In order to handle this ambiguity, when we encounter a ',' after a '<'
29728 we try to parse what follows as a parameter-declaration-list (in the
29729 case of a default argument) or a member-declarator (in the case of an
29730 NSDMI). If that succeeds, then we stop caching. */
29732 static tree
29734 {
29739 tree default_argument;
29741 /* Add tokens until we have processed the entire default
29742 argument. We add the range [first_token, token). */
29745 {
29746 /* For list-initialization, this is straightforward. */
29749 }
29751 {
29754 /* Peek at the next token. */
29756 /* What we do depends on what token we have. */
29758 {
29759 /* In valid code, a default argument must be
29760 immediately followed by a `,' `)', or `...'. */
29763 {
29764 /* If we've seen a '<', we might be in a
29765 template-argument-list. Until Core issue 325 is
29766 resolved, we don't know how this situation ought
29767 to be handled, so try to DTRT. We check whether
29768 what comes after the comma is a valid parameter
29769 declaration list. If it is, then the comma ends
29770 the default argument; otherwise the default
29771 argument continues. */
29775 /* Set ITALP so cp_parser_parameter_declaration_list
29776 doesn't decide to commit to this parse. */
29783 {
29784 /* Parse declarators until we reach a non-comma or
29785 somthing that cannot be an initializer.
29786 Just checking whether we're looking at a single
29787 declarator is insufficient. Consider:
29788 int var = tuple<T,U>::x;
29789 The template parameter 'U' looks exactly like a
29790 declarator. */
29791 do
29792 {
29796 CP_PARSER_FLAGS_NONE,
29805 }
29807 /* If we met an '=' or ';' then the original comma
29808 was the end of the NSDMI. Otherwise assume
29809 we're still in the NSDMI. */
29812 }
29813 else
29814 {
29817 tree t = cp_parser_parameter_declaration_list
29822 }
29829 }
29830 /* FALLTHRU */
29833 /* If we run into a non-nested `;', `}', or `]',
29834 then the code is invalid -- but the default
29835 argument is certainly over. */
29840 /* Handle correctly int n = sizeof ... ( p ); */
29843 /* Update DEPTH, if necessary. */
29858 /* This might be the comparison operator, or it might
29859 start a template argument list. */
29866 /* Fall through for C++0x, which treats the `>>'
29867 operator like two `>' tokens in certain
29868 cases. */
29873 {
29874 /* This might be an operator, or it might close a
29875 template argument list. But if a previous '<'
29876 started a template argument list, this will have
29877 closed it, so we can't be in one anymore. */
29881 }
29884 /* If we run out of tokens, issue an error message. */
29892 /* In these cases, we should look for template-ids.
29893 For example, if the default argument is
29894 `X<int, double>()', we need to do name lookup to
29895 figure out whether or not `X' is a template; if
29896 so, the `,' does not end the default argument.
29898 That is not yet done. */
29903 }
29905 /* If we've reached the end, stop. */
29909 /* Add the token to the token block. */
29911 }
29913 /* Create a DEFAULT_ARG to represent the unparsed default
29914 argument. */
29921 }
29923 /* A location to use for diagnostics about an unparsed DEFAULT_ARG. */
29925 location_t
29927 {
29932 }
29934 /* Begin parsing tentatively. We always save tokens while parsing
29935 tentatively so that if the tentative parsing fails we can restore the
29936 tokens. */
29938 static void
29940 {
29941 /* Enter a new parsing context. */
29943 /* Begin saving tokens. */
29945 /* In order to avoid repetitive access control error messages,
29946 access checks are queued up until we are no longer parsing
29947 tentatively. */
29949 }
29951 /* Commit to the currently active tentative parse. */
29953 static void
29955 {
29959 /* Mark all of the levels as committed. */
29962 {
29969 }
29970 }
29972 /* Commit to the topmost currently active tentative parse.
29974 Note that this function shouldn't be called when there are
29975 irreversible side-effects while in a tentative state. For
29976 example, we shouldn't create a permanent entry in the symbol
29977 table, or issue an error message that might not apply if the
29978 tentative parse is aborted. */
29980 static void
29982 {
29987 {
29995 }
29996 }
29998 /* Abort the currently active tentative parse. All consumed tokens
29999 will be rolled back, and no diagnostics will be issued. */
30001 static void
30003 {
30007 /* Now, pretend that we want to see if the construct was
30008 successfully parsed. */
30010 }
30012 /* Stop parsing tentatively. If a parse error has occurred, restore the
30013 token stream. Otherwise, commit to the tokens we have consumed.
30014 Returns true if no error occurred; false otherwise. */
30016 static bool
30018 {
30022 /* Remember whether or not an error occurred, since we are about to
30023 destroy that information. */
30025 /* Remove the topmost context from the stack. */
30028 /* If no parse errors occurred, commit to the tentative parse. */
30030 {
30031 /* Commit to the tokens read tentatively, unless that was
30032 already done. */
30037 }
30038 /* Otherwise, if errors occurred, roll back our state so that things
30039 are just as they were before we began the tentative parse. */
30040 else
30041 {
30044 }
30045 /* Add the context to the front of the free list. */
30050 }
30052 /* Returns true if we are parsing tentatively and are not committed to
30053 this tentative parse. */
30055 static bool
30057 {
30060 }
30062 /* Returns nonzero iff an error has occurred during the most recent
30063 tentative parse. */
30065 static bool
30067 {
30070 }
30072 /* Returns nonzero if GNU extensions are allowed. */
30074 static bool
30076 {
30078 }
30079 \f
30080 /* Objective-C++ Productions */
30083 /* Parse an Objective-C expression, which feeds into a primary-expression
30084 above.
30086 objc-expression:
30087 objc-message-expression
30088 objc-string-literal
30089 objc-encode-expression
30090 objc-protocol-expression
30091 objc-selector-expression
30093 Returns a tree representation of the expression. */
30095 static cp_expr
30097 {
30098 /* Try to figure out what kind of declaration is present. */
30102 {
30112 {
30124 }
30125 /* FALLTHRU */
30131 }
30134 }
30136 /* Parse an Objective-C message expression.
30138 objc-message-expression:
30139 [ objc-message-receiver objc-message-args ]
30141 Returns a representation of an Objective-C message. */
30143 static tree
30145 {
30157 /* Construct a location e.g.
30158 [self func1:5]
30159 ^~~~~~~~~~~~~~
30160 ranging from the '[' to the ']', with the caret at the start. */
30165 }
30167 /* Parse an objc-message-receiver.
30169 objc-message-receiver:
30170 expression
30171 simple-type-specifier
30173 Returns a representation of the type or expression. */
30175 static tree
30177 {
30178 tree rcv;
30180 /* An Objective-C message receiver may be either (1) a type
30181 or (2) an expression. */
30185 /* If that worked out, fine. */
30192 CP_PARSER_FLAGS_NONE);
30199 }
30201 /* Parse the arguments and selectors comprising an Objective-C message.
30203 objc-message-args:
30204 objc-selector
30205 objc-selector-args
30206 objc-selector-args , objc-comma-args
30208 objc-selector-args:
30209 objc-selector [opt] : assignment-expression
30210 objc-selector-args objc-selector [opt] : assignment-expression
30212 objc-comma-args:
30213 assignment-expression
30214 objc-comma-args , assignment-expression
30216 Returns a TREE_LIST, with TREE_PURPOSE containing a list of
30217 selector arguments and TREE_VALUE containing a list of comma
30218 arguments. */
30220 static tree
30222 {
30228 {
30234 /* Detect if we have a unary selector. */
30243 sel_args
30248 }
30250 /* Handle non-selector arguments, if any. */
30252 {
30253 tree arg;
30258 addl_args
30263 }
30266 {
30269 }
30272 }
30274 /* Parse an Objective-C encode expression.
30276 objc-encode-expression:
30277 @encode objc-typename
30279 Returns an encoded representation of the type argument. */
30281 static cp_expr
30283 {
30284 tree type;
30289 matching_parens parens;
30296 {
30300 }
30302 /* This happens if we find @encode(T) (where T is a template
30303 typename or something dependent on a template typename) when
30304 parsing a template. In that case, we can't compile it
30305 immediately, but we rather create an AT_ENCODE_EXPR which will
30306 need to be instantiated when the template is used.
30307 */
30309 {
30313 }
30316 /* Build a location of the form:
30317 @encode(int)
30318 ^~~~~~~~~~~~
30319 with caret==start at the @ token, finishing at the close paren. */
30320 location_t combined_loc
30325 }
30327 /* Parse an Objective-C @defs expression. */
30329 static tree
30331 {
30332 tree name;
30335 matching_parens parens;
30341 }
30343 /* Parse an Objective-C protocol expression.
30345 objc-protocol-expression:
30346 @protocol ( identifier )
30348 Returns a representation of the protocol expression. */
30350 static tree
30352 {
30353 tree proto;
30357 matching_parens parens;
30362 /* Build a location of the form:
30363 @protocol(prot)
30364 ^~~~~~~~~~~~~~~
30365 with caret==start at the @ token, finishing at the close paren. */
30366 location_t combined_loc
30372 }
30374 /* Parse an Objective-C selector expression.
30376 objc-selector-expression:
30377 @selector ( objc-method-signature )
30379 objc-method-signature:
30380 objc-selector
30381 objc-selector-seq
30383 objc-selector-seq:
30384 objc-selector :
30385 objc-selector-seq objc-selector :
30387 Returns a representation of the method selector. */
30389 static tree
30391 {
30398 matching_parens parens;
30404 {
30413 {
30414 /* Detect if we have a unary selector. */
30416 {
30419 }
30420 else
30421 {
30423 }
30424 }
30429 {
30430 sel_seq
30433 sel_seq
30436 }
30437 else
30438 sel_seq
30443 }
30445 finish_selector:
30449 /* Build a location of the form:
30450 @selector(func)
30451 ^~~~~~~~~~~~~~~
30452 with caret==start at the @ token, finishing at the close paren. */
30453 location_t combined_loc
30457 /* TODO: objc_build_selector_expr doesn't always honor the location. */
30460 }
30462 /* Parse a list of identifiers.
30464 objc-identifier-list:
30465 identifier
30466 objc-identifier-list , identifier
30468 Returns a TREE_LIST of identifier nodes. */
30470 static tree
30472 {
30473 tree identifier;
30474 tree list;
30485 {
30492 identifier));
30494 }
30497 }
30499 /* Parse an Objective-C alias declaration.
30501 objc-alias-declaration:
30502 @compatibility_alias identifier identifier ;
30504 This function registers the alias mapping with the Objective-C front end.
30505 It returns nothing. */
30507 static void
30509 {
30517 }
30519 /* Parse an Objective-C class forward-declaration.
30521 objc-class-declaration:
30522 @class objc-identifier-list ;
30524 The function registers the forward declarations with the Objective-C
30525 front end. It returns nothing. */
30527 static void
30529 {
30532 {
30533 tree id;
30543 else
30545 }
30547 }
30549 /* Parse a list of Objective-C protocol references.
30551 objc-protocol-refs-opt:
30552 objc-protocol-refs [opt]
30554 objc-protocol-refs:
30555 < objc-identifier-list >
30557 Returns a TREE_LIST of identifiers, if any. */
30559 static tree
30561 {
30565 {
30569 }
30572 }
30574 /* Parse a Objective-C visibility specification. */
30576 static void
30578 {
30582 {
30597 }
30599 /* Eat '@private'/'@protected'/'@public'. */
30601 }
30603 /* Parse an Objective-C method type. Return 'true' if it is a class
30604 (+) method, and 'false' if it is an instance (-) method. */
30608 {
30611 else
30613 }
30615 /* Parse an Objective-C protocol qualifier. */
30617 static tree
30619 {
30632 {
30637 }
30640 }
30642 /* Parse an Objective-C typename. */
30644 static tree
30646 {
30650 {
30653 matching_parens parens;
30657 /* An ObjC type name may consist of just protocol qualifiers, in which
30658 case the type shall default to 'id'. */
30660 {
30663 /* If the type could not be parsed, an error has already
30664 been produced. For error recovery, behave as if it had
30665 not been specified, which will use the default type
30666 'id'. */
30668 {
30670 /* We need to skip to the closing parenthesis as
30671 cp_parser_type_id() does not seem to do it for
30672 us. */
30677 }
30678 }
30682 }
30685 }
30687 /* Check to see if TYPE refers to an Objective-C selector name. */
30689 static bool
30691 {
30697 }
30699 /* Parse an Objective-C selector. */
30701 static tree
30703 {
30707 {
30710 }
30712 /* C++ operator names are allowed to appear in ObjC selectors. */
30714 {
30727 }
30728 }
30730 /* Parse an Objective-C params list. */
30732 static tree
30734 {
30740 {
30750 /* Detect if we have a unary selector. */
30753 {
30756 }
30760 {
30761 /* Something went quite wrong. There should be a colon
30762 here, but there is not. Stop parsing parameters. */
30764 }
30766 /* New ObjC allows attributes on parameters too. */
30771 params
30774 type_name,
30775 identifier,
30776 parm_attr));
30779 }
30782 {
30785 }
30787 /* We allow tail attributes for the method. */
30789 {
30797 }
30800 {
30803 }
30805 }
30807 /* Parse the non-keyword Objective-C params. */
30809 static tree
30812 {
30818 {
30820 tree parm;
30826 {
30831 }
30833 /* TODO: parse attributes for tail parameters. */
30843 }
30845 /* We allow tail attributes for the method. */
30847 {
30849 {
30854 }
30855 else
30856 /* We have an error, but parse the attributes, so that we can
30857 carry on. */
30863 }
30866 }
30868 /* Parse a linkage specification, a pragma, an extra semicolon or a block. */
30870 static void
30872 {
30875 /* If the next token is `extern' and the following token is a string
30876 literal, then we have a linkage specification. */
30878 && cp_parser_is_pure_string_literal
30881 /* Handle #pragma, if any. */
30884 /* Allow stray semicolons. */
30887 /* Mark methods as optional or required, when building protocols. */
30889 {
30892 }
30894 {
30897 }
30900 /* Other stray characters must generate errors. */
30902 {
30906 }
30907 /* Finally, try to parse a block-declaration, or a function-definition. */
30908 else
30910 }
30912 /* Parse a method signature. */
30914 static tree
30916 {
30932 }
30934 static bool
30936 {
30937 tree tattr;
30942 /* If the attributes are followed by a method introducer, this is not allowed.
30943 Dump the attributes and flag the situation. */
30948 /* Otherwise, the attributes introduce some interstitial code, possibly so
30949 rewind to allow that check. */
30952 }
30954 /* Parse an Objective-C method prototype list. */
30956 static void
30958 {
30962 {
30964 {
30969 else
30973 {
30977 }
30980 }
30986 OPT_Wattributes,
30988 else
30989 /* Allow for interspersed non-ObjC++ code. */
30993 }
30997 else
31001 }
31003 /* Parse an Objective-C method definition list. */
31005 static void
31007 {
31011 {
31012 tree meth;
31015 {
31021 else
31026 {
31030 }
31032 NULL_TREE);
31034 /* For historical reasons, we accept an optional semicolon. */
31041 {
31048 }
31049 }
31050 /* The following case will be removed once @synthesize is
31051 completely implemented. */
31062 else
31063 /* Allow for interspersed non-ObjC++ code. */
31067 }
31071 else
31075 }
31077 /* Parse Objective-C ivars. */
31079 static void
31081 {
31092 {
31093 cp_decl_specifier_seq declspecs;
31095 tree prefix_attributes;
31103 CP_PARSER_FLAGS_OPTIONAL,
31107 /* auto, register, static, extern, mutable. */
31109 {
31112 }
31114 /* thread_local. */
31116 {
31119 }
31121 /* typedef. */
31123 {
31126 }
31131 /* Keep going until we hit the `;' at the end of the
31132 declaration. */
31134 {
31139 /* Check for a (possibly unnamed) bitfield declaration. */
31147 {
31148 /* Get the name of the bitfield. */
31153 eat_colon:
31155 /* Get the width of the bitfield. */
31156 width
31158 }
31159 else
31160 {
31161 /* Parse the declarator. */
31162 declarator
31164 CP_PARSER_FLAGS_NONE,
31170 }
31172 /* Look for attributes that apply to the ivar. */
31174 /* Remember which attributes are prefix attributes and
31175 which are not. */
31177 /* Combine the attributes. */
31181 /* Create the bitfield declaration. */
31184 else
31189 /* Add the instance variable. */
31193 /* Reset PREFIX_ATTRIBUTES. */
31195 {
31200 }
31205 {
31208 }
31210 }
31214 }
31219 /* Do not consume the RID_AT_END, so it will be read again as terminating
31220 the @interface of @implementation. */
31224 /* For historical reasons, we accept an optional semicolon. */
31227 }
31229 /* Parse an Objective-C protocol declaration. */
31231 static void
31233 {
31239 {
31244 }
31246 /* See if we have a forward declaration or a definition. */
31249 /* Try a forward declaration first. */
31251 {
31253 {
31254 tree id;
31264 else
31266 }
31268 }
31270 /* Ok, we got a full-fledged definition (or at least should). */
31271 else
31272 {
31277 }
31278 }
31280 /* Parse an Objective-C superclass or category. */
31282 static void
31287 {
31293 {
31296 }
31298 {
31299 matching_parens parens;
31302 /* If there is no category name, and this is an @interface, we
31303 have a class extension. */
31305 {
31308 }
31309 else
31313 }
31314 }
31316 /* Parse an Objective-C class interface. */
31318 static void
31320 {
31327 {
31328 /* It's hard to recover because even if valid @interface stuff
31329 is to follow, we can't compile it (or validate it) if we
31330 don't even know which class it refers to. Let's assume this
31331 was a stray '@interface' token in the stream and skip it.
31332 */
31334 }
31339 /* We have either a class or a category on our hands. */
31342 else
31343 {
31345 /* Handle instance variable declarations, if any. */
31348 }
31351 }
31353 /* Parse an Objective-C class implementation. */
31355 static void
31357 {
31364 {
31365 /* It's hard to recover because even if valid @implementation
31366 stuff is to follow, we can't compile it (or validate it) if
31367 we don't even know which class it refers to. Let's assume
31368 this was a stray '@implementation' token in the stream and
31369 skip it.
31370 */
31372 }
31376 /* We have either a class or a category on our hands. */
31379 else
31380 {
31382 /* Handle instance variable declarations, if any. */
31385 }
31388 }
31390 /* Consume the @end token and finish off the implementation. */
31392 static void
31394 {
31397 }
31399 /* Parse an Objective-C declaration. */
31401 static void
31403 {
31404 /* Try to figure out what kind of declaration is present. */
31409 {
31425 }
31428 {
31451 }
31452 }
31454 /* Parse an Objective-C try-catch-finally statement.
31456 objc-try-catch-finally-stmt:
31457 @try compound-statement objc-catch-clause-seq [opt]
31458 objc-finally-clause [opt]
31460 objc-catch-clause-seq:
31461 objc-catch-clause objc-catch-clause-seq [opt]
31463 objc-catch-clause:
31464 @catch ( objc-exception-declaration ) compound-statement
31466 objc-finally-clause:
31467 @finally compound-statement
31469 objc-exception-declaration:
31470 parameter-declaration
31471 '...'
31473 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
31475 Returns NULL_TREE.
31477 PS: This function is identical to c_parser_objc_try_catch_finally_statement
31478 for C. Keep them in sync. */
31480 static tree
31482 {
31483 location_t location;
31484 tree stmt;
31489 /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST
31490 node, lest it get absorbed into the surrounding block. */
31496 {
31500 matching_parens parens;
31506 {
31507 /* We have "@catch (...)" (where the '...' are literally
31508 what is in the code). Skip the '...'.
31509 parameter_declaration is set to NULL_TREE, and
31510 objc_being_catch_clauses() knows that that means
31511 '...'. */
31514 }
31515 else
31516 {
31517 /* We have "@catch (NSException *exception)" or something
31518 like that. Parse the parameter declaration. */
31523 else
31528 }
31531 else
31532 {
31533 /* If there was no open parenthesis, we are recovering from
31534 an error, and we are trying to figure out what mistake
31535 the user has made. */
31537 /* If there is an immediate closing parenthesis, the user
31538 probably forgot the opening one (ie, they typed "@catch
31539 NSException *e)". Parse the closing parenthesis and keep
31540 going. */
31544 /* If these is no immediate closing parenthesis, the user
31545 probably doesn't know that parenthesis are required at
31546 all (ie, they typed "@catch NSException *e"). So, just
31547 forget about the closing parenthesis and keep going. */
31548 }
31552 }
31554 {
31557 /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST
31558 node, lest it get absorbed into the surrounding block. */
31562 }
31565 }
31567 /* Parse an Objective-C synchronized statement.
31569 objc-synchronized-stmt:
31570 @synchronized ( expression ) compound-statement
31572 Returns NULL_TREE. */
31574 static tree
31576 {
31577 location_t location;
31584 matching_parens parens;
31589 /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST
31590 node, lest it get absorbed into the surrounding block. */
31595 }
31597 /* Parse an Objective-C throw statement.
31599 objc-throw-stmt:
31600 @throw assignment-expression [opt] ;
31602 Returns a constructed '@throw' statement. */
31604 static tree
31606 {
31618 }
31620 /* Parse an Objective-C statement. */
31622 static tree
31624 {
31625 /* Try to figure out what kind of declaration is present. */
31629 {
31640 }
31643 }
31645 /* If we are compiling ObjC++ and we see an __attribute__ we neeed to
31646 look ahead to see if an objc keyword follows the attributes. This
31647 is to detect the use of prefix attributes on ObjC @interface and
31648 @protocol. */
31650 static bool
31652 {
31657 {
31660 }
31663 }
31665 /* This routine is a minimal replacement for
31666 c_parser_struct_declaration () used when parsing the list of
31667 types/names or ObjC++ properties. For example, when parsing the
31668 code
31670 @property (readonly) int a, b, c;
31672 this function is responsible for parsing "int a, int b, int c" and
31673 returning the declarations as CHAIN of DECLs.
31675 TODO: Share this code with cp_parser_objc_class_ivars. It's very
31676 similar parsing. */
31677 static tree
31679 {
31681 cp_decl_specifier_seq declspecs;
31683 tree prefix_attributes;
31686 CP_PARSER_FLAGS_NONE,
31693 /* auto, register, static, extern, mutable. */
31695 {
31698 }
31700 /* thread_local. */
31702 {
31705 }
31707 /* typedef. */
31709 {
31712 }
31717 /* Keep going until we hit the `;' at the end of the declaration. */
31719 {
31724 /* Parse the declarator. */
31726 CP_PARSER_FLAGS_NONE,
31729 /* Look for attributes that apply to the ivar. */
31731 /* Remember which attributes are prefix attributes and
31732 which are not. */
31734 /* Combine the attributes. */
31744 /* Reset PREFIX_ATTRIBUTES. */
31746 {
31751 }
31758 {
31761 }
31762 else
31764 }
31766 }
31768 /* Parse an Objective-C @property declaration. The syntax is:
31770 objc-property-declaration:
31771 '@property' objc-property-attributes[opt] struct-declaration ;
31773 objc-property-attributes:
31774 '(' objc-property-attribute-list ')'
31776 objc-property-attribute-list:
31777 objc-property-attribute
31778 objc-property-attribute-list, objc-property-attribute
31780 objc-property-attribute
31781 'getter' = identifier
31782 'setter' = identifier
31783 'readonly'
31784 'readwrite'
31785 'assign'
31786 'retain'
31787 'copy'
31788 'nonatomic'
31790 For example:
31791 @property NSString *name;
31792 @property (readonly) id object;
31793 @property (retain, nonatomic, getter=getTheName) id name;
31794 @property int a, b, c;
31796 PS: This function is identical to
31797 c_parser_objc_at_property_declaration for C. Keep them in sync. */
31798 static void
31800 {
31801 /* The following variables hold the attributes of the properties as
31802 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
31803 seen. When we see an attribute, we set them to 'true' (if they
31804 are boolean properties) or to the identifier (if they have an
31805 argument, ie, for getter and setter). Note that here we only
31806 parse the list of attributes, check the syntax and accumulate the
31807 attributes that we find. objc_add_property_declaration() will
31808 then process the information. */
31818 /* 'properties' is the list of properties that we read. Usually a
31819 single one, but maybe more (eg, in "@property int a, b, c;" there
31820 are three). */
31821 tree properties;
31822 location_t loc;
31828 /* Parse the optional attribute list... */
31830 {
31831 /* Eat the '('. */
31832 matching_parens parens;
31836 {
31842 {
31845 }
31849 {
31860 {
31864 else
31869 }
31872 {
31876 }
31878 {
31880 {
31883 }
31884 else
31888 else
31890 }
31891 else
31892 {
31894 {
31897 }
31898 else
31900 }
31906 }
31913 else
31915 }
31917 /* FIXME: "@property (setter, assign);" will generate a spurious
31918 "error: expected ‘)’ before ‘,’ token". This is because
31919 cp_parser_require, unlike the C counterpart, will produce an
31920 error even if we are in error recovery. */
31922 {
31927 }
31928 }
31930 /* ... and the property declaration(s). */
31934 {
31936 /* If the next token is now a `;', consume it. */
31940 }
31944 else
31945 {
31946 /* Comma-separated properties are chained together in
31947 reverse order; add them one by one. */
31956 }
31959 }
31961 /* Parse an Objective-C++ @synthesize declaration. The syntax is:
31963 objc-synthesize-declaration:
31964 @synthesize objc-synthesize-identifier-list ;
31966 objc-synthesize-identifier-list:
31967 objc-synthesize-identifier
31968 objc-synthesize-identifier-list, objc-synthesize-identifier
31970 objc-synthesize-identifier
31971 identifier
31972 identifier = identifier
31974 For example:
31975 @synthesize MyProperty;
31976 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
31978 PS: This function is identical to c_parser_objc_at_synthesize_declaration
31979 for C. Keep them in sync.
31980 */
31981 static void
31983 {
31985 location_t loc;
31990 {
31994 {
31997 }
31999 {
32003 {
32006 }
32007 }
32008 else
32013 else
32015 }
32018 }
32020 /* Parse an Objective-C++ @dynamic declaration. The syntax is:
32022 objc-dynamic-declaration:
32023 @dynamic identifier-list ;
32025 For example:
32026 @dynamic MyProperty;
32027 @dynamic MyProperty, AnotherProperty;
32029 PS: This function is identical to c_parser_objc_at_dynamic_declaration
32030 for C. Keep them in sync.
32031 */
32032 static void
32034 {
32036 location_t loc;
32041 {
32042 tree property;
32045 {
32048 }
32052 else
32054 }
32057 }
32059 \f
32060 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 / 4.5 / 5.0 parsing routines. */
32062 /* Returns name of the next clause.
32063 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
32064 the token is not consumed. Otherwise appropriate pragma_omp_clause is
32065 returned and the token is consumed. */
32067 static pragma_omp_clause
32069 {
32085 {
32090 {
32277 }
32278 }
32284 }
32286 /* Validate that a clause of the given type does not already exist. */
32288 static void
32291 {
32292 tree c;
32296 {
32299 }
32300 }
32302 /* OpenMP 2.5:
32303 variable-list:
32304 identifier
32305 variable-list , identifier
32307 In addition, we match a closing parenthesis (or, if COLON is non-NULL,
32308 colon). An opening parenthesis will have been consumed by the caller.
32310 If KIND is nonzero, create the appropriate node and install the decl
32311 in OMP_CLAUSE_DECL and add the node to the head of the list.
32313 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
32314 return the list created.
32316 COLON can be NULL if only closing parenthesis should end the list,
32317 or pointer to bool which will receive false if the list is terminated
32318 by closing parenthesis or true if the list is terminated by colon. */
32320 static tree
32323 {
32327 {
32330 }
32332 {
32339 && current_class_ptr
32341 {
32347 }
32348 else
32349 {
32356 {
32361 }
32365 else
32368 {
32374 }
32375 }
32377 ;
32379 {
32381 {
32383 /* The OpenACC cache directive explicitly only allows "array
32384 elements or subarrays". */
32386 {
32390 }
32391 /* FALLTHROUGH. */
32396 {
32397 location_t loc
32402 decl
32406 }
32407 /* FALLTHROUGH. */
32413 {
32421 parser->colon_corrects_to_scope_p
32425 else
32426 {
32427 /* Look for `:'. */
32429 {
32434 }
32438 CPP_CLOSE_SQUARE))
32440 }
32441 /* Look for the closing `]'. */
32443 RT_CLOSE_SQUARE))
32444 {
32449 }
32452 }
32456 }
32459 {
32463 {
32464 depend_lvalue:
32468 }
32469 else
32471 }
32477 }
32478 else
32481 get_comma:
32485 }
32491 {
32495 }
32498 {
32501 /* Try to resync to an unnested comma. Copied from
32502 cp_parser_parenthesized_expression_list. */
32503 skip_comma:
32512 }
32515 }
32517 /* Similarly, but expect leading and trailing parenthesis. This is a very
32518 common case for omp clauses. */
32520 static tree
32522 {
32526 }
32528 /* OpenACC 2.0:
32529 copy ( variable-list )
32530 copyin ( variable-list )
32531 copyout ( variable-list )
32532 create ( variable-list )
32533 delete ( variable-list )
32534 present ( variable-list ) */
32536 static tree
32538 tree list)
32539 {
32542 {
32575 }
32583 }
32585 /* OpenACC 2.0:
32586 deviceptr ( variable-list ) */
32588 static tree
32590 {
32594 /* Can't use OMP_CLAUSE_MAP here (that is, can't use the generic
32595 cp_parser_oacc_data_clause), as for PRAGMA_OACC_CLAUSE_DEVICEPTR,
32596 variable-list must only allow for pointer variables. */
32599 {
32606 }
32609 }
32611 /* OpenACC 2.5:
32612 auto
32613 finalize
32614 independent
32615 nohost
32616 seq */
32618 static tree
32620 tree list)
32621 {
32628 }
32630 /* OpenACC:
32631 num_gangs ( expression )
32632 num_workers ( expression )
32633 vector_length ( expression ) */
32635 static tree
32638 {
32641 matching_parens parens;
32649 {
32654 }
32662 }
32664 /* OpenACC:
32666 gang [( gang-arg-list )]
32667 worker [( [num:] int-expr )]
32668 vector [( [length:] int-expr )]
32670 where gang-arg is one of:
32672 [num:] int-expr
32673 static: size-expr
32675 and size-expr may be:
32677 *
32678 int-expr
32679 */
32681 static tree
32683 omp_clause_code kind,
32685 {
32694 {
32695 matching_parens parens;
32698 do
32699 {
32703 /* Gang static argument. */
32706 {
32714 {
32717 }
32719 /* Check for the '*' argument. */
32723 CPP_CLOSE_PAREN)))
32724 {
32729 {
32732 }
32734 }
32735 }
32736 /* Worker num: argument and vector length: arguments. */
32740 {
32743 }
32745 /* Now collect the actual argument. */
32747 {
32750 }
32762 {
32765 }
32767 }
32772 }
32786 cleanup_error:
32789 }
32791 /* OpenACC 2.0:
32792 tile ( size-expr-list ) */
32794 static tree
32796 {
32800 /* Collapse and tile are mutually exclusive. (The spec doesn't say
32801 so, but the spec authors never considered such a case and have
32802 differing opinions on what it might mean, including 'not
32803 allowed'.) */
32806 clause_loc);
32811 do
32812 {
32819 {
32822 }
32823 else
32827 }
32830 /* Consume the trailing ')'. */
32838 }
32840 /* OpenACC 2.0
32841 Parse wait clause or directive parameters. */
32843 static tree
32845 {
32855 {
32857 {
32860 }
32862 }
32869 {
32873 {
32876 else
32877 {
32884 }
32885 }
32886 }
32889 }
32891 /* OpenACC:
32892 wait [( int-expr-list )] */
32894 static tree
32896 {
32901 else
32902 {
32908 }
32911 }
32913 /* OpenMP 3.0:
32914 collapse ( constant-expression ) */
32916 static tree
32918 {
32920 location_t loc;
32921 HOST_WIDE_INT n;
32924 matching_parens parens;
32942 {
32945 }
32954 }
32956 /* OpenMP 2.5:
32957 default ( none | shared )
32959 OpenACC:
32960 default ( none | present ) */
32962 static tree
32965 {
32967 tree c;
32969 matching_parens parens;
32973 {
32978 {
32999 }
33002 }
33003 else
33004 {
33005 invalid_kind:
33008 else
33010 }
33027 }
33029 /* OpenMP 3.1:
33030 final ( expression ) */
33032 static tree
33034 {
33037 matching_parens parens;
33056 }
33058 /* OpenMP 2.5:
33059 if ( expression )
33061 OpenMP 4.5:
33062 if ( directive-name-modifier : expression )
33064 directive-name-modifier:
33065 parallel | task | taskloop | target data | target | target update
33066 | target enter data | target exit data
33068 OpenMP 5.0:
33069 directive-name-modifier:
33070 ... | simd | cancel */
33072 static tree
33075 {
33079 matching_parens parens;
33084 {
33100 {
33103 {
33116 else
33117 {
33118 location_t loc
33123 }
33126 {
33128 {
33133 }
33135 {
33136 location_t loc
33140 }
33141 }
33142 }
33143 }
33145 {
33147 {
33150 }
33151 else
33152 {
33154 {
33155 location_t loc
33158 }
33160 }
33161 }
33162 }
33174 {
33177 {
33180 {
33192 }
33194 p);
33196 }
33198 {
33201 else
33204 }
33207 {
33211 }
33212 }
33220 }
33222 /* OpenMP 3.1:
33223 mergeable */
33225 static tree
33228 {
33229 tree c;
33232 location);
33237 }
33239 /* OpenMP 2.5:
33240 nowait */
33242 static tree
33245 {
33246 tree c;
33253 }
33255 /* OpenMP 2.5:
33256 num_threads ( expression ) */
33258 static tree
33260 location_t location)
33261 {
33264 matching_parens parens;
33284 }
33286 /* OpenMP 4.5:
33287 num_tasks ( expression ) */
33289 static tree
33291 location_t location)
33292 {
33295 matching_parens parens;
33315 }
33317 /* OpenMP 4.5:
33318 grainsize ( expression ) */
33320 static tree
33322 location_t location)
33323 {
33326 matching_parens parens;
33346 }
33348 /* OpenMP 4.5:
33349 priority ( expression ) */
33351 static tree
33353 location_t location)
33354 {
33357 matching_parens parens;
33377 }
33379 /* OpenMP 4.5:
33380 hint ( expression ) */
33382 static tree
33384 {
33387 matching_parens parens;
33406 }
33408 /* OpenMP 4.5:
33409 defaultmap ( tofrom : scalar )
33411 OpenMP 5.0:
33412 defaultmap ( implicit-behavior [ : variable-category ] ) */
33414 static tree
33416 location_t location)
33417 {
33421 enum omp_clause_defaultmap_kind category
33424 matching_parens parens;
33431 {
33432 invalid_behavior:
33434 "%<tofrom%>, %<firstprivate%>, %<none%> "
33437 }
33438 else
33439 {
33442 }
33445 {
33449 else
33456 else
33465 else
33472 else
33481 else
33487 }
33491 {
33496 {
33497 invalid_category:
33501 }
33506 {
33510 else
33517 else
33524 else
33530 }
33533 }
33543 {
33550 {
33565 }
33568 p);
33569 else
33573 }
33580 out_err:
33585 }
33587 /* OpenMP 2.5:
33588 ordered
33590 OpenMP 4.5:
33591 ordered ( constant-expression ) */
33593 static tree
33596 {
33598 HOST_WIDE_INT n;
33604 {
33605 matching_parens parens;
33622 {
33624 "ordered argument needs positive constant integer "
33627 }
33628 }
33634 }
33636 /* OpenMP 2.5:
33637 reduction ( reduction-operator : variable-list )
33639 reduction-operator:
33640 One of: + * - & ^ | && ||
33642 OpenMP 3.1:
33644 reduction-operator:
33645 One of: + * - & ^ | && || min max
33647 OpenMP 4.0:
33649 reduction-operator:
33650 One of: + * - & ^ | && ||
33651 id-expression
33653 OpenMP 5.0:
33654 reduction ( reduction-modifier, reduction-operator : variable-list )
33655 in_reduction ( reduction-operator : variable-list )
33656 task_reduction ( reduction-operator : variable-list ) */
33658 static tree
33661 {
33671 {
33674 {
33677 }
33680 {
33686 {
33690 }
33692 {
33695 }
33696 }
33697 }
33700 {
33710 }
33714 else
33715 {
33726 {
33756 }
33757 else
33758 {
33760 resync_fail:
33765 }
33766 }
33772 NULL);
33774 {
33781 }
33784 }
33786 /* OpenMP 2.5:
33787 schedule ( schedule-kind )
33788 schedule ( schedule-kind , expression )
33790 schedule-kind:
33791 static | dynamic | guided | runtime | auto
33793 OpenMP 4.5:
33794 schedule ( schedule-modifier : schedule-kind )
33795 schedule ( schedule-modifier [ , schedule-modifier ] : schedule-kind , expression )
33797 schedule-modifier:
33798 simd
33799 monotonic
33800 nonmonotonic */
33802 static tree
33804 {
33808 matching_parens parens;
33815 {
33824 else
33830 else
33831 {
33834 }
33835 }
33838 {
33843 {
33864 }
33865 }
33870 else
33876 == (OMP_CLAUSE_SCHEDULE_MONOTONIC
33878 {
33882 }
33885 {
33900 else
33905 }
33917 invalid_kind:
33919 resync_fail:
33924 }
33926 /* OpenMP 3.0:
33927 untied */
33929 static tree
33932 {
33933 tree c;
33940 }
33942 /* OpenMP 4.0:
33943 inbranch
33944 notinbranch */
33946 static tree
33949 {
33954 }
33956 /* OpenMP 4.0:
33957 parallel
33958 for
33959 sections
33960 taskgroup */
33962 static tree
33966 {
33970 }
33972 /* OpenMP 4.5:
33973 nogroup */
33975 static tree
33978 {
33983 }
33985 /* OpenMP 4.5:
33986 simd
33987 threads */
33989 static tree
33993 {
33998 }
34000 /* OpenMP 4.0:
34001 num_teams ( expression ) */
34003 static tree
34005 location_t location)
34006 {
34009 matching_parens parens;
34029 }
34031 /* OpenMP 4.0:
34032 thread_limit ( expression ) */
34034 static tree
34036 location_t location)
34037 {
34040 matching_parens parens;
34060 }
34062 /* OpenMP 4.0:
34063 aligned ( variable-list )
34064 aligned ( variable-list : constant-expression ) */
34066 static tree
34068 {
34072 matching_parens parens;
34080 {
34090 }
34096 }
34098 /* OpenMP 2.5:
34099 lastprivate ( variable-list )
34101 OpenMP 5.0:
34102 lastprivate ( [ lastprivate-modifier : ] variable-list ) */
34104 static tree
34106 {
34114 {
34119 {
34123 }
34124 }
34133 }
34135 /* OpenMP 4.0:
34136 linear ( variable-list )
34137 linear ( variable-list : expression )
34139 OpenMP 4.5:
34140 linear ( modifier ( variable-list ) )
34141 linear ( modifier ( variable-list ) : expression ) */
34143 static tree
34146 {
34151 matching_parens parens;
34156 {
34168 else
34170 }
34175 else
34176 {
34185 }
34188 {
34193 {
34204 {
34207 }
34210 }
34221 }
34224 {
34227 }
34230 }
34232 /* OpenMP 4.0:
34233 safelen ( constant-expression ) */
34235 static tree
34237 location_t location)
34238 {
34241 matching_parens parens;
34260 }
34262 /* OpenMP 4.0:
34263 simdlen ( constant-expression ) */
34265 static tree
34267 location_t location)
34268 {
34271 matching_parens parens;
34290 }
34292 /* OpenMP 4.5:
34293 vec:
34294 identifier [+/- integer]
34295 vec , identifier [+/- integer]
34296 */
34298 static tree
34300 tree list)
34301 {
34305 {
34308 }
34311 {
34318 else
34319 {
34320 t = cp_parser_lookup_name_simple
34325 id_loc);
34326 }
34332 {
34335 }
34339 {
34342 }
34346 {
34349 }
34352 add_to_vector:
34354 {
34358 }
34364 }
34367 {
34373 }
34375 }
34377 /* OpenMP 5.0:
34378 iterators ( iterators-definition )
34380 iterators-definition:
34381 iterator-specifier
34382 iterator-specifier , iterators-definition
34384 iterator-specifier:
34385 identifier = range-specification
34386 iterator-type identifier = range-specification
34388 range-specification:
34389 begin : end
34390 begin : end : step */
34392 static tree
34394 {
34398 matching_parens parens;
34402 bool saved_colon_corrects_to_scope_p
34404 bool saved_colon_doesnt_start_class_def_p
34407 do
34408 {
34409 tree iter_type;
34413 else
34414 {
34417 parser->type_definition_forbidden_message
34423 }
34427 {
34430 }
34450 {
34453 }
34468 {
34471 }
34473 }
34477 parser->colon_doesnt_start_class_def_p
34487 }
34489 /* OpenMP 4.0:
34490 depend ( depend-kind : variable-list )
34492 depend-kind:
34493 in | out | inout
34495 OpenMP 4.5:
34496 depend ( source )
34498 depend ( sink : vec )
34500 OpenMP 5.0:
34501 depend ( depend-modifier , depend-kind: variable-list )
34503 depend-kind:
34504 in | out | inout | mutexinoutset | depobj
34506 depend-modifier:
34507 iterator ( iterators-definition ) */
34509 static tree
34511 {
34515 matching_parens parens;
34519 do
34520 {
34528 {
34533 }
34548 else
34551 }
34558 {
34563 }
34566 {
34576 }
34583 else
34584 {
34589 {
34593 else
34595 }
34598 {
34603 }
34604 }
34607 invalid_kind:
34609 resync_fail:
34616 }
34618 /* OpenMP 4.0:
34619 map ( map-kind : variable-list )
34620 map ( variable-list )
34622 map-kind:
34623 alloc | to | from | tofrom
34625 OpenMP 4.5:
34626 map-kind:
34627 alloc | to | from | tofrom | release | delete
34629 map ( always [,] map-kind: variable-list ) */
34631 static tree
34633 {
34642 {
34647 {
34650 nth++;
34656 {
34661 }
34662 }
34663 }
34667 {
34681 else
34682 {
34688 }
34691 }
34694 {
34698 }
34701 NULL);
34707 }
34709 /* OpenMP 4.0:
34710 device ( expression ) */
34712 static tree
34714 location_t location)
34715 {
34718 matching_parens parens;
34738 }
34740 /* OpenMP 4.0:
34741 dist_schedule ( static )
34742 dist_schedule ( static , expression ) */
34744 static tree
34746 location_t location)
34747 {
34750 matching_parens parens;
34761 {
34772 }
34777 location);
34781 invalid_kind:
34783 resync_fail:
34788 }
34790 /* OpenMP 4.0:
34791 proc_bind ( proc-bind-kind )
34793 proc-bind-kind:
34794 master | close | spread */
34796 static tree
34798 location_t location)
34799 {
34800 tree c;
34807 {
34817 else
34819 }
34820 else
34829 location);
34834 invalid_kind:
34836 resync_fail:
34841 }
34843 /* OpenACC:
34844 async [( int-expr )] */
34846 static tree
34848 {
34855 {
34856 matching_parens parens;
34865 }
34875 }
34877 /* Parse all OpenACC clauses. The set clauses allowed by the directive
34878 is a bitmask in MASK. Return the list of clauses found. */
34880 static tree
34884 {
34889 {
34890 location_t here;
34891 pragma_omp_clause c_kind;
34892 omp_clause_code code;
34903 {
34910 clauses);
34955 clauses);
34960 clauses);
34978 clauses);
34983 clauses);
34994 clauses);
35000 clauses);
35008 clauses);
35012 clauses
35019 clauses);
35028 clauses);
35034 OMP_CLAUSE_VECTOR,
35041 clauses);
35050 OMP_CLAUSE_WORKER,
35056 }
35061 {
35062 /* Remove the invalid clause(s) from the list to avoid
35063 confusing the rest of the compiler. */
35066 }
35067 }
35069 saw_error:
35076 }
35078 /* Parse all OpenMP clauses. The set clauses allowed by the directive
35079 is a bitmask in MASK. Return the list of clauses found; the result
35080 of clause default goes in *pdefault. */
35082 static tree
35086 {
35091 /* Don't create location wrapper nodes within OpenMP clauses. */
35092 auto_suppress_location_wrappers sentinel;
35095 {
35096 pragma_omp_clause c_kind;
35107 {
35119 clauses);
35133 clauses);
35153 clauses);
35158 clauses);
35167 clauses
35207 clauses);
35211 clauses
35223 clauses);
35227 clauses
35229 OMP_CLAUSE_TASK_REDUCTION,
35245 clauses);
35250 OMP_CLAUSE_NOTINBRANCH,
35259 {
35260 clause_not_first:
35264 }
35294 clauses);
35295 else
35305 clauses);
35323 {
35328 }
35371 clauses
35377 clauses
35385 }
35390 {
35391 /* Remove the invalid clause(s) from the list to avoid
35392 confusing the rest of the compiler. */
35395 }
35396 }
35397 saw_error:
35400 {
35403 else
35405 }
35407 }
35409 /* OpenMP 2.5:
35410 structured-block:
35411 statement
35413 In practice, we're also interested in adding the statement to an
35414 outer node. So it is convenient if we work around the fact that
35415 cp_parser_statement calls add_stmt. */
35417 static unsigned
35419 {
35422 /* Only move the values to IN_OMP_BLOCK if they weren't false.
35423 This preserves the "not within loop or switch" style error messages
35424 for nonsense cases like
35425 void foo() {
35426 #pragma omp single
35427 break;
35428 }
35429 */
35434 }
35436 static void
35438 {
35440 }
35442 static tree
35444 {
35452 }
35454 /* OpenMP 2.5:
35455 # pragma omp atomic new-line
35456 expression-stmt
35458 expression-stmt:
35459 x binop= expr | x++ | ++x | x-- | --x
35460 binop:
35461 +, *, -, /, &, ^, |, <<, >>
35463 where x is an lvalue expression with scalar type.
35465 OpenMP 3.1:
35466 # pragma omp atomic new-line
35467 update-stmt
35469 # pragma omp atomic read new-line
35470 read-stmt
35472 # pragma omp atomic write new-line
35473 write-stmt
35475 # pragma omp atomic update new-line
35476 update-stmt
35478 # pragma omp atomic capture new-line
35479 capture-stmt
35481 # pragma omp atomic capture new-line
35482 capture-block
35484 read-stmt:
35485 v = x
35486 write-stmt:
35487 x = expr
35488 update-stmt:
35489 expression-stmt | x = x binop expr
35490 capture-stmt:
35491 v = expression-stmt
35492 capture-block:
35493 { v = x; update-stmt; } | { update-stmt; v = x; }
35495 OpenMP 4.0:
35496 update-stmt:
35497 expression-stmt | x = x binop expr | x = expr binop x
35498 capture-stmt:
35499 v = update-stmt
35500 capture-block:
35501 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
35503 where x and v are lvalue expressions with scalar type. */
35505 static void
35507 {
35518 {
35525 {
35530 enum omp_memory_order new_memory_order
35552 {
35556 }
35557 else
35558 {
35561 "%<capture%>, %<seq_cst%>, %<acq_rel%>, "
35563 }
35565 {
35567 {
35570 else
35572 }
35574 {
35577 else
35579 }
35582 }
35583 }
35585 }
35591 {
35592 omp_requires_mask
35597 {
35607 {
35618 }
35622 }
35623 }
35624 else
35626 {
35630 {
35634 }
35639 {
35643 }
35648 {
35652 }
35656 }
35659 {
35669 else
35674 {
35675 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
35676 opcode. */
35681 }
35685 {
35688 }
35689 else
35690 {
35696 }
35699 }
35701 restart:
35705 {
35712 /* FALLTHROUGH */
35722 /* FALLTHROUGH */
35737 /* Undo effects of boolean_increment for post {in,de}crement. */
35739 /* FALLTHRU */
35743 {
35744 /* Undo effects of boolean_increment. */
35746 {
35747 /* This is pre or post increment. */
35752 && !structured_block
35756 }
35757 }
35758 /* FALLTHRU */
35761 {
35796 {
35800 }
35803 {
35809 {
35814 }
35816 {
35828 {
35830 {
35835 }
35836 else
35838 }
35842 }
35845 {
35852 }
35856 }
35860 {
35863 {
35871 }
35873 {
35878 }
35913 }
35924 /* FALLTHROUGH */
35929 }
35936 }
35937 stmt_done:
35939 {
35950 }
35952 {
35955 }
35956 done:
35964 saw_error:
35967 {
35971 {
35975 }
35976 }
35977 }
35980 /* OpenMP 2.5:
35981 # pragma omp barrier new-line */
35983 static void
35985 {
35988 }
35990 /* OpenMP 2.5:
35991 # pragma omp critical [(name)] new-line
35992 structured-block
35994 OpenMP 4.5:
35995 # pragma omp critical [(name) [hint(expression)]] new-line
35996 structured-block */
35998 #define OMP_CRITICAL_CLAUSE_MASK \
35999 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_HINT) )
36001 static tree
36003 {
36007 {
36008 matching_parens parens;
36026 OMP_CRITICAL_CLAUSE_MASK,
36028 }
36029 else
36034 }
36036 /* OpenMP 5.0:
36037 # pragma omp depobj ( depobj ) depobj-clause new-line
36039 depobj-clause:
36040 depend (dependence-type : locator)
36041 destroy
36042 update (dependence-type)
36044 dependence-type:
36045 in
36046 out
36047 inout
36048 mutexinout */
36050 static void
36052 {
36054 matching_parens parens;
36056 {
36059 }
36072 {
36078 {
36084 }
36088 {
36089 matching_parens c_parens;
36091 {
36092 location_t c2_loc
36095 {
36108 }
36110 {
36114 }
36120 }
36121 else
36123 }
36124 }
36126 {
36129 }
36133 }
36136 /* OpenMP 2.5:
36137 # pragma omp flush flush-vars[opt] new-line
36139 flush-vars:
36140 ( variable-list )
36142 OpenMP 5.0:
36143 # pragma omp flush memory-order-clause new-line */
36145 static void
36147 {
36150 {
36159 else
36163 }
36165 {
36168 "%<flush%> list specified together with memory order "
36171 }
36175 }
36177 /* Helper function, to parse omp for increment expression. */
36179 static tree
36181 {
36186 {
36189 }
36192 {
36204 }
36206 /* If decl is an iterator, preserve LHS and RHS of the relational
36207 expr until finish_omp_for. */
36218 }
36220 /* Helper function, to parse omp for increment expression. */
36222 static tree
36224 {
36228 cp_id_kind idk;
36232 {
36241 }
36250 {
36255 }
36262 {
36266 }
36279 do
36280 {
36287 {
36289 {
36292 else
36294 tf_warning_or_error);
36295 }
36296 else
36299 }
36300 }
36304 {
36310 }
36311 else
36315 }
36317 /* Parse the initialization statement of an OpenMP for loop.
36319 Return true if the resulting construct should have an
36320 OMP_CLAUSE_PRIVATE added to it. */
36322 static tree
36330 {
36336 /* See 2.5.1 (in OpenMP 3.0, similar wording is in 2.5 standard too):
36338 init-expr:
36339 var = lb
36340 integer-type var = lb
36341 random-access-iterator-type var = lb
36342 pointer-type var = lb
36343 */
36344 cp_decl_specifier_seq type_specifiers;
36346 /* First, try to parse as an initialized declaration. See
36347 cp_parser_condition, from whence the bulk of this is copied. */
36355 {
36356 /* If parsing a type specifier seq succeeded, then this
36357 MUST be a initialized declaration. */
36362 CP_PARSER_DECLARATOR_NAMED,
36363 CP_PARSER_FLAGS_NONE,
36375 else
36376 {
36386 {
36388 CPP_OPEN_PAREN))
36391 else
36392 /* Trigger an error. */
36397 }
36401 {
36409 {
36412 auto_node);
36417 }
36420 asm_specification,
36421 LOOKUP_ONLYCONVERTING);
36424 {
36427 }
36428 else
36429 {
36432 {
36434 /* Move lambda DECL_EXPRs to FOR_BLOCK. */
36436 {
36440 {
36444 }
36446 }
36448 {
36453 }
36454 }
36455 }
36457 }
36458 else
36459 {
36460 /* Consume '='. */
36464 non_class:
36467 else
36470 asm_specification,
36471 LOOKUP_ONLYCONVERTING);
36472 }
36476 }
36477 }
36478 else
36479 {
36480 cp_id_kind idk;
36481 /* If parsing a type specifier sequence failed, then
36482 this MUST be a simple expression. */
36488 && decl
36491 {
36502 {
36507 }
36512 }
36514 && decl
36517 {
36518 tree rhs;
36526 rhs,
36527 tf_warning_or_error));
36530 }
36531 else
36532 {
36537 {
36541 }
36542 }
36543 }
36545 }
36547 /* Helper for cp_parser_omp_for_loop, handle one range-for loop. */
36549 void
36553 {
36558 {
36562 /* do_auto_deduction doesn't mess with template init-lists. */
36564 {
36567 {
36573 }
36575 }
36582 }
36587 /* If an error happened previously do nothing or else a lot of
36588 unhelpful errors would be issued. */
36590 else
36591 {
36592 tree range_temp;
36596 /* Can't bind a reference to an array of runtime bound. */
36598 else
36599 {
36605 LOOKUP_ONLYCONVERTING);
36608 }
36611 }
36622 LOOKUP_ONLYCONVERTING);
36624 /* The new for initialization statement. */
36632 else
36633 {
36636 }
36639 LOOKUP_ONLYCONVERTING);
36641 /* The new for condition. */
36644 else
36650 /* The new increment expression. */
36653 else
36656 tf_warning_or_error);
36661 {
36664 }
36669 {
36674 {
36679 }
36680 }
36684 {
36686 tf_none);
36690 }
36697 {
36700 }
36702 }
36704 /* Helper for cp_parser_omp_for_loop, finalize part of range for
36705 inside of the collapsed body. */
36707 void
36709 {
36717 {
36721 }
36723 /* The declaration is initialized with *__begin inside the loop body. */
36726 tf_warning_or_error),
36728 LOOKUP_ONLYCONVERTING);
36731 }
36733 /* Parse the restricted form of the for statement allowed by OpenMP. */
36735 static tree
36738 {
36740 tree orig_decl;
36743 location_t loc_first;
36754 {
36757 }
36760 {
36763 }
36766 {
36772 }
36774 {
36777 {
36779 "%<linear%> clause may not be specified together "
36782 }
36783 else
36785 }
36799 {
36802 location_t loc;
36805 {
36809 }
36812 /* Don't create location wrapper nodes within an OpenMP "for"
36813 statement. */
36814 auto_suppress_location_wrappers sentinel;
36816 matching_parens parens;
36824 {
36825 /* Save tokens so that we can put them back. */
36828 /* Look for ':' that is not nested in () or {}. */
36829 bool is_range_for
36832 CPP_COLON,
36833 /*consume_paren=*/
36836 /* Roll back the tokens we skipped. */
36840 {
36841 bool saved_colon_corrects_to_scope_p
36844 /* A colon is used in range-based for. */
36847 /* Parse the declaration. */
36849 /*function_definition_allowed_p=*/
36851 parser->colon_corrects_to_scope_p
36863 {
36865 {
36871 }
36872 else
36874 }
36878 "%<ordered%> clause with parameter on "
36882 }
36883 }
36885 add_private_clause
36891 {
36894 {
36900 }
36901 else
36903 }
36910 {
36915 {
36919 }
36922 {
36923 /* Move lastprivate (decl) clause to OMP_FOR_CLAUSES. */
36927 {
36930 }
36931 else
36932 {
36935 }
36937 }
36938 else
36939 {
36944 }
36945 }
36948 {
36949 tree c;
36951 {
36960 decl);
36965 decl);
36966 }
36968 {
36973 else
36978 {
36981 /* For linear, signal that we need to fill up
36982 the so far unknown linear step. */
36985 }
36986 }
36987 }
36996 {
36997 /* If decl is an iterator, preserve the operator on decl
36998 until finish_omp_for. */
37000 && ((processing_template_decl
37005 else
37009 }
37011 parse_close_paren:
37022 {
37025 }
37027 {
37031 }
37038 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
37039 in between the collapsed for loops to be still considered perfectly
37040 nested. Hopefully the final version clarifies this.
37041 For now handle (multiple) {'s and empty statements. */
37044 {
37048 {
37050 bracecount++;
37051 }
37055 else
37056 {
37063 }
37064 }
37067 {
37070 }
37071 }
37076 /* Note that we saved the original contents of this flag when we entered
37077 the structured block, and so we don't need to re-save it here. */
37080 /* Note that the grammar doesn't call for a structured block here,
37081 though the loop as a whole is a structured block. */
37083 {
37089 }
37090 else
37095 else
37100 else
37105 {
37107 {
37109 nbraces--;
37110 }
37113 else
37114 {
37116 {
37119 }
37124 }
37125 }
37128 {
37132 else
37134 }
37138 }
37140 /* Helper function for OpenMP parsing, split clauses and call
37141 finish_omp_clauses on each of the set of clauses afterwards. */
37143 static void
37146 {
37152 }
37154 /* OpenMP 4.0:
37155 #pragma omp simd simd-clause[optseq] new-line
37156 for-loop */
37158 #define OMP_SIMD_CLAUSE_MASK \
37159 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
37160 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
37161 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
37162 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
37163 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37164 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
37165 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
37166 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
37167 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
37168 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NONTEMPORAL))
37170 static tree
37174 {
37185 {
37189 OMP_CLAUSE_ORDERED);
37191 {
37193 "%<ordered%> clause with parameter may not be specified "
37196 }
37197 }
37209 }
37211 /* OpenMP 2.5:
37212 #pragma omp for for-clause[optseq] new-line
37213 for-loop
37215 OpenMP 4.0:
37216 #pragma omp for simd for-simd-clause[optseq] new-line
37217 for-loop */
37219 #define OMP_FOR_CLAUSE_MASK \
37220 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37221 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37222 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
37223 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
37224 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
37225 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
37226 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
37227 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
37228 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
37230 static tree
37234 {
37241 /* parallel for{, simd} disallows nowait clause, but for
37242 target {teams distribute ,}parallel for{, simd} it should be accepted. */
37245 /* Composite distribute parallel for{, simd} disallows ordered clause. */
37250 {
37255 {
37279 }
37280 }
37282 {
37285 }
37287 /* Composite distribute parallel for disallows linear clause. */
37294 {
37297 }
37309 }
37314 /* OpenMP 2.5:
37315 # pragma omp master new-line
37316 structured-block */
37318 static tree
37322 {
37330 {
37335 {
37353 }
37354 }
37356 {
37359 }
37362 {
37366 }
37367 else
37372 }
37374 /* OpenMP 2.5:
37375 # pragma omp ordered new-line
37376 structured-block
37378 OpenMP 4.5:
37379 # pragma omp ordered ordered-clauses new-line
37380 structured-block */
37382 #define OMP_ORDERED_CLAUSE_MASK \
37383 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREADS) \
37384 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMD))
37386 #define OMP_ORDERED_DEPEND_CLAUSE_MASK \
37387 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
37389 static bool
37392 {
37396 {
37401 {
37403 {
37406 }
37408 {
37410 "%<depend%> clause may only be used in compound "
37414 }
37415 tree clauses
37417 OMP_ORDERED_DEPEND_CLAUSE_MASK,
37421 }
37422 }
37424 tree clauses
37435 }
37437 /* OpenMP 2.5:
37439 section-scope:
37440 { section-sequence }
37442 section-sequence:
37443 section-directive[opt] structured-block
37444 section-sequence section-directive structured-block */
37446 static tree
37448 {
37453 matching_braces braces;
37461 {
37465 }
37468 {
37476 {
37480 }
37482 {
37485 }
37490 }
37501 }
37503 /* OpenMP 2.5:
37504 # pragma omp sections sections-clause[optseq] newline
37505 sections-scope */
37507 #define OMP_SECTIONS_CLAUSE_MASK \
37508 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37509 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37510 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
37511 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
37512 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
37514 static tree
37517 {
37529 {
37532 }
37539 }
37541 /* OpenMP 2.5:
37542 # pragma omp parallel parallel-clause[optseq] new-line
37543 structured-block
37544 # pragma omp parallel for parallel-for-clause[optseq] new-line
37545 structured-block
37546 # pragma omp parallel sections parallel-sections-clause[optseq] new-line
37547 structured-block
37549 OpenMP 4.0:
37550 # pragma omp parallel for simd parallel-for-simd-clause[optseq] new-line
37551 structured-block */
37553 #define OMP_PARALLEL_CLAUSE_MASK \
37554 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
37555 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37556 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37557 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
37558 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
37559 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
37560 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
37561 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
37562 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
37564 static tree
37568 {
37575 /* #pragma omp target parallel{, for, for simd} disallow copyin clause. */
37581 {
37589 if_p);
37593 if_p);
37596 block);
37601 }
37602 /* When combined with distribute, parallel has to be followed by for.
37603 #pragma omp target parallel is allowed though. */
37607 {
37611 }
37613 {
37617 {
37628 block);
37633 }
37635 {
37638 }
37640 {
37650 block);
37653 }
37654 }
37656 {
37659 }
37664 {
37667 }
37675 }
37677 /* OpenMP 2.5:
37678 # pragma omp single single-clause[optseq] new-line
37679 structured-block */
37681 #define OMP_SINGLE_CLAUSE_MASK \
37682 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37683 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
37685 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
37687 static tree
37689 {
37700 }
37702 /* OpenMP 3.0:
37703 # pragma omp task task-clause[optseq] new-line
37704 structured-block */
37706 #define OMP_TASK_CLAUSE_MASK \
37707 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
37708 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
37709 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
37710 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37711 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37712 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
37713 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
37714 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
37715 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
37716 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
37717 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
37719 static tree
37721 {
37732 }
37734 /* OpenMP 3.0:
37735 # pragma omp taskwait new-line
37737 OpenMP 5.0:
37738 # pragma omp taskwait taskwait-clause[opt] new-line */
37740 #define OMP_TASKWAIT_CLAUSE_MASK \
37741 (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND)
37743 static void
37745 {
37746 tree clauses
37751 {
37758 }
37759 else
37761 }
37763 /* OpenMP 3.1:
37764 # pragma omp taskyield new-line */
37766 static void
37768 {
37771 }
37773 /* OpenMP 4.0:
37774 # pragma omp taskgroup new-line
37775 structured-block
37777 OpenMP 5.0:
37778 # pragma omp taskgroup taskgroup-clause[optseq] new-line */
37780 #define OMP_TASKGROUP_CLAUSE_MASK \
37781 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASK_REDUCTION))
37783 static tree
37785 {
37786 tree clauses
37791 if_p),
37792 clauses);
37793 }
37796 /* OpenMP 2.5:
37797 # pragma omp threadprivate (variable-list) */
37799 static void
37801 {
37802 tree vars;
37808 }
37810 /* OpenMP 4.0:
37811 # pragma omp cancel cancel-clause[optseq] new-line */
37813 #define OMP_CANCEL_CLAUSE_MASK \
37814 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
37815 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
37816 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
37817 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
37818 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
37820 static void
37822 {
37826 }
37828 /* OpenMP 4.0:
37829 # pragma omp cancellation point cancelpt-clause[optseq] new-line */
37831 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
37832 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
37833 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
37834 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
37835 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
37837 static void
37840 {
37841 tree clauses;
37845 {
37850 {
37853 }
37854 }
37856 {
37860 }
37863 {
37868 else
37872 }
37875 OMP_CANCELLATION_POINT_CLAUSE_MASK,
37877 pragma_tok);
37879 }
37881 /* OpenMP 4.0:
37882 #pragma omp distribute distribute-clause[optseq] new-line
37883 for-loop */
37885 #define OMP_DISTRIBUTE_CLAUSE_MASK \
37886 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37887 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37888 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
37889 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
37890 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
37892 static tree
37896 {
37905 {
37913 else
37916 {
37922 {
37926 else
37929 }
37935 else
37949 }
37950 }
37952 {
37955 }
37960 {
37963 }
37975 }
37977 /* OpenMP 4.0:
37978 # pragma omp teams teams-clause[optseq] new-line
37979 structured-block */
37981 #define OMP_TEAMS_CLAUSE_MASK \
37982 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
37983 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
37984 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
37985 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
37986 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
37987 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
37988 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
37990 static tree
37994 {
38003 {
38007 {
38033 }
38034 }
38036 {
38039 }
38044 {
38047 }
38057 }
38059 /* OpenMP 4.0:
38060 # pragma omp target data target-data-clause[optseq] new-line
38061 structured-block */
38063 #define OMP_TARGET_DATA_CLAUSE_MASK \
38064 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
38065 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
38066 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
38067 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_USE_DEVICE_PTR))
38069 static tree
38071 {
38072 tree clauses
38077 {
38080 {
38097 "%<#pragma omp target data%> with map-type other "
38098 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
38102 }
38106 }
38109 {
38112 "%<#pragma omp target data%> must contain at least "
38115 }
38126 }
38128 /* OpenMP 4.5:
38129 # pragma omp target enter data target-enter-data-clause[optseq] new-line
38130 structured-block */
38132 #define OMP_TARGET_ENTER_DATA_CLAUSE_MASK \
38133 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
38134 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
38135 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
38136 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
38137 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
38139 static tree
38142 {
38145 {
38150 {
38153 }
38154 }
38156 {
38160 }
38163 {
38169 }
38171 tree clauses
38176 {
38179 {
38192 "%<#pragma omp target enter data%> with map-type other "
38196 }
38198 }
38201 {
38204 "%<#pragma omp target enter data%> must contain at least "
38207 }
38214 }
38216 /* OpenMP 4.5:
38217 # pragma omp target exit data target-enter-data-clause[optseq] new-line
38218 structured-block */
38220 #define OMP_TARGET_EXIT_DATA_CLAUSE_MASK \
38221 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
38222 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
38223 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
38224 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
38225 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
38227 static tree
38230 {
38233 {
38238 {
38241 }
38242 }
38244 {
38248 }
38251 {
38257 }
38259 tree clauses
38264 {
38267 {
38281 "%<#pragma omp target exit data%> with map-type other "
38282 "than %<from%>, %<release%> or %<delete%> on %<map%>"
38286 }
38288 }
38291 {
38294 "%<#pragma omp target exit data%> must contain at least "
38297 }
38304 }
38306 /* OpenMP 4.0:
38307 # pragma omp target update target-update-clause[optseq] new-line */
38309 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
38310 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
38311 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
38312 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
38313 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
38314 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
38315 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
38317 static bool
38320 {
38322 {
38328 }
38330 tree clauses
38335 {
38337 "%<#pragma omp target update%> must contain at least one "
38340 }
38348 }
38350 /* OpenMP 4.0:
38351 # pragma omp target target-clause[optseq] new-line
38352 structured-block */
38354 #define OMP_TARGET_CLAUSE_MASK \
38355 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
38356 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
38357 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
38358 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND) \
38359 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT) \
38360 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
38361 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
38362 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULTMAP) \
38363 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IS_DEVICE_PTR))
38365 static bool
38368 {
38372 omp_requires_mask
38376 {
38388 {
38396 {
38397 tree stmt;
38399 {
38402 OMP_TARGET_CLAUSE_MASK,
38407 OMP_TARGET_CLAUSE_MASK,
38412 OMP_TARGET_CLAUSE_MASK,
38417 }
38419 }
38424 {
38428 if_p);
38433 if_p);
38438 if_p);
38442 }
38448 {
38449 /* For combined target teams, ensure the num_teams and
38450 thread_limit clause expressions are evaluated on the host,
38451 before entering the target construct. */
38452 tree c;
38458 {
38467 OMP_CLAUSE_FIRSTPRIVATE);
38472 }
38473 }
38483 }
38485 {
38488 }
38490 {
38494 }
38496 {
38500 }
38502 {
38506 }
38508 {
38511 }
38512 }
38514 {
38517 }
38532 check_clauses:
38534 {
38537 {
38551 "%<#pragma omp target%> with map-type other "
38552 "than %<to%>, %<from%>, %<tofrom%> or %<alloc%> "
38556 }
38558 }
38560 }
38562 /* OpenACC 2.0:
38563 # pragma acc cache (variable-list) new-line
38564 */
38566 static tree
38568 {
38583 }
38585 /* OpenACC 2.0:
38586 # pragma acc data oacc-data-clause[optseq] new-line
38587 structured-block */
38589 #define OACC_DATA_CLAUSE_MASK \
38590 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
38591 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
38592 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
38593 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
38594 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
38595 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
38596 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
38598 static tree
38600 {
38613 }
38615 /* OpenACC 2.0:
38616 # pragma acc host_data <clauses> new-line
38617 structured-block */
38619 #define OACC_HOST_DATA_CLAUSE_MASK \
38620 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_USE_DEVICE) )
38622 static tree
38624 {
38637 }
38639 /* OpenACC 2.0:
38640 # pragma acc declare oacc-data-clause[optseq] new-line
38641 */
38643 #define OACC_DECLARE_CLAUSE_MASK \
38644 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
38645 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
38646 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
38647 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
38648 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
38649 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE_RESIDENT) \
38650 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_LINK) \
38651 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) )
38653 static tree
38655 {
38664 {
38668 }
38671 {
38675 {
38679 }
38682 {
38694 {
38696 "%qD must be a global variable in "
38698 decl);
38701 }
38706 {
38710 }
38712 {
38714 "invalid use of %<extern%> variable %qD "
38718 }
38720 {
38722 "invalid use of %<global%> variable %qD "
38726 }
38728 }
38733 {
38738 }
38741 {
38742 tree id;
38746 else
38752 {
38755 {
38758 {
38762 }
38763 }
38764 }
38765 }
38766 }
38779 }
38781 /* OpenACC 2.0:
38782 # pragma acc enter data oacc-enter-data-clause[optseq] new-line
38784 or
38786 # pragma acc exit data oacc-exit-data-clause[optseq] new-line
38788 LOC is the location of the #pragma token.
38789 */
38791 #define OACC_ENTER_DATA_CLAUSE_MASK \
38792 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
38793 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
38794 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
38795 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
38796 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
38798 #define OACC_EXIT_DATA_CLAUSE_MASK \
38799 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
38800 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
38801 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
38802 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DELETE) \
38803 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FINALIZE) \
38804 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
38806 static tree
38809 {
38818 {
38823 }
38830 else
38835 {
38839 }
38847 }
38849 /* OpenACC 2.0:
38850 # pragma acc loop oacc-loop-clause[optseq] new-line
38851 structured-block */
38853 #define OACC_LOOP_CLAUSE_MASK \
38854 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COLLAPSE) \
38855 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
38856 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
38857 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
38858 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
38859 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
38860 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_AUTO) \
38861 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_INDEPENDENT) \
38862 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ) \
38863 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_TILE))
38865 static tree
38868 {
38877 {
38883 }
38892 }
38894 /* OpenACC 2.0:
38895 # pragma acc kernels oacc-kernels-clause[optseq] new-line
38896 structured-block
38898 or
38900 # pragma acc parallel oacc-parallel-clause[optseq] new-line
38901 structured-block
38902 */
38904 #define OACC_KERNELS_CLAUSE_MASK \
38905 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
38906 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
38907 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
38908 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
38909 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
38910 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
38911 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
38912 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
38913 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
38914 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
38915 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
38916 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
38917 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
38919 #define OACC_PARALLEL_CLAUSE_MASK \
38920 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
38921 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPY) \
38922 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYIN) \
38923 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_COPYOUT) \
38924 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_CREATE) \
38925 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEFAULT) \
38926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICEPTR) \
38927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_FIRSTPRIVATE) \
38928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
38929 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_GANGS) \
38930 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_NUM_WORKERS) \
38931 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRESENT) \
38932 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_PRIVATE) \
38933 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_REDUCTION) \
38934 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR_LENGTH) \
38935 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT) )
38937 static tree
38940 {
38941 omp_clause_mask mask;
38944 {
38957 }
38960 {
38964 {
38967 tree clauses;
38972 }
38973 }
38982 }
38984 /* OpenACC 2.0:
38985 # pragma acc update oacc-update-clause[optseq] new-line
38986 */
38988 #define OACC_UPDATE_CLAUSE_MASK \
38989 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC) \
38990 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_DEVICE) \
38991 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_HOST) \
38992 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF) \
38993 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_IF_PRESENT) \
38994 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WAIT))
38996 static tree
38998 {
39005 {
39007 "%<#pragma acc update%> must contain at least one "
39010 }
39018 }
39020 /* OpenACC 2.0:
39021 # pragma acc wait [(intseq)] oacc-wait-clause[optseq] new-line
39023 LOC is the location of the #pragma token.
39024 */
39026 #define OACC_WAIT_CLAUSE_MASK \
39027 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_ASYNC))
39029 static tree
39031 {
39045 }
39047 /* OpenMP 4.0:
39048 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
39050 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
39051 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
39052 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
39053 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
39054 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
39055 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
39056 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
39058 static void
39061 {
39063 cp_omp_declare_simd_data data;
39065 {
39070 /* It is safe to take the address of a local variable; it will only be
39071 used while this scope is live. */
39073 }
39075 /* Store away all pragma tokens. */
39087 {
39091 {
39104 }
39109 "%<#pragma omp declare simd%> not immediately followed by "
39113 }
39114 }
39116 /* Finalize #pragma omp declare simd clauses after direct declarator has
39117 been parsed, and put that into "omp declare simd" attribute. */
39119 static tree
39121 {
39127 {
39131 }
39136 {
39154 }
39158 }
39161 /* OpenMP 4.0:
39162 # pragma omp declare target new-line
39163 declarations and definitions
39164 # pragma omp end declare target new-line
39166 OpenMP 4.5:
39167 # pragma omp declare target ( extended-list ) new-line
39169 # pragma omp declare target declare-target-clauses[seq] new-line */
39171 #define OMP_DECLARE_TARGET_CLAUSE_MASK \
39172 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
39173 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK))
39175 static void
39177 {
39180 clauses
39184 {
39186 clauses);
39189 }
39190 else
39191 {
39195 }
39198 "%<#pragma omp declare target%> with clauses in between "
39199 "%<#pragma omp declare target%> without clauses and "
39202 {
39208 {
39211 }
39212 else
39215 {
39217 "%qD specified both in declare target %<link%> and %<to%>"
39220 }
39222 {
39229 {
39232 {
39236 }
39237 }
39238 }
39239 }
39240 }
39242 static void
39244 {
39247 {
39250 }
39252 {
39256 {
39259 }
39262 else
39263 {
39267 }
39268 }
39269 else
39270 {
39274 }
39278 "%<#pragma omp end declare target%> without corresponding "
39280 else
39282 }
39284 /* Helper function of cp_parser_omp_declare_reduction. Parse the combiner
39285 expression and optional initializer clause of
39286 #pragma omp declare reduction. We store the expression(s) as
39287 either 3, 6 or 7 special statements inside of the artificial function's
39288 body. The first two statements are DECL_EXPRs for the artificial
39289 OMP_OUT resp. OMP_IN variables, followed by a statement with the combiner
39290 expression that uses those variables.
39291 If there was any INITIALIZER clause, this is followed by further statements,
39292 the fourth and fifth statements are DECL_EXPRs for the artificial
39293 OMP_PRIV resp. OMP_ORIG variables. If the INITIALIZER clause wasn't the
39294 constructor variant (first token after open paren is not omp_priv),
39295 then the sixth statement is a statement with the function call expression
39296 that uses the OMP_PRIV and optionally OMP_ORIG variable.
39297 Otherwise, the sixth statement is whatever statement cp_finish_decl emits
39298 to initialize the OMP_PRIV artificial variable and there is seventh
39299 statement, a DECL_EXPR of the OMP_PRIV statement again. */
39301 static bool
39303 {
39315 tree combiner;
39330 {
39333 }
39336 {
39338 matching_parens parens;
39344 {
39347 }
39363 {
39367 /* Reject initializer (omp_priv) and initializer (omp_priv ()). */
39371 == CPP_CLOSE_PAREN
39374 {
39378 }
39383 }
39384 else
39385 {
39387 /* Don't create location wrapper nodes here. */
39388 auto_suppress_location_wrappers sentinel;
39403 {
39408 }
39410 tree arg;
39423 }
39434 }
39438 UNKNOWN_LOCATION);
39441 }
39443 /* OpenMP 4.0
39444 #pragma omp declare reduction (reduction-id : typename-list : expression) \
39445 initializer-clause[opt] new-line
39447 initializer-clause:
39448 initializer (omp_priv initializer)
39449 initializer (function-name (argument-list)) */
39451 static void
39454 {
39464 /* Get the high-water mark for the DECLARATOR_OBSTACK. */
39471 {
39503 }
39515 /* Types may not be defined in declare reduction type list. */
39518 parser->type_definition_forbidden_message
39524 saved_colon_doesnt_start_class_def_p
39529 {
39533 ;
39552 else
39557 else
39559 }
39561 /* Restore the saved message. */
39564 parser->colon_doesnt_start_class_def_p
39569 {
39570 fail:
39573 }
39579 {
39580 tree fntype
39583 NULL_TREE);
39603 {
39608 }
39610 {
39612 {
39621 }
39628 }
39629 else
39630 {
39633 }
39636 else
39639 {
39642 }
39644 {
39647 else
39652 }
39657 else
39658 {
39667 }
39674 }
39678 done:
39679 /* Free any declarators allocated. */
39681 }
39683 /* OpenMP 4.0
39684 #pragma omp declare simd declare-simd-clauses[optseq] new-line
39685 #pragma omp declare reduction (reduction-id : typename-list : expression) \
39686 initializer-clause[opt] new-line
39687 #pragma omp declare target new-line */
39689 static bool
39692 {
39694 {
39699 {
39702 context);
39704 }
39707 {
39710 context);
39712 }
39714 {
39717 }
39719 {
39723 }
39724 }
39729 }
39731 /* OpenMP 5.0
39732 #pragma omp requires clauses[optseq] new-line */
39734 static bool
39736 {
39742 {
39749 {
39764 {
39767 matching_parens parens;
39769 {
39771 {
39776 this_req
39779 this_req
39782 this_req
39784 }
39786 {
39788 "expected %<seq_cst%>, %<relaxed%> or "
39791 CPP_CLOSE_PAREN))
39793 }
39794 else
39801 /*consume_paren=*/
39805 {
39808 }
39809 }
39811 }
39812 else
39813 {
39815 "%<unified_shared_memory%>, "
39816 "%<dynamic_allocators%>, "
39817 "%<reverse_offload%> "
39821 }
39828 {
39830 {
39837 }
39839 {
39843 }
39846 {
39849 this_req
39851 (omp_requires_mask
39853 }
39857 "lexically after first %<atomic%> construct "
39860 omp_requires_mask
39863 }
39864 }
39866 }
39872 }
39875 /* OpenMP 4.5:
39876 #pragma omp taskloop taskloop-clause[optseq] new-line
39877 for-loop
39879 #pragma omp taskloop simd taskloop-simd-clause[optseq] new-line
39880 for-loop */
39882 #define OMP_TASKLOOP_CLAUSE_MASK \
39883 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
39884 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
39885 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
39886 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
39887 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
39888 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_GRAINSIZE) \
39889 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TASKS) \
39890 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
39891 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
39892 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
39893 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
39894 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
39895 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOGROUP) \
39896 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIORITY) \
39897 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
39898 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IN_REDUCTION))
39900 static tree
39904 {
39911 /* #pragma omp parallel master taskloop{, simd} disallow in_reduction
39912 clause. */
39917 {
39922 {
39946 }
39947 }
39949 {
39952 }
39957 {
39960 }
39967 if_p);
39973 }
39976 /* OpenACC 2.0:
39977 # pragma acc routine oacc-routine-clause[optseq] new-line
39978 function-definition
39980 # pragma acc routine ( name ) oacc-routine-clause[optseq] new-line
39981 */
39983 #define OACC_ROUTINE_CLAUSE_MASK \
39984 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_GANG) \
39985 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_WORKER) \
39986 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_VECTOR) \
39987 | (OMP_CLAUSE_MASK_1 << PRAGMA_OACC_CLAUSE_SEQ))
39990 /* Parse the OpenACC routine pragma. This has an optional '( name )'
39991 component, which must resolve to a declared namespace-scope
39992 function. The clauses are either processed directly (for a named
39993 function), or defered until the immediatley following declaration
39994 is parsed. */
39996 static void
39999 {
40001 /* The checking for "another pragma following this one" in the "no optional
40002 '( name )'" case makes sure that we dont re-enter. */
40005 cp_oacc_routine_data data;
40011 /* It is safe to take the address of a local variable; it will only be
40012 used while this scope is live. */
40015 /* Look for optional '( name )'. */
40017 {
40018 matching_parens parens;
40021 /* We parse the name as an id-expression. If it resolves to
40022 anything other than a non-overloaded function at namespace
40023 scope, it's an error. */
40039 {
40043 }
40045 data.clauses
40053 {
40058 }
40060 /* Perhaps we should use the same rule as declarations in different
40061 namespaces? */
40063 {
40068 }
40071 {
40075 }
40079 }
40081 {
40082 /* Store away all pragma tokens. */
40093 /* Emit a helpful diagnostic if there's another pragma following this
40094 one. */
40096 {
40099 /* ..., and then just keep going. */
40101 }
40103 /* We only have to consider the pragma_external case here. */
40108 else
40111 }
40112 }
40114 /* Finalize #pragma acc routine clauses after direct declarator has
40115 been parsed. */
40117 static tree
40119 {
40124 {
40126 "%<#pragma acc routine%> not immediately followed by "
40129 }
40146 /* Later, cp_finalize_oacc_routine will process the clauses, and then set
40147 fndecl_seen. */
40150 }
40152 /* Apply any saved OpenACC routine clauses to a just-parsed
40153 declaration. */
40155 static void
40157 {
40159 {
40160 /* Keep going if we're in error reporting mode. */
40166 {
40168 "%<#pragma acc routine%> not immediately followed by"
40172 }
40174 {
40177 }
40180 {
40185 }
40188 {
40196 }
40198 /* Process the routine's dimension clauses. */
40202 /* Add an "omp declare target" attribute. */
40207 /* Don't unset parser->oacc_routine here: we may still need it to
40208 diagnose wrong usage. But, remember that we've used this "#pragma acc
40209 routine". */
40211 }
40212 }
40214 /* Main entry point to OpenMP statement pragmas. */
40216 static void
40218 {
40219 tree stmt;
40224 {
40247 if_p);
40252 if_p);
40269 if_p);
40274 if_p);
40279 if_p);
40284 if_p);
40293 if_p);
40307 if_p);
40312 if_p);
40316 }
40319 }
40320 \f
40321 /* Transactional Memory parsing routines. */
40323 /* Parse a transaction attribute.
40325 txn-attribute:
40326 attribute
40327 [ [ identifier ] ]
40329 We use this instead of cp_parser_attributes_opt for transactions to avoid
40330 the pedwarn in C++98 mode. */
40332 static tree
40334 {
40349 {
40353 /* For keywords, use the canonical spelling,
40354 not the parsed identifier. */
40358 }
40359 else
40363 error1:
40366 }
40368 /* Parse a __transaction_atomic or __transaction_relaxed statement.
40370 transaction-statement:
40371 __transaction_atomic txn-attribute[opt] txn-noexcept-spec[opt]
40372 compound-statement
40373 __transaction_relaxed txn-noexcept-spec[opt] compound-statement
40374 */
40376 static tree
40378 {
40389 else
40390 {
40394 }
40396 /* Parse a noexcept specification. */
40400 {
40401 /* cancel-and-throw is unimplemented. */
40404 }
40405 else
40408 /* Keep track if we're in the lexical scope of an outer transaction. */
40420 }
40422 /* Parse a __transaction_atomic or __transaction_relaxed expression.
40424 transaction-expression:
40425 __transaction_atomic txn-noexcept-spec[opt] ( expression )
40426 __transaction_relaxed txn-noexcept-spec[opt] ( expression )
40427 */
40429 static tree
40431 {
40444 keyword == RID_TRANSACTION_RELAXED
40458 /* Set this early. This might mean that we allow transaction_cancel in
40459 an expression that we find out later actually has to be a constexpr.
40460 However, we expect that cxx_constant_value will be able to deal with
40461 this; also, if the noexcept has no constexpr, then what we parse next
40462 really is a transaction's body. */
40465 /* Parse a noexcept specification. */
40471 {
40472 matching_parens parens;
40479 }
40480 else
40481 {
40482 /* The only expression that is available got parsed for the noexcept
40483 already. noexcept is true then. */
40486 }
40495 }
40497 /* Parse a function-transaction-block.
40499 function-transaction-block:
40500 __transaction_atomic txn-attribute[opt] ctor-initializer[opt]
40501 function-body
40502 __transaction_atomic txn-attribute[opt] function-try-block
40503 __transaction_relaxed ctor-initializer[opt] function-body
40504 __transaction_relaxed function-try-block
40505 */
40507 static void
40509 {
40524 else
40525 {
40529 }
40537 else
40538 cp_parser_ctor_initializer_opt_and_function_body
40544 }
40546 /* Parse a __transaction_cancel statement.
40548 cancel-statement:
40549 __transaction_cancel txn-attribute[opt] ;
40550 __transaction_cancel txn-attribute[opt] throw-expression ;
40552 ??? Cancel and throw is not yet implemented. */
40554 static tree
40556 {
40562 RT_TRANSACTION_CANCEL);
40569 /* ??? Parse cancel-and-throw here. */
40574 {
40578 }
40580 {
40584 }
40586 {
40589 {
40595 }
40596 }
40598 {
40602 }
40608 }
40609 \f
40610 /* The parser. */
40614 \f
40615 /* Special handling for the first token or line in the file. The first
40616 thing in the file might be #pragma GCC pch_preprocess, which loads a
40617 PCH file, which is a GC collection point. So we need to handle this
40618 first pragma without benefit of an existing lexer structure.
40620 Always returns one token to the caller in *FIRST_TOKEN. This is
40621 either the true first token of the file, or the first token after
40622 the initial pragma. */
40624 static void
40626 {
40635 {
40642 }
40643 else
40646 /* Skip to the end of the pragma. */
40650 /* Now actually load the PCH file. */
40654 /* Read one more token to return to our caller. We have to do this
40655 after reading the PCH file in, since its pointers have to be
40656 live. */
40658 }
40660 /* Parse a pragma GCC ivdep. */
40662 static bool
40664 {
40667 }
40669 /* Parse a pragma GCC unroll. */
40671 static unsigned short
40673 {
40683 {
40685 " assignment-expression that evaluates to a non-negative"
40688 }
40689 else
40690 {
40694 }
40697 }
40699 /* Normal parsing of a pragma token. Here we can (and must) use the
40700 regular lexer. */
40702 static bool
40704 {
40707 tree stmt;
40718 {
40726 {
40736 }
40741 {
40751 }
40756 {
40766 }
40771 {
40782 }
40787 {
40798 }
40803 {
40814 }
40834 {
40839 }
40847 {
40852 }
40860 {
40864 }
40870 {
40875 }
40883 {
40888 }
40946 "%<#pragma omp section%> may only be used in "
40951 {
40953 {
40957 }
40963 {
40967 }
40968 else
40974 {
40977 }
40980 }
40983 {
40985 {
40989 }
40990 const unsigned short unroll
40996 {
41000 }
41001 else
41007 {
41010 }
41013 }
41020 bad_stmt:
41023 }
41027 }
41029 /* The interface the pragma parsers have to the lexer. */
41031 enum cpp_ttype
41033 {
41045 else
41046 {
41050 }
41053 }
41055 \f
41056 /* External interface. */
41058 /* Parse one entire translation unit. */
41060 void
41062 {
41077 }
41079 /* Create an identifier for a generic parameter type (a synthesized
41080 template parameter implied by `auto' or a concept identifier). */
41083 static tree
41085 {
41089 }
41091 /* Add an implicit template type parameter to the CURRENT_TEMPLATE_PARMS
41092 (creating a new template parameter list if necessary). Returns the newly
41093 created template type parm. */
41095 static tree
41097 {
41100 /* Before committing to modifying any scope, if we're in an
41101 implicit template scope, and we're trying to synthesize a
41102 constrained parameter, try to find a previous parameter with
41103 the same name. This is the same-type rule for abbreviated
41104 function templates.
41106 NOTE: We can generate implicit parameters when tentatively
41107 parsing a nested name specifier, only to reject that parse
41108 later. However, matching the same template-id as part of a
41109 direct-declarator should generate an identical template
41110 parameter, so this rule will merge them. */
41112 {
41115 {
41117 {
41120 /* Return the TEMPLATE_PARM_INDEX. */
41123 }
41125 }
41126 }
41128 /* We are either continuing a function template that already contains implicit
41129 template parameters, creating a new fully-implicit function template, or
41130 extending an existing explicit function template with implicit template
41131 parameters. */
41139 {
41143 }
41144 else
41145 {
41146 /* Roll back to the existing template parameter scope (in the case of
41147 extending an explicit function template) or introduce a new template
41148 parameter scope ahead of the function parameter scope (or class scope
41149 in the case of out-of-line member definitions). The function scope is
41150 added back after template parameter synthesis below. */
41155 {
41158 }
41160 {
41161 /* If not defining a class, then any class scope is a scope level in
41162 an out-of-line member definition. In this case simply wind back
41163 beyond the first such scope to inject the template parameter list.
41164 Otherwise wind back to the class being defined. The latter can
41165 occur in class member friend declarations such as:
41167 class A {
41168 void foo (auto);
41169 };
41170 class B {
41171 friend void A::foo (auto);
41172 };
41174 The template parameter list synthesized for the friend declaration
41175 must be injected in the scope of 'B'. This can also occur in
41176 erroneous cases such as:
41178 struct A {
41179 struct B {
41180 void foo (auto);
41181 };
41182 void B::foo (auto) {}
41183 };
41185 Here the attempted definition of 'B::foo' within 'A' is ill-formed
41186 but, nevertheless, the template parameter list synthesized for the
41187 declarator should be injected into the scope of 'A' as if the
41188 ill-formed template was specified explicitly. */
41191 {
41194 }
41195 }
41201 {
41202 /* Introduce a new template parameter list for implicit template
41203 parameters. */
41207 parser->implicit_template_scope
41214 }
41215 else
41216 {
41217 /* Synthesize implicit template parameters at the end of the explicit
41218 template parameter list. */
41225 parser->implicit_template_parms
41227 }
41228 }
41230 /* Synthesize a new template parameter and track the current template
41231 parameter chain with implicit_template_parms. */
41235 tree synth_tmpl_parm;
41239 synth_tmpl_parm
41242 synth_tmpl_parm
41244 else
41245 {
41249 }
41251 // Attach the constraint to the parm before processing.
41254 tree new_parm
41256 input_location,
41257 node,
41261 // Chain the new parameter to the list of implicit parameters.
41263 parser->implicit_template_parms
41265 else
41270 /* Return the TEMPLATE_PARM_INDEX, not the PARM_DECL. */
41273 /* If creating a fully implicit function template, start the new implicit
41274 template parameter list with this synthesized type, otherwise grow the
41275 current template parameter list. */
41278 {
41285 }
41286 else
41287 {
41292 }
41294 // If the new parameter was constrained, we need to add that to the
41295 // constraints in the template parameter list.
41297 {
41301 }
41306 }
41308 /* Finish the declaration of a fully implicit function template. Such a
41309 template has no explicit template parameter list so has not been through the
41310 normal template head and tail processing. synthesize_implicit_template_parm
41311 tries to do the head; this tries to do the tail. MEMBER_DECL_OPT should be
41312 provided if the declaration is a class member such that its template
41313 declaration can be completed. If MEMBER_DECL_OPT is provided the finished
41314 form is returned. Otherwise NULL_TREE is returned. */
41316 static tree
41318 {
41323 {
41327 }
41339 }
41341 /* Like finish_fully_implicit_template, but to be used in error
41342 recovery, rearranging scopes so that we restore the state we had
41343 before synthesize_implicit_template_parm inserted the implement
41344 template parms scope. */
41346 static void
41348 {
41353 {
41362 }
41363 else
41369 }
41371 /* Helper function for diagnostics that have complained about things
41372 being used with 'extern "C"' linkage.
41374 Attempt to issue a note showing where the 'extern "C"' linkage began. */
41376 void
41378 {
41382 }